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
|
/*************************************************************************
*
* $RCSfile: threadpool.h,v $
*
* $Revision: 1.1.1.1 $
*
* last change: $Author: hr $ $Date: 2000-09-18 15:25:52 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
*
* - GNU Lesser General Public License Version 2.1
* - Sun Industry Standards Source License Version 1.1
*
* Sun Microsystems Inc., October, 2000
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2000 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
*
* Sun Industry Standards Source License Version 1.1
* =================================================
* The contents of this file are subject to the Sun Industry Standards
* Source License Version 1.1 (the "License"); You may not use this file
* except in compliance with the License. You may obtain a copy of the
* License at http://www.openoffice.org/license.html.
*
* Software provided under this License is provided on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
* WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
* MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
* See the License for the specific provisions governing your rights and
* obligations concerning the Software.
*
* The Initial Developer of the Original Code is: Sun Microsystems, Inc.
*
* Copyright: 2000 by Sun Microsystems, Inc.
*
* All Rights Reserved.
*
* Contributor(s): _______________________________________
*
*
************************************************************************/
#include <sal/types.h>
#include <rtl/byteseq.h>
#ifdef __cplusplus
extern "C" {
#endif
/***
* Thread identifier administration.
***/
/**
* Establishs an association between the current thread an the given thread identifier.
* There can be only one association at a time. The association must be broken by
* uno_releaseIdFromCurrentThread.
* This method is in general called by a bridge, that wants to bind a remote threadId
* to a new thread.
*
* @param pThreadId a byte sequence, that contains the identifier of the current thread.
* @return true, when the identifier was registered. <br>
* false, when the thread has already an identifier. The identifier was not
* altered. ( This is in general a bug ). <br>
**/
SAL_DLLEXPORT sal_Bool SAL_CALL uno_bindIdToCurrentThread( sal_Sequence *pThreadId );
/**
* Get the identifier of the current thread.
* If no id has been bound for the thread before, a new one is generated and bound
* to the thread.
* For each call to uno_getIdOfCurrentThread, a call to uno_releaseIdFromCurrentThread
* must be done.
*
* @param ppThreadId [out] Contains the (acquired) ThreadId.
**/
SAL_DLLEXPORT void SAL_CALL uno_getIdOfCurrentThread( sal_Sequence **ppThreadId );
/**
* If the internal refcount drops to zero, the association betwen threadId and
* thread is broken.
**/
SAL_DLLEXPORT void SAL_CALL uno_releaseIdFromCurrentThread();
/**
* The threadpool
**/
struct uno_threadpool_Handle;
/**
* Create a handle for the current thread before entering waiting pool. This method must be
* called, BEFORE the request is sent (to avoid a race between this thread and an incoming
* reply).
* This method shall only be called for synchronous requests.
*
* @param nDisposeId An ID, that uniquely identifies a bridge within the
* local process. The pointer to the bridge object should be used.
* @see uno_threadpool_disposeThreads
***/
SAL_DLLEXPORT struct uno_threadpool_Handle * SAL_CALL
uno_threadpool_createHandle( sal_Int64 nDisposeId );
/**
* This method is called to wait for a reply of a previously sent request. This is a
* blocking method.
*
* @param pHandle the handle that was previously created by uno_threadpool_createHandle.
* @param ppThreadSpecificData [out] the pointer, that was given by uno_threadpool_reply.
* If the threads for this bridge were disposed,
* *ppThreadSpecificData is null.
**/
SAL_DLLEXPORT void SAL_CALL
uno_threadpool_enter( struct uno_threadpool_Handle * pHandle , void **ppThreadSpecificData );
/**
* A request is put into a queue of waiting requests. This method is non-blocking.
*
* If the request is synchronous, it is first looked up,
* if there exists a handle with the given
* identifier. If this is the case, the thread is woken up and the doRequest
* function is called with the given pThreadSpecificData. If no handle exists,
* a new thread is created and the given threadId is bound to the new thread.
*
* If the request is asynchronous, it is put into the queue of asynchronous
* requests for the current threadid. The requests are always executed in a new
* thread, even if the thread with the given Id waiting in the pool. No Id is bound
* to the newly created thread. The responsibilty is left to the bridge ( if it
* wishes to bind a name).
*
* @param pThreadId The Id of thread, that initialized this request. (In general a
* remote threadid).
* @param pThreadSpecificData The argument, that doRequest will get.
* @param doRequest The function, that shall be called to execute the request.
* @param bIsOneway True, if the request is asynchrons. False, if it is synchronous
*
**/
SAL_DLLEXPORT void SAL_CALL
uno_threadpool_putRequest( sal_Sequence *pThreadId,
void *pThreadSpecificData,
void ( SAL_CALL * doRequest ) ( void *pThreadSpecificData ),
sal_Bool bIsOneway );
/**
* A reply is put into the threadpool. There MUST be a thread with the given threadId waiting
* for this reply. This method is non-blocking.
*
* @param pThreadSpecificData The pointer, that is returned by uno_threadpool_enter.
**/
SAL_DLLEXPORT void SAL_CALL
uno_threadpool_putReply( sal_Sequence *pThreadId, void *pThreadSpecificData );
/**
* All threads, that are waiting on handles, that were created with
* nDisposeId, are forced out of the pool.
* (@see uno_threadpool_createTicket) These threads will return from
* uno_threadpool_enter with 0 == *ppThreadSpecificData.
* Later calls to uno_threadpool_enter with the given disposeId also
* return immeadiatly.
*
* @param nDisposeId Identfies the caller of uno_threadpool_createTicket
*
* This function is called i.e. by a bridge, that is forced to dispose itself.
* When disposing of the bridge has finished, the bridge MUST call
* uno_threadpool_stopDisposeThreads.
**/
SAL_DLLEXPORT void SAL_CALL
uno_threadpool_disposeThreads( sal_Int64 nDisposeId );
/**
* Informs the threadpool, that no special treatment is needed for the given nDisposeId.
* This allows the threadpool to release internal resources
* and must be called after all threads originated from this bridge have returned.
* (This can in general be done in the bridge destructor).
*
* @param nDisposeId Identifies the caller of uno_threadpool_createTicket
* @see uno_threadpool_disposeThreads
**/
SAL_DLLEXPORT void SAL_CALL
uno_threadpool_stopDisposeThreads( sal_Int64 nDisposeId );
#ifdef __cplusplus
}
#endif
|
