Memory-Allocator/benchmark.cpp at main · Mog9/Memory-Allocator · 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
#include <iostream>
#include <cstdlib>
#include <time.h>
#include <vector>
#include "allocator.h"

const int ITERATIONS = 1000000;

long benchmark_my(size_t size) {
    struct timespec start, end;
    clock_gettime(CLOCK_MONOTONIC, &start);
    for (int i = 0; i < ITERATIONS; i++) {
        void* ptr = mymalloc(size);
        myfree(ptr);
    }
    clock_gettime(CLOCK_MONOTONIC, &end);
    return (end.tv_sec - start.tv_sec) * 1e9 + (end.tv_nsec - start.tv_nsec);
}

long benchmark_std(size_t size) {
    struct timespec start, end;
    clock_gettime(CLOCK_MONOTONIC, &start);
    for (int i = 0; i < ITERATIONS; i++) {
        void* ptr = malloc(size);
        free(ptr);
    }
    clock_gettime(CLOCK_MONOTONIC, &end);
    return (end.tv_sec - start.tv_sec) * 1e9 + (end.tv_nsec - start.tv_nsec);
}

void print_result(const char* label, long my_ns, long std_ns) {
    std::cout << "\n" << label << "\n";
    std::cout << "mymalloc: " << my_ns / 1e6 << " ms\n";
    std::cout << "malloc: " << std_ns / 1e6 << " ms\n\n";
}

int main() {
    init_pool();
    struct timespec start, end;

    // test 1: single size
    print_result("single size (4 bytes)",
        benchmark_my(sizeof(int)),
        benchmark_std(sizeof(int)));

    // test 2: mixed sizes
    size_t sizes[] = {8, 16, 64, 128, 256, 512};
    long my_ns = 0, std_ns = 0;
    clock_gettime(CLOCK_MONOTONIC, &start);
    for (int i = 0; i < ITERATIONS; i++) {
        size_t s = sizes[i % 6];
        void* ptr = mymalloc(s);
        myfree(ptr);
    }
    clock_gettime(CLOCK_MONOTONIC, &end);
    my_ns = (end.tv_sec - start.tv_sec) * 1e9 + (end.tv_nsec - start.tv_nsec);

    clock_gettime(CLOCK_MONOTONIC, &start);
    for (int i = 0; i < ITERATIONS; i++) {
        size_t s = sizes[i % 6];
        void* ptr = malloc(s);
        free(ptr);
    }
    clock_gettime(CLOCK_MONOTONIC, &end);
    std_ns = (end.tv_sec - start.tv_sec) * 1e9 + (end.tv_nsec - start.tv_nsec);
    print_result("mixed sizes (8-512 bytes)", my_ns, std_ns);

    // test 3: bulk allocate then free
    const int BULK = 1000;
    void* my_ptrs[BULK];
    void* std_ptrs[BULK];

    clock_gettime(CLOCK_MONOTONIC, &start);
    for (int i = 0; i < BULK; i++) my_ptrs[i] = mymalloc(sizeof(int));
    for (int i = 0; i < BULK; i++) myfree(my_ptrs[i]);
    clock_gettime(CLOCK_MONOTONIC, &end);
    my_ns = (end.tv_sec - start.tv_sec) * 1e9 + (end.tv_nsec - start.tv_nsec);

    clock_gettime(CLOCK_MONOTONIC, &start);
    for (int i = 0; i < BULK; i++) std_ptrs[i] = malloc(sizeof(int));
    for (int i = 0; i < BULK; i++) free(std_ptrs[i]);
    clock_gettime(CLOCK_MONOTONIC, &end);
    std_ns = (end.tv_sec - start.tv_sec) * 1e9 + (end.tv_nsec - start.tv_nsec);
    print_result("bulk allocate 1000 then free all", my_ns, std_ns);

    // test 4: random order free
    void* rptrs[BULK];
    clock_gettime(CLOCK_MONOTONIC, &start);
    for (int i = 0; i < BULK; i++) rptrs[i] = mymalloc(sizeof(int));
    for (int i = BULK - 1; i >= 0; i--) myfree(rptrs[i]);
    clock_gettime(CLOCK_MONOTONIC, &end);
    my_ns = (end.tv_sec - start.tv_sec) * 1e9 + (end.tv_nsec - start.tv_nsec);

    void* srptrs[BULK];
    clock_gettime(CLOCK_MONOTONIC, &start);
    for (int i = 0; i < BULK; i++) srptrs[i] = malloc(sizeof(int));
    for (int i = BULK - 1; i >= 0; i--) free(srptrs[i]);
    clock_gettime(CLOCK_MONOTONIC, &end);
    std_ns = (end.tv_sec - start.tv_sec) * 1e9 + (end.tv_nsec - start.tv_nsec);
    print_result("reverse order free", my_ns, std_ns);
}