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
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
|
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
/*
** Thread Private Data
**
** There is an aribitrary limit on the number of keys that will be allocated
** by the runtime. It's largish, so it is intended to be a sanity check, not
** an impediment.
**
** There is a counter, initialized to zero and incremented every time a
** client asks for a new key, that holds the high water mark for keys. All
** threads logically have the same high water mark and are permitted to
** ask for TPD up to that key value.
**
** The vector to hold the TPD are allocated when PR_SetThreadPrivate() is
** called. The size of the vector will be some value greater than or equal
** to the current high water mark. Each thread has its own TPD length and
** vector.
**
** Threads that get private data for keys they have not set (or perhaps
** don't even exist for that thread) get a NULL return. If the key is
** beyond the high water mark, an error will be returned.
*/
/*
** As of this time, BeOS has its own TPD implementation. Integrating
** this standard one is a TODO for anyone with a bit of spare time on
** their hand. For now, we just #ifdef out this whole file and use
** the routines in pr/src/btthreads/
*/
#include "primpl.h"
#include <string.h>
#if defined(WIN95)
/*
** Some local variables report warnings on Win95 because the code paths
** using them are conditioned on HAVE_CUSTOME_USER_THREADS.
** The pragma suppresses the warning.
**
*/
#pragma warning(disable : 4101)
#endif
#define _PR_TPD_LIMIT 128 /* arbitary limit on the TPD slots */
static PRInt32 _pr_tpd_length = 0; /* current length of destructor vector */
static PRInt32 _pr_tpd_highwater = 0; /* next TPD key to be assigned */
static PRThreadPrivateDTOR *_pr_tpd_destructors = NULL;
/* the destructors are associated with
the keys, therefore asserting that
the TPD key depicts the data's 'type' */
/*
** Initialize the thread private data manipulation
*/
void _PR_InitTPD(void)
{
_pr_tpd_destructors = (PRThreadPrivateDTOR*)
PR_CALLOC(_PR_TPD_LIMIT * sizeof(PRThreadPrivateDTOR*));
PR_ASSERT(NULL != _pr_tpd_destructors);
_pr_tpd_length = _PR_TPD_LIMIT;
}
/*
** Clean up the thread private data manipulation
*/
void _PR_CleanupTPD(void)
{
} /* _PR_CleanupTPD */
/*
** This routine returns a new index for per-thread-private data table.
** The index is visible to all threads within a process. This index can
** be used with the PR_SetThreadPrivate() and PR_GetThreadPrivate() routines
** to save and retrieve data associated with the index for a thread.
**
** The index independently maintains specific values for each binding thread.
** A thread can only get access to its own thread-specific-data.
**
** Upon a new index return the value associated with the index for all threads
** is NULL, and upon thread creation the value associated with all indices for
** that thread is NULL.
**
** "dtor" is the destructor function to invoke when the private
** data is set or destroyed
**
** Returns PR_FAILURE if the total number of indices will exceed the maximun
** allowed.
*/
PR_IMPLEMENT(PRStatus) PR_NewThreadPrivateIndex(
PRUintn *newIndex, PRThreadPrivateDTOR dtor)
{
PRStatus rv;
PRInt32 index;
if (!_pr_initialized) _PR_ImplicitInitialization();
PR_ASSERT(NULL != newIndex);
PR_ASSERT(NULL != _pr_tpd_destructors);
index = PR_ATOMIC_INCREMENT(&_pr_tpd_highwater) - 1; /* allocate index */
if (_PR_TPD_LIMIT <= index)
{
PR_SetError(PR_TPD_RANGE_ERROR, 0);
rv = PR_FAILURE; /* that's just wrong */
}
else
{
_pr_tpd_destructors[index] = dtor; /* record destructor @index */
*newIndex = (PRUintn)index; /* copy into client's location */
rv = PR_SUCCESS; /* that's okay */
}
return rv;
}
/*
** Define some per-thread-private data.
** "index" is an index into the per-thread private data table
** "priv" is the per-thread-private data
**
** If the per-thread private data table has a previously registered
** destructor function and a non-NULL per-thread-private data value,
** the destructor function is invoked.
**
** This can return PR_FAILURE if index is invalid (ie., beyond the limit
** on the TPD slots) or memory is insufficient to allocate an expanded
** vector.
*/
PR_IMPLEMENT(PRStatus) PR_SetThreadPrivate(PRUintn index, void *priv)
{
PRThread *self = PR_GetCurrentThread();
/*
** To improve performance, we don't check if the index has been
** allocated.
*/
if (index >= _PR_TPD_LIMIT)
{
PR_SetError(PR_TPD_RANGE_ERROR, 0);
return PR_FAILURE;
}
PR_ASSERT(((NULL == self->privateData) && (0 == self->tpdLength))
|| ((NULL != self->privateData) && (0 != self->tpdLength)));
/*
** If this thread does not have a sufficient vector for the index
** being set, go ahead and extend this vector now.
*/
if ((NULL == self->privateData) || (self->tpdLength <= index))
{
void *extension = PR_CALLOC(_pr_tpd_length * sizeof(void*));
if (NULL == extension)
{
PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
return PR_FAILURE;
}
if (self->privateData) {
(void)memcpy(
extension, self->privateData,
self->tpdLength * sizeof(void*));
PR_DELETE(self->privateData);
}
self->tpdLength = _pr_tpd_length;
self->privateData = (void**)extension;
}
/*
** There wasn't much chance of having to call the destructor
** unless the slot already existed.
*/
else if (self->privateData[index] && _pr_tpd_destructors[index])
{
void *data = self->privateData[index];
self->privateData[index] = NULL;
(*_pr_tpd_destructors[index])(data);
}
PR_ASSERT(index < self->tpdLength);
self->privateData[index] = priv;
return PR_SUCCESS;
}
/*
** Recover the per-thread-private data for the current thread. "index" is
** the index into the per-thread private data table.
**
** The returned value may be NULL which is indistinguishable from an error
** condition.
**
*/
PR_IMPLEMENT(void*) PR_GetThreadPrivate(PRUintn index)
{
PRThread *self = PR_GetCurrentThread();
void *tpd = ((NULL == self->privateData) || (index >= self->tpdLength)) ?
NULL : self->privateData[index];
return tpd;
}
/*
** Destroy the thread's private data, if any exists. This is called at
** thread termination time only. There should be no threading issues
** since this is being called by the thread itself.
*/
void _PR_DestroyThreadPrivate(PRThread* self)
{
#define _PR_TPD_DESTRUCTOR_ITERATIONS 4
if (NULL != self->privateData) /* we have some */
{
PRBool clean;
PRUint32 index;
PRInt32 passes = _PR_TPD_DESTRUCTOR_ITERATIONS;
PR_ASSERT(0 != self->tpdLength);
do
{
clean = PR_TRUE;
for (index = 0; index < self->tpdLength; ++index)
{
void *priv = self->privateData[index]; /* extract */
if (NULL != priv) /* we have data at this index */
{
if (NULL != _pr_tpd_destructors[index])
{
self->privateData[index] = NULL; /* precondition */
(*_pr_tpd_destructors[index])(priv); /* destroy */
clean = PR_FALSE; /* unknown side effects */
}
}
}
} while ((--passes > 0) && !clean); /* limit # of passes */
/*
** We give up after a fixed number of passes. Any non-NULL
** thread-private data value with a registered destructor
** function is not destroyed.
*/
memset(self->privateData, 0, self->tpdLength * sizeof(void*));
}
} /* _PR_DestroyThreadPrivate */
|
