From 5ffea8ddef1b966286c14a3294f501201d9edc70 Mon Sep 17 00:00:00 2001 From: Héctor Ramón Jiménez Date: Sun, 7 Apr 2024 08:11:42 +0200 Subject: Add a simple `wgpu` benchmark using `criterion` --- benches/wgpu.rs | 182 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 182 insertions(+) create mode 100644 benches/wgpu.rs (limited to 'benches') diff --git a/benches/wgpu.rs b/benches/wgpu.rs new file mode 100644 index 00000000..c8d38dc9 --- /dev/null +++ b/benches/wgpu.rs @@ -0,0 +1,182 @@ +use criterion::{criterion_group, criterion_main, Bencher, Criterion}; + +use iced::alignment; +use iced::mouse; +use iced::widget::{canvas, text}; +use iced::{ + Color, Element, Font, Length, Pixels, Point, Rectangle, Size, Theme, +}; +use iced_wgpu::Renderer; + +criterion_main!(benches); +criterion_group!(benches, wgpu_benchmark); + +pub fn wgpu_benchmark(c: &mut Criterion) { + c.bench_function("wgpu — canvas (light)", |b| benchmark(b, scene(10))); + c.bench_function("wgpu — canvas (heavy)", |b| benchmark(b, scene(1_000))); +} + +fn benchmark<'a>( + bencher: &mut Bencher<'_>, + widget: Element<'a, (), Theme, Renderer>, +) { + use iced_futures::futures::executor; + use iced_wgpu::graphics; + use iced_wgpu::graphics::Antialiasing; + use iced_wgpu::wgpu; + use iced_winit::core; + use iced_winit::runtime; + + let instance = wgpu::Instance::new(wgpu::InstanceDescriptor { + backends: wgpu::Backends::all(), + ..Default::default() + }); + + let adapter = executor::block_on(instance.request_adapter( + &wgpu::RequestAdapterOptions { + power_preference: wgpu::PowerPreference::HighPerformance, + compatible_surface: None, + force_fallback_adapter: false, + }, + )) + .expect("request adapter"); + + let (device, queue) = executor::block_on(adapter.request_device( + &wgpu::DeviceDescriptor { + label: None, + required_features: wgpu::Features::empty(), + required_limits: wgpu::Limits::default(), + }, + None, + )) + .expect("request device"); + + let format = wgpu::TextureFormat::Bgra8UnormSrgb; + + let mut engine = iced_wgpu::Engine::new( + &adapter, + &device, + &queue, + format, + Some(Antialiasing::MSAAx4), + ); + + let mut renderer = Renderer::new( + iced_wgpu::Settings { + present_mode: wgpu::PresentMode::Immediate, + backends: wgpu::Backends::all(), + default_font: Font::DEFAULT, + default_text_size: Pixels::from(16), + antialiasing: Some(Antialiasing::MSAAx4), + }, + &engine, + ); + + let viewport = + graphics::Viewport::with_physical_size(Size::new(3840, 2160), 2.0); + + let texture = device.create_texture(&wgpu::TextureDescriptor { + label: None, + size: wgpu::Extent3d { + width: 3840, + height: 2160, + depth_or_array_layers: 1, + }, + mip_level_count: 1, + sample_count: 1, + dimension: wgpu::TextureDimension::D2, + format, + usage: wgpu::TextureUsages::RENDER_ATTACHMENT, + view_formats: &[], + }); + + let texture_view = + texture.create_view(&wgpu::TextureViewDescriptor::default()); + + let mut user_interface = runtime::UserInterface::build( + widget, + viewport.logical_size(), + runtime::user_interface::Cache::default(), + &mut renderer, + ); + + bencher.iter(|| { + user_interface.draw( + &mut renderer, + &Theme::Dark, + &core::renderer::Style { + text_color: Color::WHITE, + }, + mouse::Cursor::Unavailable, + ); + + let mut encoder = + device.create_command_encoder(&wgpu::CommandEncoderDescriptor { + label: None, + }); + + renderer.present::<&str>( + &mut engine, + &device, + &queue, + &mut encoder, + Some(Color::BLACK), + format, + &texture_view, + &viewport, + &[], + ); + + engine.submit(&queue, encoder); + }); +} + +fn scene<'a, Message: 'a, Theme: 'a>( + n: usize, +) -> Element<'a, Message, Theme, Renderer> { + canvas(Scene { n }) + .width(Length::Fill) + .height(Length::Fill) + .into() +} + +struct Scene { + n: usize, +} + +impl canvas::Program for Scene { + type State = canvas::Cache; + + fn draw( + &self, + cache: &Self::State, + renderer: &Renderer, + _theme: &Theme, + bounds: Rectangle, + _cursor: mouse::Cursor, + ) -> Vec> { + vec![cache.draw(renderer, bounds.size(), |frame| { + for i in 0..self.n { + frame.fill_rectangle( + Point::new(0.0, i as f32), + Size::new(10.0, 10.0), + Color::WHITE, + ); + } + + for i in 0..self.n { + frame.fill_text(canvas::Text { + content: i.to_string(), + position: Point::new(0.0, i as f32), + color: Color::BLACK, + size: Pixels::from(16), + line_height: text::LineHeight::default(), + font: Font::DEFAULT, + horizontal_alignment: alignment::Horizontal::Left, + vertical_alignment: alignment::Vertical::Top, + shaping: text::Shaping::Basic, + }); + } + })] + } +} -- cgit From 67716720875368ac4ab2354bcea026a4fadbb469 Mon Sep 17 00:00:00 2001 From: Héctor Ramón Jiménez Date: Sun, 7 Apr 2024 08:48:27 +0200 Subject: Wait for submission in `wgpu` benchmark --- benches/wgpu.rs | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) (limited to 'benches') diff --git a/benches/wgpu.rs b/benches/wgpu.rs index c8d38dc9..47e3f7cc 100644 --- a/benches/wgpu.rs +++ b/benches/wgpu.rs @@ -127,7 +127,9 @@ fn benchmark<'a>( &[], ); - engine.submit(&queue, encoder); + let submission = engine.submit(&queue, encoder); + + let _ = device.poll(wgpu::Maintain::WaitForSubmissionIndex(submission)); }); } -- cgit From bcd6873b37ed63ade9743900cdae8e8619299eb2 Mon Sep 17 00:00:00 2001 From: Héctor Ramón Jiménez Date: Sun, 7 Apr 2024 09:33:33 +0200 Subject: Fix lint in `wgpu` benchmark --- benches/wgpu.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'benches') diff --git a/benches/wgpu.rs b/benches/wgpu.rs index 47e3f7cc..8489f61a 100644 --- a/benches/wgpu.rs +++ b/benches/wgpu.rs @@ -16,9 +16,9 @@ pub fn wgpu_benchmark(c: &mut Criterion) { c.bench_function("wgpu — canvas (heavy)", |b| benchmark(b, scene(1_000))); } -fn benchmark<'a>( +fn benchmark( bencher: &mut Bencher<'_>, - widget: Element<'a, (), Theme, Renderer>, + widget: Element<'_, (), Theme, Renderer>, ) { use iced_futures::futures::executor; use iced_wgpu::graphics; -- cgit From a865b380026ce8c26b818e8e94ea14cb930865a3 Mon Sep 17 00:00:00 2001 From: Héctor Ramón Jiménez Date: Sun, 7 Apr 2024 08:11:42 +0200 Subject: Add a simple `wgpu` benchmark using `criterion` --- benches/wgpu.rs | 185 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 185 insertions(+) create mode 100644 benches/wgpu.rs (limited to 'benches') diff --git a/benches/wgpu.rs b/benches/wgpu.rs new file mode 100644 index 00000000..617be16d --- /dev/null +++ b/benches/wgpu.rs @@ -0,0 +1,185 @@ +use criterion::{criterion_group, criterion_main, Bencher, Criterion}; + +use iced::alignment; +use iced::mouse; +use iced::widget::{canvas, text}; +use iced::{ + Color, Element, Font, Length, Pixels, Point, Rectangle, Size, Theme, +}; +use iced_wgpu::Renderer; + +criterion_main!(benches); +criterion_group!(benches, wgpu_benchmark); + +pub fn wgpu_benchmark(c: &mut Criterion) { + c.bench_function("wgpu — canvas (light)", |b| benchmark(b, scene(10))); + c.bench_function("wgpu — canvas (heavy)", |b| benchmark(b, scene(1_000))); +} + +fn benchmark<'a>( + bencher: &mut Bencher<'_>, + widget: Element<'a, (), Theme, Renderer>, +) { + use iced_futures::futures::executor; + use iced_wgpu::graphics; + use iced_wgpu::graphics::Antialiasing; + use iced_wgpu::wgpu; + use iced_winit::core; + use iced_winit::runtime; + + let instance = wgpu::Instance::new(wgpu::InstanceDescriptor { + backends: wgpu::Backends::all(), + ..Default::default() + }); + + let adapter = executor::block_on(instance.request_adapter( + &wgpu::RequestAdapterOptions { + power_preference: wgpu::PowerPreference::HighPerformance, + compatible_surface: None, + force_fallback_adapter: false, + }, + )) + .expect("request adapter"); + + let (device, queue) = executor::block_on(adapter.request_device( + &wgpu::DeviceDescriptor { + label: None, + required_features: wgpu::Features::empty(), + required_limits: wgpu::Limits::default(), + }, + None, + )) + .expect("request device"); + + let format = wgpu::TextureFormat::Bgra8UnormSrgb; + + let backend = iced_wgpu::Backend::new( + &adapter, + &device, + &queue, + iced_wgpu::Settings { + present_mode: wgpu::PresentMode::Immediate, + internal_backend: wgpu::Backends::all(), + default_font: Font::DEFAULT, + default_text_size: Pixels::from(16), + antialiasing: Some(Antialiasing::MSAAx4), + }, + format, + ); + + let mut renderer = Renderer::new(backend, Font::DEFAULT, Pixels::from(16)); + + let viewport = + graphics::Viewport::with_physical_size(Size::new(3840, 2160), 2.0); + + let texture = device.create_texture(&wgpu::TextureDescriptor { + label: None, + size: wgpu::Extent3d { + width: 3840, + height: 2160, + depth_or_array_layers: 1, + }, + mip_level_count: 1, + sample_count: 1, + dimension: wgpu::TextureDimension::D2, + format, + usage: wgpu::TextureUsages::RENDER_ATTACHMENT, + view_formats: &[], + }); + + let texture_view = + texture.create_view(&wgpu::TextureViewDescriptor::default()); + + let mut user_interface = runtime::UserInterface::build( + widget, + viewport.logical_size(), + runtime::user_interface::Cache::default(), + &mut renderer, + ); + + bencher.iter(|| { + user_interface.draw( + &mut renderer, + &Theme::Dark, + &core::renderer::Style { + text_color: Color::WHITE, + }, + mouse::Cursor::Unavailable, + ); + + let mut encoder = + device.create_command_encoder(&wgpu::CommandEncoderDescriptor { + label: None, + }); + + renderer.with_primitives(|backend, primitives| { + backend.present::<&str>( + &device, + &queue, + &mut encoder, + Some(Color::BLACK), + format, + &texture_view, + primitives, + &viewport, + &[], + ); + + let submission = queue.submit(Some(encoder.finish())); + backend.recall(); + + let _ = + device.poll(wgpu::Maintain::WaitForSubmissionIndex(submission)); + }); + }); +} + +fn scene<'a, Message: 'a, Theme: 'a>( + n: usize, +) -> Element<'a, Message, Theme, Renderer> { + canvas(Scene { n }) + .width(Length::Fill) + .height(Length::Fill) + .into() +} + +struct Scene { + n: usize, +} + +impl canvas::Program for Scene { + type State = canvas::Cache; + + fn draw( + &self, + cache: &Self::State, + renderer: &Renderer, + _theme: &Theme, + bounds: Rectangle, + _cursor: mouse::Cursor, + ) -> Vec> { + vec![cache.draw(renderer, bounds.size(), |frame| { + for i in 0..self.n { + frame.fill_rectangle( + Point::new(0.0, i as f32), + Size::new(10.0, 10.0), + Color::WHITE, + ); + } + + for i in 0..self.n { + frame.fill_text(canvas::Text { + content: i.to_string(), + position: Point::new(0.0, i as f32), + color: Color::BLACK, + size: Pixels::from(16), + line_height: text::LineHeight::default(), + font: Font::DEFAULT, + horizontal_alignment: alignment::Horizontal::Left, + vertical_alignment: alignment::Vertical::Top, + shaping: text::Shaping::Basic, + }); + } + })] + } +} -- cgit From 5cd98f069dea8720bca7748d6c12fa410cbe79b5 Mon Sep 17 00:00:00 2001 From: Héctor Ramón Jiménez Date: Sun, 7 Apr 2024 12:42:12 +0200 Subject: Use built-in `[lints]` table in `Cargo.toml` --- benches/wgpu.rs | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) (limited to 'benches') diff --git a/benches/wgpu.rs b/benches/wgpu.rs index 617be16d..2c117858 100644 --- a/benches/wgpu.rs +++ b/benches/wgpu.rs @@ -1,3 +1,4 @@ +#![allow(missing_docs)] use criterion::{criterion_group, criterion_main, Bencher, Criterion}; use iced::alignment; @@ -12,8 +13,12 @@ criterion_main!(benches); criterion_group!(benches, wgpu_benchmark); pub fn wgpu_benchmark(c: &mut Criterion) { - c.bench_function("wgpu — canvas (light)", |b| benchmark(b, scene(10))); - c.bench_function("wgpu — canvas (heavy)", |b| benchmark(b, scene(1_000))); + let _ = c + .bench_function("wgpu — canvas (light)", |b| benchmark(b, scene(10))); + + let _ = c.bench_function("wgpu — canvas (heavy)", |b| { + benchmark(b, scene(1_000)) + }); } fn benchmark<'a>( @@ -98,7 +103,7 @@ fn benchmark<'a>( ); bencher.iter(|| { - user_interface.draw( + let _ = user_interface.draw( &mut renderer, &Theme::Dark, &core::renderer::Style { -- cgit From 2c6fd9ac14c5d270e05b97b7a7fab811d25834c4 Mon Sep 17 00:00:00 2001 From: Héctor Ramón Jiménez Date: Mon, 8 Apr 2024 15:35:54 +0200 Subject: Make arguments of `Renderer::new` explicit in `iced_wgpu` --- benches/wgpu.rs | 11 +---------- 1 file changed, 1 insertion(+), 10 deletions(-) (limited to 'benches') diff --git a/benches/wgpu.rs b/benches/wgpu.rs index 780c6bc2..61b4eb6c 100644 --- a/benches/wgpu.rs +++ b/benches/wgpu.rs @@ -63,16 +63,7 @@ fn benchmark( Some(Antialiasing::MSAAx4), ); - let mut renderer = Renderer::new( - iced_wgpu::Settings { - present_mode: wgpu::PresentMode::Immediate, - backends: wgpu::Backends::all(), - default_font: Font::DEFAULT, - default_text_size: Pixels::from(16), - antialiasing: Some(Antialiasing::MSAAx4), - }, - &engine, - ); + let mut renderer = Renderer::new(&engine, Font::DEFAULT, Pixels::from(16)); let viewport = graphics::Viewport::with_physical_size(Size::new(3840, 2160), 2.0); -- cgit From e2aee80aa1371b91d08a2aeccc814f742d4dedb4 Mon Sep 17 00:00:00 2001 From: Héctor Ramón Jiménez Date: Wed, 1 May 2024 15:39:05 +0200 Subject: Introduce `layered_text` benchmarks --- benches/wgpu.rs | 98 ++++++++++++++++++++++++++++++++------------------------- 1 file changed, 56 insertions(+), 42 deletions(-) (limited to 'benches') diff --git a/benches/wgpu.rs b/benches/wgpu.rs index 61b4eb6c..3dd415db 100644 --- a/benches/wgpu.rs +++ b/benches/wgpu.rs @@ -3,7 +3,7 @@ use criterion::{criterion_group, criterion_main, Bencher, Criterion}; use iced::alignment; use iced::mouse; -use iced::widget::{canvas, text}; +use iced::widget::{canvas, stack, text}; use iced::{ Color, Element, Font, Length, Pixels, Point, Rectangle, Size, Theme, }; @@ -16,6 +16,13 @@ criterion_group!(benches, wgpu_benchmark); pub fn wgpu_benchmark(c: &mut Criterion) { c.bench_function("wgpu — canvas (light)", |b| benchmark(b, scene(10))); c.bench_function("wgpu — canvas (heavy)", |b| benchmark(b, scene(1_000))); + + c.bench_function("wgpu - layered text (light)", |b| { + benchmark(b, layered_text(10)); + }); + c.bench_function("wgpu - layered text (heavy)", |b| { + benchmark(b, layered_text(1_000)); + }); } fn benchmark( @@ -125,52 +132,59 @@ fn benchmark( }); } -fn scene<'a, Message: 'a, Theme: 'a>( - n: usize, -) -> Element<'a, Message, Theme, Renderer> { +fn scene<'a, Message: 'a>(n: usize) -> Element<'a, Message, Theme, Renderer> { + struct Scene { + n: usize, + } + + impl canvas::Program for Scene { + type State = canvas::Cache; + + fn draw( + &self, + cache: &Self::State, + renderer: &Renderer, + _theme: &Theme, + bounds: Rectangle, + _cursor: mouse::Cursor, + ) -> Vec> { + vec![cache.draw(renderer, bounds.size(), |frame| { + for i in 0..self.n { + frame.fill_rectangle( + Point::new(0.0, i as f32), + Size::new(10.0, 10.0), + Color::WHITE, + ); + } + + for i in 0..self.n { + frame.fill_text(canvas::Text { + content: i.to_string(), + position: Point::new(0.0, i as f32), + color: Color::BLACK, + size: Pixels::from(16), + line_height: text::LineHeight::default(), + font: Font::DEFAULT, + horizontal_alignment: alignment::Horizontal::Left, + vertical_alignment: alignment::Vertical::Top, + shaping: text::Shaping::Basic, + }); + } + })] + } + } + canvas(Scene { n }) .width(Length::Fill) .height(Length::Fill) .into() } -struct Scene { +fn layered_text<'a, Message: 'a>( n: usize, -} - -impl canvas::Program for Scene { - type State = canvas::Cache; - - fn draw( - &self, - cache: &Self::State, - renderer: &Renderer, - _theme: &Theme, - bounds: Rectangle, - _cursor: mouse::Cursor, - ) -> Vec> { - vec![cache.draw(renderer, bounds.size(), |frame| { - for i in 0..self.n { - frame.fill_rectangle( - Point::new(0.0, i as f32), - Size::new(10.0, 10.0), - Color::WHITE, - ); - } - - for i in 0..self.n { - frame.fill_text(canvas::Text { - content: i.to_string(), - position: Point::new(0.0, i as f32), - color: Color::BLACK, - size: Pixels::from(16), - line_height: text::LineHeight::default(), - font: Font::DEFAULT, - horizontal_alignment: alignment::Horizontal::Left, - vertical_alignment: alignment::Vertical::Top, - shaping: text::Shaping::Basic, - }); - } - })] - } +) -> Element<'a, Message, Theme, Renderer> { + stack((0..n).map(|i| text(format!("I am paragraph {i}!")).into())) + .width(Length::Fill) + .height(Length::Fill) + .into() } -- cgit From 547446f0de076149a4c61e6a4179308b266fd9fd Mon Sep 17 00:00:00 2001 From: Héctor Ramón Jiménez Date: Mon, 6 May 2024 12:14:42 +0200 Subject: Fix windows fighting over shared `image::Cache` Image caches are local to each window now. --- benches/wgpu.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'benches') diff --git a/benches/wgpu.rs b/benches/wgpu.rs index 3dd415db..2d308666 100644 --- a/benches/wgpu.rs +++ b/benches/wgpu.rs @@ -70,7 +70,8 @@ fn benchmark( Some(Antialiasing::MSAAx4), ); - let mut renderer = Renderer::new(&engine, Font::DEFAULT, Pixels::from(16)); + let mut renderer = + Renderer::new(&device, &engine, Font::DEFAULT, Pixels::from(16)); let viewport = graphics::Viewport::with_physical_size(Size::new(3840, 2160), 2.0); -- cgit From fb5f1ba0bc728069b63d299e98411fad483b4177 Mon Sep 17 00:00:00 2001 From: Héctor Ramón Jiménez Date: Wed, 8 May 2024 20:29:27 +0200 Subject: Create dynamic text `wgpu` benchmark --- benches/ipsum.txt | 9 ++++++++ benches/wgpu.rs | 63 +++++++++++++++++++++++++++++++++++++++++++------------ 2 files changed, 59 insertions(+), 13 deletions(-) create mode 100644 benches/ipsum.txt (limited to 'benches') diff --git a/benches/ipsum.txt b/benches/ipsum.txt new file mode 100644 index 00000000..3e2d6396 --- /dev/null +++ b/benches/ipsum.txt @@ -0,0 +1,9 @@ +Lorem ipsum dolor sit amet, consectetur adipiscing elit. Curabitur at elit mollis, dictum nunc non, tempus metus. Sed iaculis ac mauris eu lobortis. Integer elementum venenatis eros, id placerat odio feugiat vel. Maecenas consequat convallis tincidunt. Nunc eu lorem justo. Praesent quis ornare sapien. Aliquam interdum tortor ut rhoncus faucibus. Suspendisse molestie scelerisque nulla, eget sodales lacus sodales vel. Nunc placerat id arcu sodales venenatis. Praesent ullamcorper viverra nibh eget efficitur. Aliquam molestie felis vehicula, finibus sapien eget, accumsan purus. Praesent vestibulum eleifend consectetur. Sed tincidunt lectus a libero efficitur, non scelerisque lectus tincidunt. + +Cras ullamcorper tincidunt tellus non tempor. Integer pulvinar turpis quam, nec pharetra purus egestas non. Vivamus sed ipsum consequat, dignissim ante et, suscipit nibh. Quisque et mauris eu erat rutrum cursus. Pellentesque ut neque eu neque eleifend auctor ac hendrerit dolor. Morbi eget egestas ex. Integer hendrerit ipsum in enim bibendum, at vehicula ipsum dapibus. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce tempus consectetur tortor, vel fermentum sem pulvinar eget. Maecenas rutrum fringilla eros a pellentesque. Cras quis magna consectetur, tristique massa vel, aliquet nunc. Aliquam erat volutpat. Suspendisse porttitor risus id auctor fermentum. Vivamus efficitur tellus sed tortor cursus tincidunt. Sed auctor varius arcu, non congue tellus vehicula finibus. + +Fusce a tincidunt urna. Nunc at quam ac enim tempor vehicula imperdiet in sapien. Donec lobortis tristique felis vel semper. Quisque vulputate felis eu enim vestibulum malesuada. Fusce a lobortis mauris, iaculis eleifend ligula. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Vivamus sodales vel elit dignissim mattis. + +Aliquam placerat vulputate dignissim. Proin pellentesque vitae arcu ut feugiat. Nunc mi felis, ornare at gravida sed, vestibulum sed urna. Duis fermentum maximus viverra. Donec imperdiet pellentesque sollicitudin. Cras non sem quis metus bibendum molestie. Duis imperdiet nec lectus eu rutrum. Mauris congue enim purus, in iaculis arcu dapibus ut. Nullam id erat tincidunt, iaculis dolor non, lobortis magna. Proin convallis scelerisque maximus. Morbi at lorem fringilla libero blandit fringilla. Ut aliquet tellus non sem dictum viverra. Aenean venenatis purus eget lacus placerat, non mollis mauris pellentesque. + +Etiam elit diam, aliquet quis suscipit non, condimentum viverra odio. Praesent mi enim, suscipit id mi in, rhoncus ultricies lorem. Nulla facilisi. Integer convallis sagittis euismod. Vestibulum porttitor sodales turpis ac accumsan. Nullam molestie turpis vel lacus tincidunt, sed finibus erat pharetra. Nullam vestibulum turpis id sollicitudin accumsan. Praesent eget posuere lacus. Donec vehicula, nisl nec suscipit porta, felis lorem gravida orci, a hendrerit tellus nibh sit amet elit. diff --git a/benches/wgpu.rs b/benches/wgpu.rs index 2d308666..02c7b1f9 100644 --- a/benches/wgpu.rs +++ b/benches/wgpu.rs @@ -3,7 +3,7 @@ use criterion::{criterion_group, criterion_main, Bencher, Criterion}; use iced::alignment; use iced::mouse; -use iced::widget::{canvas, stack, text}; +use iced::widget::{canvas, scrollable, stack, text}; use iced::{ Color, Element, Font, Length, Pixels, Point, Rectangle, Size, Theme, }; @@ -14,20 +14,31 @@ criterion_group!(benches, wgpu_benchmark); #[allow(unused_results)] pub fn wgpu_benchmark(c: &mut Criterion) { - c.bench_function("wgpu — canvas (light)", |b| benchmark(b, scene(10))); - c.bench_function("wgpu — canvas (heavy)", |b| benchmark(b, scene(1_000))); + c.bench_function("wgpu — canvas (light)", |b| { + benchmark(b, |_| scene(10)) + }); + c.bench_function("wgpu — canvas (heavy)", |b| { + benchmark(b, |_| scene(1_000)) + }); c.bench_function("wgpu - layered text (light)", |b| { - benchmark(b, layered_text(10)); + benchmark(b, |_| layered_text(10)); }); c.bench_function("wgpu - layered text (heavy)", |b| { - benchmark(b, layered_text(1_000)); + benchmark(b, |_| layered_text(1_000)); + }); + + c.bench_function("wgpu - dynamic text (light)", |b| { + benchmark(b, |i| dynamic_text(1_000, i)); + }); + c.bench_function("wgpu - dynamic text (heavy)", |b| { + benchmark(b, |i| dynamic_text(100_000, i)); }); } -fn benchmark( +fn benchmark<'a>( bencher: &mut Bencher<'_>, - widget: Element<'_, (), Theme, Renderer>, + view: impl Fn(usize) -> Element<'a, (), Theme, Renderer>, ) { use iced_futures::futures::executor; use iced_wgpu::graphics; @@ -94,14 +105,17 @@ fn benchmark( let texture_view = texture.create_view(&wgpu::TextureViewDescriptor::default()); - let mut user_interface = runtime::UserInterface::build( - widget, - viewport.logical_size(), - runtime::user_interface::Cache::default(), - &mut renderer, - ); + let mut i = 0; + let mut cache = Some(runtime::user_interface::Cache::default()); bencher.iter(|| { + let mut user_interface = runtime::UserInterface::build( + view(i), + viewport.logical_size(), + cache.take().unwrap(), + &mut renderer, + ); + let _ = user_interface.draw( &mut renderer, &Theme::Dark, @@ -111,6 +125,8 @@ fn benchmark( mouse::Cursor::Unavailable, ); + cache = Some(user_interface.into_cache()); + let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None, @@ -130,6 +146,8 @@ fn benchmark( let submission = engine.submit(&queue, encoder); let _ = device.poll(wgpu::Maintain::WaitForSubmissionIndex(submission)); + + i += 1; }); } @@ -189,3 +207,22 @@ fn layered_text<'a, Message: 'a>( .height(Length::Fill) .into() } + +fn dynamic_text<'a, Message: 'a>( + n: usize, + i: usize, +) -> Element<'a, Message, Theme, Renderer> { + const LOREM_IPSUM: &'static str = include_str!("ipsum.txt"); + + scrollable( + text(format!( + "{}... Iteration {i}", + std::iter::repeat(LOREM_IPSUM.chars()) + .flatten() + .take(n) + .collect::(), + )) + .size(10), + ) + .into() +} -- cgit From 7e7af91e6f7dc187e8fb95746d8811289a088217 Mon Sep 17 00:00:00 2001 From: Héctor Ramón Jiménez Date: Wed, 8 May 2024 20:34:31 +0200 Subject: Fix `clippy` lints in `wgpu` benchmark --- benches/wgpu.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'benches') diff --git a/benches/wgpu.rs b/benches/wgpu.rs index 02c7b1f9..0e407253 100644 --- a/benches/wgpu.rs +++ b/benches/wgpu.rs @@ -15,10 +15,10 @@ criterion_group!(benches, wgpu_benchmark); #[allow(unused_results)] pub fn wgpu_benchmark(c: &mut Criterion) { c.bench_function("wgpu — canvas (light)", |b| { - benchmark(b, |_| scene(10)) + benchmark(b, |_| scene(10)); }); c.bench_function("wgpu — canvas (heavy)", |b| { - benchmark(b, |_| scene(1_000)) + benchmark(b, |_| scene(1_000)); }); c.bench_function("wgpu - layered text (light)", |b| { @@ -212,7 +212,7 @@ fn dynamic_text<'a, Message: 'a>( n: usize, i: usize, ) -> Element<'a, Message, Theme, Renderer> { - const LOREM_IPSUM: &'static str = include_str!("ipsum.txt"); + const LOREM_IPSUM: &str = include_str!("ipsum.txt"); scrollable( text(format!( -- cgit