Optimize the filling code for bitmap

Author: 38

benches/benches/parallel.rs

@@ -84,7 +84,7 @@ fn draw_func_2x1_parallel_and_blit(c: &mut Criterion) {
     c.bench_function("parallel::draw_func_2x1_parallel_and_blit", |b| {
         b.iter(|| {
             let root = BitMapBackend::with_buffer(&mut buffer, (W, H)).into_drawing_area();
-            let areas = root.split_evenly((2,1));
+            let areas = root.split_evenly((2, 1));
             let mut elements: Vec<_> = areas
                 .iter()
                 .map(|area| area.dim_in_pixel())
@@ -116,9 +116,12 @@ fn draw_func_2x1_inplace_parallel(c: &mut Criterion) {
                 )
             };
 
-            [upper, lower]
-                .par_iter_mut()
-                .for_each(|b| draw_plot(&BitMapBackend::with_buffer(*b, (W, H / 2)).into_drawing_area(), 2.0));
+            [upper, lower].par_iter_mut().for_each(|b| {
+                draw_plot(
+                    &BitMapBackend::with_buffer(*b, (W, H / 2)).into_drawing_area(),
+                    2.0,
+                )
+            });
         })
     });
 }
@@ -128,7 +131,7 @@ fn draw_func_2x1_seq(c: &mut Criterion) {
     c.bench_function("parallel::draw_func_2x1_seq", |b| {
         b.iter(|| {
             let root = BitMapBackend::with_buffer(&mut buffer, (W, H)).into_drawing_area();
-            root.split_evenly((2,1))
+            root.split_evenly((2, 1))
                 .iter_mut()
                 .for_each(|area| draw_plot(area, 2.0));
         })
@@ -138,9 +141,9 @@ fn draw_func_2x1_seq(c: &mut Criterion) {
 criterion_group! {
     name = parallel_group;
     config = Criterion::default().sample_size(10);
-    targets = 
-        draw_func_1x1_seq, 
-        draw_func_4x4_seq, 
+    targets =
+        draw_func_1x1_seq,
+        draw_func_4x4_seq,
         draw_func_4x4_parallel_and_blit,
         draw_func_2x1_parallel_and_blit,
         draw_func_2x1_inplace_parallel,

src/drawing/backend_impl/bitmap.rs

@@ -242,14 +242,35 @@ impl<'a> BitMapBackend<'a> {
                     .for_each(|e| *e = r);
             }
         } else {
-            for y in y0..=y1 {
-                let start = (y * w as i32 + x0) as usize;
-                let count = (x1 - x0 + 1) as usize;
-                let mut iter = dst[(start * 3)..((start + count) * 3)].iter_mut();
-                for _ in 0..(x1 - x0 + 1) {
-                    *iter.next().unwrap() = r;
-                    *iter.next().unwrap() = g;
-                    *iter.next().unwrap() = b;
+            let count = (x1 - x0 + 1) as usize;
+            if count < 8 {
+                for y in y0..=y1 {
+                    let start = (y * w as i32 + x0) as usize;
+                    let mut iter = dst[(start * 3)..((start + count) * 3)].iter_mut();
+                    for _ in 0..(x1 - x0 + 1) {
+                        *iter.next().unwrap() = r;
+                        *iter.next().unwrap() = g;
+                        *iter.next().unwrap() = b;
+                    }
+                }
+            } else {
+                for y in y0..=y1 {
+                    let start = (y * w as i32 + x0) as usize;
+                    let start_ptr = &mut dst[start * 3] as *mut u8 as *mut (u8, u8, u8, u8, u8, u8);
+                    let slice =
+                        unsafe { std::slice::from_raw_parts_mut(start_ptr, (count - 1) / 2) };
+                    for p in slice.iter_mut() {
+                        unsafe {
+                            let ptr = p as *mut (u8, u8, u8, u8, u8, u8) as *mut u64;
+                            *ptr = std::mem::transmute([r, g, b, r, g, b, 0, 0]);
+                        }
+                    }
+
+                    for idx in (slice.len() * 2)..count {
+                        dst[start * 3 + idx * 3] = r;
+                        dst[start * 3 + idx * 3 + 1] = g;
+                        dst[start * 3 + idx * 3 + 2] = b;
+                    }
                 }
             }
         }
@@ -318,7 +339,21 @@ impl<'a> DrawingBackend for BitMapBackend<'a> {
 
         if from.0 == to.0 || from.1 == to.1 {
             if alpha >= 1.0 {
-                self.fill_rect_fast(from, to, r, g, b);
+                if from.1 == to.1 {
+                    self.fill_rect_fast(from, to, r, g, b);
+                } else {
+                    let w = self.get_size().0 as i32;
+                    let dst = self.get_raw_pixel_buffer();
+                    let (mut y0, mut y1) = (from.1, to.1);
+                    if y0 > y1 {
+                        std::mem::swap(&mut y0, &mut y1);
+                    }
+                    for y in y0..=y1 {
+                        dst[(y * w + from.0) as usize * 3] = r;
+                        dst[(y * w + from.0) as usize * 3 + 1] = g;
+                        dst[(y * w + from.0) as usize * 3 + 2] = b;
+                    }
+                }
             } else {
                 self.blend_rect_fast(from, to, r, g, b, alpha);
             }