Add stride implementation for the node class.

[drslebedev]

Few details on implementation:

1. If stride == 0 then it is not used and n_samples_to_consume == n_samples_to_process.
2. If stride != 0 and stride < in_available_samples then n_samples_to_consume == stride.
3. If stride != 0 and stride > in_available_samples then samples are consumed till stride_consumed_counter == stride.

Depending on the parameters like numerator, denominator and available samples. n_samples_to_process can change for each work function execution, but stride is always the same. It can lead to different sample rates over time. In many cases this is normal behavior. If it is not the case then it is user responsibility to set proper parameters .

It also can happen that n_required_samples >= stride but actual n_samples_to_process < stride because of input-output port limitations, interpolation, decimation requirements etc. This is the user responsibility to set block parameters according to the needs.

Performance tests

stride

┌──────────────────────────────benchmark:───────────────────────────────┬──────┬─#N──┬─CTX-SW─┬───CPU cache misses────┬───CPU branch misses───┬─<CPU-I>─┬──min───┬──mean──┬─stddev─┬─median─┬──max───┬─total time─┬─ops/s─┐
│ merged src->sink work                                                 │ PASS │ 10  │     0  │ 2.22k / 3.86k = 57.4% │   390  / 212k =  0.2% │   10.4  │  17 us │  19 us │   1 us │  18 us │  21 us │     185 us │  552M │
│ merged src->copy->sink                                                │ PASS │ 10  │     0  │  649  / 1.33k = 48.8% │  199  / 11.4k =  1.8% │    1.1  │   4 us │   5 us │ 489 ns │   5 us │   6 us │      46 us │  2.2G │
│ merged src->copy->sink work                                           │ PASS │ 10  │     0  │   272  / 817  = 33.3% │   150  / 210k =  0.1% │   10.3  │  11 us │  12 us │ 388 ns │  12 us │  12 us │     117 us │  876M │
│ merged src->copy^10->sink                                             │ PASS │ 10  │     0  │  684  / 1.37k = 50.1% │   231  / 110k =  0.2% │    7.7  │  10 us │  11 us │ 433 ns │  11 us │  12 us │     109 us │  941M │
│ merged src(N=1024)->b1(N≤128)->b2(N=1024)->b3(N=32...128)->sink       │ PASS │ 10  │     0  │  715  / 1.41k = 50.7% │  205  / 11.3k =  1.8% │    1.1  │   4 us │   5 us │ 434 ns │   5 us │   5 us │      46 us │  2.2G │
│ merged src->mult(2.0)->divide(2.0)->add(-1)->sink - float             │ PASS │ 10  │     0  │  660  / 1.46k = 45.4% │   217  / 111k =  0.2% │   10.7  │  11 us │  12 us │ 451 ns │  12 us │  13 us │     120 us │  852M │
│ merged src->mult(2.0)->divide(2.0)->add(-1)->sink - int               │ PASS │ 10  │     0  │  650  / 1.31k = 49.6% │   220  / 110k =  0.2% │   11.7  │  16 us │  17 us │ 502 ns │  17 us │  18 us │     169 us │  604M │
│ merged src->(mult(2.0)->div(2.0)->add(-1))^10->sink - float           │ PASS │ 10  │     0  │  706  / 1.36k = 52.0% │  3.39k / 114k =  3.0% │   38.7  │ 104 us │ 118 us │  21 us │ 109 us │ 177 us │       1 ms │ 87.0M │
│ merged src->(mult(2.0)->div(2.0)->add(-1))^10->sink - int             │ PASS │ 10  │     0  │  818  / 1.60k = 51.2% │  3.39k / 114k =  3.0% │   48.8  │ 156 us │ 169 us │  31 us │ 161 us │ 260 us │       2 ms │ 60.6M │
│ runtime   src->sink overhead                                          │ PASS │ 10  │     0  │  13.5k / 179k =  7.5% │  2.58k / 435k =  0.6% │   21.6  │  12 us │  50 us │ 109 us │  13 us │ 378 us │     497 us │  206M │
│ runtime   src->copy->sink                                             │ PASS │ 10  │     0  │  30.5k / 354k =  8.6% │  4.09k / 734k =  0.6% │   34.2  │  13 us │  70 us │ 168 us │  14 us │ 575 us │     704 us │  145M │
│ runtime   src->copy^10->sink                                          │ PASS │ 10  │     0  │  119k / 1.92M =  6.2% │ 18.4k / 3.47M =  0.5% │    150  │  27 us │ 345 us │ 935 us │  35 us │   3 ms │       3 ms │ 29.7M │
│ runtime   src(N=1024)->b1(N≤128)->b2(N=1024)->b3(N=32...128)->sink    │ PASS │ 10  │     0  │  41.3k / 670k =  6.2% │ 6.67k / 1.43M =  0.5% │   65.6  │  21 us │ 157 us │ 382 us │  32 us │   1 ms │       2 ms │ 65.3M │
│ runtime   src->mult(2.0)->div(2.0)->add(-1)->sink - float             │ PASS │ 10  │     0  │  52.1k / 716k =  7.3% │ 7.79k / 1.37M =  0.6% │   61.6  │  14 us │ 130 us │ 339 us │  18 us │   1 ms │       1 ms │ 78.6M │
│ runtime   src->mult(2.0)->div(2.0)->add(-1)->sink - int               │ PASS │ 10  │     0  │  43.2k / 719k =  6.0% │ 7.88k / 1.37M =  0.6% │   62.6  │  17 us │ 134 us │ 344 us │  19 us │   1 ms │       1 ms │ 76.4M │
│ runtime   src->(mult(2.0)->div(2.0)->add(-1))^10->sink - float        │ PASS │ 10  │     0  │  372k / 5.77M =  6.4% │ 49.5k / 10.1M =  0.5% │    443  │ 139 us │   1 ms │   3 ms │ 149 us │  11 ms │      12 ms │  8.4M │
│ runtime   src->(mult(2.0)->div(2.0)->add(-1))^10->sink - int          │ PASS │ 10  │     0  │  323k / 5.64M =  5.7% │ 47.3k / 10.0M =  0.5% │    451  │ 132 us │   1 ms │   3 ms │ 137 us │   9 ms │      10 ms │ 10.2M │
│ runtime   src->mult(2.0)->mult(0.5)->add(-1)->sink (SIMD)             │ PASS │ 10  │     0  │  37.2k / 701k =  5.3% │ 7.20k / 1.36M =  0.5% │   60.2  │  13 us │ 130 us │ 344 us │  16 us │   1 ms │       1 ms │ 78.7M │
│ runtime   src->(mult(2.0)->mult(0.5)->add(-1))^10->sink (SIMD)        │ PASS │ 10  │     0  │  260k / 5.39M =  4.8% │ 47.0k / 9.80M =  0.5% │    412  │  79 us │ 918 us │   3 ms │  85 us │   8 ms │       9 ms │ 11.2M │
│ runtime   src->mult(2.0)->div(2.0)->add(-1)->sink - float single      │ PASS │ 10  │   115  │  907k / 5.88M = 15.4% │  184k / 10.5M =  1.7% │    544  │   2 ms │   3 ms │   1 ms │   2 ms │   6 ms │      26 ms │  4.0M │
│ runtime   src->mult(2.0)->div(2.0)->add(-1)->sink - int single        │ PASS │ 10  │    94  │  893k / 5.83M = 15.3% │  184k / 10.4M =  1.8% │    539  │   2 ms │   4 ms │   4 ms │   2 ms │  14 ms │      39 ms │  2.6M │
│ runtime   src->mult(2.0)->div(2.0)->add(-1)->sink - float bulk        │ PASS │ 10  │     0  │  47.4k / 723k =  6.5% │ 7.74k / 1.40M =  0.6% │   62.1  │  16 us │ 172 us │ 462 us │  19 us │   2 ms │       2 ms │ 59.4M │
│ runtime   src->mult(2.0)->div(2.0)->add(-1)->sink - int bulk          │ PASS │ 10  │     0  │  40.3k / 719k =  5.6% │ 7.26k / 1.48M =  0.5% │   68.2  │  32 us │ 153 us │ 353 us │  35 us │   1 ms │       2 ms │ 67.1M │
└───────────────────────────────────────────────────────────────────────┴──────┴─────┴────────┴───────────────────────┴───────────────────────┴─────────┴────────┴────────┴────────┴────────┴────────┴────────────┴───────┘

main

┌──────────────────────────────benchmark:───────────────────────────────┬──────┬─#N──┬─CTX-SW─┬───CPU cache misses────┬───CPU branch misses───┬─<CPU-I>─┬──min───┬──mean──┬─stddev─┬─median─┬──max───┬─total time─┬─ops/s─┐
│ merged src->sink work                                                 │ PASS │ 10  │     0  │ 2.00k / 3.68k = 54.2% │   388  / 212k =  0.2% │   10.4  │  23 us │  24 us │ 734 ns │  24 us │  25 us │     240 us │  426M │
│ merged src->copy->sink                                                │ PASS │ 10  │     0  │  646  / 1.36k = 47.7% │  200  / 11.1k =  1.8% │    1.1  │   4 us │   5 us │ 581 ns │   5 us │   5 us │      46 us │  2.2G │
│ merged src->copy->sink work                                           │ PASS │ 10  │     0  │   273  / 778  = 35.1% │   140  / 210k =  0.1% │   10.3  │  10 us │  12 us │ 792 ns │  12 us │  14 us │     118 us │  870M │
│ merged src->copy^10->sink                                             │ PASS │ 10  │     0  │  668  / 1.39k = 48.1% │   219  / 110k =  0.2% │    7.7  │  10 us │  11 us │ 511 ns │  11 us │  12 us │     111 us │  925M │
│ merged src(N=1024)->b1(N≤128)->b2(N=1024)->b3(N=32...128)->sink       │ PASS │ 10  │     0  │  683  / 1.37k = 50.0% │  195  / 11.0k =  1.8% │    1.1  │   4 us │   5 us │ 461 ns │   5 us │   5 us │      46 us │  2.2G │
│ merged src->mult(2.0)->divide(2.0)->add(-1)->sink - float             │ PASS │ 10  │     0  │  648  / 1.26k = 51.3% │   226  / 110k =  0.2% │   10.7  │  11 us │  12 us │ 459 ns │  12 us │  13 us │     121 us │  848M │
│ merged src->mult(2.0)->divide(2.0)->add(-1)->sink - int               │ PASS │ 10  │     0  │  676  / 1.37k = 49.4% │   217  / 110k =  0.2% │   11.7  │  16 us │  17 us │ 278 ns │  17 us │  17 us │     168 us │  610M │
│ merged src->(mult(2.0)->div(2.0)->add(-1))^10->sink - float           │ PASS │ 10  │     0  │  738  / 1.41k = 52.2% │  3.40k / 114k =  3.0% │   38.8  │ 107 us │ 136 us │  50 us │ 108 us │ 235 us │       1 ms │ 75.1M │
│ merged src->(mult(2.0)->div(2.0)->add(-1))^10->sink - int             │ PASS │ 10  │     0  │  709  / 1.44k = 49.2% │  3.40k / 113k =  3.0% │   48.7  │ 156 us │ 206 us │  75 us │ 161 us │ 349 us │       2 ms │ 49.8M │
│ runtime   src->sink overhead                                          │ PASS │ 10  │     0  │  13.4k / 185k =  7.2% │  2.61k / 434k =  0.6% │   21.5  │  13 us │  49 us │ 101 us │  15 us │ 352 us │     485 us │  211M │
│ runtime   src->copy->sink                                             │ PASS │ 10  │     0  │  29.4k / 360k =  8.2% │  4.12k / 732k =  0.6% │   34.1  │  14 us │  62 us │ 142 us │  15 us │ 486 us │     617 us │  166M │
│ runtime   src->copy^10->sink                                          │ PASS │ 10  │     0  │  118k / 1.91M =  6.2% │ 17.5k / 3.45M =  0.5% │    149  │  29 us │ 334 us │ 899 us │  36 us │   3 ms │       3 ms │ 30.7M │
│ runtime   src(N=1024)->b1(N≤128)->b2(N=1024)->b3(N=32...128)->sink    │ PASS │ 10  │     0  │  47.4k / 687k =  6.9% │ 6.65k / 1.43M =  0.5% │   65.9  │  22 us │ 154 us │ 380 us │  28 us │   1 ms │       2 ms │ 66.4M │
│ runtime   src->mult(2.0)->div(2.0)->add(-1)->sink - float             │ PASS │ 10  │     0  │  43.9k / 724k =  6.1% │ 7.59k / 1.38M =  0.5% │   62.0  │  18 us │ 146 us │ 369 us │  23 us │   1 ms │       1 ms │ 70.2M │
│ runtime   src->mult(2.0)->div(2.0)->add(-1)->sink - int               │ PASS │ 10  │     0  │  57.5k / 732k =  7.9% │ 7.42k / 1.37M =  0.5% │   62.5  │  21 us │ 138 us │ 342 us │  23 us │   1 ms │       1 ms │ 74.4M │
│ runtime   src->(mult(2.0)->div(2.0)->add(-1))^10->sink - float        │ PASS │ 10  │     0  │  308k / 5.62M =  5.5% │ 47.2k / 10.0M =  0.5% │    440  │ 117 us │ 935 us │   2 ms │ 122 us │   8 ms │       9 ms │ 10.9M │
│ runtime   src->(mult(2.0)->div(2.0)->add(-1))^10->sink - int          │ PASS │ 10  │     0  │  306k / 5.64M =  5.4% │ 46.8k / 10.0M =  0.5% │    451  │ 131 us │ 925 us │   2 ms │ 138 us │   8 ms │       9 ms │ 11.1M │
│ runtime   src->mult(2.0)->mult(0.5)->add(-1)->sink (SIMD)             │ PASS │ 10  │     0  │  50.4k / 718k =  7.0% │ 6.92k / 1.37M =  0.5% │   60.5  │  18 us │ 152 us │ 396 us │  21 us │   1 ms │       2 ms │ 67.5M │
│ runtime   src->(mult(2.0)->mult(0.5)->add(-1))^10->sink (SIMD)        │ PASS │ 10  │     0  │  315k / 5.41M =  5.8% │ 46.8k / 9.82M =  0.5% │    413  │  74 us │ 908 us │   2 ms │  78 us │   8 ms │       9 ms │ 11.3M │
│ runtime   src->mult(2.0)->div(2.0)->add(-1)->sink - float single      │ PASS │ 10  │    97  │  870k / 5.85M = 14.9% │  201k / 10.4M =  1.9% │    536  │   2 ms │   3 ms │   2 ms │   2 ms │   9 ms │      30 ms │  3.4M │
│ runtime   src->mult(2.0)->div(2.0)->add(-1)->sink - int single        │ PASS │ 10  │    89  │  888k / 5.84M = 15.2% │  197k / 10.4M =  1.9% │    535  │   2 ms │   5 ms │   5 ms │   4 ms │  20 ms │      52 ms │  2.0M │
│ runtime   src->mult(2.0)->div(2.0)->add(-1)->sink - float bulk        │ PASS │ 10  │     0  │  45.7k / 725k =  6.3% │ 7.71k / 1.39M =  0.6% │   62.0  │  19 us │ 141 us │ 355 us │  22 us │   1 ms │       1 ms │ 72.7M │
│ runtime   src->mult(2.0)->div(2.0)->add(-1)->sink - int bulk          │ PASS │ 10  │     0  │  54.0k / 723k =  7.5% │ 7.74k / 1.49M =  0.5% │   68.3  │  35 us │ 151 us │ 343 us │  36 us │   1 ms │       2 ms │ 67.7M │
└───────────────────────────────────────────────────────────────────────┴──────┴─────┴────────┴───────────────────────┴───────────────────────┴─────────┴────────┴────────┴────────┴────────┴────────┴────────────┴───────┘

[pr-explainer-bot]

Pull Request Review Markdown Doc

Hey there! 👋 Here's a summary of the previous results for the Pull Request review. Let's dive right in!

Changes ✨

1. Changed the type of numerator, denominator, and stride from uint64_t to std::size_t.
2. Added a new member variable stride_counter of type std::size_t.
3. Modified the condition for is_ill_defined in line 614.
4. Added a new condition for is_ill_defined in line 615.
5. Removed the redundant assignment of ratio in line 618.
6. Modified the calculation of in_min_samples in line 622.
7. Added a new block of code for handling stride in lines 708-731.

Suggestions 🤔

1. In line 615, the condition denominator > ports_status.in_max_samples can be simplified to denominator > ports_status.in_max_samples.
2. In line 616, the condition ports_status.in_min_samples * ratio > ports_status.out_max_samples can be simplified to ports_status.in_min_samples > ports_status.out_max_samples / ratio.
3. In line 617, the condition ports_status.in_max_samples * ratio < ports_status.out_min_samples can be simplified to ports_status.in_max_samples < ports_status.out_min_samples / ratio.
4. In line 625, the condition in_min_samples % denominator != 0 can be simplified to in_min_samples % denominator.
5. In line 633, the condition stride.value > stride_counter + ports_status.in_available...

Bugs 🐛

1. Potential bug on line 719 in the include/node.hpp file. The consume_readers function is called with the n_samples_to_consume parameter, but it's unclear where this value is coming from. Make sure it's properly initialized and passed to the function.
2. Potential bug on line 759 in the include/node.hpp file. The consume_readers function is called with the n_samples_to_consume parameter, but it's unclear where this value is coming from. Make sure it's properly initialized and passed to the function.

Improvements 🚀

One place in the code that could be refactored for better readability is in the test/qa_node.cpp file, specifically in the interpolation_decimation_test function. The function calls this function multiple times with different parameters, which leads to repetitive code. It can be refactored by creating a loop or using a data structure to store the test parameters and then iterating over them to call the function. Here's a code snippet to demonstrate the refactoring:

std::vector<TestParams> testParams = {
  { .n_samples{ 1024 }, .numerator{ 1 }, .denominator{ 1 }, .exp_in{ 1024 }, .exp_out{ 1024 }, .exp_counter{ 1 } },
  { .n_samples{ 1024 }, .numerator{ 1 }, .denominator{ 2 }, .exp_in{ 1024 }, .exp_out{ 512 }, .exp_counter{ 1 } },
  // Add more test parameters
};

for (const auto& params : testParams) {
  interpolation_decimation_test(params, thread_pool);
}

Rating ⭐

I cannot rate the code as I am a bot and do not have the capability to evaluate code based on criteria such as readability, performance, and security. It would be best for a human reviewer to assess these aspects of the code.

That's it for the summary! If you have any further questions or need assistance, feel free to ask. Good luck with the Pull Request! 🎉

[sonarcloud]

SonarCloud Quality Gate failed.   

0 Bugs
0 Vulnerabilities
0 Security Hotspots
17 Code Smells

68.3% Coverage
0.0% Duplication

The version of Java (11.0.17) you have used to run this analysis is deprecated and we will stop accepting it soon. Please update to at least Java 17.
Read more here

Catch issues before they fail your Quality Gate with our IDE extension SonarLint

[RalphSteinhagen]

Nice and sweet PR! This does what it advertises is sufficiently tested and documented! Well done 👍!

Thanks for making the additional minor adjustments. This bodes well ...