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
|
/* -----------------------------------------------------------------------------
*
* (c) The GHC Team, 1995-2009
*
* The RTS stores some "global" values on behalf of libraries, so that
* some libraries can ensure that certain top-level things are shared
* even when multiple versions of the library are loaded. e.g. see
* Data.Typeable and GHC.Conc.
*
* How are multiple versions of a library loaded? Examples:
*
* base - a statically-linked ghci has its own copy, so might libraries it
* dynamically loads
*
* libHSghc - a statically-linked ghc has its own copy and so will Core
* plugins it dynamically loads (cf CoreMonad.reinitializeGlobals)
*
* ---------------------------------------------------------------------------*/
#include "PosixSource.h"
#include "Rts.h"
#include "Globals.h"
#include "Stable.h"
typedef enum {
GHCConcSignalSignalHandlerStore,
GHCConcWindowsPendingDelaysStore,
GHCConcWindowsIOManagerThreadStore,
GHCConcWindowsProddingStore,
SystemEventThreadEventManagerStore,
SystemEventThreadIOManagerThreadStore,
SystemTimerThreadEventManagerStore,
SystemTimerThreadIOManagerThreadStore,
LibHSghcFastStringTable,
MaxStoreKey
} StoreKey;
#ifdef THREADED_RTS
Mutex globalStoreLock;
#endif
static StgStablePtr store[MaxStoreKey];
void
initGlobalStore(void)
{
nat i;
for (i=0; i < MaxStoreKey; i++) {
store[i] = 0;
}
#ifdef THREADED_RTS
initMutex(&globalStoreLock);
#endif
}
void
exitGlobalStore(void)
{
nat i;
#ifdef THREADED_RTS
closeMutex(&globalStoreLock);
#endif
for (i=0; i < MaxStoreKey; i++) {
if (store[i] != 0) {
freeStablePtr(store[i]);
store[i] = 0;
}
}
}
static StgStablePtr getOrSetKey(StoreKey key, StgStablePtr ptr)
{
StgStablePtr ret = store[key];
if(ret==0) {
#ifdef THREADED_RTS
ACQUIRE_LOCK(&globalStoreLock);
ret = store[key];
if(ret==0) {
#endif
store[key] = ret = ptr;
#ifdef THREADED_RTS
}
RELEASE_LOCK(&globalStoreLock);
#endif
}
return ret;
}
StgStablePtr
getOrSetGHCConcSignalSignalHandlerStore(StgStablePtr ptr)
{
return getOrSetKey(GHCConcSignalSignalHandlerStore,ptr);
}
StgStablePtr
getOrSetGHCConcWindowsPendingDelaysStore(StgStablePtr ptr)
{
return getOrSetKey(GHCConcWindowsPendingDelaysStore,ptr);
}
StgStablePtr
getOrSetGHCConcWindowsIOManagerThreadStore(StgStablePtr ptr)
{
return getOrSetKey(GHCConcWindowsIOManagerThreadStore,ptr);
}
StgStablePtr
getOrSetGHCConcWindowsProddingStore(StgStablePtr ptr)
{
return getOrSetKey(GHCConcWindowsProddingStore,ptr);
}
StgStablePtr
getOrSetSystemEventThreadEventManagerStore(StgStablePtr ptr)
{
return getOrSetKey(SystemEventThreadEventManagerStore,ptr);
}
StgStablePtr
getOrSetSystemEventThreadIOManagerThreadStore(StgStablePtr ptr)
{
return getOrSetKey(SystemEventThreadIOManagerThreadStore,ptr);
}
StgStablePtr
getOrSetSystemTimerThreadEventManagerStore(StgStablePtr ptr)
{
return getOrSetKey(SystemTimerThreadEventManagerStore,ptr);
}
StgStablePtr
getOrSetSystemTimerThreadIOManagerThreadStore(StgStablePtr ptr)
{
return getOrSetKey(SystemTimerThreadIOManagerThreadStore,ptr);
}
StgStablePtr
getOrSetLibHSghcFastStringTable(StgStablePtr ptr)
{
return getOrSetKey(LibHSghcFastStringTable,ptr);
}
|
