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
38 #include "probeinfo.h"
43 static enum DaOptions _sopt = OPT_THREAD;
51 // virtual result Stop(void);
53 // virtual result Finalize(void);
54 const Thread* GetThread(void) const;
56 static void* ThreadProc(void* pParam);
61 //_ThreadImpl::GetThread(void) const
63 // typedef const Thread*
64 // (_ThreadImpl::*methodType)(void) const;
65 // static methodType GetThreadp = 0;
66 // probeInfo_t probeInfo;
69 // bool bfiltering = false;
74 // void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
75 // if (lib_handle == NULL) {
76 // perror("dlopen failed : libosp-appfw.so");
79 // tmpPtr = dlsym(lib_handle, "_ZNK5Tizen4Base7Runtime11_ThreadImpl9GetThreadEv");
81 // if (tmpPtr == NULL || dlerror() != NULL) {
82 // perror("dlsym failed : Tizen::Base::Runtime::_ThreadImpl::GetThreadp");
86 // memcpy(&GetThreadp, &tmpPtr, sizeof(tmpPtr));
91 // if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
92 // setProbePoint(&probeInfo);
96 // const Thread* ret = (this->*GetThreadp)();
97 // result res = GetLastResult();
99 // if (postBlockBegin(blockresult)) {
102 // log.data[0] = '\0';
103 // log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_THREAD,
104 // probeInfo.eventIndex, "_ThreadImpl::GetThread", probeInfo.currentTime,
105 // probeInfo.pID, probeInfo.tID);
108 // log.length += sprintf(log.data + log.length, "`,`,0x%x",ret);
109 // //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
110 // log.length += sprintf(log.data + log.length,
111 // "`,0`,%ld`,%d`,0`,%u`,0x%x`,%d`,%d`,`,", res,blockresult,
112 // (unsigned int)CALLER_ADDRESS, (unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_OTHER);
114 // log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
115 // getBacktraceString(&log, 4096 - log.length - 17);
116 // log.length += sprintf(log.data + log.length, "`,callstack_end");
118 // printLog(&log, MSG_LOG);
125 _ThreadImpl::ThreadProc(void* params) {
127 (*methodType)(void*);
128 static methodType ThreadProcp = 0;
129 probeInfo_t probeInfo;
131 bool bfiltering = false;
137 if(lib_handle[LIBOSP_APPFW] == NULL) {
138 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
139 if (lib_handle[LIBOSP_APPFW] == NULL) {
140 perror("dlopen failed : libosp-appfw.so");
144 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime11_ThreadImpl10ThreadProcEPv");
146 if (tmpPtr == NULL || dlerror() != NULL) {
147 perror("dlsym failed : Tizen::Base::Runtime::_ThreadImpl::ThreadProc");
151 memcpy(&ThreadProcp, &tmpPtr, sizeof(tmpPtr));
156 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
157 setProbePoint(&probeInfo);
159 _ThreadImpl* pSelf =(_ThreadImpl*)params;
160 const Thread* pThread = NULL;
162 pThread = pSelf->GetThread();
166 PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
167 API_ID_void___ThreadImpl__ThreadProc_void__params_,
168 "p", voidp_to_uint64(params));
169 PACK_COMMON_END('p', 0, 0, blockresult);
170 PACK_THREAD((unsigned int)pThread, THREAD_TIZENTHREAD_WORKER, THREAD_API_INTERNAL_START, THREAD_CLASS_BLANK);
176 // all probe should be reachable inside thread start_routine (user implemented Thread::Run)
177 ret = (ThreadProcp)(params);
179 if (postBlockBegin(blockresult)) {
181 setProbePoint(&probeInfo);
183 _ThreadImpl* pSelf =(_ThreadImpl*)params;
184 const Thread* pThread = NULL;
186 pThread = pSelf->GetThread();
190 PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
191 API_ID_void___ThreadImpl__ThreadProc_void__params_,
192 "p", voidp_to_uint64(params));
193 PACK_COMMON_END('p', ret, 0, blockresult);
194 PACK_THREAD((unsigned int)pThread, THREAD_TIZENTHREAD_WORKER, THREAD_API_INTERNAL_STOP, THREAD_CLASS_BLANK);
201 //result _ThreadImpl::Stop(void) {
203 // (_ThreadImpl::*methodType)(void);
204 // static methodType Stopp = 0;
205 // probeInfo_t probeInfo;
208 // bool bfiltering = true;
212 // probeBlockStart();
213 // void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
214 // if (lib_handle == NULL) {
215 // perror("dlopen failed : libosp-appfw.so");
218 // tmpPtr = dlsym(lib_handle, "_ZN5Tizen4Base7Runtime11_ThreadImpl4StopEv");
220 // if (tmpPtr == NULL || dlerror() != NULL) {
221 // perror("dlsym failed : Tizen::Base::Runtime::_ThreadImpl::Stopp");
225 // memcpy(&Stopp, &tmpPtr, sizeof(tmpPtr));
230 // if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
231 // setProbePoint(&probeInfo);
235 // result ret= (this->*Stopp)();
237 // if (postBlockBegin(blockresult)) {
240 // log.data[0] = '\0';
241 // log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_THREAD,
242 // probeInfo.eventIndex, "_ThreadImpl::Stop", probeInfo.currentTime,
243 // probeInfo.pID, probeInfo.tID);
245 // log.length += sprintf(log.data + log.length, "`,`,%ld", ret);
246 // //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
247 // log.length += sprintf(log.data + log.length,
248 // "`,0`,%ld`,%d`,0`,%u`,0x%x`,%d`,%d`,`,", ret, blockresult,
249 // (unsigned int)CALLER_ADDRESS, (unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_CLOSE);
251 // log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
252 // getBacktraceString(&log, 4096 - log.length - 17);
253 // log.length += sprintf(log.data + log.length, "`,callstack_end");
255 // printLog(&log, MSG_LOG);
261 //result _ThreadImpl::Finalize(void) {
263 // (_ThreadImpl::*methodType)(void);
264 // static methodType Finalizep = 0;
265 // probeInfo_t probeInfo;
268 // bool bfiltering = false;
272 // probeBlockStart();
273 // void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
274 // if (lib_handle == NULL) {
275 // perror("dlopen failed : libosp-appfw.so");
278 // tmpPtr = dlsym(lib_handle, "_ZN5Tizen4Base7Runtime11_ThreadImpl8FinalizeEv");
280 // if (tmpPtr == NULL || dlerror() != NULL) {
281 // perror("dlsym failed : Tizen::Base::Runtime::_ThreadImpl::Finalizep");
285 // memcpy(&Finalizep, &tmpPtr, sizeof(tmpPtr));
289 // if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
290 // setProbePoint(&probeInfo);
294 // result ret= (this->*Finalizep)();
296 // if (postBlockBegin(blockresult)) {
299 // log.data[0] = '\0';
300 // log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_THREAD,
301 // probeInfo.eventIndex, "_ThreadImpl::Finalize", probeInfo.currentTime,
302 // probeInfo.pID, probeInfo.tID);
304 // log.length += sprintf(log.data + log.length, "`,`,%ld", ret);
305 // //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
306 // log.length += sprintf(log.data + log.length,
307 // "`,0`,%ld`,%d`,0`,%u`,0x%x`,%d`,%d`,`,", ret, blockresult,
308 // (unsigned int)CALLER_ADDRESS, (unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_CLOSE);
310 // log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
311 // getBacktraceString(&log, 4096 - log.length - 17);
312 // log.length += sprintf(log.data + log.length, "`,callstack_end");
314 // printLog(&log, MSG_LOG);
319 //Thread::Thread(void) {
320 // typedef void (Thread::*methodType)();
321 // static methodType Threadp = 0;
322 // probeInfo_t probeInfo;
325 // bool bfiltering = true;
329 // probeBlockStart();
331 // tmpPtr = dlsym(RTLD_NEXT, "_ZN5Tizen4Base7Runtime6ThreadC1Ev");
333 // if (tmpPtr == NULL || dlerror() != NULL) {
336 // log.data[0] = '\0';
337 // log.length = sprintf(log.data,"dlsym failed : Tizen::Base::Runtime::Thread::Thread");
338 // perror("dlsym failed : Tizen::Base::Runtime::Thread::Thread");
339 // printLog(&log, MSG_MSG);
343 // memcpy(&Threadp, &tmpPtr, sizeof(tmpPtr));
347 // if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
348 // setProbePoint(&probeInfo);
352 // (this->*Threadp)();
354 // if (postBlockBegin(blockresult)) {
357 // log.data[0] = '\0';
358 // log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_THREAD,
359 // probeInfo.eventIndex, "Thread::Thread", probeInfo.currentTime,
360 // probeInfo.pID, probeInfo.tID);
362 // log.length += sprintf(log.data + log.length, "`,`,");
363 // //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
365 // log.length += sprintf(log.data + log.length,
366 // "`,0`,0`,%d`,0`,0x%x`,%d`,%d`,`,", blockresult,
367 // (unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_OPEN);
369 // log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
370 // getBacktraceString(&log, 4096 - log.length - 17);
371 // log.length += sprintf(log.data + log.length, "`,callstack_end");
373 // printLog(&log, MSG_LOG);
378 //Thread::~Thread(void) {
379 // typedef void (Thread::*methodType)();
380 // static methodType ThreadDp = 0;
381 // probeInfo_t probeInfo;
384 // bool bfiltering = true;
388 // probeBlockStart();
390 // void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
391 // if (lib_handle == NULL) {
392 // perror("dlopen failed : libosp-appfw.so");
395 // tmpPtr = dlsym(lib_handle, "_ZN5Tizen4Base7Runtime6ThreadD0Ev");
397 // if (tmpPtr == NULL || dlerror() != NULL) {
398 // perror("dlsym failed : Tizen::Base::Runtime::Thread::~Thread");
402 // memcpy(&ThreadDp, &tmpPtr, sizeof(tmpPtr));
406 // if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
407 // setProbePoint(&probeInfo);
411 // (this->*ThreadDp)();
413 // if (postBlockBegin(blockresult)) {
416 // log.data[0] = '\0';
417 // log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_THREAD,
418 // probeInfo.eventIndex, "Thread::~Thread", probeInfo.currentTime,
419 // probeInfo.pID, probeInfo.tID);
421 // log.length += sprintf(log.data + log.length, "`,`,");
422 // //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
424 // log.length += sprintf(log.data + log.length,
425 // "`,0`,0`,%d`,0`,0x%x`,%d`,%d`,`,", blockresult,
426 // (unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_CLOSE);
428 // log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
429 // getBacktraceString(&log, 4096 - log.length - 17);
430 // log.length += sprintf(log.data + log.length, "`,callstack_end");
432 // printLog(&log, MSG_LOG);
436 result Thread::Sleep(long milliSeconds) {
439 static methodType Sleepp = 0;
440 probeInfo_t probeInfo;
442 bool bfiltering = true;
447 if(lib_handle[LIBOSP_APPFW] == NULL) {
448 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
449 if (lib_handle[LIBOSP_APPFW] == NULL) {
450 perror("dlopen failed : libosp-appfw.so");
454 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime6Thread5SleepEl");
456 if (tmpPtr == NULL || dlerror() != NULL) {
457 perror("dlsym failed : Tizen::Base::Runtime::Thread::Sleep");
461 memcpy(&Sleepp, &tmpPtr, sizeof(tmpPtr));
466 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
467 setProbePoint(&probeInfo);
469 Thread *currentThread;
470 currentThread = GetCurrentThread();
473 PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
474 API_ID_result_Thread__Sleep_long_milliSeconds_,
475 "x", (uint64_t)(milliSeconds));
476 PACK_COMMON_END('x', 0, 0, blockresult);
477 PACK_THREAD((unsigned int)currentThread, THREAD_TIZENTHREAD_WORKER, THREAD_API_WAIT_START, THREAD_CLASS_BLANK);
483 result ret = (Sleepp)(milliSeconds);
485 if (postBlockBegin(blockresult)) {
486 setProbePoint(&probeInfo);
488 Thread *currentThread;
489 currentThread = GetCurrentThread();
492 PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
493 API_ID_result_Thread__Yield_void_,
494 "x", (uint64_t)(milliSeconds));
495 PACK_COMMON_END('x', ret, ret, blockresult);
496 PACK_THREAD((unsigned int)currentThread, THREAD_TIZENTHREAD_WORKER, THREAD_API_WAIT_END, THREAD_CLASS_BLANK);
504 Thread* Thread::GetCurrentThread(void) {
507 static methodType GetCurrentThreadp = 0;
508 probeInfo_t probeInfo;
510 bool bfiltering = true;
513 if (!GetCurrentThreadp) {
515 if(lib_handle[LIBOSP_APPFW] == NULL) {
516 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
517 if (lib_handle[LIBOSP_APPFW] == NULL) {
518 perror("dlopen failed : libosp-appfw.so");
522 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime6Thread16GetCurrentThreadEv");
524 if (tmpPtr == NULL || dlerror() != NULL) {
525 perror("dlsym failed : Tizen::Base::Runtime::Thread::GetCurrentThread");
529 memcpy(&GetCurrentThreadp, &tmpPtr, sizeof(tmpPtr));
534 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
535 setProbePoint(&probeInfo);
539 Thread *currentThread = (GetCurrentThreadp)();
540 result res = GetLastResult();
542 if (postBlockBegin(blockresult)) {
545 PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
546 API_ID_Thread__Thread__GetCurrentThread_void_,
548 PACK_COMMON_END('p', voidp_to_uint64(currentThread),
550 PACK_THREAD((unsigned int)currentThread, THREAD_TIZENTHREAD_WORKER, THREAD_API_OTHER, THREAD_CLASS_BLANK);
555 return currentThread;
558 result Thread::Yield(void) {
561 static methodType Yieldp = 0;
562 probeInfo_t probeInfo;
564 bool bfiltering = true;
569 if(lib_handle[LIBOSP_APPFW] == NULL) {
570 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
571 if (lib_handle[LIBOSP_APPFW] == NULL) {
572 perror("dlopen failed : libosp-appfw.so");
576 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime6Thread5YieldEv");
578 if (tmpPtr == NULL || dlerror() != NULL) {
579 perror("dlsym failed : Tizen::Base::Runtime::Thread::Yield");
583 memcpy(&Yieldp, &tmpPtr, sizeof(tmpPtr));
588 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
589 setProbePoint(&probeInfo);
593 result ret = (Yieldp)();
595 if (postBlockBegin(blockresult)) {
596 Thread *currentThread;
597 currentThread = GetCurrentThread();
600 PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
601 API_ID_result_Thread__Yield_void_,
603 PACK_COMMON_END('x', ret, ret, blockresult);
604 PACK_THREAD((unsigned int)currentThread, THREAD_TIZENTHREAD_WORKER, THREAD_API_OTHER, THREAD_CLASS_BLANK);
612 result Thread::Exit(int exitCode) {
614 (*methodType)(int exitCode);
615 static methodType Exitp = 0;
616 probeInfo_t probeInfo;
618 bool bfiltering = true;
623 if(lib_handle[LIBOSP_APPFW] == NULL) {
624 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
625 if (lib_handle[LIBOSP_APPFW] == NULL) {
626 perror("dlopen failed : libosp-appfw.so");
630 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime6Thread4ExitEi");
632 if (tmpPtr == NULL || dlerror() != NULL) {
633 perror("dlsym failed : Tizen::Base::Runtime::Thread::Exit");
637 memcpy(&Exitp, &tmpPtr, sizeof(tmpPtr));
642 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
643 setProbePoint(&probeInfo);
645 Thread *currentThread;
646 currentThread = GetCurrentThread();
649 PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
650 API_ID_result_Thread__Exit_int_exitCode_,
652 PACK_COMMON_END('n', 0, 0, blockresult);
653 PACK_THREAD((unsigned int)currentThread, THREAD_TIZENTHREAD_WORKER, THREAD_API_EXIT, THREAD_CLASS_BLANK);
659 result ret = (Exitp)(exitCode);
664 result Thread::Construct(ThreadType threadType, long stackSize,
665 ThreadPriority priority) {
667 (Thread::*methodType)(ThreadType threadType, long stackSize,
668 ThreadPriority priority);
669 static methodType Constructp = 0;
671 probeInfo_t probeInfo;
673 bool bfiltering = true;
678 if(lib_handle[LIBOSP_APPFW] == NULL) {
679 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
680 if (lib_handle[LIBOSP_APPFW] == NULL) {
681 perror("dlopen failed : libosp-appfw.so");
687 lib_handle[LIBOSP_APPFW],
688 "_ZN5Tizen4Base7Runtime6Thread9ConstructENS1_10ThreadTypeElNS1_14ThreadPriorityE");
690 if (tmpPtr == NULL || dlerror() != NULL) {
691 perror("dlsym failed : Tizen::Base::Runtime::Thread::Construct");
695 memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
699 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
700 setProbePoint(&probeInfo);
704 ret = (this->*Constructp)(threadType, stackSize, priority);
706 if (postBlockBegin(blockresult)) {
709 PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
710 API_ID_result_Thread__Construct_ThreadType_threadType__long_stackSize__ThreadPriority_priority_,
711 "dxd", threadType, (uint64_t)(stackSize),
713 PACK_COMMON_END('x', ret, ret, blockresult);
714 PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_NEW, THREAD_CLASS_BLANK);
721 result Thread::Construct(long stackSize, ThreadPriority priority) {
723 (Thread::*methodType)(long stackSize, ThreadPriority priority);
724 static methodType Constructp = 0;
726 probeInfo_t probeInfo;
728 bool bfiltering = true;
733 if(lib_handle[LIBOSP_APPFW] == NULL) {
734 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
735 if (lib_handle[LIBOSP_APPFW] == NULL) {
736 perror("dlopen failed : libosp-appfw.so");
740 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW],
741 "_ZN5Tizen4Base7Runtime6Thread9ConstructElNS1_14ThreadPriorityE");
742 if (tmpPtr == NULL || dlerror() != NULL) {
743 perror("dlsym failed : Tizen::Base::Runtime::Thread::Construct");
747 memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
751 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
752 setProbePoint(&probeInfo);
756 ret = (this->*Constructp)(stackSize, priority);
758 if (postBlockBegin(blockresult)) {
761 PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
762 API_ID_result_Thread__Construct_long_stackSize__ThreadPriority_priority_,
763 "xd", (uint64_t)(stackSize), priority);
764 PACK_COMMON_END('x', ret, ret, blockresult);
765 PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_NEW, THREAD_CLASS_BLANK);
772 result Thread::Construct(const Tizen::Base::String &name, long stackSize,
773 ThreadPriority priority) {
775 (Thread::*methodType)(const Tizen::Base::String &name, long stackSize,
776 ThreadPriority priority);
777 static methodType Constructp = 0;
779 probeInfo_t probeInfo;
781 bool bfiltering = true;
787 if(lib_handle[LIBOSP_APPFW] == NULL) {
788 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
789 if (lib_handle[LIBOSP_APPFW] == NULL) {
790 perror("dlopen failed : libosp-appfw.so");
796 lib_handle[LIBOSP_APPFW],
797 "_ZN5Tizen4Base7Runtime6Thread9ConstructERKNS0_6StringElNS1_14ThreadPriorityE");
799 if (tmpPtr == NULL || dlerror() != NULL) {
800 perror("dlsym failed : Tizen::Base::Runtime::Thread::Construct");
804 memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
808 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
809 setProbePoint(&probeInfo);
813 ret = (this->*Constructp)(name, stackSize, priority);
815 if (postBlockBegin(blockresult)) {
818 PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
819 API_ID_result_Thread__Construct_const_Tizen__Base__String__name__long_stackSize__ThreadPriority_priority_,
820 "sxd", temp, (uint64_t)(stackSize), priority);
821 PACK_COMMON_END('x', ret, ret, blockresult);
822 PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_NEW, THREAD_CLASS_BLANK);
829 result Thread::Construct(const Tizen::Base::String &name, ThreadType threadType,
830 long stackSize, ThreadPriority priority) {
832 (Thread::*methodType)(const Tizen::Base::String &name, ThreadType threadType,
833 long stackSize, ThreadPriority priority);
834 static methodType Constructp = 0;
836 probeInfo_t probeInfo;
838 bool bfiltering = true;
844 if(lib_handle[LIBOSP_APPFW] == NULL) {
845 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
846 if (lib_handle[LIBOSP_APPFW] == NULL) {
847 perror("dlopen failed : libosp-appfw.so");
854 lib_handle[LIBOSP_APPFW],
855 "_ZN5Tizen4Base7Runtime6Thread9ConstructERKNS0_6StringENS1_10ThreadTypeElNS1_14ThreadPriorityE");
856 if (tmpPtr == NULL || dlerror() != NULL) {
857 perror("dlsym failed : Tizen::Base::Runtime::Thread::Construct");
861 memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
865 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
866 setProbePoint(&probeInfo);
870 ret = (this->*Constructp)(name, threadType, stackSize, priority);
872 if (postBlockBegin(blockresult)) {
874 WcharToChar(temp, name.GetPointer());
877 PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
878 API_ID_result_Thread__Construct_const_Tizen__Base__String__name__ThreadType_threadType__long_stackSize__ThreadPriority_priority_,
879 "sdxd", temp, threadType,
880 (uint64_t)(stackSize), priority);
881 PACK_COMMON_END('x', ret, ret, blockresult);
882 PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_NEW, THREAD_CLASS_BLANK);
889 result Thread::Construct(IRunnable &target, long stackSize,
890 ThreadPriority priority) {
892 (Thread::*methodType)(IRunnable &target, long stackSize,
893 ThreadPriority priority);
894 static methodType Constructp = 0;
896 probeInfo_t probeInfo;
898 bool bfiltering = true;
903 if(lib_handle[LIBOSP_APPFW] == NULL) {
904 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
905 if (lib_handle[LIBOSP_APPFW] == NULL) {
906 perror("dlopen failed : libosp-appfw.so");
912 lib_handle[LIBOSP_APPFW],
913 "_ZN5Tizen4Base7Runtime6Thread9ConstructERNS1_9IRunnableElNS1_14ThreadPriorityE");
915 if (tmpPtr == NULL || dlerror() != NULL) {
916 perror("dlsym failed : Tizen::Base::Runtime::Thread::Construct");
920 memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
924 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
925 setProbePoint(&probeInfo);
929 ret = (this->*Constructp)(target, stackSize, priority);
931 if (postBlockBegin(blockresult)) {
934 PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
935 API_ID_result_Thread__Construct_IRunnable__target__long_stackSize__ThreadPriority_priority_,
936 "xxd", (uint64_t)(&target),
937 (uint64_t)(stackSize), priority);
938 PACK_COMMON_END('x', ret, ret, blockresult);
939 PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_NEW, THREAD_CLASS_BLANK);
946 result Thread::Construct(const Tizen::Base::String &name, IRunnable &target,
947 long stackSize, ThreadPriority priority) {
949 (Thread::*methodType)(const Tizen::Base::String &name, IRunnable &target,
950 long stackSize, ThreadPriority priority);
951 static methodType Constructp = 0;
953 probeInfo_t probeInfo;
955 bool bfiltering = true;
961 if(lib_handle[LIBOSP_APPFW] == NULL) {
962 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
963 if (lib_handle[LIBOSP_APPFW] == NULL) {
964 perror("dlopen failed : libosp-appfw.so");
970 lib_handle[LIBOSP_APPFW],
971 "_ZN5Tizen4Base7Runtime6Thread9ConstructERKNS0_6StringERNS1_9IRunnableElNS1_14ThreadPriorityE");
973 if (tmpPtr == NULL || dlerror() != NULL) {
974 perror("dlsym failed : Tizen::Base::Runtime::Thread::Construct");
978 memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
982 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
983 setProbePoint(&probeInfo);
987 ret = (this->*Constructp)(name, target, stackSize, priority);
989 if (postBlockBegin(blockresult)) {
991 WcharToChar(temp, name.GetPointer());
994 PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
995 API_ID_result_Thread__Construct_const_Tizen__Base__String__name__IRunnable__target__long_stackSize__ThreadPriority_priority_,
996 "sxxd", temp, (uint64_t)(&target),
997 (uint64_t)(stackSize), priority);
998 PACK_COMMON_END('x', ret, ret, blockresult);
999 PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_NEW, THREAD_CLASS_BLANK);
1007 result Thread::GetExitCode(int &exitCode) const {
1009 (Thread::*methodType)(int &exitCode) const;
1010 static methodType GetExitCodep = 0;
1012 probeInfo_t probeInfo;
1014 bool bfiltering = true;
1016 // int exitOld = exitCode;
1018 if (!GetExitCodep) {
1020 if(lib_handle[LIBOSP_APPFW] == NULL) {
1021 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
1022 if (lib_handle[LIBOSP_APPFW] == NULL) {
1023 perror("dlopen failed : libosp-appfw.so");
1027 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW],
1028 "_ZNK5Tizen4Base7Runtime6Thread11GetExitCodeERi");
1030 if (tmpPtr == NULL || dlerror() != NULL) {
1031 perror("dlsym failed : Tizen::Base::Runtime::Thread::GetExitCode");
1035 memcpy(&GetExitCodep, &tmpPtr, sizeof(tmpPtr));
1039 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
1040 setProbePoint(&probeInfo);
1044 ret = (this->*GetExitCodep)(exitCode);
1046 if (postBlockBegin(blockresult)) {
1048 PREPARE_LOCAL_BUF();
1049 PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
1050 API_ID_result_Thread__GetExitCode_int__exitCode__const,
1052 PACK_COMMON_END('x', ret, ret, blockresult);
1053 PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_OTHER, THREAD_CLASS_BLANK);
1061 const Tizen::Base::String & Thread::GetName(void) const {
1062 typedef const Tizen::Base::String &
1063 (Thread::*methodType)(void) const;
1064 static methodType GetNamep = 0;
1065 probeInfo_t probeInfo;
1067 bool bfiltering = true;
1073 if(lib_handle[LIBOSP_APPFW] == NULL) {
1074 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
1075 if (lib_handle[LIBOSP_APPFW] == NULL) {
1076 perror("dlopen failed : libosp-appfw.so");
1080 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZNK5Tizen4Base7Runtime6Thread7GetNameEv");
1082 if (tmpPtr == NULL || dlerror() != NULL) {
1083 perror("dlsym failed : Tizen::Base::Runtime::Thread::GetName");
1087 memcpy(&GetNamep, &tmpPtr, sizeof(tmpPtr));
1091 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
1092 setProbePoint(&probeInfo);
1096 const Tizen::Base::String& ret = (this->*GetNamep)();
1097 result res = GetLastResult();
1099 if (postBlockBegin(blockresult)) {
1101 WcharToChar(temp, ret.GetPointer());
1103 PREPARE_LOCAL_BUF();
1104 PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
1105 API_ID_const_Tizen__Base__String___Thread__GetName_void__const,
1107 PACK_COMMON_END('p', ret.GetPointer(), res, blockresult);
1108 PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_OTHER, THREAD_CLASS_BLANK);
1116 result Thread::Join(void) {
1118 (Thread::*methodType)(void);
1119 static methodType Joinp = 0;
1121 probeInfo_t probeInfo;
1123 bool bfiltering = true;
1128 if(lib_handle[LIBOSP_APPFW] == NULL) {
1129 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
1130 if (lib_handle[LIBOSP_APPFW] == NULL) {
1131 perror("dlopen failed : libosp-appfw.so");
1135 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime6Thread4JoinEv");
1137 if (tmpPtr == NULL || dlerror() != NULL) {
1138 perror("dlsym failed : Tizen::Base::Runtime::Thread::Join");
1142 memcpy(&Joinp, &tmpPtr, sizeof(tmpPtr));
1146 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
1147 setProbePoint(&probeInfo);
1149 PREPARE_LOCAL_BUF();
1150 PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
1151 API_ID_result_Thread__Join_void_,
1153 PACK_COMMON_END('x', 0, 0, blockresult);
1154 PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_WAIT_START, THREAD_CLASS_BLANK);
1160 ret = (this->*Joinp)();
1162 if (postBlockBegin(blockresult)) {
1163 setProbePoint(&probeInfo);
1165 PREPARE_LOCAL_BUF();
1166 PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
1167 API_ID_result_Thread__Join_void_,
1169 PACK_COMMON_END('x', ret, ret, blockresult);
1170 PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_WAIT_END, THREAD_CLASS_BLANK);
1177 //Tizen::Base::Object * Thread::Run(void) {
1178 // typedef Tizen::Base::Object * (Thread::*methodType)(void);
1179 // static methodType Runp = 0;
1180 // Tizen::Base::Object * ret;
1181 // probeInfo_t probeInfo;
1184 // bool bfiltering = true;
1188 // log.data[0] = '\0';
1189 // log.length = sprintf(log.data, "call Thread::Run");
1190 // printLog(&log, MSG_MSG);
1193 // probeBlockStart();
1194 // void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
1195 // if (lib_handle == NULL) {
1196 // perror("dlopen failed : libosp-appfw.so");
1199 // log.data[0] = '\0';
1200 // log.length = sprintf(log.data, "dlopen failed :libosp-appfw.so");
1201 // printLog(&log, MSG_MSG);
1207 // "_ZN5Tizen4Base7Runtime6Thread3RunEv");
1209 // if (tmpPtr == NULL || dlerror() != NULL) {
1210 // perror("dlsym failed : Thread::Run");
1213 // log.data[0] = '\0';
1214 // log.length = sprintf(log.data, "dlsym failed : Thread::Run");
1215 // printLog(&log, MSG_MSG);
1219 // memcpy(&Runp, &tmpPtr, sizeof(tmpPtr));
1223 // if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
1224 // setProbePoint(&probeInfo);
1228 // ret = (this->*Runp)();
1230 // if (postBlockBegin(blockresult)) {
1233 // log.data[0] = '\0';
1234 // log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_THREAD,
1235 // probeInfo.eventIndex, "Thread::Run",
1236 // probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
1238 // log.length += sprintf(log.data + log.length, "`,`,0x%x",(unsigned int)ret;
1239 // //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
1242 // log.length += sprintf(log.data + log.length,
1243 // "`,0`,0`,%d`,0`,0x%x`,%d`,%d`,`,", blockresult,
1244 // (unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_OTHER);
1246 // log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
1247 // getBacktraceString(&log, 4096 - log.length - 17);
1248 // log.length += sprintf(log.data + log.length, "`,callstack_end");
1250 // printLog(&log, MSG_LOG);
1256 result Thread::Start(void) {
1257 typedef result (Thread::*methodType)(void);
1258 static methodType Startp = 0;
1260 probeInfo_t probeInfo;
1262 bool bfiltering = true;
1267 if(lib_handle[LIBOSP_APPFW] == NULL) {
1268 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
1269 if (lib_handle[LIBOSP_APPFW] == NULL) {
1270 perror("dlopen failed : libosp-appfw.so");
1274 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime6Thread5StartEv");
1276 if (tmpPtr == NULL || dlerror() != NULL) {
1277 perror("dlsym failed : Tizen::Base::Runtime::Thread::Start");
1281 memcpy(&Startp, &tmpPtr, sizeof(tmpPtr));
1285 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
1286 setProbePoint(&probeInfo);
1290 ret = (this->*Startp)();
1292 if (postBlockBegin(blockresult)) {
1294 char *class_name = abi::__cxa_demangle(typeid(*this).name(),0,0,&status);
1295 PREPARE_LOCAL_BUF();
1296 PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
1297 API_ID_result_Thread__Start_void_,
1299 PACK_COMMON_END('x', ret, ret, blockresult);
1300 PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_START, class_name);
1307 result Thread::Stop(void) {
1308 typedef result (Thread::*methodType)(void);
1309 static methodType Stopp = 0;
1311 probeInfo_t probeInfo;
1313 bool bfiltering = true;
1318 if(lib_handle[LIBOSP_APPFW] == NULL) {
1319 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
1320 if (lib_handle[LIBOSP_APPFW] == NULL) {
1321 perror("dlopen failed : libosp-appfw.so");
1325 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime6Thread4StopEv");
1327 if (tmpPtr == NULL || dlerror() != NULL) {
1328 perror("dlsym failed : Tizen::Base::Runtime::Thread::Stop");
1332 memcpy(&Stopp, &tmpPtr, sizeof(tmpPtr));
1336 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
1337 setProbePoint(&probeInfo);
1341 ret = (this->*Stopp)();
1343 if (postBlockBegin(blockresult)) {
1345 PREPARE_LOCAL_BUF();
1346 PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
1347 API_ID_result_Thread__Stop_void_,
1349 PACK_COMMON_END('x', ret, ret, blockresult);
1350 PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_STOP, THREAD_CLASS_BLANK);
1358 result EventDrivenThread::Construct(long stackSize, ThreadPriority priority) {
1360 (Thread::*methodType)(long stackSize, ThreadPriority priority);
1361 static methodType Constructp = 0;
1363 probeInfo_t probeInfo;
1365 bool bfiltering = true;
1370 if(lib_handle[LIBOSP_APPFW] == NULL) {
1371 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
1372 if (lib_handle[LIBOSP_APPFW] == NULL) {
1373 perror("dlopen failed : libosp-appfw.so");
1377 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW],
1378 "_ZN5Tizen4Base7Runtime17EventDrivenThread9ConstructElNS1_14ThreadPriorityE");
1379 if (tmpPtr == NULL || dlerror() != NULL) {
1380 perror("dlsym failed : Tizen::Base::Runtime::EventDrivenThread::Construct");
1384 memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
1388 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
1389 setProbePoint(&probeInfo);
1393 ret = (this->*Constructp)(stackSize, priority);
1395 if (postBlockBegin(blockresult)) {
1397 PREPARE_LOCAL_BUF();
1398 PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
1399 API_ID_result_EventDrivenThread__Construct_long_stackSize__ThreadPriority_priority_,
1400 "xd", (uint64_t)(stackSize), priority);
1401 PACK_COMMON_END('x', ret, ret, blockresult);
1402 PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_EVENTDRIVEN, THREAD_API_NEW, THREAD_CLASS_BLANK);
1410 result EventDrivenThread::Construct(const Tizen::Base::String &name, long stackSize,
1411 ThreadPriority priority) {
1413 (Thread::*methodType)(const Tizen::Base::String &name, long stackSize,
1414 ThreadPriority priority);
1415 static methodType Constructp = 0;
1417 probeInfo_t probeInfo;
1419 bool bfiltering = true;
1425 if(lib_handle[LIBOSP_APPFW] == NULL) {
1426 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
1427 if (lib_handle[LIBOSP_APPFW] == NULL) {
1428 perror("dlopen failed : libosp-appfw.so");
1434 lib_handle[LIBOSP_APPFW],
1435 "_ZN5Tizen4Base7Runtime17EventDrivenThread9ConstructERKNS0_6StringElNS1_14ThreadPriorityE");
1437 if (tmpPtr == NULL || dlerror() != NULL) {
1438 perror("dlsym failed : Tizen::Base::Runtime::EventDrivenThread::Construct");
1442 memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
1446 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
1447 setProbePoint(&probeInfo);
1451 ret = (this->*Constructp)(name, stackSize, priority);
1453 if (postBlockBegin(blockresult)) {
1455 WcharToChar(temp, name.GetPointer());
1457 PREPARE_LOCAL_BUF();
1458 PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
1459 API_ID_result_EventDrivenThread__Construct_const_Tizen__Base__String__name__long_stackSize__ThreadPriority_priority_,
1460 "sx", temp, (uint64_t)(stackSize));
1461 PACK_COMMON_END('x', ret, ret, blockresult);
1462 PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_EVENTDRIVEN, THREAD_API_NEW, THREAD_CLASS_BLANK);
1471 result EventDrivenThread::Quit() {
1472 typedef result (Thread::*methodType)(void);
1473 static methodType Quitp = 0;
1475 probeInfo_t probeInfo;
1477 bool bfiltering = true;
1482 if(lib_handle[LIBOSP_APPFW] == NULL) {
1483 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
1484 if (lib_handle[LIBOSP_APPFW] == NULL) {
1485 perror("dlopen failed : libosp-appfw.so");
1489 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime17EventDrivenThread4QuitEv");
1491 if (tmpPtr == NULL || dlerror() != NULL) {
1492 perror("dlsym failed : Tizen::Base::Runtime::EventThread::Quit");
1496 memcpy(&Quitp, &tmpPtr, sizeof(tmpPtr));
1500 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
1501 setProbePoint(&probeInfo);
1505 ret = (this->*Quitp)();
1507 if (postBlockBegin(blockresult)) {
1509 PREPARE_LOCAL_BUF();
1510 PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
1511 API_ID_result_EventDrivenThread__Quit__,
1513 PACK_COMMON_END('x', ret, ret, blockresult);
1514 PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_EVENTDRIVEN, THREAD_API_STOP, THREAD_CLASS_BLANK);