AppendOnlyGCHashMap.h
3.36 KB
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
#pragma once
#include "utils/Il2CppHashMap.h"
#include "utils/NonCopyable.h"
#include "GarbageCollector.h"
namespace il2cpp
{
namespace gc
{
template<class Key, class T,
class HashFcn,
class EqualKey = std::equal_to<Key> >
class AppendOnlyGCHashMap : public il2cpp::utils::NonCopyable
{
typedef Il2CppHashMap<Key, size_t, HashFcn, EqualKey> hash_map_type;
typedef typename Il2CppHashMap<Key, size_t, HashFcn, EqualKey>::const_iterator ConstIterator;
public:
typedef typename hash_map_type::key_type key_type;
typedef T data_type;
typedef typename hash_map_type::size_type size_type;
typedef typename hash_map_type::hasher hasher;
typedef typename hash_map_type::key_equal key_equal;
AppendOnlyGCHashMap() :
m_Data(NULL),
m_Size(0)
{
}
~AppendOnlyGCHashMap()
{
if (m_Data)
il2cpp::gc::GarbageCollector::FreeFixed(m_Data);
}
bool Contains(const Key& k)
{
return m_Map.find(k) != m_Map.end();
}
// Returns true if value was added. False if it already existed
bool Add(const Key& k, T value)
{
if (m_Map.find(k) != m_Map.end())
return false;
if (m_Size == 0)
{
m_Size = 8;
m_Data = (T*)il2cpp::gc::GarbageCollector::AllocateFixed(m_Size * sizeof(T), NULL);
assert(m_Data);
}
else if (m_Map.size() == m_Size)
{
size_t newSize = 2 * m_Size;
T* newData = (T*)il2cpp::gc::GarbageCollector::AllocateFixed(newSize * sizeof(T), NULL);
MemCpyData memCpyData = { newData, m_Data, m_Size * sizeof(T) };
// perform memcpy with GC lock held so GC doesn't see torn pointer values.I think this is less of an issue with Boehm than other GCs, but being safe.
il2cpp::gc::GarbageCollector::CallWithAllocLockHeld(&CopyValues, &memCpyData);
il2cpp::gc::GarbageCollector::FreeFixed(m_Data);
GarbageCollector::SetWriteBarrier((void**)newData, m_Size * sizeof(T));
m_Size = newSize;
m_Data = newData;
assert(m_Data);
}
size_t index = m_Map.size();
m_Map.insert(std::make_pair(k, index));
m_Data[index] = value;
GarbageCollector::SetWriteBarrier((void**)(m_Data + index));
assert(m_Map.size() <= m_Size);
return true;
}
bool TryGetValue(const Key& k, T* value)
{
ConstIterator iter = m_Map.find(k);
if (iter == m_Map.end())
return false;
size_t index = iter->second;
assert(index <= m_Map.size());
*value = m_Data[index];
return true;
}
private:
struct MemCpyData
{
void* dst;
const void* src;
size_t size;
};
static void* CopyValues(void* arg)
{
MemCpyData* thisPtr = (MemCpyData*)arg;
memcpy(thisPtr->dst, thisPtr->src, thisPtr->size);
return NULL;
}
Il2CppHashMap<Key, size_t, HashFcn, EqualKey> m_Map;
T* m_Data;
size_t m_Size;
};
}
}