blob: 2164fb0c5eb9f9f9edd1e52124cf7f06100fc513 (
plain)
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
|
//
// Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
//
#include "common.h"
#include "windows.h"
#include "gcenv.h"
#include "gc.h"
EEConfig * g_pConfig;
#ifdef _MSC_VER
__declspec(thread)
#else
__thread
#endif
Thread * pCurrentThread;
Thread * GetThread()
{
return pCurrentThread;
}
Thread * g_pThreadList = NULL;
Thread * ThreadStore::GetThreadList(Thread * pThread)
{
if (pThread == NULL)
return g_pThreadList;
return pThread->m_pNext;
}
void ThreadStore::AttachCurrentThread()
{
// TODO: Locks
Thread * pThread = new Thread();
pThread->GetAllocContext()->init();
pCurrentThread = pThread;
pThread->m_pNext = g_pThreadList;
g_pThreadList = pThread;
}
void GCToEEInterface::SuspendEE(GCToEEInterface::SUSPEND_REASON reason)
{
GCHeap::GetGCHeap()->SetGCInProgress(TRUE);
// TODO: Implement
}
void GCToEEInterface::RestartEE(bool bFinishedGC)
{
// TODO: Implement
GCHeap::GetGCHeap()->SetGCInProgress(FALSE);
}
void GCToEEInterface::GcScanRoots(promote_func* fn, int condemned, int max_gen, ScanContext* sc)
{
// TODO: Implement - Scan stack roots on given thread
}
void GCToEEInterface::GcStartWork(int condemned, int max_gen)
{
}
void GCToEEInterface::AfterGcScanRoots(int condemned, int max_gen, ScanContext* sc)
{
}
void GCToEEInterface::GcBeforeBGCSweepWork()
{
}
void GCToEEInterface::GcDone(int condemned)
{
}
bool GCToEEInterface::RefCountedHandleCallbacks(Object * pObject)
{
return false;
}
bool GCToEEInterface::IsPreemptiveGCDisabled(Thread * pThread)
{
return pThread->PreemptiveGCDisabled();
}
void GCToEEInterface::EnablePreemptiveGC(Thread * pThread)
{
return pThread->EnablePreemptiveGC();
}
void GCToEEInterface::DisablePreemptiveGC(Thread * pThread)
{
pThread->DisablePreemptiveGC();
}
void GCToEEInterface::SetGCSpecial(Thread * pThread)
{
pThread->SetGCSpecial(true);
}
alloc_context * GCToEEInterface::GetAllocContext(Thread * pThread)
{
return pThread->GetAllocContext();
}
bool GCToEEInterface::CatchAtSafePoint(Thread * pThread)
{
return pThread->CatchAtSafePoint();
}
// does not acquire thread store lock
void GCToEEInterface::AttachCurrentThread()
{
ThreadStore::AttachCurrentThread();
}
void GCToEEInterface::GcEnumAllocContexts (enum_alloc_context_func* fn, void* param)
{
Thread * pThread = NULL;
while ((pThread = ThreadStore::GetThreadList(pThread)) != NULL)
{
fn(pThread->GetAllocContext(), param);
}
}
void FinalizerThread::EnableFinalization()
{
// Signal to finalizer thread that there are objects to finalize
// TODO: Implement for finalization
}
bool FinalizerThread::HaveExtraWorkForFinalizer()
{
return false;
}
bool PalStartBackgroundGCThread(BackgroundCallback callback, void* pCallbackContext)
{
// TODO: Implement for background GC
return false;
}
bool IsGCSpecialThread()
{
// TODO: Implement for background GC
return false;
}
|
