add sam to ram conversion benchmark

Signed-off-by: AdityaPandeyCN <[email protected]>

Author: AdityaPandeyCN

benchmark/CMakeLists.txt

@@ -1,7 +1,7 @@
 list(APPEND CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake/modules)
 include(GoogleBenchmark)
 
-add_library(sam_generator STATIC
+add_library(sam_generator STATIC 
     generate_sam_benchmark.cxx
 )
 
@@ -10,6 +10,7 @@ target_include_directories(sam_generator PUBLIC
 )
 
 target_link_libraries(sam_generator PRIVATE benchmark::benchmark)
+target_compile_definitions(sam_generator PRIVATE LIBRARY_BUILD)
 add_dependencies(sam_generator benchmark::benchmark)
 
 ROOT_EXECUTABLE(generate_sam_benchmark
@@ -18,13 +19,22 @@ ROOT_EXECUTABLE(generate_sam_benchmark
         benchmark::benchmark
 )
 
-install(TARGETS generate_sam_benchmark
+ROOT_EXECUTABLE(sam_to_ram_benchmark
+    sam_to_ram_benchmark.cxx
+    LIBRARIES
+        benchmark::benchmark
+        ramcore
+        sam_generator
+)
+
+install(TARGETS generate_sam_benchmark sam_to_ram_benchmark
     RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
 )
 
 add_custom_target(benchmark
-    COMMAND generate_sam_benchmark
-    DEPENDS generate_sam_benchmark
+    COMMAND sam_to_ram_benchmark
+    DEPENDS sam_to_ram_benchmark
     WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
-    COMMENT "Running SAM generation benchmarks"
+    COMMENT "Running SAM to RAM conversion benchmark"
 )
+

benchmark/generate_sam_benchmark.cxx

@@ -93,6 +93,7 @@ static void BM_GenerateSAM(benchmark::State& state) {
        num_reads * 200, benchmark::Counter::kIsRate);
 }
 
+#ifndef LIBRARY_BUILD
 int main(int argc, char** argv) {
    for (int i = 1; i < argc; ++i) {
        if (std::string(argv[i]) == "--generate" && i + 1 < argc) {
@@ -115,4 +116,5 @@ int main(int argc, char** argv) {
    ::benchmark::RunSpecifiedBenchmarks();
    return 0;
 }
+#endif
 

benchmark/sam_to_ram_benchmark.cxx

@@ -0,0 +1,73 @@
+#include <benchmark/benchmark.h>
+#include "generate_sam_benchmark.h"
+#include "ramcore/SamToTTree.h"
+#include "ramcore/SamToNTuple.h"
+#include <filesystem>
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+
+static void BM_SamToRamComparison(benchmark::State& state) {
+    int num_reads = state.range(0);
+    
+    std::string sam_file = "benchmark_test.sam";
+    std::string ttree_file = "benchmark_ttree.root";
+    std::string rntuple_file = "benchmark_rntuple.root";
+    
+    GenerateSAMFile(sam_file, num_reads);
+    
+    for (auto _ : state) {
+        
+        FILE* original_stdout = stdout;
+        stdout = fopen("/dev/null", "w");
+        
+        samtoram(sam_file.c_str(), ttree_file.c_str(), 
+                true, true, true, 1, 0);
+        
+        samtoramntuple(sam_file.c_str(), rntuple_file.c_str(), 
+                      true, true, true, 505, 0);
+        
+        fclose(stdout);
+        stdout = original_stdout;
+        
+        if (std::filesystem::exists(ttree_file)) {
+            auto ttree_size = std::filesystem::file_size(ttree_file);
+            state.counters["ttree_size_mb"] = ttree_size / (1024.0 * 1024.0);
+        }
+        
+        if (std::filesystem::exists(rntuple_file)) {
+            auto rntuple_size = std::filesystem::file_size(rntuple_file);
+            state.counters["rntuple_size_mb"] = rntuple_size / (1024.0 * 1024.0);
+        }
+        
+        if (state.counters["ttree_size_mb"] > 0 && state.counters["rntuple_size_mb"] > 0) {
+            state.counters["compression_ratio"] = 
+                state.counters["ttree_size_mb"] / state.counters["rntuple_size_mb"];
+        }
+    }
+    
+    std::remove(sam_file.c_str());
+    std::remove(ttree_file.c_str());
+    std::remove(rntuple_file.c_str());
+    
+    state.counters["reads"] = num_reads;
+    state.counters["reads_per_second"] = benchmark::Counter(
+        num_reads, benchmark::Counter::kIsRate);
+}
+
+int main(int argc, char** argv) {
+    std::cout << "SAM to RAM Conversion Benchmark" << std::endl;
+    std::cout << "Comparing TTree vs RNTuple performance and file sizes" << std::endl;
+    std::cout << std::endl;
+    
+    ::benchmark::RegisterBenchmark("BM_SamToRamComparison", BM_SamToRamComparison)
+        ->Args({1000})    
+        ->Args({10000})   
+        ->Args({100000})  
+        ->Unit(benchmark::kMillisecond);
+    
+    ::benchmark::Initialize(&argc, argv);
+    ::benchmark::RunSpecifiedBenchmarks();
+    return 0;
+} 
+