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
|
//===-- bytemap_test.cc -----------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "bytemap.h"
#include "gtest/gtest.h"
#include <string.h>
template <typename T> void testMap(T &Map, scudo::uptr Size) {
Map.init();
for (scudo::uptr I = 0; I < Size; I += 7)
Map.set(I, (I % 100) + 1);
for (scudo::uptr J = 0; J < Size; J++) {
if (J % 7)
EXPECT_EQ(Map[J], 0);
else
EXPECT_EQ(Map[J], (J % 100) + 1);
}
}
TEST(ScudoByteMapTest, FlatByteMap) {
const scudo::uptr Size = 1U << 10;
scudo::FlatByteMap<Size> Map;
testMap(Map, Size);
Map.unmapTestOnly();
}
TEST(ScudoByteMapTest, TwoLevelByteMap) {
const scudo::uptr Size1 = 1U << 6, Size2 = 1U << 12;
scudo::TwoLevelByteMap<Size1, Size2> Map;
testMap(Map, Size1 * Size2);
Map.unmapTestOnly();
}
using TestByteMap = scudo::TwoLevelByteMap<1U << 12, 1U << 13>;
struct TestByteMapParam {
TestByteMap *Map;
scudo::uptr Shard;
scudo::uptr NumberOfShards;
};
void *populateByteMap(void *Param) {
TestByteMapParam *P = reinterpret_cast<TestByteMapParam *>(Param);
for (scudo::uptr I = P->Shard; I < P->Map->size(); I += P->NumberOfShards) {
scudo::u8 V = static_cast<scudo::u8>((I % 100) + 1);
P->Map->set(I, V);
EXPECT_EQ((*P->Map)[I], V);
}
return 0;
}
TEST(ScudoByteMapTest, ThreadedTwoLevelByteMap) {
TestByteMap Map;
Map.init();
static const scudo::uptr NumberOfThreads = 16U;
pthread_t T[NumberOfThreads];
TestByteMapParam P[NumberOfThreads];
for (scudo::uptr I = 0; I < NumberOfThreads; I++) {
P[I].Map = ⤅
P[I].Shard = I;
P[I].NumberOfShards = NumberOfThreads;
pthread_create(&T[I], 0, populateByteMap, &P[I]);
}
for (scudo::uptr I = 0; I < NumberOfThreads; I++)
pthread_join(T[I], 0);
Map.unmapTestOnly();
}
|
