xref: /aoo4110/main/framework/test/threadtest.cxx (revision b1cdbd2c)
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_framework.hxx"
26 
27 //_________________________________________________________________________________________________________________
28 //	my own includes
29 //_________________________________________________________________________________________________________________
30 #include <macros/generic.hxx>
31 #include <macros/debug.hxx>
32 #include <threadhelp/resetableguard.hxx>
33 #include <threadhelp/transactionguard.hxx>
34 
35 #ifndef __FRAMEWORK_THREADHELP_RWLOCKBASE_HXX_
36 #include <threadhelp/rwlockbase.hxx>
37 #endif
38 
39 #ifndef __FRAMEWORK_THREADHELP_TRANSACTIONBASE_HXX_
40 #include <threadhelp/transactionbase.hxx>
41 #endif
42 #include <threadhelp/readguard.hxx>
43 #include <threadhelp/writeguard.hxx>
44 
45 //_________________________________________________________________________________________________________________
46 //	interface includes
47 //_________________________________________________________________________________________________________________
48 
49 //_________________________________________________________________________________________________________________
50 //	other includes
51 //_________________________________________________________________________________________________________________
52 #include <rtl/random.h>
53 #include <vos/process.hxx>
54 #include <vos/thread.hxx>
55 #include <rtl/ustring.hxx>
56 #include <rtl/ustrbuf.hxx>
57 #include <osl/time.h>
58 
59 #ifndef _OSL_INTERLOCK_H_
60 #include <osl/interlock.h>
61 #endif
62 
63 #include <vcl/event.hxx>
64 #include <vcl/svapp.hxx>
65 #include <vcl/wrkwin.hxx>
66 #include <vcl/msgbox.hxx>
67 #include <stdio.h>
68 
69 //_________________________________________________________________________________________________________________
70 //	const
71 //_________________________________________________________________________________________________________________
72 
73 #define	LOGFILE				"threadtest.log"
74 #define	STATISTICS_FILE		"threadtest_statistic.csv"
75 
76 //_________________________________________________________________________________________________________________
77 //	namespace
78 //_________________________________________________________________________________________________________________
79 
80 using namespace ::rtl		;
81 using namespace ::osl		;
82 using namespace ::vos		;
83 using namespace ::framework	;
84 
85 //_________________________________________________________________________________________________________________
86 //	defines
87 //_________________________________________________________________________________________________________________
88 
89 /*---------------- Use follow defines to enable/disable some special features of this little test program! -------*/
90 
91 #define ENABLE_LOG
92 //#define ENABLE_THREADDELAY
93 #define ENABLE_REQUESTCOUNT
94 
95 /*----------------------------------------------------------------------------------------------------------------*/
96 
97 #ifdef ENABLE_LOG
98 	#define	LOG_SETA_START( NA, NID )											\
99 		{																		\
100 			sal_uInt32 nTimeStamp = osl_getGlobalTimer();						\
101 			ResetableGuard aLogGuard( m_aLogMutex );							\
102 			OStringBuffer sLog(256);											\
103 			sLog.append( (sal_Int32)nTimeStamp	);								\
104 			sLog.append( ": Thread[ "			);								\
105 			sLog.append( NID					);								\
106 			sLog.append( " ] call setA( "		);								\
107 			sLog.append( NA						);								\
108 			sLog.append( " )\n"					);								\
109 			WRITE_LOGFILE( LOGFILE, sLog.makeStringAndClear() )					\
110 		}
111 
112 	#define	LOG_SETA_END( NA, EREASON, NID )									\
113 		{																		\
114 			sal_uInt32 nTimeStamp = osl_getGlobalTimer();						\
115 			ResetableGuard aLogGuard( m_aLogMutex );							\
116 			OStringBuffer sLog(256);											\
117 			sLog.append( (sal_Int32)nTimeStamp	);								\
118 			sLog.append( ": Thread[ "			);								\
119 			sLog.append( NID					);								\
120 			if( EREASON == E_NOREASON )											\
121 				sLog.append( " ] finish setA( "			);						\
122 			else																\
123 				sLog.append( " ] was refused at setA( ");						\
124 			sLog.append( NA		);												\
125 			sLog.append( " )\n"	);												\
126 			WRITE_LOGFILE( LOGFILE, sLog.makeStringAndClear() )					\
127 		}
128 
129 	#define	LOG_GETA_START( NID )												\
130 		{																		\
131 			sal_uInt32 nTimeStamp = osl_getGlobalTimer();						\
132 			ResetableGuard aLogGuard( m_aLogMutex );							\
133 			OStringBuffer sLog(256);											\
134 			sLog.append( (sal_Int32)nTimeStamp	);								\
135 			sLog.append( ": Thread[ "			);								\
136 			sLog.append( NID					);								\
137 			sLog.append( " ] call getA()\n"		);								\
138 			WRITE_LOGFILE( LOGFILE, sLog.makeStringAndClear() )					\
139 		}
140 
141 	#define	LOG_GETA_END( NRETURN, EREASON, NID )								\
142 		{																		\
143 			sal_uInt32 nTimeStamp = osl_getGlobalTimer();						\
144 			ResetableGuard aLogGuard( m_aLogMutex );							\
145 			OStringBuffer sLog(256);											\
146 			sLog.append( (sal_Int32)nTimeStamp	);								\
147 			sLog.append( ": Thread[ "			);								\
148 			sLog.append( NID					);								\
149 			if( EREASON == E_NOREASON )											\
150 				sLog.append( " ] finish getA() with "			);				\
151 			else																\
152 				sLog.append( " ] was refused at getA() with "	);				\
153 			sLog.append( NRETURN	);											\
154 			sLog.append( "\n"		);											\
155 			WRITE_LOGFILE( LOGFILE, sLog.makeStringAndClear() )					\
156 		}
157 
158 	#define	LOG_WORKA_START( NA, NID )											\
159 		{																		\
160 			sal_uInt32 nTimeStamp = osl_getGlobalTimer();						\
161 			ResetableGuard aLogGuard( m_aLogMutex );							\
162 			OStringBuffer sLog(256);											\
163 			sLog.append( (sal_Int32)nTimeStamp	);								\
164 			sLog.append( ": Thread[ "			);								\
165 			sLog.append( NID					);								\
166 			sLog.append( " ] call workA( "		);								\
167 			sLog.append( NA						);								\
168 			sLog.append( " )\n"					);								\
169 			WRITE_LOGFILE( LOGFILE, sLog.makeStringAndClear() )					\
170 		}
171 
172 	#define	LOG_WORKA_END( NRETURN, EREASON, NID )								\
173 		{																		\
174 			sal_uInt32 nTimeStamp = osl_getGlobalTimer();						\
175 			ResetableGuard aLogGuard( m_aLogMutex );							\
176 			OStringBuffer sLog(256);											\
177 			sLog.append( (sal_Int32)nTimeStamp	);								\
178 			sLog.append( ": Thread[ "			);								\
179 			sLog.append( NID					);								\
180 			if( EREASON == E_NOREASON )											\
181 				sLog.append( " ] finish workA() with "			);				\
182 			else																\
183 				sLog.append( " ] was refused at workA() with "	);				\
184 			sLog.append( NRETURN	);											\
185 			sLog.append( "\n"		);											\
186 			WRITE_LOGFILE( LOGFILE, sLog.makeStringAndClear() )					\
187 		}
188 
189 	#define	LOG_INITEXCEPTION( SMETHOD, NID )									\
190 		{																		\
191 			sal_uInt32 nTimeStamp = osl_getGlobalTimer();						\
192 			ResetableGuard aLogGuard( m_aLogMutex );							\
193 			OStringBuffer sLog(256);											\
194 			sLog.append( (sal_Int32)nTimeStamp				);					\
195 			sLog.append( ": Thread[ "						);					\
196 			sLog.append( NID								);					\
197 			sLog.append( " ] get EInitException from \""	);					\
198 			sLog.append( SMETHOD							);					\
199 			sLog.append( "\"\n"								);					\
200 			WRITE_LOGFILE( LOGFILE, sLog.makeStringAndClear() )					\
201 		}
202 
203 	#define	LOG_CLOSEEXCEPTION( SMETHOD, NID )									\
204 		{																		\
205 			sal_uInt32 nTimeStamp = osl_getGlobalTimer();						\
206 			ResetableGuard aLogGuard( m_aLogMutex );							\
207 			OStringBuffer sLog(256);											\
208 			sLog.append( (sal_Int32)nTimeStamp				);					\
209 			sLog.append( ": Thread[ "						);					\
210 			sLog.append( NID								);					\
211 			sLog.append( " ] get ECloseException from \""	);					\
212 			sLog.append( SMETHOD							);					\
213 			sLog.append( "\"\n"								);					\
214 			WRITE_LOGFILE( LOGFILE, sLog.makeStringAndClear() )					\
215 		}
216 
217 	#define	LOG_INIT( NA, NID )													\
218 		{																		\
219 			sal_uInt32 nTimeStamp = osl_getGlobalTimer();						\
220 			ResetableGuard aLogGuard( m_aLogMutex );							\
221 			OStringBuffer sLog(256);											\
222 			sLog.append( (sal_Int32)nTimeStamp		);							\
223 			sLog.append( ": Thread[ "				);							\
224 			sLog.append( NID						);							\
225 			sLog.append( " ] initialize me with "	);							\
226 			sLog.append( NA							);							\
227 			sLog.append( "\n"						);							\
228 			WRITE_LOGFILE( LOGFILE, sLog.makeStringAndClear() )					\
229 		}
230 
231 	#define	LOG_CLOSE( NID )													\
232 		{																		\
233 			sal_uInt32 nTimeStamp = osl_getGlobalTimer();						\
234 			ResetableGuard aLogGuard( m_aLogMutex );							\
235 			OStringBuffer sLog(256);											\
236 			sLog.append( (sal_Int32)nTimeStamp	);								\
237 			sLog.append( ": Thread[ "			);								\
238 			sLog.append( NID					);								\
239 			sLog.append( " ] close me\n"		);								\
240 			WRITE_LOGFILE( LOGFILE, sLog.makeStringAndClear() )					\
241 		}
242 #else
243 	#define	LOG_SETA_START( NA, NID )
244 	#define	LOG_SETA_END( NA, EREASON, NID )
245 	#define	LOG_GETA_START( NID )
246 	#define	LOG_GETA_END( NRETURN, EREASON, NID )
247 	#define	LOG_WORKA_START( NA, NID )
248 	#define	LOG_WORKA_END( NRETURN, EREASON, NID )
249 	#define	LOG_INITEXCEPTION( SMETHOD, NID )
250 	#define	LOG_CLOSEEXCEPTION( SMETHOD, NID )
251 	#define	LOG_INIT( NA, NID )
252 	#define	LOG_CLOSE( NID )
253 #endif
254 
255 //_________________________________________________________________________________________________________________
256 //	declarations
257 //_________________________________________________________________________________________________________________
258 
getRandomValue()259 sal_uInt16 getRandomValue()
260 {
261 	// Get new random value for thread-sleep!
262 	// See run() for further informations.
263 	// Always calculate a new random number.
264 	sal_uInt16		nValue;
265 	rtlRandomPool	aPool = rtl_random_createPool();
266 	rtl_random_getBytes		( aPool, &nValue, 2	);
267 	rtl_random_destroyPool	( aPool				);
268 	return nValue;
269 }
270 
271 /*-************************************************************************************************************//**
272 	@descr			This class is used from different threads at the same time.
273 					We start working after calling init() first(!) ...
274 					and finish it by calling close(). It exist two methods for reading/writing an
275 					internal variable "A". Another function workA() do both things at the same time.
276 					All public methods log information in a file if DO_LOG is defined.
277 
278 	@attention		Our public base class FaiRWLockBase is a struct with a RWLock as member.
279 					This member can be used by guards to safe access at internal variables
280 					in interface methods.
281                     Another baseclass is the TransactionBase. They support rejection of wrong calls at wrong time.
282                     e.g. calls after closing object!
283 *//*-*************************************************************************************************************/
284 
285 class ThreadSafeClass : private TransactionBase
286                       , private FairRWLockBase
287 {
288 	public:
289 
290 		ThreadSafeClass	();
291 		~ThreadSafeClass();
292 
293 		// This methods are used from differnt threads
294 		// to test this class.
295 		void		init	(	sal_Int32	nA			,
296 								sal_Int32	nThreadID	);
297 		void		close	(	sal_Int32	nThreadID	);
298 		void		setA	(	sal_Int32	nA			,
299 								sal_Int32	nThreadID	);
300 		sal_Int32	getA	(	sal_Int32	nThreadID	);
301 		sal_Int32	workA	(	sal_Int32	nA			,
302 								sal_Int32	nThreadID	);
303 
304 		#ifdef ENABLE_REQUESTCOUNT
305 		// This methods are used for statistics only!
getReadCount()306 		sal_Int32 getReadCount () { return m_nReadCount;	}
getWriteCount()307 		sal_Int32 getWriteCount() { return m_nWriteCount;	}
308 		#endif
309 
310 	private:
311 
312 		sal_Int32				m_nA			;	/// test member fro reading/writing
313 
314 		#ifdef ENABLE_LOG
315 		::osl::Mutex			m_aLogMutex		;	/// mutex to serialize writing log file!
316 		#endif
317 
318 		#ifdef ENABLE_REQUESTCOUNT
319 		oslInterlockedCount		m_nReadCount	;	/// statistic variables to count read/write requests
320 		oslInterlockedCount		m_nWriteCount	;
321 		#endif
322 };
323 
324 //_________________________________________________________________________________________________________________
ThreadSafeClass()325 ThreadSafeClass::ThreadSafeClass()
326     :   TransactionBase (   )
327     ,   FairRWLockBase  (   )
328 	,	m_nA			( 0 )
329 	#ifdef ENABLE_REQUESTCOUNT
330 	,	m_nReadCount	( 0	)
331 	,	m_nWriteCount	( 0	)
332 	#endif
333 {
334 }
335 
336 //_________________________________________________________________________________________________________________
~ThreadSafeClass()337 ThreadSafeClass::~ThreadSafeClass()
338 {
339 }
340 
341 //_________________________________________________________________________________________________________________
init(sal_Int32 nA,sal_Int32 nThreadID)342 void ThreadSafeClass::init( sal_Int32 nA, sal_Int32 nThreadID )
343 {
344     // Set write lock for setting internal member AND
345     // protect changing of working mode!
346     WriteGuard aWriteLock( m_aLock );
347 
348     LOG_INIT( nA, nThreadID )
349 
350     // Look for multiple calls of this method first!
351     // Use E_SOFTEXCEPTIONS to disable automaticly throwing of exceptions for some working modes.
352     ERejectReason       eReason;
353     TransactionGuard    aTransaction( m_aTransactionManager, E_NOEXCEPTIONS, eReason );
354     if( eReason == E_UNINITIALIZED )
355     {
356         // OK, it must be the first call and we are synchronized with all other threads by using the write lock!
357         // Otherwise (e.g. if working mode == E_WORK) we get a exception and follow lines are never called.
358 
359         // We can set our member and change the working mode now.
360         m_nA = nA;
361         m_aTransactionManager.setWorkingMode( E_WORK );
362     }
363 }
364 
365 //_________________________________________________________________________________________________________________
close(sal_Int32 nThreadID)366 void ThreadSafeClass::close( sal_Int32 nThreadID )
367 {
368     // Make it threadsafe.
369     // It must be an exclusiv access! => WriteLock!
370     WriteGuard aWriteLock( m_aLock );
371 
372     LOG_CLOSE( nThreadID )
373 
374     // We must look for multiple calls of this method.
375     // Try to register this method as a transaction.
376     // In combination with E_HARDEXCEPTIONS only working mode E_WORK pass this barrier.
377     ERejectReason       eReason;
378     TransactionGuard    aTransaction( m_aTransactionManager, E_NOEXCEPTIONS, eReason );
379     if( eReason == E_NOREASON )
380     {
381         // Change working mode to BEFORECLOSE to enable rejection of normal interface calls
382         // and enable SOFTEXCEPTION mode for some impl- or helper methods!
383         // Attention: We must stop successful registered transaction first ...
384         // because setWorkingMode() blocks and wait for all current existing ones!
385         aTransaction.stop();
386         m_aTransactionManager.setWorkingMode( E_BEFORECLOSE );
387 
388         // Now we are alone ...
389         // All further calls to this object are rejected ...
390         // (not all ... some special ones can work by using E_SOFTEXCEPTIONS!)
391 
392         // Deinitialize all member and set working mode to E_CLOSE.
393         m_nA = 0;
394         m_aTransactionManager.setWorkingMode( E_CLOSE );
395     }
396 }
397 
398 //_________________________________________________________________________________________________________________
setA(sal_Int32 nA,sal_Int32 nThreadID)399 void ThreadSafeClass::setA( sal_Int32 nA, sal_Int32 nThreadID	)
400 {
401     // Make it threadsafe.
402     WriteGuard aWriteLock( m_aLock );
403 
404     LOG_SETA_START( nA, nThreadID )
405 
406     // Register this method as a transaction to prevent code against wrong calls
407     // after close() or before init()!
408     ERejectReason       eReason;
409     TransactionGuard    aTransaction( m_aTransactionManager, E_NOEXCEPTIONS, eReason );
410     if( eReason == E_NOREASON )
411     {
412         // This object is ready for working and we have full write access.
413         // We can work with our member.
414         m_nA = nA;
415         #ifdef ENABLE_REQUESTCOUNT
416         osl_incrementInterlockedCount( &m_nWriteCount );
417         #endif
418     }
419     LOG_SETA_END( nA, eReason, nThreadID )
420 }
421 
422 //_________________________________________________________________________________________________________________
getA(sal_Int32 nThreadID)423 sal_Int32 ThreadSafeClass::getA( sal_Int32 nThreadID )
424 {
425     // Make it threadsafe.
426     ReadGuard aReadLock( m_aLock );
427 
428 	LOG_GETA_START( nThreadID )
429 
430     // Register this method as a transaction to prevent code against wrong calls
431     // after close() or before init()!
432     sal_Int32           nReturn = 0;
433     ERejectReason       eReason;
434     TransactionGuard    aTransaction( m_aTransactionManager, E_NOEXCEPTIONS, eReason );
435     if( eReason == E_NOREASON )
436     {
437         // This object is ready for working and we have a read access.
438         // We can work with our member.
439         nReturn = m_nA;
440         #ifdef ENABLE_REQUESTCOUNT
441         osl_incrementInterlockedCount( &m_nReadCount );
442         #endif
443     }
444 
445     LOG_GETA_END( nReturn, eReason, nThreadID )
446     return nReturn;
447 }
448 
449 //_________________________________________________________________________________________________________________
workA(sal_Int32 nA,sal_Int32 nThreadID)450 sal_Int32 ThreadSafeClass::workA(	sal_Int32	nA			,
451 									sal_Int32	nThreadID	)
452 {
453 	// This method test the downgrade-mechanism of used lock implementation!
454     // Make it threadsafe.
455     WriteGuard aWriteLock( m_aLock );
456 
457     LOG_WORKA_START( nA, nThreadID )
458 
459     // Register this method as a transaction to prevent code against wrong calls
460     // after close() or before init()!
461     sal_Int32           nReturn = 0;
462     ERejectReason       eReason;
463     TransactionGuard    aTransaction( m_aTransactionManager, E_NOEXCEPTIONS, eReason );
464     if( eReason == E_NOREASON )
465     {
466         // We have write access to our member.
467         // Set new value.
468         m_nA = nA;
469         #ifdef ENABLE_REQUESTCOUNT
470         osl_incrementInterlockedCount( &m_nWriteCount );
471         #endif
472 
473         // Downgrade write access to read access and read the set value again.
474         // This call can't be rejected - but it can fail!
475         aWriteLock.downgrade();
476         nReturn = m_nA;
477         #ifdef ENABLE_REQUESTCOUNT
478         osl_incrementInterlockedCount( &m_nReadCount );
479         #endif
480     }
481 
482     LOG_WORKA_END( nReturn, eReason, nThreadID )
483     return nReturn;
484 }
485 
486 /*-****************************************************************************************************//**
487 	@descr	Every thread instance of these class lopp from 0 up to "nLoops".
488 			He sleep for a random time and work with given test class "pClass" then.
489 			We use random values for waiting for better results!
490 			Otherwise all threads are sychron after first 2,3...5 calls - I think!
491 *//*-*****************************************************************************************************/
492 
493 class TestThread : public OThread
494 {
495 	public:
496 
497 		TestThread(	ThreadSafeClass*	pClass						,
498 					sal_Int32			nLoops						,
499 					Condition*			pListener					,
500 					sal_Bool			bOwner		=	sal_False	);
501 
502 	private:
503 
504    		virtual void SAL_CALL	run				();
505    		virtual void SAL_CALL	onTerminated	();
506 
507 	private:
508 
509 		ThreadSafeClass*	m_pClass		;
510 		sal_Int32			m_nLoops		;
511 		sal_Int32			m_nThreadID		;
512 		Condition*			m_pListener		;
513 		sal_Bool			m_bOwner		;
514 };
515 
516 //_________________________________________________________________________________________________________________
TestThread(ThreadSafeClass * pClass,sal_Int32 nLoops,Condition * pListener,sal_Bool bOwner)517 TestThread::TestThread(	ThreadSafeClass*	pClass		,
518 						sal_Int32			nLoops		,
519 						Condition*			pListener	,
520 						sal_Bool			bOwner		)
521 	:	m_pClass	( pClass	)
522 	,	m_nLoops	( nLoops	)
523 	,	m_pListener	( pListener	)
524 	,	m_bOwner	( bOwner	)
525 {
526 }
527 
528 //_________________________________________________________________________________________________________________
run()529 void SAL_CALL TestThread::run()
530 {
531 	// Get ID of this thread.
532 	// Is used for logging information ...
533 	m_nThreadID = getCurrentIdentifier();
534 
535 	// If we are the owner of given pClass
536 	// we must initialize ... and close
537 	// it. See at the end of this method too.
538 	if( m_bOwner == sal_True )
539 	{
540 		m_pClass->init( 0, m_nThreadID );
541 	}
542 
543 	#ifdef ENABLE_THREADDELAY
544 	TimeValue	nDelay	;
545 	#endif
546 
547 	sal_Int32	nA		;
548 
549 	for( sal_Int32 nCount=0; nCount<m_nLoops; ++nCount )
550 	{
551 		// Work with class.
552 		// Use random to select called method.
553 		nA = (sal_Int32)getRandomValue();
554         if( nA % 5 == 0 )
555 		{
556 			nA = m_pClass->workA( nA, m_nThreadID );
557 		}
558         else
559         if( nA % 3 == 0 )
560 		{
561 			m_pClass->setA( nA, m_nThreadID );
562 		}
563 		else
564 		{
565 			nA = m_pClass->getA( m_nThreadID );
566 		}
567 		#ifdef ENABLE_THREADDELAY
568 		// Sleep - use random value to do that too!
569 		nDelay.Seconds = 0;
570 		nDelay.Nanosec = getRandomValue();
571 		sleep( nDelay );
572 		#endif
573 	}
574 
575 	// Don't forget to "close" teset object if you are the owner!
576 	if( m_bOwner == sal_True )
577 	{
578 		m_pClass->close( m_nThreadID );
579 	}
580 }
581 
582 //_________________________________________________________________________________________________________________
onTerminated()583 void SAL_CALL TestThread::onTerminated()
584 {
585 	// Destroy yourself if you finished.
586 	// But don't forget to call listener before.
587 	m_pListener->set();
588 
589 	m_pClass	= NULL;
590 	m_pListener	= NULL;
591 
592 	delete this;
593 }
594 
595 /*-****************************************************************************************************//**
596 	@descr	This is our test application.
597 			We create one ThreadSafeClass object and a lot of threads
598 			which use it at different times.
599 *//*-*****************************************************************************************************/
600 
601 struct ThreadInfo
602 {
603 	Condition*	pCondition	;
604 	TestThread*	pThread		;
605 };
606 
607 class TestApplication : public Application
608 {
609 	public:
610 		void		Main		(								);
611 		sal_Int32	measureTime	(	sal_Int32	nThreadCount	,
612 									sal_Int32	nOwner			,
613 									sal_Int32	nLoops=0		);
614 };
615 
616 //_________________________________________________________________________________________________________________
617 //	definition
618 //_________________________________________________________________________________________________________________
619 
620 TestApplication aApplication;
621 
622 //_________________________________________________________________________________________________________________
623 // This function start "nThreadCount" threads to use same test class.
624 // You can specify the owner thread of this test class which start/stop it by using "nOwner". [1..nThreadcount]!
625 // If you specify "nLoops" different from 0 we use it as loop count for every started thread.
626 // Otherwise we work with random values.
measureTime(sal_Int32 nThreadCount,sal_Int32 nOwner,sal_Int32 nLoops)627 sal_Int32 TestApplication::measureTime(	sal_Int32	nThreadCount	,
628 	  	 								sal_Int32	nOwner			,
629 	  									sal_Int32	nLoops			)
630 {
631 	// This is the class which should be tested.
632 	ThreadSafeClass aClass;
633 
634 	// Create list of threads.
635 	ThreadInfo* pThreads	=	new ThreadInfo[nThreadCount];
636 	sal_Int32	nLoopCount	=	nLoops						;
637 	sal_Bool	bOwner		=	sal_False					;
638 	for( sal_Int32 nI=1; nI<=nThreadCount; ++nI )
639 	{
640 		// If nLoops==0 => we must use random value; otherwise we must use given count ...
641 		if( nLoops == 0 )
642 		{
643 			nLoopCount = getRandomValue();
644 		}
645 		// Search owner of class.
646 		bOwner = sal_False;
647 		if( nOwner == nI )
648 		{
649 			bOwner = sal_True;
650 		}
651 		// initialize condition.
652 		pThreads[nI].pCondition = new Condition;
653 		// Initialize thread.
654 		pThreads[nI].pThread = new TestThread( &aClass, nLoopCount, pThreads[nI].pCondition, bOwner );
655 	}
656 
657 	// Start clock to get information about used time.
658 	sal_uInt32	nStartTime	;
659 	sal_uInt32	nEndTime	;
660 
661 	nStartTime = osl_getGlobalTimer();
662 
663 	// Start threads ...
664 	for( nI=1; nI<=nThreadCount; ++nI )
665 	{
666 		pThreads[nI].pThread->create();
667 	}
668 
669 	// Wait for threads ...
670 	for( nI=1; nI<=nThreadCount; ++nI )
671 	{
672 		pThreads[nI].pCondition->wait();
673 		delete pThreads[nI].pCondition;
674 		pThreads[nI].pCondition = NULL;
675 	}
676 
677 	delete[] pThreads;
678 	pThreads = NULL;
679 
680 	nEndTime = osl_getGlobalTimer();
681 
682 	// Calc used time and return it. [ms]
683 	return( nEndTime-nStartTime );
684 }
685 
686 //_________________________________________________________________________________________________________________
Main()687 void TestApplication::Main()
688 {
689 	sal_Int32 nTestCount	= 0;	/// count of calling "measureTime()"
690 	sal_Int32 nThreadCount	= 0;	/// count of used threads by "measure..."
691 	sal_Int32 nLoops		= 0;	/// loop count for every thread
692 	sal_Int32 nOwner		= 0;	/// number of owner thread
693 
694 	// Parse command line.
695 	// Attention: All parameter are required and must exist!
696 	// syntax: "threadtest.exe <testcount> <threadcount> <loops> <owner>"
697 	OStartupInfo	aInfo		;
698 	OUString		sArgument	;
699 	sal_Int32		nArgument	;
700 	sal_Int32		nCount		= aInfo.getCommandArgCount();
701 
702 	LOG_ASSERT2( nCount!=4 ,"TestApplication::Main()" , "Wrong argument line detected!")
703 
704 	for( nArgument=0; nArgument<nCount; ++nArgument )
705 	{
706 		aInfo.getCommandArg( nArgument, sArgument );
707 		if( nArgument== 0 )	nTestCount	=sArgument.toInt32();
708 		if( nArgument== 1 )	nThreadCount=sArgument.toInt32();
709 		if( nArgument== 2 )	nLoops		=sArgument.toInt32();
710 		if( nArgument== 3 )	nOwner		=sArgument.toInt32();
711 	}
712 
713 	// Start test.
714 	OStringBuffer	sBuf(256);
715 	sal_Int32		nTime=0;
716 	sBuf.append( "Nr.\tTime\tThreadCount\tLoops\tOwner\n" );
717 	for( sal_Int32 nI=1; nI<=nTestCount; ++nI )
718 	{
719 		nTime = measureTime( nThreadCount, nOwner, nLoops );
720 		sBuf.append( nI				);
721 		sBuf.append( "\t"			);
722 		sBuf.append( nTime			);
723 		sBuf.append( "\t"			);
724 		sBuf.append( nThreadCount	);
725 		sBuf.append( "\t"			);
726 		sBuf.append( nLoops			);
727 		sBuf.append( "\t"			);
728 		sBuf.append( nOwner 		);
729 		sBuf.append( "\n"			);
730 	}
731 
732 	WRITE_LOGFILE( STATISTICS_FILE, sBuf.makeStringAndClear() );
733 	LOG_ERROR( "TApplication::Main()", "Test finish successful!" )
734 }
735