Fix compilation error in benchmarks

.github/workflows/ci.yml

@@ -43,6 +43,9 @@ jobs:
       - name: Run tests
         run: make test
 
+      - name: Compile benchmarks
+        run: cargo bench --features benchmarking --no-run
+
       - name: Run tests (no-std)
         run: cargo test --no-default-features
 

benches/codec_benchmark.rs

@@ -78,7 +78,7 @@ fn criterion_benchmark(c: &mut Criterion) {
         Benchmark::new("", move |b| {
             b.iter(|| {
                 let config = ObjectTransmissionInformation::new(0, symbol_size, 0, 1, 1);
-                let encoder = SourceBlockEncoder::new2(1, &config, &encode_data);
+                let encoder = SourceBlockEncoder::new(1, &config, &encode_data);
                 return encoder.source_packets();
             })
         })
@@ -91,8 +91,8 @@ fn criterion_benchmark(c: &mut Criterion) {
         Benchmark::new("", move |b| {
             b.iter(|| {
                 let config = ObjectTransmissionInformation::new(0, symbol_size, 0, 1, 1);
-                let encoder = SourceBlockEncoder::new2(1, &config, &roundtrip_data);
-                let mut decoder = SourceBlockDecoder::new2(1, &config, elements as u64);
+                let encoder = SourceBlockEncoder::new(1, &config, &roundtrip_data);
+                let mut decoder = SourceBlockDecoder::new(1, &config, elements as u64);
                 return decoder.decode(encoder.source_packets());
             })
         })
@@ -105,9 +105,9 @@ fn criterion_benchmark(c: &mut Criterion) {
         Benchmark::new("", move |b| {
             b.iter(|| {
                 let config = ObjectTransmissionInformation::new(0, symbol_size, 0, 1, 1);
-                let encoder = SourceBlockEncoder::new2(1, &config, &repair_data);
+                let encoder = SourceBlockEncoder::new(1, &config, &repair_data);
                 let repair_packets = (elements / symbol_size as usize) as u32;
-                let mut decoder = SourceBlockDecoder::new2(1, &config, elements as u64);
+                let mut decoder = SourceBlockDecoder::new(1, &config, elements as u64);
                 return decoder.decode(encoder.repair_packets(0, repair_packets));
             })
         })

benches/decode_benchmark.rs

@@ -22,12 +22,12 @@ fn benchmark(symbol_size: u16, overhead: f64) -> u64 {
 
         let iterations = TARGET_TOTAL_BYTES / elements;
         let config = ObjectTransmissionInformation::new(0, symbol_size, 0, 1, 1);
-        let encoder = SourceBlockEncoder::new2(1, &config, &data);
+        let encoder = SourceBlockEncoder::new(1, &config, &data);
         let elements_and_overhead = (symbol_count as f64 * (1.0 + overhead)) as u32;
         let mut packets = encoder.repair_packets(0, iterations as u32 * elements_and_overhead);
         let now = Instant::now();
         for _ in 0..iterations {
-            let mut decoder = SourceBlockDecoder::new2(1, &config, elements as u64);
+            let mut decoder = SourceBlockDecoder::new(1, &config, elements as u64);
             let start = packets.len() - elements_and_overhead as usize;
             if let Some(result) = decoder.decode(packets.drain(start..)) {
                 black_box_value += result[0] as u64;

benches/encode_benchmark.rs

@@ -31,9 +31,9 @@ fn benchmark(symbol_size: u16, pre_plan: bool) -> u64 {
         let config = ObjectTransmissionInformation::new(0, symbol_size, 0, 1, 1);
         for _ in 0..iterations {
             let encoder = if let Some(ref plan) = plan {
-                SourceBlockEncoder::with_encoding_plan2(1, &config, &data, plan)
+                SourceBlockEncoder::with_encoding_plan(1, &config, &data, plan)
             } else {
-                SourceBlockEncoder::new2(1, &config, &data)
+                SourceBlockEncoder::new(1, &config, &data)
             };
             let packets = encoder.repair_packets(0, 1);
             black_box_value += packets[0].data()[0] as u64;

rust-toolchain

@@ -1 +1 @@
-1.65
+1.66

src/octets.rs

@@ -135,9 +135,8 @@ pub fn fused_addassign_mul_scalar_binary(
     }
 }
 
-#[cfg(target_arch = "aarch64")]
 // TODO: enable when stable
-// #[cfg(any(target_arch = "arm", target_arch = "aarch64"))]
+#[cfg(all(any(target_arch = "arm", target_arch = "aarch64"), feature = "std"))]
 // #[target_feature(enable = "neon")]
 unsafe fn fused_addassign_mul_scalar_binary_neon(
     octets: &mut [u8],
@@ -290,9 +289,8 @@ fn mulassign_scalar_fallback(octets: &mut [u8], scalar: &Octet) {
     }
 }
 
-#[cfg(target_arch = "aarch64")]
 // TODO: enable when stable
-// #[cfg(any(target_arch = "arm", target_arch = "aarch64"))]
+#[cfg(all(any(target_arch = "arm", target_arch = "aarch64"), feature = "std"))]
 // #[target_feature(enable = "neon")]
 unsafe fn mulassign_scalar_neon(octets: &mut [u8], scalar: &Octet) {
     #[cfg(target_arch = "aarch64")]
@@ -458,9 +456,8 @@ fn fused_addassign_mul_scalar_fallback(octets: &mut [u8], other: &[u8], scalar:
     }
 }
 
-#[cfg(target_arch = "aarch64")]
 // TODO: enable when stable
-// #[cfg(any(target_arch = "arm", target_arch = "aarch64"))]
+#[cfg(all(any(target_arch = "arm", target_arch = "aarch64"), feature = "std"))]
 // #[target_feature(enable = "neon")]
 unsafe fn fused_addassign_mul_scalar_neon(octets: &mut [u8], other: &[u8], scalar: &Octet) {
     #[cfg(target_arch = "aarch64")]
@@ -671,15 +668,14 @@ fn add_assign_fallback(octets: &mut [u8], other: &[u8]) {
     }
 }
 
-#[cfg(target_arch = "aarch64")]
+#[cfg(all(target_arch = "aarch64", feature = "std"))]
 use std::arch::aarch64::uint8x16_t;
 // TODO: enable when stable
 // #[cfg(target_arch = "arm")]
 // use std::arch::arm::uint8x16_t;
 
-#[cfg(target_arch = "aarch64")]
 // TODO: enable when stable
-// #[cfg(any(target_arch = "arm", target_arch = "aarch64"))]
+#[cfg(all(any(target_arch = "arm", target_arch = "aarch64"), feature = "std"))]
 // #[target_feature(enable = "neon")]
 unsafe fn store_neon(ptr: *mut uint8x16_t, value: uint8x16_t) {
     #[cfg(target_arch = "aarch64")]
@@ -695,9 +691,8 @@ unsafe fn store_neon(ptr: *mut uint8x16_t, value: uint8x16_t) {
         .write_unaligned(vgetq_lane_u64(reinterp, 1));
 }
 
-#[cfg(all(target_arch = "aarch64", feature = "std"))]
 // TODO: enable when stable
-// #[cfg(any(target_arch = "arm", target_arch = "aarch64"))]
+#[cfg(all(any(target_arch = "arm", target_arch = "aarch64"), feature = "std"))]
 // #[target_feature(enable = "neon")]
 unsafe fn add_assign_neon(octets: &mut [u8], other: &[u8]) {
     #[cfg(target_arch = "aarch64")]