Let's benchmark malloc
[WebKit-https.git] / PerformanceTests / MallocBench / MallocBench / Benchmark.cpp
1 /*
2  * Copyright (C) 2014 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #include "Benchmark.h"
27 #include "CPUCount.h"
28 #include "balloon.h"
29 #include "big.h"
30 #include "churn.h"
31 #include "facebook.h"
32 #include "fragment.h"
33 #include "list.h"
34 #include "medium.h"
35 #include "message.h"
36 #include "tree.h"
37 #include <dispatch/dispatch.h>
38 #include <iostream>
39 #include <mach/mach.h>
40 #include <mach/task_info.h>
41 #include <map>
42 #include <string>
43 #include <sys/time.h>
44 #include <thread>
45 #include <unistd.h>
46
47 #include "mbmalloc.h"
48
49 using namespace std;
50
51 struct BenchmarkPair {
52     const char* const name;
53     const BenchmarkFunction function;
54 };
55
56 static const BenchmarkPair benchmarkPairs[] = {
57     { "churn", benchmark_churn },
58     { "list_allocate", benchmark_list_allocate },
59     { "list_traverse", benchmark_list_traverse },
60     { "tree_allocate", benchmark_tree_allocate },
61     { "tree_traverse", benchmark_tree_traverse },
62     { "tree_churn", benchmark_tree_churn },
63     { "fragment", benchmark_fragment },
64     { "fragment_iterate", benchmark_fragment_iterate },
65     { "message_one", benchmark_message_one },
66     { "message_many", benchmark_message_many },
67     { "medium", benchmark_medium },
68     { "big", benchmark_big },
69     { "facebook", benchmark_facebook },
70     { "balloon", benchmark_balloon },
71 };
72
73 static const size_t benchmarksPairsCount = sizeof(benchmarkPairs) / sizeof(BenchmarkPair);
74
75 static inline bool operator==(const BenchmarkPair& benchmarkPair, const string& string)
76 {
77     return string == benchmarkPair.name;
78 }
79
80 static void*** allocateHeap(size_t heapSize, size_t chunkSize, size_t objectSize)
81 {
82     if (!heapSize)
83         return 0;
84
85     size_t chunkCount = heapSize / chunkSize;
86     size_t objectCount = chunkSize / objectSize;
87     void*** chunks = (void***)mbmalloc(chunkCount * sizeof(void**));
88     for (size_t i = 0; i < chunkCount; ++i) {
89         chunks[i] = (void**)mbmalloc(objectCount * sizeof(void*));
90         for (size_t j = 0; j < objectCount; ++j) {
91             chunks[i][j] = (void*)mbmalloc(objectSize);
92             bzero(chunks[i][j], objectSize);
93         }
94     }
95     return chunks;
96 }
97
98 static void deallocateHeap(void*** chunks, size_t heapSize, size_t chunkSize, size_t objectSize)
99 {
100     if (!heapSize)
101         return;
102
103     size_t chunkCount = heapSize / chunkSize;
104     size_t objectCount = chunkSize / objectSize;
105     for (size_t i = 0; i < chunkCount; ++i) {
106         for (size_t j = 0; j < objectCount; ++j)
107             mbfree(chunks[i][j], objectSize);
108         mbfree(chunks[i], objectCount * sizeof(void*));
109     }
110     mbfree(chunks, chunkCount * sizeof(void**));
111 }
112
113 Benchmark::Benchmark(const string& benchmarkName, bool isParallel, bool measureHeap, size_t heapSize)
114     : m_benchmarkPair()
115     , m_elapsedTime()
116     , m_isParallel(isParallel)
117     , m_heapSize(heapSize)
118     , m_measureHeap(measureHeap)
119 {
120     const BenchmarkPair* benchmarkPair = std::find(
121         benchmarkPairs, benchmarkPairs + benchmarksPairsCount, benchmarkName);
122     if (benchmarkPair == benchmarkPairs + benchmarksPairsCount)
123         return;
124     
125     m_benchmarkPair = benchmarkPair;
126 }
127     
128 void Benchmark::printBenchmarks()
129 {
130     cout << "Benchmarks: " << endl;
131     for (size_t i = 0; i < benchmarksPairsCount; ++i)
132         cout << "\t" << benchmarkPairs[i].name << endl;
133 }
134
135 void Benchmark::runOnce()
136 {
137     if (!m_isParallel) {
138         m_benchmarkPair->function(m_isParallel);
139         return;
140     }
141
142     dispatch_group_t group = dispatch_group_create();
143
144     for (size_t i = 0; i < cpuCount(); ++i) {
145         dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
146             m_benchmarkPair->function(m_isParallel);
147         });
148     }
149
150     dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
151
152     dispatch_release(group);
153 }
154
155 void Benchmark::run()
156 {
157     static const size_t count = 4;
158     static const size_t objectSize = 32;
159     static const size_t chunkSize = 1024 * 1024;
160     
161     void*** heap = allocateHeap(m_heapSize, chunkSize, objectSize);
162
163     runOnce(); // Warmup run.
164
165     for (size_t i = 0; i < count; ++i) {
166         double start = currentTimeMS();
167         runOnce();
168         double end = currentTimeMS();
169         double elapsed = end - start;
170         m_elapsedTime += elapsed;
171     }
172     m_elapsedTime /= count;
173
174     deallocateHeap(heap, m_heapSize, chunkSize, objectSize);
175     
176     if (!m_measureHeap)
177         return;
178
179     // Wait a bit for any async freeing to finish.
180     size_t last;
181     do {
182         last = currentMemoryBytes().resident;
183         std::this_thread::sleep_for(std::chrono::seconds(2));
184     } while (currentMemoryBytes().resident < last);
185
186     m_memory = currentMemoryBytes();
187 }
188
189 void Benchmark::printReport()
190 {
191     size_t kB = 1024;
192
193     cout << "Time:       \t" << m_elapsedTime << "ms" << endl;
194     if (!m_measureHeap)
195         return;
196
197     cout << "Memory:     \t" << m_memory.resident / kB << "kB" << endl;
198     cout << "Peak Memory:\t" << m_memory.residentMax / kB << "kB" << endl;
199 }
200
201 double Benchmark::currentTimeMS()
202 {
203     struct timeval now;
204     gettimeofday(&now, 0);
205     return (now.tv_sec * 1000.0) + now.tv_usec / 1000.0;
206 }
207
208 Benchmark::Memory Benchmark::currentMemoryBytes()
209 {
210     Memory memory;
211
212     task_vm_info_data_t vm_info;
213     mach_msg_type_number_t vm_size = TASK_VM_INFO_COUNT;
214     if (KERN_SUCCESS != task_info(mach_task_self(), TASK_VM_INFO_PURGEABLE, (task_info_t)(&vm_info), &vm_size)) {
215         cout << "Failed to get mach task info" << endl;
216         exit(1);
217     }
218
219     memory.resident = vm_info.internal - vm_info.purgeable_volatile_pmap;
220     memory.residentMax = vm_info.resident_size_peak;
221     return memory;
222 }