minimalloc/BenchMark.cpp at main · ruijayfeng/minimalloc · 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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
#include "ConcurrentAlloc.h"
#include <vector>
#include <thread>
#include <atomic>
#include <cstdio>
#include <iostream>

using std::cout;
using std::endl;

// ntimes: number of alloc/free operations per thread
// rounds: number of test rounds
void BenchmarkMalloc(size_t ntimes, size_t nworks, size_t rounds)
{
	std::vector<std::thread> vthread(nworks);
	std::atomic<size_t> malloc_costtime = 0;
	std::atomic<size_t> free_costtime = 0;

	for (size_t k = 0; k < nworks; ++k)
	{
		vthread[k] = std::thread([&, k]() {
			std::vector<void*> v;
			v.reserve(ntimes);

			for (size_t j = 0; j < rounds; ++j)
			{
				size_t begin1 = clock();
				for (size_t i = 0; i < ntimes; i++)
				{
					//v.push_back(malloc(16));
					v.push_back(malloc((16 + i) % 8192 + 1));
				}
				size_t end1 = clock();

				size_t begin2 = clock();
				for (size_t i = 0; i < ntimes; i++)
				{
					free(v[i]);
				}
				size_t end2 = clock();
				v.clear();

				malloc_costtime += (end1 - begin1);
				free_costtime += (end2 - begin2);
			}
			});
	}

	for (auto& t : vthread)
	{
		t.join();
	}

	printf("%zu threads, %zu rounds, malloc %zu objects per round: cost %zu ms\n",
		nworks, rounds, ntimes, (size_t)malloc_costtime);

	printf("%zu threads, %zu rounds, free %zu objects per round: cost %zu ms\n",
		nworks, rounds, ntimes, (size_t)free_costtime);

	printf("%zu threads malloc&free %zu times, total cost: %zu ms\n",
		nworks, nworks * rounds * ntimes, (size_t)malloc_costtime + (size_t)free_costtime);
}


// Test concurrent malloc/free with multiple threads and rounds
void BenchmarkConcurrentMalloc(size_t ntimes, size_t nworks, size_t rounds)
{
	std::vector<std::thread> vthread(nworks);
	std::atomic<size_t> malloc_costtime = 0;
	std::atomic<size_t> free_costtime = 0;

	for (size_t k = 0; k < nworks; ++k)
	{
		vthread[k] = std::thread([&]() {
			std::vector<void*> v;
			v.reserve(ntimes);

			for (size_t j = 0; j < rounds; ++j)
			{
				size_t begin1 = clock();
				for (size_t i = 0; i < ntimes; i++)
				{
					//v.push_back(ConcurrentAlloc(16));
					v.push_back(ConcurrentAlloc((16 + i) % 8192 + 1));
				}
				size_t end1 = clock();

				size_t begin2 = clock();
				for (size_t i = 0; i < ntimes; i++)
				{
					ConcurrentFree(v[i]);
				}
				size_t end2 = clock();
				v.clear();

				malloc_costtime += (end1 - begin1);
				free_costtime += (end2 - begin2);
			}
			});
	}

	for (auto& t : vthread)
	{
		t.join();
	}

	printf("%zu threads, %zu rounds, concurrent alloc %zu objects per round: cost %zu ms\n",
		nworks, rounds, ntimes, (size_t)malloc_costtime);

	printf("%zu threads, %zu rounds, concurrent dealloc %zu objects per round: cost %zu ms\n",
		nworks, rounds, ntimes, (size_t)free_costtime);

	printf("%zu threads concurrent alloc&dealloc %zu times, total cost: %zu ms\n",
		nworks, nworks * rounds * ntimes, (size_t)malloc_costtime + (size_t)free_costtime);
}

int main()
{
	size_t n = 10000;
	cout << "========== Concurrent Memory Pool Test ==========" << endl;
	BenchmarkConcurrentMalloc(n, 4, 10);
	cout << endl;

	cout << "========== System malloc Test ==========" << endl;
	BenchmarkMalloc(n, 4, 10);
	cout << "==========================================" << endl;

	return 0;
}