Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 :
21 : #include "osl/thread.hxx"
22 : #include "osl/conditn.hxx"
23 : #include "osl/mutex.hxx"
24 : #include <osl/diagnose.h>
25 :
26 : #include <cppu/Enterable.hxx>
27 : #include "cppu/helper/purpenv/Environment.hxx"
28 : #include "cppu/helper/purpenv/Mapping.hxx"
29 :
30 :
31 : #ifdef debug
32 : # define LOG_LIFECYCLE_AffineBridge
33 : #endif
34 :
35 : #ifdef LOG_LIFECYCLE_AffineBridge
36 : # include <iostream>
37 : # define LOG_LIFECYCLE_AffineBridge_emit(x) x
38 :
39 : #else
40 : # define LOG_LIFECYCLE_AffineBridge_emit(x)
41 :
42 : #endif
43 :
44 : class InnerThread;
45 : class OuterThread;
46 :
47 : class AffineBridge : public cppu::Enterable
48 : {
49 : public:
50 : enum Msg
51 : {
52 : CB_DONE,
53 : CB_FPOINTER
54 : };
55 :
56 : Msg m_message;
57 : uno_EnvCallee * m_pCallee;
58 : va_list * m_pParam;
59 :
60 : osl::Mutex m_innerMutex;
61 : oslThreadIdentifier m_innerThreadId;
62 : InnerThread * m_pInnerThread;
63 : osl::Condition m_innerCondition;
64 : sal_Int32 m_enterCount;
65 :
66 : osl::Mutex m_outerMutex;
67 : oslThreadIdentifier m_outerThreadId;
68 : osl::Condition m_outerCondition;
69 : OuterThread * m_pOuterThread;
70 :
71 : explicit AffineBridge();
72 : virtual ~AffineBridge();
73 :
74 : virtual void v_callInto_v(uno_EnvCallee * pCallee, va_list * pParam) SAL_OVERRIDE;
75 : virtual void v_callOut_v (uno_EnvCallee * pCallee, va_list * pParam) SAL_OVERRIDE;
76 :
77 : virtual void v_enter() SAL_OVERRIDE;
78 : virtual void v_leave() SAL_OVERRIDE;
79 :
80 : virtual bool v_isValid(rtl::OUString * pReason) SAL_OVERRIDE;
81 :
82 : void innerDispatch();
83 : void outerDispatch(int loop);
84 : };
85 :
86 2 : class InnerThread : public osl::Thread
87 : {
88 : virtual void SAL_CALL run() SAL_OVERRIDE;
89 :
90 : AffineBridge * m_pAffineBridge;
91 :
92 : public:
93 5 : explicit InnerThread(AffineBridge * threadEnvironment)
94 5 : : m_pAffineBridge(threadEnvironment)
95 : {
96 5 : create();
97 5 : }
98 : };
99 :
100 5 : void InnerThread::run()
101 : {
102 5 : osl_setThreadName("UNO AffineBridge InnerThread");
103 :
104 5 : m_pAffineBridge->enter();
105 5 : m_pAffineBridge->innerDispatch();
106 1 : m_pAffineBridge->leave();
107 1 : }
108 :
109 0 : class OuterThread : public osl::Thread
110 : {
111 : virtual void SAL_CALL run() SAL_OVERRIDE;
112 :
113 : AffineBridge * m_pAffineBridge;
114 :
115 : public:
116 : explicit OuterThread(AffineBridge * threadEnvironment);
117 : };
118 :
119 0 : OuterThread::OuterThread(AffineBridge * threadEnvironment)
120 0 : : m_pAffineBridge(threadEnvironment)
121 : {
122 0 : create();
123 0 : }
124 :
125 0 : void OuterThread::run()
126 : {
127 0 : osl_setThreadName("UNO AffineBridge OuterThread");
128 :
129 0 : osl::MutexGuard guard(m_pAffineBridge->m_outerMutex);
130 :
131 0 : m_pAffineBridge->m_outerThreadId = getIdentifier();
132 0 : m_pAffineBridge->outerDispatch(0);
133 0 : m_pAffineBridge->m_outerThreadId = 0;
134 :
135 0 : m_pAffineBridge->m_pOuterThread = NULL;
136 0 : m_pAffineBridge = NULL;
137 0 : }
138 :
139 :
140 5 : AffineBridge::AffineBridge()
141 : : m_message (CB_DONE),
142 : m_pCallee (0),
143 : m_pParam (0),
144 : m_innerThreadId(0),
145 : m_pInnerThread (NULL),
146 : m_enterCount (0),
147 : m_outerThreadId(0),
148 5 : m_pOuterThread (NULL)
149 : {
150 : LOG_LIFECYCLE_AffineBridge_emit(fprintf(stderr, "LIFE: %s -> %p\n", "AffineBridge::AffineBridge(uno_Environment * pEnv)", this));
151 5 : }
152 :
153 3 : AffineBridge::~AffineBridge()
154 : {
155 : LOG_LIFECYCLE_AffineBridge_emit(fprintf(stderr, "LIFE: %s -> %p\n", "AffineBridge::~AffineBridge()", this));
156 :
157 1 : if (m_pInnerThread && osl::Thread::getCurrentIdentifier() != m_innerThreadId)
158 : {
159 1 : m_message = CB_DONE;
160 1 : m_innerCondition.set();
161 :
162 1 : m_pInnerThread->join();
163 : }
164 :
165 1 : delete m_pInnerThread;
166 :
167 1 : if (m_pOuterThread)
168 : {
169 0 : m_pOuterThread->join();
170 0 : delete m_pOuterThread;
171 : }
172 2 : }
173 :
174 :
175 759033 : void AffineBridge::outerDispatch(int loop)
176 : {
177 : OSL_ASSERT(m_outerThreadId == osl::Thread::getCurrentIdentifier());
178 : OSL_ASSERT(m_innerThreadId != m_outerThreadId);
179 :
180 : Msg mm;
181 :
182 759033 : do
183 : {
184 : // FIXME: created outer thread must not wait
185 : // in case of no message
186 : // note: no message can happen in case newly created
187 : // outer thread acquire outerMutex after a real outer
188 : // thread enters outerDispatch!
189 759033 : m_outerCondition.wait();
190 759033 : m_outerCondition.reset();
191 :
192 759033 : mm = m_message;
193 :
194 759033 : switch(mm)
195 : {
196 : case CB_DONE:
197 714518 : break;
198 :
199 : case CB_FPOINTER:
200 : {
201 44515 : m_pCallee(m_pParam);
202 :
203 44515 : m_message = CB_DONE;
204 44515 : m_innerCondition.set();
205 44515 : break;
206 : }
207 : default:
208 0 : abort();
209 : }
210 : }
211 44515 : while(mm != CB_DONE && loop);
212 714518 : }
213 :
214 759038 : void AffineBridge::innerDispatch()
215 : {
216 : OSL_ASSERT(m_innerThreadId == osl::Thread::getCurrentIdentifier());
217 : OSL_ASSERT(m_innerThreadId != m_outerThreadId);
218 :
219 : Msg mm;
220 :
221 759034 : do
222 : {
223 759038 : m_innerCondition.wait();
224 759034 : m_innerCondition.reset();
225 :
226 759034 : mm = m_message;
227 :
228 759034 : switch(mm)
229 : {
230 : case CB_DONE:
231 44516 : break;
232 :
233 : case CB_FPOINTER:
234 : {
235 714518 : m_pCallee(m_pParam);
236 :
237 714518 : m_message = CB_DONE;
238 714518 : m_outerCondition.set();
239 714518 : break;
240 : }
241 : default:
242 0 : abort();
243 : }
244 : }
245 : while(mm != CB_DONE);
246 44516 : }
247 :
248 714518 : void AffineBridge::v_callInto_v(uno_EnvCallee * pCallee, va_list * pParam)
249 : {
250 714518 : osl::MutexGuard guard(m_outerMutex); // only one thread at a time can call into
251 :
252 714518 : if (m_innerThreadId == 0) // no inner thread yet
253 : {
254 5 : m_pInnerThread = new InnerThread(this);
255 5 : m_pInnerThread->resume();
256 : }
257 :
258 714518 : bool resetId = false;
259 714518 : if (!m_outerThreadId)
260 : {
261 714241 : m_outerThreadId = osl::Thread::getCurrentIdentifier();
262 714241 : resetId = true;
263 : }
264 :
265 714518 : m_message = CB_FPOINTER;
266 714518 : m_pCallee = pCallee;
267 714518 : m_pParam = pParam;
268 714518 : m_innerCondition.set();
269 :
270 714518 : outerDispatch(1);
271 :
272 714518 : if (resetId)
273 714241 : m_outerThreadId = 0;
274 714518 : }
275 :
276 44515 : void AffineBridge::v_callOut_v(uno_EnvCallee * pCallee, va_list * pParam)
277 : {
278 : OSL_ASSERT(m_innerThreadId);
279 :
280 44515 : osl::MutexGuard guard(m_innerMutex);
281 :
282 44515 : if (m_outerThreadId == 0) // no outer thread yet
283 : {
284 0 : osl::MutexGuard guard_m_outerMutex(m_outerMutex);
285 :
286 0 : if (m_outerThreadId == 0)
287 : {
288 0 : if (m_pOuterThread)
289 : {
290 0 : m_pOuterThread->join();
291 0 : delete m_pOuterThread;
292 : }
293 :
294 0 : m_pOuterThread = new OuterThread(this);
295 0 : }
296 : }
297 :
298 44515 : m_message = CB_FPOINTER;
299 44515 : m_pCallee = pCallee;
300 44515 : m_pParam = pParam;
301 44515 : m_outerCondition.set();
302 :
303 44515 : innerDispatch();
304 44515 : }
305 :
306 5 : void AffineBridge::v_enter()
307 : {
308 5 : m_innerMutex.acquire();
309 :
310 5 : if (!m_enterCount)
311 5 : m_innerThreadId = osl::Thread::getCurrentIdentifier();
312 :
313 : OSL_ASSERT(m_innerThreadId == osl::Thread::getCurrentIdentifier());
314 :
315 5 : ++ m_enterCount;
316 5 : }
317 :
318 1 : void AffineBridge::v_leave()
319 : {
320 : OSL_ASSERT(m_innerThreadId == osl::Thread::getCurrentIdentifier());
321 :
322 1 : -- m_enterCount;
323 1 : if (!m_enterCount)
324 1 : m_innerThreadId = 0;
325 :
326 1 : m_innerMutex.release();
327 1 : }
328 :
329 0 : bool AffineBridge::v_isValid(rtl::OUString * pReason)
330 : {
331 0 : bool result = m_enterCount > 0;
332 0 : if (!result)
333 0 : *pReason = "not entered";
334 :
335 : else
336 : {
337 0 : result = m_innerThreadId == osl::Thread::getCurrentIdentifier();
338 :
339 0 : if (!result)
340 0 : *pReason = "wrong thread";
341 : }
342 :
343 0 : if (result)
344 0 : *pReason = "OK";
345 :
346 0 : return result;
347 : }
348 :
349 : #ifdef DISABLE_DYNLOADING
350 :
351 : #define uno_initEnvironment affine_uno_uno_initEnvironment
352 : #define uno_ext_getMapping affine_uno_uno_ext_getMapping
353 :
354 : #endif
355 :
356 5 : extern "C" void SAL_DLLPUBLIC_EXPORT SAL_CALL uno_initEnvironment(uno_Environment * pEnv)
357 : SAL_THROW_EXTERN_C()
358 : {
359 5 : cppu::helper::purpenv::Environment_initWithEnterable(pEnv, new AffineBridge());
360 5 : }
361 :
362 10 : extern "C" void SAL_DLLPUBLIC_EXPORT SAL_CALL uno_ext_getMapping(uno_Mapping ** ppMapping,
363 : uno_Environment * pFrom,
364 : uno_Environment * pTo )
365 : {
366 10 : cppu::helper::purpenv::createMapping(ppMapping, pFrom, pTo);
367 10 : }
368 :
369 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
