chunk_benchmark::ChunkBenchmark< T > Class Template Reference

#include <chunk_benchmark.hpp>

Collaboration diagram for chunk_benchmark::ChunkBenchmark< T >:

Public Member Functions
	ChunkBenchmark (const std::vector< T > &data, size_t num_iterations=100)
void	add_strategy (std::shared_ptr< chunk_processing::ChunkStrategy< T > > strategy)
std::vector< BenchmarkResult >	benchmark_chunking ()
void	save_results (const std::string &filename) const

Private Attributes
size_t	iterations
std::vector< std::shared_ptr< chunk_processing::ChunkStrategy< T > > >	strategies
std::vector< T >	test_data

Detailed Description

template<typename T>
class chunk_benchmark::ChunkBenchmark< T >

Definition at line 26 of file chunk_benchmark.hpp.

Constructor & Destructor Documentation

ChunkBenchmark()

template<typename T >

chunk_benchmark::ChunkBenchmark< T >::ChunkBenchmark ( const std::vector< T > &  data, size_t  num_iterations = 100  )

inlineexplicit

Definition at line 33 of file chunk_benchmark.hpp.

        : test_data(data), iterations(num_iterations) {}

Member Function Documentation

add_strategy()

template<typename T >

void chunk_benchmark::ChunkBenchmark< T >::add_strategy ( std::shared_ptr< chunk_processing::ChunkStrategy< T > >  strategy )

inline

Definition at line 36 of file chunk_benchmark.hpp.

                                                                                {
        strategies.push_back(strategy);
    }

References chunk_benchmark::ChunkBenchmark< T >::strategies.

Referenced by run_benchmark().

benchmark_chunking()

template<typename T >

std::vector< BenchmarkResult > chunk_benchmark::ChunkBenchmark< T >::benchmark_chunking ( )

inline

Definition at line 40 of file chunk_benchmark.hpp.

                                                    {
        std::vector<BenchmarkResult> results;
        for (const auto& strategy : strategies) {
            auto start = std::chrono::high_resolution_clock::now();
 
            size_t total_chunks = 0;
            for (size_t i = 0; i < iterations; ++i) {
                auto chunks = strategy->apply(test_data);
                total_chunks += chunks.size();
            }
 
            auto end = std::chrono::high_resolution_clock::now();
            auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
 
            results.push_back({static_cast<double>(duration.count()), sizeof(T) * test_data.size(),
                               total_chunks / iterations, "Strategy"});
        }
        return results;
    }

References chunk_benchmark::ChunkBenchmark< T >::iterations, chunk_benchmark::ChunkBenchmark< T >::strategies, and chunk_benchmark::ChunkBenchmark< T >::test_data.

Referenced by run_benchmark().

save_results()

template<typename T >

void chunk_benchmark::ChunkBenchmark< T >::save_results ( const std::string &  filename ) const

inline

Definition at line 60 of file chunk_benchmark.hpp.

                                                       {
        // Implementation for saving results to file
    }

Member Data Documentation

iterations

template<typename T >

size_t chunk_benchmark::ChunkBenchmark< T >::iterations

private

Definition at line 30 of file chunk_benchmark.hpp.

Referenced by chunk_benchmark::ChunkBenchmark< T >::benchmark_chunking().

strategies

template<typename T >

std::vector<std::shared_ptr<chunk_processing::ChunkStrategy<T> > > chunk_benchmark::ChunkBenchmark< T >::strategies

private

Definition at line 29 of file chunk_benchmark.hpp.

Referenced by chunk_benchmark::ChunkBenchmark< T >::add_strategy(), and chunk_benchmark::ChunkBenchmark< T >::benchmark_chunking().

test_data

template<typename T >

std::vector<T> chunk_benchmark::ChunkBenchmark< T >::test_data

private

Definition at line 28 of file chunk_benchmark.hpp.

Referenced by chunk_benchmark::ChunkBenchmark< T >::benchmark_chunking().

---

The documentation for this class was generated from the following file:

• chunk_benchmark.hpp