Benchmark Program

#include <iostream>
#include <chrono>
#include <vector>
#include <fstream>
#include <string>
#include <map>
#include <iomanip>
#include <cmath>
#include <algorithm>

// Function declarations for all benchmark operations
double integer_benchmark();
double float_benchmark();
double memory_benchmark();
double disk_benchmark_1();
double disk_benchmark_2();

int main() {
    // Initialize program and display welcome messages
    std::cout << "Starting benchmarks..." << std::endl;
    std::cout << "Benchmark results will be displayed here" << std::endl;
    git commit -m "Added program initialization and welcome messages"

    // Create and populate results container with benchmark data
    std::map<std::string, double> results;
    results["Integer Benchmark"] = integer_benchmark();
    results["Floating Point Benchmark"] = float_benchmark();
    results["Memory Benchmark"] = memory_benchmark();
    results["Hard Drive Benchmark 1"] = disk_benchmark_1();
    results["Hard Drive Benchmark 2"] = disk_benchmark_2();
    git commit -m "Implemented benchmark execution and results collection"

    // Format and display benchmark results with extra spacing
    std::cout << "\n\n\nBenchmark Results:" << std::endl;
    std::cout << "----------------------------------------" << std::endl;
    for (const auto& [benchmark, time_taken] : results) {
        std::cout << "\n\n" << benchmark << ": " << std::fixed << std::setprecision(2) << time_taken << " seconds" << std::endl;
        std::cout << "----------------------------------------" << std::endl;
    }
    git commit -m "Added results formatting and display"

    return 0;
}

double integer_benchmark() {
    // Start timing the integer operations
    auto start_time = std::chrono::high_resolution_clock::now();
    git commit -m "Initialized timing for integer benchmark"

    // Perform addition operations (10^10 additions)
    volatile int result = 0;  // Use volatile to prevent optimization
    const int chunk_size = 1000000;  // Process in chunks of 1 million
    for (int chunk = 0; chunk < 10000; chunk++) {  // 10000 chunks × 1 million = 10^10
        for (int i = 0; i < chunk_size; i++) {
            result += 1;
        }
    }
    git commit -m "Implemented integer addition benchmark with chunking"

    // Perform multiplication operations (5 × 10^9 multiplications)
    result = 1;
    for (int chunk = 0; chunk < 5000; chunk++) {  // 5000 chunks × 1 million = 5 × 10^9
        for (int i = 0; i < chunk_size; i++) {
            result *= 2;
        }
    }
    git commit -m "Implemented integer multiplication benchmark with chunking"

    // Perform division operations (2 × 10^9 divisions)
    result = 1 << 30;
    for (int chunk = 0; chunk < 2000; chunk++) {  // 2000 chunks × 1 million = 2 × 10^9
        for (int i = 0; i < chunk_size; i++) {
            result /= 2;
        }
    }
    git commit -m "Implemented integer division benchmark with chunking"

    // Calculate and return execution time
    auto end_time = std::chrono::high_resolution_clock::now();
    return std::chrono::duration<double>(end_time - start_time).count();
    git commit -m "Completed integer benchmark timing calculation"
}

double float_benchmark() {
    // Start timing the floating-point operations
    auto start_time = std::chrono::high_resolution_clock::now();
    git commit -m "Initialized timing for float benchmark"

    // Perform addition operations (10^10 additions)
    volatile double result = 0.0;  // Use volatile to prevent optimization
    const int chunk_size = 1000000;  // Process in chunks of 1 million
    for (int chunk = 0; chunk < 10000; chunk++) {  // 10000 chunks × 1 million = 10^10
        for (int i = 0; i < chunk_size; i++) {
            result += 1.0;
        }
    }
    git commit -m "Implemented float addition benchmark with chunking"

    // Perform multiplication operations (5 × 10^9 multiplications)
    result = 1.0;
    for (int chunk = 0; chunk < 5000; chunk++) {  // 5000 chunks × 1 million = 5 × 10^9
        for (int i = 0; i < chunk_size; i++) {
            result *= 2.0;
        }
    }
    git commit -m "Implemented float multiplication benchmark with chunking"

    // Perform division operations (2 × 10^9 divisions)
    result = std::pow(2.0, 30);
    for (int chunk = 0; chunk < 2000; chunk++) {  // 2000 chunks × 1 million = 2 × 10^9
        for (int i = 0; i < chunk_size; i++) {
            result /= 2.0;
        }
    }
    git commit -m "Implemented float division benchmark with chunking"

    // Calculate and return execution time
    auto end_time = std::chrono::high_resolution_clock::now();
    return std::chrono::duration<double>(end_time - start_time).count();
    git commit -m "Completed float benchmark timing calculation"
}

double memory_benchmark() {
    // Start timing the memory operations
    auto start_time = std::chrono::high_resolution_clock::now();
    git commit -m "Initialized timing for memory benchmark"

    // Initialize array and get pointer for faster access
    const size_t chunk_size = 1000000;  // Process in chunks of 1 million
    const size_t total_size = 5000000000;  // 5 × 10^9 elements
    std::vector<int> arr(chunk_size, 0);
    volatile int32_t* data = arr.data();  // Use volatile to prevent optimization
    git commit -m "Set up memory array and pointer for benchmark"

    // Perform read and write operations in chunks
    for (size_t chunk = 0; chunk < total_size / chunk_size; chunk++) {
        // Read operations
        for (size_t i = 0; i < chunk_size; i++) {
            volatile int temp = data[i];  // Use volatile to prevent optimization
            (void)temp;  // Prevent unused variable warning
        }
        git commit -m "Implemented memory read operations in chunks"

        // Write operations
        for (size_t i = 0; i < chunk_size; i++) {
            data[i] = 1;
        }
    }
    git commit -m "Implemented memory write operations in chunks"

    // Calculate and return execution time
    auto end_time = std::chrono::high_resolution_clock::now();
    return std::chrono::duration<double>(end_time - start_time).count();
    git commit -m "Completed memory benchmark timing calculation"
}

double disk_benchmark_1() {
    // Start timing the disk operations
    auto start_time = std::chrono::high_resolution_clock::now();
    git commit -m "Initialized timing for first disk benchmark"

    // Create and write initial test file (10^9 bytes) in chunks
    std::ofstream outFile("test_file_1.bin", std::ios::binary);
    const size_t chunk_size = 1000000;  // 1MB chunks
    std::vector<char> zeros(chunk_size, '0');
    for (int i = 0; i < 1000; i++) {  // 1000 chunks × 1MB = 1GB
        outFile.write(zeros.data(), zeros.size());
    }
    outFile.close();
    git commit -m "Created initial test file with zeros in chunks"

    // Perform read operations (100 bytes at a time)
    std::ifstream inFile("test_file_1.bin", std::ios::binary);
    std::vector<char> buffer(100);
    while (inFile.read(buffer.data(), 100)) {
        // Skip data processing
    }
    inFile.close();
    git commit -m "Implemented file read operations in 100-byte chunks"

    // Perform write operations (100 bytes at a time)
    outFile.open("test_file_1.bin", std::ios::binary);
    std::vector<char> ones(100, '1');
    for (int i = 0; i < 10000000; i++) {  // 10^9 bytes total
        outFile.write(ones.data(), ones.size());
    }
    outFile.close();
    git commit -m "Implemented file write operations in 100-byte chunks"

    // Clean up and calculate execution time
    std::remove("test_file_1.bin");
    auto end_time = std::chrono::high_resolution_clock::now();
    return std::chrono::duration<double>(end_time - start_time).count();
    git commit -m "Completed first disk benchmark timing calculation"
}

double disk_benchmark_2() {
    // Start timing the disk operations
    auto start_time = std::chrono::high_resolution_clock::now();
    git commit -m "Initialized timing for second disk benchmark"

    // Create and write initial test file (10^9 bytes) in chunks
    std::ofstream outFile("test_file_2.bin", std::ios::binary);
    const size_t chunk_size = 1000000;  // 1MB chunks
    std::vector<char> zeros(chunk_size, '0');
    for (int i = 0; i < 1000; i++) {  // 1000 chunks × 1MB = 1GB
        outFile.write(zeros.data(), zeros.size());
    }
    outFile.close();
    git commit -m "Created initial test file with zeros in chunks"

    // Perform read operations (10000 bytes at a time)
    std::ifstream inFile("test_file_2.bin", std::ios::binary);
    std::vector<char> buffer(10000);
    while (inFile.read(buffer.data(), 10000)) {
        // Skip data processing
    }
    inFile.close();
    git commit -m "Implemented file read operations in 10000-byte chunks"

    // Perform write operations (10000 bytes at a time)
    outFile.open("test_file_2.bin", std::ios::binary);
    std::vector<char> ones(10000, '1');
    for (int i = 0; i < 100000; i++) {  // 10^9 bytes total
        outFile.write(ones.data(), ones.size());
    }
    outFile.close();
    git commit -m "Implemented file write operations in 10000-byte chunks"

    // Clean up and calculate execution time
    std::remove("test_file_2.bin");
    auto end_time = std::chrono::high_resolution_clock::now();
    return std::chrono::duration<double>(end_time - start_time).count();
    git commit -m "Completed second disk benchmark timing calculation"
}