Final benchmarking + reproducibility hotfix

include/scenarios/testing_order.hpp

@@ -60,7 +60,7 @@ void orderTest(Wrapper &wrapper, TestParams &params) {
     const uint32_t SEED = params.seed;
 
     std::queue<BenchmarkOrder> ordersQueue;
-    MarketState marketState;
+    MarketState marketState(SEED);
 
     CollectionOrderGenerator<BenchmarkOrder> collection = initialiseGeneratorsOrder(marketState, SEED);
     CollectionOrderGenerator<BenchmarkOrder> checkGen = initialiseGeneratorsOrder(marketState, SEED);
@@ -137,7 +137,7 @@ void orderTest(Wrapper &wrapper, TestParams &params) {
 
     wrapper.setOrderingVectors(local_timestamps, local_sequences);
     // as order generators are seeded, this will provide the exact same sequence of transactions to compare to
-    MarketState resetMarketstate;
+    MarketState resetMarketstate(SEED);
     CollectionOrderGenerator<BenchmarkOrder> resetGen = initialiseGeneratorsOrder(resetMarketstate, SEED);
 
     wrapper.processOrders(resetGen, resetMarketstate);

include/scenarios/testing_stress.hpp

@@ -51,7 +51,7 @@ void stressTest(Wrapper &wrapper, TestParams &params) {
     constexpr uint32_t WARMUP_ITERS = 5000;
 
     // market state thread
-    MarketState market_state;
+    MarketState market_state(SEED);
 
     // after cache warming, before warmup
     std::barrier warmup_start_barrier(TOTAL_THREADS);

src/benchmarking/python/benchmarking.sh

@@ -0,0 +1,52 @@
+#!/bin/bash
+
+run_ids=(
+    247032233224988
+    56502966111114
+    3586646414650
+    23213220986522
+    2095708430036
+    31913207166398
+    125032875711109
+    86972557116193
+    195072831411615
+    1684693328270
+    188632348215649
+    161882930632650
+    15317916011406
+    23540479613096
+    23862818925384
+    19752146230649
+    255021671122094
+    61562523130533
+    252452185011814
+    13118151156816
+    28331494624045
+    23238334714007
+    3672643818007
+    26336785722719
+    28198535412235
+    3860976523193
+    25552342112972
+    294172243923442
+    6056946912605
+    33272016727444
+    31475878525777
+    18514322407408
+    59781853921741
+    27832644112278
+    15012729631156
+    20777140099901
+    4343161954803
+    12781522712346
+    11758632910
+    473679451609
+    79021574127703
+)
+
+for id in "${run_ids[@]}"; do
+  echo "Running report for run-id: $id"
+  pixi run report --run-id="$id"
+done
+
+echo "Finished benchmarking!"

src/main.cpp

@@ -51,15 +51,38 @@ int main(int argc, char* argv[]) {
         static_cast<size_t>(100000),  // minimum safe capacity
         params.total_orders * params.thread_count * 2  // scale with workload
     );
-
-    // WiltMPMCBlockRing<BenchmarkOrder> ring(ring_capacity);
-    // WiltMPMCNonBlockRing<BenchmarkOrder> ring(ring_capacity);
-    // MCConcurrentQueue<BenchmarkOrder> queue;
-    RigtorpMPMCQueue<BenchmarkOrder> queue(ring_capacity);
 
-    BenchmarkWrapper<RigtorpMPMCQueue<BenchmarkOrder>, BenchmarkOrder> wrapper(queue, params);
+    // REGULAR QUEUE BENCHMARKING
+    RegularQueue<BenchmarkOrder> queue;
+    BenchmarkWrapper<RegularQueue<BenchmarkOrder>, BenchmarkOrder> wrapper(queue, params);
+    std::cout << "REGULARRRRRRRRRRRR" << std::endl;
+
+    // MCMPMC
+    // MCConcurrentQueue<BenchmarkOrder> queue;
     // BenchmarkWrapper<MCConcurrentQueue<BenchmarkOrder>, BenchmarkOrder> wrapper(queue, params);
+    // std::cout << "mpmceeeeeeeeeeee" << std::endl;
+
+    // MC Readerwriter
+    // MCLockFreeQueue<BenchmarkOrder> queue;
+    // BenchmarkWrapper<MCLockFreeQueue<BenchmarkOrder>, BenchmarkOrder> wrapper(queue, params);
+    // std::cout << "Should be the reader writer???" << std::endl;
+    // std::cout << "readerwriterrrrrrrrrrrr" << std::endl;
+
+
+    // Wilt Blocking
+    // WiltMPMCBlockRing<BenchmarkOrder> ring(ring_capacity);
+    // BenchmarkWrapper<WiltMPMCBlockRing<BenchmarkOrder>, BenchmarkOrder> wrapper(ring, params);
+    // std::cout << "blokdkkskskskks" << std::endl;
+
+    // Wilt Non-blocking
+    // WiltMPMCNonBlockRing<BenchmarkOrder> ring(ring_capacity);
     // BenchmarkWrapper<WiltMPMCNonBlockRing<BenchmarkOrder>, BenchmarkOrder> wrapper(ring, params);
+    // std::cout << "non blockkkkkkkkkkkkkkk" << std::endl;
+
+    // Rigtorp MPMC
+    // RigtorpMPMCQueue<BenchmarkOrder> queue(ring_capacity);
+    // BenchmarkWrapper<RigtorpMPMCQueue<BenchmarkOrder>, BenchmarkOrder> wrapper(queue, params);
+    // std::cout << "rigyyyyyyyyyyyyyyyyyy" << std::endl;
 
     switch (params.test){
         case TestType::STRESS: stressTest(wrapper, params); break;