CppContainerPerformance/test1.cpp at main · akTARDIGRADE13-sandbox/CppContainerPerformance · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
#include <algorithm>
#include <array>
#include <chrono>
#include <cstdlib>
#include <ctime>
#include <iostream>
#include <memory>
#include <numeric>
#include <vector>

const int SIZE = 1000000;
const int COUNT = 1000000;
const int ROOP = 1000;

int Array[SIZE];

std::array<int, SIZE> stdArray = {};
std::vector<int> vectorArray(SIZE);

template <typename T>
void measureTime(T &data, const int *randomAccess,
                 std::vector<long long> &durations) {
    for(int r = 0; r < ROOP; ++r) {
        auto start_time = std::chrono::high_resolution_clock::now();

        for(int i = 0; i < COUNT; ++i) {
            ++data[randomAccess[i]];
        }

        auto end_time = std::chrono::high_resolution_clock::now();
        auto duration = std::chrono::duration_cast<std::chrono::microseconds>(
            end_time - start_time);
        durations.push_back(duration.count());
    }
}

template <typename T> long long calculateAverage(const std::vector<T> &values) {
    return std::accumulate(values.begin(), values.end(), 0) / values.size();
}

template <typename T> T calculateMedian(std::vector<T> &values) {
    std::sort(values.begin(), values.end());
    return values[ROOP / 2];
}

int main() {
    int *dynamicArrayC03 = new int[SIZE];
    std::unique_ptr<int[]> dynamicArrayC11 = std::make_unique<int[]>(SIZE);

    int randomAccess[COUNT];

    srand(static_cast<unsigned>(time(0)));

    // 配列にランダムな値をセット
    for(int i = 0; i < COUNT; ++i) {
        randomAccess[i] = rand() % SIZE; // 0からSIZE未満のランダムな整数
    }

    // データの初期化
    for(int i = 0; i < SIZE; ++i) {
        Array[i] = i;
        stdArray[i] = i;
        dynamicArrayC03[i] = i;
        dynamicArrayC11[i] = i;
        vectorArray[i] = i;
    }

    // 実行時間の計測
    std::vector<long long> durations;

    measureTime(Array, randomAccess, durations);
    std::cout << "array - Average: " << calculateAverage(durations)
              << " microseconds, Median: " << calculateMedian(durations)
              << " microseconds" << std::endl;

    durations.clear();
    measureTime(stdArray, randomAccess, durations);
    std::cout << "std::array - Average: " << calculateAverage(durations)
              << " microseconds, Median: " << calculateMedian(durations)
              << " microseconds" << std::endl;

    durations.clear();
    measureTime(dynamicArrayC03, randomAccess, durations);
    std::cout << "Dynamic Array (C++03) - Average: "
              << calculateAverage(durations)
              << " microseconds, Median: " << calculateMedian(durations)
              << " microseconds" << std::endl;

    durations.clear();
    measureTime(dynamicArrayC11, randomAccess, durations);
    std::cout << "Dynamic Array (C++11) - Average: "
              << calculateAverage(durations)
              << " microseconds, Median: " << calculateMedian(durations)
              << " microseconds" << std::endl;

    durations.clear();
    measureTime(vectorArray, randomAccess, durations);
    std::cout << "Vector - Average: " << calculateAverage(durations)
              << " microseconds, Median: " << calculateMedian(durations)
              << " microseconds" << std::endl;

    // 動的配列のメモリ解放
    delete[] dynamicArrayC03;

    return 0;
}