static int SetThreadToPriority(pthread_t thread, UInt32 inPriority, Boolean inIsFixed, UInt64 period, UInt64 computation, UInt64 constraint) { if (inPriority == 96) { // REAL-TIME / TIME-CONSTRAINT THREAD thread_time_constraint_policy_data_t theTCPolicy; theTCPolicy.period = period; theTCPolicy.computation = computation; theTCPolicy.constraint = constraint; theTCPolicy.preemptible = true; kern_return_t res = thread_policy_set(pthread_mach_thread_np(thread), THREAD_TIME_CONSTRAINT_POLICY, (thread_policy_t)&theTCPolicy, THREAD_TIME_CONSTRAINT_POLICY_COUNT); return (res == KERN_SUCCESS) ? 0 : -1; } else { // OTHER THREADS thread_extended_policy_data_t theFixedPolicy; thread_precedence_policy_data_t thePrecedencePolicy; SInt32 relativePriority; // [1] SET FIXED / NOT FIXED theFixedPolicy.timeshare = !inIsFixed; thread_policy_set(pthread_mach_thread_np(thread), THREAD_EXTENDED_POLICY, (thread_policy_t)&theFixedPolicy, THREAD_EXTENDED_POLICY_COUNT); // [2] SET PRECEDENCE // N.B.: We expect that if thread A created thread B, and the program wishes to change // the priority of thread B, then the call to change the priority of thread B must be // made by thread A. // This assumption allows us to use pthread_self() to correctly calculate the priority // of the feeder thread (since precedency policy's importance is relative to the // spawning thread's priority.) relativePriority = inPriority - GetThreadSetPriority(pthread_self()); thePrecedencePolicy.importance = relativePriority; kern_return_t res = thread_policy_set(pthread_mach_thread_np(thread), THREAD_PRECEDENCE_POLICY, (thread_policy_t)&thePrecedencePolicy, THREAD_PRECEDENCE_POLICY_COUNT); return (res == KERN_SUCCESS) ? 0 : -1; } }
bool ph_thread_set_affinity(ph_thread_t *me, int affinity) { #ifdef HAVE_PTHREAD_SETAFFINITY_NP # ifdef __linux__ cpu_set_t set; # else /* FreeBSD */ cpuset_t set; #endif CPU_ZERO(&set); CPU_SET(affinity, &set); return pthread_setaffinity_np(me->thr, sizeof(set), &set) == 0; #elif defined(__APPLE__) thread_affinity_policy_data_t data; data.affinity_tag = affinity + 1; return thread_policy_set(pthread_mach_thread_np(me->thr), THREAD_AFFINITY_POLICY, (thread_policy_t)&data, THREAD_AFFINITY_POLICY_COUNT) == 0; #elif defined(HAVE_CPUSET_SETAFFINITY) /* untested bsdish */ cpuset_t set; CPU_ZERO(&set); CPU_SET(affinity, &set); cpuset_setaffinity(CPU_LEVEL_WHICH, CPU_WHICH_TID, -1, sizeof(set), set); #elif defined(HAVE_PROCESSOR_BIND) return processor_bind(P_LWPID, me->lwpid, affinity, NULL) == 0; #endif return true; }
void o_thrSuspend(o_thr_t thr) { mach_port_t mthread; mthread = pthread_mach_thread_np(thr); thread_suspend(mthread); }
static void pid_callback(int *const pid, int *const tid) { #if !_BT_LOG_MESSAGE_FORMAT_CONTAINS(PID, BT_LOG_MESSAGE_CTX_FORMAT) VAR_UNUSED(pid); #else #if defined(_WIN32) || defined(_WIN64) *pid = GetCurrentProcessId(); #else *pid = getpid(); #endif #endif #if !_BT_LOG_MESSAGE_FORMAT_CONTAINS(TID, BT_LOG_MESSAGE_CTX_FORMAT) VAR_UNUSED(tid); #else #if defined(_WIN32) || defined(_WIN64) *tid = GetCurrentThreadId(); #elif defined(__CYGWIN__) pthread_t thr = pthread_self(); *tid = (int)pthread_getsequence_np(&thr); #elif defined(__sun__) *tid = (int)pthread_self(); #elif defined(__ANDROID__) *tid = gettid(); #elif defined(__linux__) *tid = syscall(SYS_gettid); #elif defined(__MACH__) *tid = (int)pthread_mach_thread_np(pthread_self()); #else #define Platform not supported #endif #endif }
static void allocate_segv_handler() { #ifdef JULIA_ENABLE_THREADING arraylist_new(&suspended_threads, jl_n_threads); #endif pthread_t thread; pthread_attr_t attr; kern_return_t ret; mach_port_t self = mach_task_self(); ret = mach_port_allocate(self, MACH_PORT_RIGHT_RECEIVE, &segv_port); HANDLE_MACH_ERROR("mach_port_allocate",ret); ret = mach_port_insert_right(self, segv_port, segv_port, MACH_MSG_TYPE_MAKE_SEND); HANDLE_MACH_ERROR("mach_port_insert_right",ret); // Alright, create a thread to serve as the listener for exceptions if (pthread_attr_init(&attr) != 0) { jl_error("pthread_attr_init failed"); } pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); if (pthread_create(&thread, &attr, mach_segv_listener, NULL) != 0) { jl_error("pthread_create failed"); } pthread_attr_destroy(&attr); for (int16_t tid = 0;tid < jl_n_threads;tid++) { attach_exception_port(pthread_mach_thread_np(jl_all_task_states[tid].system_id)); } }
void o_thrResume(o_thr_t thr) { mach_port_t mthread; mthread = pthread_mach_thread_np(thr); thread_resume(mthread); }
void NaClSetCurrentMachThreadForThreadIndex(uint32_t nacl_thread_index) { /* * This implementation relies on the Mach port for the thread stored by the * pthread library, and assumes that the pthread library does not close and * re-acquire the Mach port for the thread. If that happens, Mach could * theoretically assign the port a different number in the process' port * table. This approach avoids having to deal with ownership of the port and * the system call overhad to obtain and deallocate it as would be the case * with mach_thread_self(). * * When used by the Mach exception handler, this also assumes that the * thread port number when received for an exception will match the port * stored in the mach_threads table. This is guaranteed by how the kernel * coalesces ports in a single port namespace. (A task, or process, is a * single port namespace.) * * An alternative implementation that works on Mac OS X 10.6 or higher is to * use pthread_threadid_np() to obtain a thread ID to use as the key for * this thread map. Such thread IDs are unique system-wide. An exception * handler can find the thread ID for a Mach thread by calling thread_info() * with flavor THREAD_IDENTIFIER_INFO. This approach is not used here * because of the added system call overhead at exception time. */ mach_port_t mach_thread = pthread_mach_thread_np(pthread_self()); CHECK(mach_thread != MACH_PORT_NULL); DCHECK(nacl_thread_index > NACL_TLS_INDEX_INVALID && nacl_thread_index < NACL_THREAD_MAX); DCHECK(mach_threads[nacl_thread_index] == MACH_PORT_NULL); DCHECK(NaClGetThreadIndexForMachThread(mach_thread) == NACL_TLS_INDEX_INVALID); mach_threads[nacl_thread_index] = mach_thread; }
int nacl_thread_nice(int nacl_nice) { kern_return_t kr; /* * Don't use mach_thread_self() because it requires a separate * mach_port_deallocate() system call to release it. Instead, rely on * pthread's cached copy of the port. */ thread_act_t mthread = pthread_mach_thread_np(pthread_self()); switch (nacl_nice) { case NICE_REALTIME: { struct thread_time_constraint_policy tcpolicy; const int kPeriodInNanoseconds = 2902490; const float kDutyCycle = 0.5; const float kDutyMax = 0.85; tcpolicy.period = MyConvertToHostTime(kPeriodInNanoseconds); tcpolicy.computation = kDutyCycle * tcpolicy.period; tcpolicy.constraint = kDutyMax * tcpolicy.period; tcpolicy.preemptible = 1; /* Sadly it appears that a MacOS system can be locked up by too * many real-time threads. So use normal priority until we figure * out a way to control things globally. */ /* kr = thread_policy_set(mthread, THREAD_TIME_CONSTRAINT_POLICY, * (thread_policy_t)&tcpolicy, * THREAD_TIME_CONSTRAINT_POLICY_COUNT); */ kr = thread_policy_set(mthread, THREAD_PRECEDENCE_POLICY, (thread_policy_t)&tcpolicy, THREAD_PRECEDENCE_POLICY_COUNT); } break; case NICE_BACKGROUND: { struct thread_precedence_policy tppolicy; tppolicy.importance = 0; /* IDLE_PRI */ kr = thread_policy_set(mthread, THREAD_PRECEDENCE_POLICY, (thread_policy_t)&tppolicy, THREAD_PRECEDENCE_POLICY_COUNT); } break; case NICE_NORMAL: { struct thread_standard_policy tspolicy; kr = thread_policy_set(mthread, THREAD_STANDARD_POLICY, (thread_policy_t)&tspolicy, THREAD_STANDARD_POLICY_COUNT); } break; default: NaClLog(LOG_WARNING, "nacl_thread_nice() failed (bad nice value).\n"); return -1; break; } if (kr != KERN_SUCCESS) { NaClLog(LOG_WARNING, "nacl_thread_nice() failed.\n"); return -1; } else { return 0; } }
BOOL WINAPI GetThreadTimes ( HANDLE hThread, LPFILETIME lpCreationTime, LPFILETIME lpExitTime, LPFILETIME lpKernelTime, LPFILETIME lpUserTime ) { if (!hThread) return false; if (!hThread->m_threadValid) return false; if (hThread == (HANDLE)-1) { if (lpCreationTime) TimeTToFileTime(0,lpCreationTime); if (lpExitTime) TimeTToFileTime(time(NULL),lpExitTime); if (lpKernelTime) TimeTToFileTime(0,lpKernelTime); if (lpUserTime) TimeTToFileTime(0,lpUserTime); return true; } if (lpCreationTime) TimeTToFileTime(hThread->m_tmCreation,lpCreationTime); if (lpExitTime) TimeTToFileTime(time(NULL),lpExitTime); if (lpKernelTime) TimeTToFileTime(0,lpKernelTime); #ifdef __APPLE__ thread_info_data_t threadInfo; mach_msg_type_number_t threadInfoCount = THREAD_INFO_MAX; if (hThread->m_machThreadPort == MACH_PORT_NULL) hThread->m_machThreadPort = pthread_mach_thread_np(hThread->m_hThread); kern_return_t ret = thread_info(hThread->m_machThreadPort, THREAD_BASIC_INFO, (thread_info_t)threadInfo, &threadInfoCount); if (ret == KERN_SUCCESS) { thread_basic_info_t threadBasicInfo = (thread_basic_info_t)threadInfo; if (lpUserTime) { // User time. unsigned long long time = ((__int64)threadBasicInfo->user_time.seconds * 10000000L) + threadBasicInfo->user_time.microseconds*10L; lpUserTime->dwLowDateTime = (time & 0xFFFFFFFF); lpUserTime->dwHighDateTime = (time >> 32); } if (lpKernelTime) { // System time. unsigned long long time = ((__int64)threadBasicInfo->system_time.seconds * 10000000L) + threadBasicInfo->system_time.microseconds*10L; lpKernelTime->dwLowDateTime = (time & 0xFFFFFFFF); lpKernelTime->dwHighDateTime = (time >> 32); } }
int ksbt_backtracePthread(const pthread_t thread, uintptr_t* const backtraceBuffer, const int maxEntries) { const thread_t mach_thread = pthread_mach_thread_np(thread); return ksbt_backtraceThread(mach_thread, backtraceBuffer, maxEntries); }
void gdb_pthread_kill(pthread_t pthread) { mach_port_t mthread; kern_return_t kret; int ret; mthread = pthread_mach_thread_np(pthread); kret = thread_suspend(mthread); MACH_CHECK_ERROR(kret); ret = pthread_cancel(pthread); if (ret != 0) { /* in case a macro has re-defined this function: */ #undef strerror warning("Unable to cancel thread: %s (%d)", strerror(errno), errno); thread_terminate(mthread); } kret = thread_abort (mthread); MACH_CHECK_ERROR (kret); kret = thread_resume (mthread); MACH_CHECK_ERROR (kret); ret = pthread_join (pthread, NULL); if (ret != 0) { warning ("Unable to join to canceled thread: %s (%d)", strerror (errno), errno); } }
void _dispatch_introspection_init(void) { TAILQ_INSERT_TAIL(&_dispatch_introspection_queues, &_dispatch_main_q, diq_list); TAILQ_INSERT_TAIL(&_dispatch_introspection_queues, &_dispatch_mgr_q, diq_list); #if DISPATCH_ENABLE_PTHREAD_ROOT_QUEUES TAILQ_INSERT_TAIL(&_dispatch_introspection_queues, _dispatch_mgr_q.do_targetq, diq_list); #endif for (size_t i = 0; i < DISPATCH_ROOT_QUEUE_COUNT; i++) { TAILQ_INSERT_TAIL(&_dispatch_introspection_queues, &_dispatch_root_queues[i], diq_list); } // Hack to determine queue TSD offset from start of pthread structure uintptr_t thread = _dispatch_thread_self(); thread_identifier_info_data_t tiid; mach_msg_type_number_t cnt = THREAD_IDENTIFIER_INFO_COUNT; kern_return_t kr = thread_info(pthread_mach_thread_np((void*)thread), THREAD_IDENTIFIER_INFO, (thread_info_t)&tiid, &cnt); if (!dispatch_assume_zero(kr)) { _dispatch_introspection_thread_queue_offset = (void*)(uintptr_t)tiid.dispatch_qaddr - (void*)thread; } _dispatch_thread_key_create(&dispatch_introspection_key, _dispatch_introspection_thread_remove); _dispatch_introspection_thread_add(); // add main thread }
static int gettid(void) { #ifdef __APPLE__ return pthread_mach_thread_np(pthread_self()); #else return syscall(__NR_gettid); #endif }
int create_bound_thread(pthread_t *tid, int id, void *(*func)(void *), void *arg) { int numcores, pid, rc; numcores = num_phys_cores(); pid = id % numcores; if ((id < 0)) return -1; #ifdef __APPLE__ // Apple bind code thread_affinity_policy_data_t affinityinfo; rc = pthread_create_suspended_np(tid, NULL, func, arg);// TODO: verify value of arg is correct for OSX if (rc != 0) { perror("pthread_create_suspended_np"); return -1; } affinityinfo.affinity_tag = pid+2; // FIXME: confirm +2 rc = thread_policy_set(pthread_mach_thread_np(*tid), THREAD_AFFINITY_POLICY, (int *)&affinityinfo, THREAD_AFFINITY_POLICY_COUNT); if (rc != KERN_SUCCESS) { perror("thread_policy_set"); return -1; } thread_resume(pthread_mach_thread_np(*tid)); #else // Linux bind code struct linux_thread_init_arg *lnxargs; lnxargs = (linux_thread_init_arg *)malloc(sizeof(linux_thread_init_arg));// FIXME: memory leak... lnxargs->func = func; lnxargs->args = arg; lnxargs->proc = pid; rc = pthread_create(tid, NULL, linux_thread_init, lnxargs); if (rc != 0) { perror("pthread_create"); return -1; } #endif return 0; }
static void set_affinity(pthread_t thread, int tag) { thread_affinity_policy theTCPolicy; theTCPolicy.affinity_tag = tag; kern_return_t res = thread_policy_set(pthread_mach_thread_np(thread), THREAD_AFFINITY_POLICY, (thread_policy_t)&theTCPolicy, THREAD_AFFINITY_POLICY_COUNT); if (res == KERN_SUCCESS) { //printf("set_affinity = %d\n", theTCPolicy.affinity_tag); } }
ThreadId_t ThreadPosix::getThreadId() { pthread_t t = pthread_self(); #if defined (__MACH__) return pthread_mach_thread_np(t); #else return reinterpret_cast<ThreadId_t>(pthread_self()); #endif }
static unsigned long callbackThreadID() { return static_cast<unsigned long>( #ifdef __APPLE__ pthread_mach_thread_np(pthread_self()) #else pthread_self() #endif ); }
/* * Signal a condition variable, waking a specified thread. */ int pthread_cond_signal_thread_np(pthread_cond_t *ocond, pthread_t thread) { mach_port_t mp = MACH_PORT_NULL; if (thread) { mp = pthread_mach_thread_np(thread); } return _pthread_cond_signal(ocond, false, mp); }
UInt32 ZKMORHP_ForeignThread::getScheduledPriority(pthread_t inThread, int inPriorityKind) { thread_basic_info_data_t threadInfo; policy_info_data_t thePolicyInfo; unsigned int count; if (inThread == NULL) return 0; // get basic info count = THREAD_BASIC_INFO_COUNT; thread_info (pthread_mach_thread_np (inThread), THREAD_BASIC_INFO, (thread_info_t)&threadInfo, &count); switch (threadInfo.policy) { case POLICY_TIMESHARE: count = POLICY_TIMESHARE_INFO_COUNT; thread_info(pthread_mach_thread_np (inThread), THREAD_SCHED_TIMESHARE_INFO, (thread_info_t)&(thePolicyInfo.ts), &count); if (inPriorityKind == CAPTHREAD_SCHEDULED_PRIORITY) { return thePolicyInfo.ts.cur_priority; } return thePolicyInfo.ts.base_priority; break; case POLICY_FIFO: count = POLICY_FIFO_INFO_COUNT; thread_info(pthread_mach_thread_np (inThread), THREAD_SCHED_FIFO_INFO, (thread_info_t)&(thePolicyInfo.fifo), &count); if ( (thePolicyInfo.fifo.depressed) && (inPriorityKind == CAPTHREAD_SCHEDULED_PRIORITY) ) { return thePolicyInfo.fifo.depress_priority; } return thePolicyInfo.fifo.base_priority; break; case POLICY_RR: count = POLICY_RR_INFO_COUNT; thread_info(pthread_mach_thread_np (inThread), THREAD_SCHED_RR_INFO, (thread_info_t)&(thePolicyInfo.rr), &count); if ( (thePolicyInfo.rr.depressed) && (inPriorityKind == CAPTHREAD_SCHEDULED_PRIORITY) ) { return thePolicyInfo.rr.depress_priority; } return thePolicyInfo.rr.base_priority; break; } return 0; }
static void get_affinity(pthread_t thread) { thread_affinity_policy theTCPolicy; mach_msg_type_number_t count = THREAD_AFFINITY_POLICY_COUNT; boolean_t get_default = false; kern_return_t res = thread_policy_get(pthread_mach_thread_np(thread), THREAD_AFFINITY_POLICY, (thread_policy_t)&theTCPolicy, &count, &get_default); if (res == KERN_SUCCESS) { //printf("get_affinity = %d\n", theTCPolicy.affinity_tag); } }
static inline PlatformThread getCurrentPlatformThread() { #if OS(DARWIN) return pthread_mach_thread_np(pthread_self()); #elif OS(WINDOWS) return GetCurrentThread(); #elif USE(PTHREADS) return pthread_self(); #endif }
static int sys_thread_create (struct sys_thread *td, const int is_affin) { #ifndef _WIN32 pthread_attr_t attr; int res; if ((res = pthread_attr_init(&attr))) goto err; if ((res = pthread_attr_setstacksize(&attr, td->vmtd->stack_size))) { pthread_attr_destroy(&attr); goto err; } #ifdef USE_MACH_AFFIN if (is_affin) { res = pthread_create_suspended_np(&td->tid, &attr, (thread_func_t) thread_start, td); if (!res) { mach_port_t mt = pthread_mach_thread_np(td->tid); affin_cpu_set(mt, td->vmtd->cpu); thread_resume(mt); } } else #endif res = pthread_create(&td->tid, &attr, (thread_func_t) thread_start, td); pthread_attr_destroy(&attr); if (!res) { #if defined(USE_PTHREAD_AFFIN) if (is_affin) affin_cpu_set(td->tid, td->vmtd->cpu); #else (void) is_affin; #endif return 0; } err: errno = res; #else unsigned int tid; const uintptr_t hThr = _beginthreadex(NULL, (unsigned int) td->vmtd->stack_size, (thread_func_t) thread_start, td, 0, &tid); (void) is_affin; if (hThr) { td->tid = (HANDLE) hThr; if (is_WinNT && td->vmtd->cpu) affin_cpu_set(td->tid, td->vmtd->cpu); return 0; } #endif return -1; }
void setThreadToPriority (pthread_t inThread, UInt32 inPriority, Boolean inIsFixed, UInt64 inHALIOProcCycleDurationInNanoseconds) { if (inPriority == 96) { // REAL-TIME / TIME-CONSTRAINT THREAD thread_time_constraint_policy_data_t theTCPolicy; UInt64 theComputeQuanta; UInt64 thePeriod; UInt64 thePeriodNanos; thePeriodNanos = inHALIOProcCycleDurationInNanoseconds; theComputeQuanta = AudioConvertNanosToHostTime ( thePeriodNanos * 0.15 ); thePeriod = AudioConvertNanosToHostTime (thePeriodNanos); theTCPolicy.period = thePeriod; theTCPolicy.computation = theComputeQuanta; theTCPolicy.constraint = thePeriod; theTCPolicy.preemptible = true; thread_policy_set (pthread_mach_thread_np(inThread), THREAD_TIME_CONSTRAINT_POLICY, (thread_policy_t)&theTCPolicy, THREAD_TIME_CONSTRAINT_POLICY_COUNT); } else { // OTHER THREADS thread_extended_policy_data_t theFixedPolicy; thread_precedence_policy_data_t thePrecedencePolicy; SInt32 relativePriority; // [1] SET FIXED / NOT FIXED theFixedPolicy.timeshare = !inIsFixed; thread_policy_set (pthread_mach_thread_np(inThread), THREAD_EXTENDED_POLICY, (thread_policy_t)&theFixedPolicy, THREAD_EXTENDED_POLICY_COUNT); // [2] SET PRECEDENCE // N.B.: We expect that if thread A created thread B, and the program wishes to change // the priority of thread B, then the call to change the priority of thread B must be // made by thread A. // This assumption allows us to use pthread_self() to correctly calculate the priority // of the feeder thread (since precedency policy's importance is relative to the // spawning thread's priority.) relativePriority = inPriority - getThreadSetPriority (pthread_self()); thePrecedencePolicy.importance = relativePriority; thread_policy_set (pthread_mach_thread_np(inThread), THREAD_PRECEDENCE_POLICY, (thread_policy_t)&thePrecedencePolicy, THREAD_PRECEDENCE_POLICY_COUNT); } }
UInt32 _getThreadPriority (pthread_t inThread, int inWhichPriority) { thread_basic_info_data_t threadInfo; policy_info_data_t thePolicyInfo; unsigned int count; // get basic info count = THREAD_BASIC_INFO_COUNT; thread_info (pthread_mach_thread_np (inThread), THREAD_BASIC_INFO, (thread_info_t)&threadInfo, &count); switch (threadInfo.policy) { case POLICY_TIMESHARE: count = POLICY_TIMESHARE_INFO_COUNT; thread_info(pthread_mach_thread_np (inThread), THREAD_SCHED_TIMESHARE_INFO, (thread_info_t)&(thePolicyInfo.ts), &count); if (inWhichPriority == THREAD_SCHEDULED_PRIORITY) { return thePolicyInfo.ts.cur_priority; } else { return thePolicyInfo.ts.base_priority; } break; case POLICY_FIFO: count = POLICY_FIFO_INFO_COUNT; thread_info(pthread_mach_thread_np (inThread), THREAD_SCHED_FIFO_INFO, (thread_info_t)&(thePolicyInfo.fifo), &count); if ( (thePolicyInfo.fifo.depressed) && (inWhichPriority == THREAD_SCHEDULED_PRIORITY) ) { return thePolicyInfo.fifo.depress_priority; } return thePolicyInfo.fifo.base_priority; break; case POLICY_RR: count = POLICY_RR_INFO_COUNT; thread_info(pthread_mach_thread_np (inThread), THREAD_SCHED_RR_INFO, (thread_info_t)&(thePolicyInfo.rr), &count); if ( (thePolicyInfo.rr.depressed) && (inWhichPriority == THREAD_SCHEDULED_PRIORITY) ) { return thePolicyInfo.rr.depress_priority; } return thePolicyInfo.rr.base_priority; break; } return 0; }
Thread::Thread(bool external, int stackSize) : _id(threadIdInvalid), _stackSize(stackSize), _lock(new honey::Mutex) { if (external) { _handle = pthread_self(); _id = pthread_mach_thread_np(_handle); } }
int ParaEngine::GetThisThreadID() { #ifdef WIN32 return (int)(::GetCurrentThreadId()); #elif (PARA_TARGET_PLATFORM == PARA_PLATFORM_IOS || PARA_TARGET_PLATFORM == PARA_PLATFORM_MAC) return (int)pthread_mach_thread_np(pthread_self()); #else //return (int)gettid(); return (int)pthread_self(); #endif }