4 * Copyright (Thread::*c) 2000 - 2013 Samsung Electronics Co., Ltd. All rights reserved.
8 * Woojin Jung <woojin2.jung@samsung.com>
9 * Yeongtaik Byeon <yeongtaik.byeon@samsung.com>
10 * Jaewon Lim <jaewon81.lim@samsung.com>
11 * Juyoung Kim <j0.kim@samsung.com>
12 * Anastasia Lyupa <a.lyupa@samsung.com>
14 * This library is free software; you can redistribute it and/or modify it under
15 * the terms of the GNU Lesser General Public License as published by the
16 * Free Software Foundation; either version 2.1 of the License, or (at your option)
19 * This library is distributed in the hope that it will be useful, but WITHOUT ANY
20 * WARRANTY; without even the implied warranty of MERCHANTABILITY or
21 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
22 * License for more details.
24 * You should have received a copy of the GNU Lesser General Public License
25 * along with this library; if not, write to the Free Software Foundation, Inc., 51
26 * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30 * - Samsung RnD Institute Russia
36 #include "probeinfo.h"
41 static enum DaOptions _sopt = OPT_THREAD;
49 // virtual result Stop(void);
51 // virtual result Finalize(void);
52 const Thread* GetThread(void) const;
54 static void* ThreadProc(void* pParam);
59 //_ThreadImpl::GetThread(void) const
61 // typedef const Thread*
62 // (_ThreadImpl::*methodType)(void) const;
63 // static methodType GetThreadp = 0;
64 // probeInfo_t probeInfo;
67 // bool bfiltering = false;
72 // void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
73 // if (lib_handle == NULL) {
74 // perror("dlopen failed : libosp-appfw.so");
77 // tmpPtr = dlsym(lib_handle, "_ZNK5Tizen4Base7Runtime11_ThreadImpl9GetThreadEv");
79 // if (tmpPtr == NULL || dlerror() != NULL) {
80 // perror("dlsym failed : Tizen::Base::Runtime::_ThreadImpl::GetThreadp");
84 // memcpy(&GetThreadp, &tmpPtr, sizeof(tmpPtr));
89 // if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
90 // setProbePoint(&probeInfo);
94 // const Thread* ret = (this->*GetThreadp)();
95 // result res = GetLastResult();
97 // if (postBlockBegin(blockresult)) {
100 // log.data[0] = '\0';
101 // log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_THREAD,
102 // probeInfo.eventIndex, "_ThreadImpl::GetThread", probeInfo.currentTime,
103 // probeInfo.pID, probeInfo.tID);
106 // log.length += sprintf(log.data + log.length, "`,`,0x%x",ret);
107 // //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
108 // log.length += sprintf(log.data + log.length,
109 // "`,0`,%ld`,%d`,0`,%u`,0x%x`,%d`,%d`,`,", res,blockresult,
110 // (unsigned int)CALLER_ADDRESS, (unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_OTHER);
112 // log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
113 // getBacktraceString(&log, 4096 - log.length - 17);
114 // log.length += sprintf(log.data + log.length, "`,callstack_end");
116 // printLog(&log, MSG_LOG);
123 _ThreadImpl::ThreadProc(void* params) {
125 (*methodType)(void*);
126 static methodType ThreadProcp = 0;
127 probeInfo_t probeInfo;
129 bool bfiltering = false;
134 if(lib_handle[LIBOSP_APPFW] == NULL) {
135 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
136 if (lib_handle[LIBOSP_APPFW] == NULL) {
137 perror("dlopen failed : libosp-appfw.so");
141 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime11_ThreadImpl10ThreadProcEPv");
143 if (tmpPtr == NULL || dlerror() != NULL) {
144 perror("dlsym failed : Tizen::Base::Runtime::_ThreadImpl::ThreadProc");
148 memcpy(&ThreadProcp, &tmpPtr, sizeof(tmpPtr));
153 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
154 setProbePoint(&probeInfo);
156 _ThreadImpl* pSelf =(_ThreadImpl*)params;
157 const Thread* pThread = NULL;
159 pThread = pSelf->GetThread();
163 PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
164 API_ID_void___ThreadImpl__ThreadProc_void__params_,
165 "p", voidp_to_uint64(params));
166 PACK_COMMON_END('p', (unsigned int)pSelf, 0, blockresult);
167 PACK_THREAD((unsigned int)pThread, THREAD_TIZENTHREAD_WORKER, THREAD_API_INTERNAL_START);
173 // all probe should be reachable inside thread start_routine (user implemented Thread::Run)
174 (ThreadProcp)(params);
176 if (postBlockBegin(blockresult)) {
178 setProbePoint(&probeInfo);
180 _ThreadImpl* pSelf =(_ThreadImpl*)params;
181 const Thread* pThread = NULL;
183 pThread = pSelf->GetThread();
187 PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
188 API_ID_void___ThreadImpl__ThreadProc_void__params_,
189 "p", voidp_to_uint64(params));
190 PACK_COMMON_END('p', (unsigned int)pSelf, 0, blockresult);
191 PACK_THREAD((unsigned int)pThread, THREAD_TIZENTHREAD_WORKER, THREAD_API_INTERNAL_STOP);
198 //result _ThreadImpl::Stop(void) {
200 // (_ThreadImpl::*methodType)(void);
201 // static methodType Stopp = 0;
202 // probeInfo_t probeInfo;
205 // bool bfiltering = true;
209 // probeBlockStart();
210 // void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
211 // if (lib_handle == NULL) {
212 // perror("dlopen failed : libosp-appfw.so");
215 // tmpPtr = dlsym(lib_handle, "_ZN5Tizen4Base7Runtime11_ThreadImpl4StopEv");
217 // if (tmpPtr == NULL || dlerror() != NULL) {
218 // perror("dlsym failed : Tizen::Base::Runtime::_ThreadImpl::Stopp");
222 // memcpy(&Stopp, &tmpPtr, sizeof(tmpPtr));
227 // if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
228 // setProbePoint(&probeInfo);
232 // result ret= (this->*Stopp)();
234 // if (postBlockBegin(blockresult)) {
237 // log.data[0] = '\0';
238 // log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_THREAD,
239 // probeInfo.eventIndex, "_ThreadImpl::Stop", probeInfo.currentTime,
240 // probeInfo.pID, probeInfo.tID);
242 // log.length += sprintf(log.data + log.length, "`,`,%ld", ret);
243 // //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
244 // log.length += sprintf(log.data + log.length,
245 // "`,0`,%ld`,%d`,0`,%u`,0x%x`,%d`,%d`,`,", ret, blockresult,
246 // (unsigned int)CALLER_ADDRESS, (unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_CLOSE);
248 // log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
249 // getBacktraceString(&log, 4096 - log.length - 17);
250 // log.length += sprintf(log.data + log.length, "`,callstack_end");
252 // printLog(&log, MSG_LOG);
258 //result _ThreadImpl::Finalize(void) {
260 // (_ThreadImpl::*methodType)(void);
261 // static methodType Finalizep = 0;
262 // probeInfo_t probeInfo;
265 // bool bfiltering = false;
269 // probeBlockStart();
270 // void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
271 // if (lib_handle == NULL) {
272 // perror("dlopen failed : libosp-appfw.so");
275 // tmpPtr = dlsym(lib_handle, "_ZN5Tizen4Base7Runtime11_ThreadImpl8FinalizeEv");
277 // if (tmpPtr == NULL || dlerror() != NULL) {
278 // perror("dlsym failed : Tizen::Base::Runtime::_ThreadImpl::Finalizep");
282 // memcpy(&Finalizep, &tmpPtr, sizeof(tmpPtr));
286 // if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
287 // setProbePoint(&probeInfo);
291 // result ret= (this->*Finalizep)();
293 // if (postBlockBegin(blockresult)) {
296 // log.data[0] = '\0';
297 // log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_THREAD,
298 // probeInfo.eventIndex, "_ThreadImpl::Finalize", probeInfo.currentTime,
299 // probeInfo.pID, probeInfo.tID);
301 // log.length += sprintf(log.data + log.length, "`,`,%ld", ret);
302 // //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
303 // log.length += sprintf(log.data + log.length,
304 // "`,0`,%ld`,%d`,0`,%u`,0x%x`,%d`,%d`,`,", ret, blockresult,
305 // (unsigned int)CALLER_ADDRESS, (unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_CLOSE);
307 // log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
308 // getBacktraceString(&log, 4096 - log.length - 17);
309 // log.length += sprintf(log.data + log.length, "`,callstack_end");
311 // printLog(&log, MSG_LOG);
316 //Thread::Thread(void) {
317 // typedef void (Thread::*methodType)();
318 // static methodType Threadp = 0;
319 // probeInfo_t probeInfo;
322 // bool bfiltering = true;
326 // probeBlockStart();
328 // tmpPtr = dlsym(RTLD_NEXT, "_ZN5Tizen4Base7Runtime6ThreadC1Ev");
330 // if (tmpPtr == NULL || dlerror() != NULL) {
333 // log.data[0] = '\0';
334 // log.length = sprintf(log.data,"dlsym failed : Tizen::Base::Runtime::Thread::Thread");
335 // perror("dlsym failed : Tizen::Base::Runtime::Thread::Thread");
336 // printLog(&log, MSG_MSG);
340 // memcpy(&Threadp, &tmpPtr, sizeof(tmpPtr));
344 // if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
345 // setProbePoint(&probeInfo);
349 // (this->*Threadp)();
351 // if (postBlockBegin(blockresult)) {
354 // log.data[0] = '\0';
355 // log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_THREAD,
356 // probeInfo.eventIndex, "Thread::Thread", probeInfo.currentTime,
357 // probeInfo.pID, probeInfo.tID);
359 // log.length += sprintf(log.data + log.length, "`,`,");
360 // //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
362 // log.length += sprintf(log.data + log.length,
363 // "`,0`,0`,%d`,0`,0x%x`,%d`,%d`,`,", blockresult,
364 // (unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_OPEN);
366 // log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
367 // getBacktraceString(&log, 4096 - log.length - 17);
368 // log.length += sprintf(log.data + log.length, "`,callstack_end");
370 // printLog(&log, MSG_LOG);
375 //Thread::~Thread(void) {
376 // typedef void (Thread::*methodType)();
377 // static methodType ThreadDp = 0;
378 // probeInfo_t probeInfo;
381 // bool bfiltering = true;
385 // probeBlockStart();
387 // void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
388 // if (lib_handle == NULL) {
389 // perror("dlopen failed : libosp-appfw.so");
392 // tmpPtr = dlsym(lib_handle, "_ZN5Tizen4Base7Runtime6ThreadD0Ev");
394 // if (tmpPtr == NULL || dlerror() != NULL) {
395 // perror("dlsym failed : Tizen::Base::Runtime::Thread::~Thread");
399 // memcpy(&ThreadDp, &tmpPtr, sizeof(tmpPtr));
403 // if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
404 // setProbePoint(&probeInfo);
408 // (this->*ThreadDp)();
410 // if (postBlockBegin(blockresult)) {
413 // log.data[0] = '\0';
414 // log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_THREAD,
415 // probeInfo.eventIndex, "Thread::~Thread", probeInfo.currentTime,
416 // probeInfo.pID, probeInfo.tID);
418 // log.length += sprintf(log.data + log.length, "`,`,");
419 // //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
421 // log.length += sprintf(log.data + log.length,
422 // "`,0`,0`,%d`,0`,0x%x`,%d`,%d`,`,", blockresult,
423 // (unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_CLOSE);
425 // log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
426 // getBacktraceString(&log, 4096 - log.length - 17);
427 // log.length += sprintf(log.data + log.length, "`,callstack_end");
429 // printLog(&log, MSG_LOG);
433 result Thread::Sleep(long milliSeconds) {
436 static methodType Sleepp = 0;
437 probeInfo_t probeInfo;
439 bool bfiltering = true;
444 if(lib_handle[LIBOSP_APPFW] == NULL) {
445 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
446 if (lib_handle[LIBOSP_APPFW] == NULL) {
447 perror("dlopen failed : libosp-appfw.so");
451 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime6Thread5SleepEl");
453 if (tmpPtr == NULL || dlerror() != NULL) {
454 perror("dlsym failed : Tizen::Base::Runtime::Thread::Sleep");
458 memcpy(&Sleepp, &tmpPtr, sizeof(tmpPtr));
463 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
464 setProbePoint(&probeInfo);
466 Thread *currentThread;
467 currentThread = GetCurrentThread();
470 PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
471 API_ID_result_Thread__Sleep_long_milliSeconds_,
472 "x", (uint64_t)(milliSeconds));
473 PACK_COMMON_END('p', 0, 0, blockresult);
474 PACK_THREAD((unsigned int)currentThread, THREAD_TIZENTHREAD_WORKER, THREAD_API_WAIT_START);
480 result ret = (Sleepp)(milliSeconds);
482 if (postBlockBegin(blockresult)) {
483 setProbePoint(&probeInfo);
485 Thread *currentThread;
486 currentThread = GetCurrentThread();
489 PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
490 API_ID_result_Thread__Yield_void_,
491 "x", (uint64_t)(milliSeconds));
492 PACK_COMMON_END('p', ret, ret, blockresult);
493 PACK_THREAD((unsigned int)currentThread, THREAD_TIZENTHREAD_WORKER, THREAD_API_WAIT_END);
501 Thread* Thread::GetCurrentThread(void) {
504 static methodType GetCurrentThreadp = 0;
505 probeInfo_t probeInfo;
507 bool bfiltering = true;
510 if (!GetCurrentThreadp) {
512 if(lib_handle[LIBOSP_APPFW] == NULL) {
513 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
514 if (lib_handle[LIBOSP_APPFW] == NULL) {
515 perror("dlopen failed : libosp-appfw.so");
519 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime6Thread16GetCurrentThreadEv");
521 if (tmpPtr == NULL || dlerror() != NULL) {
522 perror("dlsym failed : Tizen::Base::Runtime::Thread::GetCurrentThread");
526 memcpy(&GetCurrentThreadp, &tmpPtr, sizeof(tmpPtr));
531 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
532 setProbePoint(&probeInfo);
536 Thread *currentThread = (GetCurrentThreadp)();
537 result res = GetLastResult();
539 if (postBlockBegin(blockresult)) {
542 PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
543 API_ID_Thread__Thread__GetCurrentThread_void_,
545 PACK_COMMON_END('p', (unsigned int)currentThread, res, blockresult);
546 PACK_THREAD((unsigned int)currentThread, THREAD_TIZENTHREAD_WORKER, THREAD_API_OTHER);
551 return currentThread;
554 result Thread::Yield(void) {
557 static methodType Yieldp = 0;
558 probeInfo_t probeInfo;
560 bool bfiltering = true;
565 if(lib_handle[LIBOSP_APPFW] == NULL) {
566 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
567 if (lib_handle[LIBOSP_APPFW] == NULL) {
568 perror("dlopen failed : libosp-appfw.so");
572 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime6Thread5YieldEv");
574 if (tmpPtr == NULL || dlerror() != NULL) {
575 perror("dlsym failed : Tizen::Base::Runtime::Thread::Yield");
579 memcpy(&Yieldp, &tmpPtr, sizeof(tmpPtr));
584 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
585 setProbePoint(&probeInfo);
589 result ret = (Yieldp)();
591 if (postBlockBegin(blockresult)) {
592 Thread *currentThread;
593 currentThread = GetCurrentThread();
596 PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
597 API_ID_result_Thread__Yield_void_,
599 PACK_COMMON_END('p', ret, ret, blockresult);
600 PACK_THREAD((unsigned int)currentThread, THREAD_TIZENTHREAD_WORKER, THREAD_API_OTHER);
608 result Thread::Exit(int exitCode) {
610 (*methodType)(int exitCode);
611 static methodType Exitp = 0;
612 probeInfo_t probeInfo;
614 bool bfiltering = true;
619 if(lib_handle[LIBOSP_APPFW] == NULL) {
620 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
621 if (lib_handle[LIBOSP_APPFW] == NULL) {
622 perror("dlopen failed : libosp-appfw.so");
626 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime6Thread4ExitEi");
628 if (tmpPtr == NULL || dlerror() != NULL) {
629 perror("dlsym failed : Tizen::Base::Runtime::Thread::Exit");
633 memcpy(&Exitp, &tmpPtr, sizeof(tmpPtr));
638 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
639 setProbePoint(&probeInfo);
641 Thread *currentThread;
642 currentThread = GetCurrentThread();
645 PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
646 API_ID_result_Thread__Exit_int_exitCode_,
648 PACK_COMMON_END('p', 0, 0, blockresult);
649 PACK_THREAD((unsigned int)currentThread, THREAD_TIZENTHREAD_WORKER, THREAD_API_EXIT);
655 result ret = (Exitp)(exitCode);
660 result Thread::Construct(ThreadType threadType, long stackSize,
661 ThreadPriority priority) {
663 (Thread::*methodType)(ThreadType threadType, long stackSize,
664 ThreadPriority priority);
665 static methodType Constructp = 0;
667 probeInfo_t probeInfo;
669 bool bfiltering = true;
674 if(lib_handle[LIBOSP_APPFW] == NULL) {
675 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
676 if (lib_handle[LIBOSP_APPFW] == NULL) {
677 perror("dlopen failed : libosp-appfw.so");
683 lib_handle[LIBOSP_APPFW],
684 "_ZN5Tizen4Base7Runtime6Thread9ConstructENS1_10ThreadTypeElNS1_14ThreadPriorityE");
686 if (tmpPtr == NULL || dlerror() != NULL) {
687 perror("dlsym failed : Tizen::Base::Runtime::Thread::Construct");
691 memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
695 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
696 setProbePoint(&probeInfo);
700 ret = (this->*Constructp)(threadType, stackSize, priority);
702 if (postBlockBegin(blockresult)) {
705 PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
706 API_ID_result_Thread__Construct_ThreadType_threadType__long_stackSize__ThreadPriority_priority_,
707 "dxd", threadType, (uint64_t)(stackSize),
709 PACK_COMMON_END('p', ret, ret, blockresult);
710 PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_NEW);
717 result Thread::Construct(long stackSize, ThreadPriority priority) {
719 (Thread::*methodType)(long stackSize, ThreadPriority priority);
720 static methodType Constructp = 0;
722 probeInfo_t probeInfo;
724 bool bfiltering = true;
729 if(lib_handle[LIBOSP_APPFW] == NULL) {
730 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
731 if (lib_handle[LIBOSP_APPFW] == NULL) {
732 perror("dlopen failed : libosp-appfw.so");
736 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW],
737 "_ZN5Tizen4Base7Runtime6Thread9ConstructElNS1_14ThreadPriorityE");
738 if (tmpPtr == NULL || dlerror() != NULL) {
739 perror("dlsym failed : Tizen::Base::Runtime::Thread::Construct");
743 memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
747 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
748 setProbePoint(&probeInfo);
752 ret = (this->*Constructp)(stackSize, priority);
754 if (postBlockBegin(blockresult)) {
757 PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
758 API_ID_result_Thread__Construct_long_stackSize__ThreadPriority_priority_,
759 "xd", (uint64_t)(stackSize), priority);
760 PACK_COMMON_END('p', ret, ret, blockresult);
761 PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_NEW);
768 result Thread::Construct(const Tizen::Base::String &name, long stackSize,
769 ThreadPriority priority) {
771 (Thread::*methodType)(const Tizen::Base::String &name, long stackSize,
772 ThreadPriority priority);
773 static methodType Constructp = 0;
775 probeInfo_t probeInfo;
777 bool bfiltering = true;
783 if(lib_handle[LIBOSP_APPFW] == NULL) {
784 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
785 if (lib_handle[LIBOSP_APPFW] == NULL) {
786 perror("dlopen failed : libosp-appfw.so");
792 lib_handle[LIBOSP_APPFW],
793 "_ZN5Tizen4Base7Runtime6Thread9ConstructERKNS0_6StringElNS1_14ThreadPriorityE");
795 if (tmpPtr == NULL || dlerror() != NULL) {
796 perror("dlsym failed : Tizen::Base::Runtime::Thread::Construct");
800 memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
804 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
805 setProbePoint(&probeInfo);
809 ret = (this->*Constructp)(name, stackSize, priority);
811 if (postBlockBegin(blockresult)) {
814 PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
815 API_ID_result_Thread__Construct_const_Tizen__Base__String__name__long_stackSize__ThreadPriority_priority_,
816 "sxd", temp, (uint64_t)(stackSize), priority);
817 PACK_COMMON_END('p', ret, ret, blockresult);
818 PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_NEW);
825 result Thread::Construct(const Tizen::Base::String &name, ThreadType threadType,
826 long stackSize, ThreadPriority priority) {
828 (Thread::*methodType)(const Tizen::Base::String &name, ThreadType threadType,
829 long stackSize, ThreadPriority priority);
830 static methodType Constructp = 0;
832 probeInfo_t probeInfo;
834 bool bfiltering = true;
840 if(lib_handle[LIBOSP_APPFW] == NULL) {
841 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
842 if (lib_handle[LIBOSP_APPFW] == NULL) {
843 perror("dlopen failed : libosp-appfw.so");
850 lib_handle[LIBOSP_APPFW],
851 "_ZN5Tizen4Base7Runtime6Thread9ConstructERKNS0_6StringENS1_10ThreadTypeElNS1_14ThreadPriorityE");
852 if (tmpPtr == NULL || dlerror() != NULL) {
853 perror("dlsym failed : Tizen::Base::Runtime::Thread::Construct");
857 memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
861 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
862 setProbePoint(&probeInfo);
866 ret = (this->*Constructp)(name, threadType, stackSize, priority);
868 if (postBlockBegin(blockresult)) {
870 WcharToChar(temp, name.GetPointer());
873 PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
874 API_ID_result_Thread__Construct_const_Tizen__Base__String__name__ThreadType_threadType__long_stackSize__ThreadPriority_priority_,
875 "sdxd", temp, threadType,
876 (uint64_t)(stackSize), priority);
877 PACK_COMMON_END('p', ret, ret, blockresult);
878 PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_NEW);
885 result Thread::Construct(IRunnable &target, long stackSize,
886 ThreadPriority priority) {
888 (Thread::*methodType)(IRunnable &target, long stackSize,
889 ThreadPriority priority);
890 static methodType Constructp = 0;
892 probeInfo_t probeInfo;
894 bool bfiltering = true;
899 if(lib_handle[LIBOSP_APPFW] == NULL) {
900 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
901 if (lib_handle[LIBOSP_APPFW] == NULL) {
902 perror("dlopen failed : libosp-appfw.so");
908 lib_handle[LIBOSP_APPFW],
909 "_ZN5Tizen4Base7Runtime6Thread9ConstructERNS1_9IRunnableElNS1_14ThreadPriorityE");
911 if (tmpPtr == NULL || dlerror() != NULL) {
912 perror("dlsym failed : Tizen::Base::Runtime::Thread::Construct");
916 memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
920 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
921 setProbePoint(&probeInfo);
925 ret = (this->*Constructp)(target, stackSize, priority);
927 if (postBlockBegin(blockresult)) {
930 PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
931 API_ID_result_Thread__Construct_IRunnable__target__long_stackSize__ThreadPriority_priority_,
932 "xxd", (uint64_t)(&target),
933 (uint64_t)(stackSize), priority);
934 PACK_COMMON_END('p', ret, ret, blockresult);
935 PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_NEW);
942 result Thread::Construct(const Tizen::Base::String &name, IRunnable &target,
943 long stackSize, ThreadPriority priority) {
945 (Thread::*methodType)(const Tizen::Base::String &name, IRunnable &target,
946 long stackSize, ThreadPriority priority);
947 static methodType Constructp = 0;
949 probeInfo_t probeInfo;
951 bool bfiltering = true;
957 if(lib_handle[LIBOSP_APPFW] == NULL) {
958 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
959 if (lib_handle[LIBOSP_APPFW] == NULL) {
960 perror("dlopen failed : libosp-appfw.so");
966 lib_handle[LIBOSP_APPFW],
967 "_ZN5Tizen4Base7Runtime6Thread9ConstructERKNS0_6StringERNS1_9IRunnableElNS1_14ThreadPriorityE");
969 if (tmpPtr == NULL || dlerror() != NULL) {
970 perror("dlsym failed : Tizen::Base::Runtime::Thread::Construct");
974 memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
978 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
979 setProbePoint(&probeInfo);
983 ret = (this->*Constructp)(name, target, stackSize, priority);
985 if (postBlockBegin(blockresult)) {
987 WcharToChar(temp, name.GetPointer());
990 PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
991 API_ID_result_Thread__Construct_const_Tizen__Base__String__name__IRunnable__target__long_stackSize__ThreadPriority_priority_,
992 "sxxd", temp, (uint64_t)(&target),
993 (uint64_t)(stackSize), priority);
994 PACK_COMMON_END('p', ret, ret, blockresult);
995 PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_NEW);
1003 result Thread::GetExitCode(int &exitCode) const {
1005 (Thread::*methodType)(int &exitCode) const;
1006 static methodType GetExitCodep = 0;
1008 probeInfo_t probeInfo;
1010 bool bfiltering = true;
1012 // int exitOld = exitCode;
1014 if (!GetExitCodep) {
1016 if(lib_handle[LIBOSP_APPFW] == NULL) {
1017 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
1018 if (lib_handle[LIBOSP_APPFW] == NULL) {
1019 perror("dlopen failed : libosp-appfw.so");
1023 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW],
1024 "_ZNK5Tizen4Base7Runtime6Thread11GetExitCodeERi");
1026 if (tmpPtr == NULL || dlerror() != NULL) {
1027 perror("dlsym failed : Tizen::Base::Runtime::Thread::GetExitCode");
1031 memcpy(&GetExitCodep, &tmpPtr, sizeof(tmpPtr));
1035 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
1036 setProbePoint(&probeInfo);
1040 ret = (this->*GetExitCodep)(exitCode);
1042 if (postBlockBegin(blockresult)) {
1044 PREPARE_LOCAL_BUF();
1045 PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
1046 API_ID_result_Thread__GetExitCode_int__exitCode__const,
1048 PACK_COMMON_END('p', ret, ret, blockresult);
1049 PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_OTHER);
1057 const Tizen::Base::String & Thread::GetName(void) const {
1058 typedef const Tizen::Base::String &
1059 (Thread::*methodType)(void) const;
1060 static methodType GetNamep = 0;
1061 probeInfo_t probeInfo;
1063 bool bfiltering = true;
1069 if(lib_handle[LIBOSP_APPFW] == NULL) {
1070 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
1071 if (lib_handle[LIBOSP_APPFW] == NULL) {
1072 perror("dlopen failed : libosp-appfw.so");
1076 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZNK5Tizen4Base7Runtime6Thread7GetNameEv");
1078 if (tmpPtr == NULL || dlerror() != NULL) {
1079 perror("dlsym failed : Tizen::Base::Runtime::Thread::GetName");
1083 memcpy(&GetNamep, &tmpPtr, sizeof(tmpPtr));
1087 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
1088 setProbePoint(&probeInfo);
1092 const Tizen::Base::String& ret = (this->*GetNamep)();
1093 result res = GetLastResult();
1095 if (postBlockBegin(blockresult)) {
1097 WcharToChar(temp, ret.GetPointer());
1099 PREPARE_LOCAL_BUF();
1100 PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
1101 API_ID_const_Tizen__Base__String___Thread__GetName_void__const,
1103 PACK_COMMON_END('p', ret.GetPointer(), res, blockresult);
1104 PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_OTHER);
1112 result Thread::Join(void) {
1114 (Thread::*methodType)(void);
1115 static methodType Joinp = 0;
1117 probeInfo_t probeInfo;
1119 bool bfiltering = true;
1124 if(lib_handle[LIBOSP_APPFW] == NULL) {
1125 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
1126 if (lib_handle[LIBOSP_APPFW] == NULL) {
1127 perror("dlopen failed : libosp-appfw.so");
1131 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime6Thread4JoinEv");
1133 if (tmpPtr == NULL || dlerror() != NULL) {
1134 perror("dlsym failed : Tizen::Base::Runtime::Thread::Join");
1138 memcpy(&Joinp, &tmpPtr, sizeof(tmpPtr));
1142 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
1143 setProbePoint(&probeInfo);
1145 PREPARE_LOCAL_BUF();
1146 PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
1147 API_ID_result_Thread__Join_void_,
1149 PACK_COMMON_END('p', 0, 0, blockresult);
1150 PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_WAIT_START);
1156 ret = (this->*Joinp)();
1158 if (postBlockBegin(blockresult)) {
1159 setProbePoint(&probeInfo);
1161 PREPARE_LOCAL_BUF();
1162 PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
1163 API_ID_result_Thread__Join_void_,
1165 PACK_COMMON_END('p', ret, ret, blockresult);
1166 PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_WAIT_END);
1173 //Tizen::Base::Object * Thread::Run(void) {
1174 // typedef Tizen::Base::Object * (Thread::*methodType)(void);
1175 // static methodType Runp = 0;
1176 // Tizen::Base::Object * ret;
1177 // probeInfo_t probeInfo;
1180 // bool bfiltering = true;
1184 // log.data[0] = '\0';
1185 // log.length = sprintf(log.data, "call Thread::Run");
1186 // printLog(&log, MSG_MSG);
1189 // probeBlockStart();
1190 // void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
1191 // if (lib_handle == NULL) {
1192 // perror("dlopen failed : libosp-appfw.so");
1195 // log.data[0] = '\0';
1196 // log.length = sprintf(log.data, "dlopen failed :libosp-appfw.so");
1197 // printLog(&log, MSG_MSG);
1203 // "_ZN5Tizen4Base7Runtime6Thread3RunEv");
1205 // if (tmpPtr == NULL || dlerror() != NULL) {
1206 // perror("dlsym failed : Thread::Run");
1209 // log.data[0] = '\0';
1210 // log.length = sprintf(log.data, "dlsym failed : Thread::Run");
1211 // printLog(&log, MSG_MSG);
1215 // memcpy(&Runp, &tmpPtr, sizeof(tmpPtr));
1219 // if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
1220 // setProbePoint(&probeInfo);
1224 // ret = (this->*Runp)();
1226 // if (postBlockBegin(blockresult)) {
1229 // log.data[0] = '\0';
1230 // log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_THREAD,
1231 // probeInfo.eventIndex, "Thread::Run",
1232 // probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
1234 // log.length += sprintf(log.data + log.length, "`,`,0x%x",(unsigned int)ret;
1235 // //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
1238 // log.length += sprintf(log.data + log.length,
1239 // "`,0`,0`,%d`,0`,0x%x`,%d`,%d`,`,", blockresult,
1240 // (unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_OTHER);
1242 // log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
1243 // getBacktraceString(&log, 4096 - log.length - 17);
1244 // log.length += sprintf(log.data + log.length, "`,callstack_end");
1246 // printLog(&log, MSG_LOG);
1252 result Thread::Start(void) {
1253 typedef result (Thread::*methodType)(void);
1254 static methodType Startp = 0;
1256 probeInfo_t probeInfo;
1258 bool bfiltering = true;
1263 if(lib_handle[LIBOSP_APPFW] == NULL) {
1264 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
1265 if (lib_handle[LIBOSP_APPFW] == NULL) {
1266 perror("dlopen failed : libosp-appfw.so");
1270 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime6Thread5StartEv");
1272 if (tmpPtr == NULL || dlerror() != NULL) {
1273 perror("dlsym failed : Tizen::Base::Runtime::Thread::Start");
1277 memcpy(&Startp, &tmpPtr, sizeof(tmpPtr));
1281 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
1282 setProbePoint(&probeInfo);
1286 ret = (this->*Startp)();
1288 if (postBlockBegin(blockresult)) {
1290 PREPARE_LOCAL_BUF();
1291 PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
1292 API_ID_result_Thread__Start_void_,
1294 PACK_COMMON_END('p', ret, ret, blockresult);
1295 PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_START);
1302 result Thread::Stop(void) {
1303 typedef result (Thread::*methodType)(void);
1304 static methodType Stopp = 0;
1306 probeInfo_t probeInfo;
1308 bool bfiltering = true;
1313 if(lib_handle[LIBOSP_APPFW] == NULL) {
1314 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
1315 if (lib_handle[LIBOSP_APPFW] == NULL) {
1316 perror("dlopen failed : libosp-appfw.so");
1320 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime6Thread4StopEv");
1322 if (tmpPtr == NULL || dlerror() != NULL) {
1323 perror("dlsym failed : Tizen::Base::Runtime::Thread::Stop");
1327 memcpy(&Stopp, &tmpPtr, sizeof(tmpPtr));
1331 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
1332 setProbePoint(&probeInfo);
1336 ret = (this->*Stopp)();
1338 if (postBlockBegin(blockresult)) {
1340 PREPARE_LOCAL_BUF();
1341 PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
1342 API_ID_result_Thread__Stop_void_,
1344 PACK_COMMON_END('p', ret, ret, blockresult);
1345 PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_STOP);
1353 result EventDrivenThread::Construct(long stackSize, ThreadPriority priority) {
1355 (Thread::*methodType)(long stackSize, ThreadPriority priority);
1356 static methodType Constructp = 0;
1358 probeInfo_t probeInfo;
1360 bool bfiltering = true;
1365 if(lib_handle[LIBOSP_APPFW] == NULL) {
1366 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
1367 if (lib_handle[LIBOSP_APPFW] == NULL) {
1368 perror("dlopen failed : libosp-appfw.so");
1372 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW],
1373 "_ZN5Tizen4Base7Runtime17EventDrivenThread9ConstructElNS1_14ThreadPriorityE");
1374 if (tmpPtr == NULL || dlerror() != NULL) {
1375 perror("dlsym failed : Tizen::Base::Runtime::EventDrivenThread::Construct");
1379 memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
1383 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
1384 setProbePoint(&probeInfo);
1388 ret = (this->*Constructp)(stackSize, priority);
1390 if (postBlockBegin(blockresult)) {
1392 PREPARE_LOCAL_BUF();
1393 PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
1394 API_ID_result_EventDrivenThread__Construct_long_stackSize__ThreadPriority_priority_,
1395 "xd", (uint64_t)(stackSize), priority);
1396 PACK_COMMON_END('p', ret, ret, blockresult);
1397 PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_EVENTDRIVEN, THREAD_API_NEW);
1405 result EventDrivenThread::Construct(const Tizen::Base::String &name, long stackSize,
1406 ThreadPriority priority) {
1408 (Thread::*methodType)(const Tizen::Base::String &name, long stackSize,
1409 ThreadPriority priority);
1410 static methodType Constructp = 0;
1412 probeInfo_t probeInfo;
1414 bool bfiltering = true;
1420 if(lib_handle[LIBOSP_APPFW] == NULL) {
1421 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
1422 if (lib_handle[LIBOSP_APPFW] == NULL) {
1423 perror("dlopen failed : libosp-appfw.so");
1429 lib_handle[LIBOSP_APPFW],
1430 "_ZN5Tizen4Base7Runtime17EventDrivenThread9ConstructERKNS0_6StringElNS1_14ThreadPriorityE");
1432 if (tmpPtr == NULL || dlerror() != NULL) {
1433 perror("dlsym failed : Tizen::Base::Runtime::EventDrivenThread::Construct");
1437 memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
1441 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
1442 setProbePoint(&probeInfo);
1446 ret = (this->*Constructp)(name, stackSize, priority);
1448 if (postBlockBegin(blockresult)) {
1450 WcharToChar(temp, name.GetPointer());
1452 PREPARE_LOCAL_BUF();
1453 PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
1454 API_ID_result_EventDrivenThread__Construct_const_Tizen__Base__String__name__long_stackSize__ThreadPriority_priority_,
1455 "sx", temp, (uint64_t)(stackSize));
1456 PACK_COMMON_END('p', ret, ret, blockresult);
1457 PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_EVENTDRIVEN, THREAD_API_NEW);
1466 result EventDrivenThread::Quit() {
1467 typedef result (Thread::*methodType)(void);
1468 static methodType Quitp = 0;
1470 probeInfo_t probeInfo;
1472 bool bfiltering = true;
1477 if(lib_handle[LIBOSP_APPFW] == NULL) {
1478 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
1479 if (lib_handle[LIBOSP_APPFW] == NULL) {
1480 perror("dlopen failed : libosp-appfw.so");
1484 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime17EventDrivenThread4QuitEv");
1486 if (tmpPtr == NULL || dlerror() != NULL) {
1487 perror("dlsym failed : Tizen::Base::Runtime::EventThread::Quit");
1491 memcpy(&Quitp, &tmpPtr, sizeof(tmpPtr));
1495 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
1496 setProbePoint(&probeInfo);
1500 ret = (this->*Quitp)();
1502 if (postBlockBegin(blockresult)) {
1504 PREPARE_LOCAL_BUF();
1505 PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
1506 API_ID_result_EventDrivenThread__Quit__,
1508 PACK_COMMON_END('p', ret, ret, blockresult);
1509 PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_EVENTDRIVEN, THREAD_API_STOP);