rework ci testing (#151)

* don't run a full benchmark, but do test fuzzers, and all targets in release mode
* fix benchmarks for no-std

.github/workflows/rust.yml

@@ -28,7 +28,7 @@ jobs:
     - name: Install cargo tools
       uses: taiki-e/install-action@v2
       with:
-        tool: cargo-hack,cargo-minimal-versions
+        tool: cargo-hack,cargo-minimal-versions${{ matrix.os == 'ubuntu-latest' && ',cargo-fuzz' || '' }}
       if: matrix.rust == 'nightly' && matrix.cargo_features == 'default'
 
     - uses: actions/checkout@v4
@@ -51,7 +51,7 @@ jobs:
       if: matrix.os == 'ubuntu-latest' && matrix.rust == 'nightly' && matrix.cargo_features == 'default'
 
     - name: Test
-      run: cargo +${{ matrix.rust }} test --no-default-features --features "${{ matrix.cargo_features }}"
+      run: cargo +${{ matrix.rust }} test --no-default-features --features "${{ matrix.cargo_features }}" --all-targets
 
     - name: Minimal versions
       # cargo-minimal-versions won't detach the path deps if we're using dev dependencies
@@ -65,6 +65,21 @@ jobs:
       run: cargo update && cargo +${{ matrix.rust }} test --no-default-features --features "${{ matrix.cargo_features }}"
       if: matrix.rust == 'stable' && matrix.cargo_features == 'default'
 
-    - name: Benchmark
-      run: cargo +${{ matrix.rust }} bench --no-default-features --features "${{ matrix.cargo_features }}"
+    - name: Short Fuzz
+      run: |
+        cargo +${{ matrix.rust }} install cargo-fuzz --locked
+        cd fuzz || exit 1
+        CFLAGS="-fsanitize=address -g -fno-omit-frame-pointer"
+        targets=( $(cargo metadata --format-version 1 --no-deps | jq -r ".packages[].targets[].name") )
+        target_triple=$(cargo --version --verbose | grep 'host:' | cut -d ' ' -f 2)
+        for target in "${targets[@]}"; do
+          # https://github.com/rust-fuzz/cargo-fuzz/issues/355
+          cargo +${{ matrix.rust }} fuzz run "$target" --target "${target_triple}" -- -max_total_time=10
+        done
+      if: matrix.rust == 'nightly' && matrix.cargo_features == 'default' && matrix.os == 'ubuntu-latest'
+
+    - name: Release Test
+      run: |
+        cargo +${{ matrix.rust }} test --no-default-features --features "${{ matrix.cargo_features }}" --release --all-targets
       if: matrix.rust == 'nightly' && matrix.cargo_features == 'default'
+

croaring/benches/benches.rs

@@ -89,22 +89,36 @@ fn binops(c: &mut Criterion) {
             group
         }};
         ($new:ident, $inplace:ident, $fast:ident) => {{
-            let mut group = bench_op!($new, $inplace);
+            #[cfg(not(feature = "alloc"))]
+            {
+                bench_op!($new, $inplace)
+            }
+            #[cfg(feature = "alloc")]
+            {
+                let mut group = bench_op!($new, $inplace);
 
-            group.bench_function("fast", |b| {
-                b.iter(|| Bitmap::$fast(&[&bitmap1, &bitmap2]));
-            });
+                group.bench_function("fast", |b| {
+                    b.iter(|| Bitmap::$fast(&[&bitmap1, &bitmap2]));
+                });
 
-            group
+                group
+            }
         }};
         ($new:ident, $inplace:ident, $fast:ident, $fast_heap:ident) => {{
-            let mut group = bench_op!($new, $inplace, $fast);
+            #[cfg(not(feature = "alloc"))]
+            {
+                bench_op!($new, $inplace, $fast)
+            }
+            #[cfg(feature = "alloc")]
+            {
+                let mut group = bench_op!($new, $inplace, $fast);
 
-            group.bench_function("fast_heap", |b| {
-                b.iter(|| Bitmap::$fast_heap(&[&bitmap1, &bitmap2]));
-            });
+                group.bench_function("fast_heap", |b| {
+                    b.iter(|| Bitmap::$fast_heap(&[&bitmap1, &bitmap2]));
+                });
 
-            group
+                group
+            }
         }};
     }
 
@@ -134,6 +148,8 @@ fn to_vec(c: &mut Criterion) {
     const N: usize = 100_000;
     let bitmap: Bitmap = random_iter().take(N).collect();
     let mut g = c.benchmark_group("collect");
+
+    #[cfg(feature = "alloc")]
     g.bench_function("to_vec", |b| {
         b.iter(|| bitmap.to_vec());
     });
@@ -178,21 +194,31 @@ fn of(c: &mut Criterion) {
 }
 
 fn serialize(c: &mut Criterion) {
-    let mut group = c.benchmark_group("serialize");
-    for &size in &[100_000, 1_000_000] {
-        let bitmap: Bitmap = (1..size).collect();
-        group.throughput(Throughput::Elements(size.into()));
-        group.bench_with_input(BenchmarkId::from_parameter(size), &size, |b, _| {
-            b.iter(|| bitmap.serialize::<Portable>());
-        });
+    #[cfg(not(feature = "alloc"))]
+    {
+        _ = c;
+    }
+    #[cfg(feature = "alloc")]
+    {
+        let mut group = c.benchmark_group("serialize");
+        for &size in &[100_000, 1_000_000] {
+            let bitmap: Bitmap = (1..size).collect();
+            group.throughput(Throughput::Elements(size.into()));
+            group.bench_with_input(BenchmarkId::from_parameter(size), &size, |b, _| {
+                b.iter(|| bitmap.serialize::<Portable>());
+            });
+        }
     }
 }
 
 fn deserialize(c: &mut Criterion) {
     let mut group = c.benchmark_group("deserialize");
     for &size in &[100_000, 1_000_000] {
         let bitmap: Bitmap = (1..size).collect();
-        let serialized_buffer = bitmap.serialize::<Portable>();
+        let mut serialized_buffer = vec![0; bitmap.get_serialized_size_in_bytes::<Portable>()];
+        let serialized_buffer = bitmap
+            .try_serialize_into::<Portable>(&mut serialized_buffer)
+            .unwrap();
         group.throughput(Throughput::Elements(size.into()));
         group.bench_with_input(BenchmarkId::from_parameter(size), &size, |b, _| {
             b.iter(|| Bitmap::deserialize::<Portable>(&serialized_buffer));
@@ -285,6 +311,8 @@ fn collect_bitmap64_to_vec(c: &mut Criterion) {
     let mut group = c.benchmark_group("collect_bitmap64_to_vec");
     group.throughput(Throughput::Elements(N.into()));
     let bitmap = Bitmap64::from_range(0..N);
+
+    #[cfg(feature = "alloc")]
     group.bench_function("to_vec", |b| {
         b.iter_batched(|| (), |()| bitmap.to_vec(), BatchSize::LargeInput);
     });