static noreturn void thread_entry(cloudabi_tid_t tid, void *data) { // Set up TLS space. char tls_space[tls_size()]; char *tls_start = tls_addr(tls_space); memcpy(tls_start, __pt_tls_vaddr_abs, __pt_tls_filesz); memset(tls_start + __pt_tls_filesz, '\0', __pt_tls_memsz_aligned - __pt_tls_filesz); tls_replace(tls_space); // Fix up some of the variables stored in TLS. pthread_t handle = data; __pthread_self_object = handle; __pthread_thread_id = tid; __safestack_unsafe_stack_ptr = (void *)__rounddown( (uintptr_t)handle->unsafe_stack + handle->unsafe_stacksize, PTHREAD_UNSAFE_STACK_ALIGNMENT); // Initialize the the once object used for joining. This is also done // by the parent, but it may be the case that we call pthread_exit() // before the parent has a chance to initialize it. cloudabi_lock_t expected = CLOUDABI_LOCK_BOGUS; atomic_compare_exchange_strong_explicit( &handle->join, &expected, tid | CLOUDABI_LOCK_WRLOCKED, memory_order_acquire, memory_order_relaxed); // Free thread startup information and invoke user-supplied start routine. void *(*start_routine)(void *) = handle->start_routine; void *argument = handle->argument; pthread_exit(start_routine(argument)); }
void wrapper(void* (*start_routine)(void*), void *arg) { void *retval; retval = (void *) start_routine(arg); gtthread_exit(retval); return; }
static gsize WINAPI inner_start_thread (gpointer data) { CreateThreadData *thread_data; MonoThreadInfo *info; MonoThreadStart start_routine; gpointer start_routine_arg; gsize start_routine_res; gsize dummy; thread_data = (CreateThreadData*) data; g_assert (thread_data); start_routine = thread_data->start_routine; start_routine_arg = thread_data->start_routine_arg; info = mono_thread_info_attach (&dummy); info->runtime_thread = TRUE; thread_data->handle = mono_threads_open_thread_handle (info->handle); mono_coop_sem_post (&thread_data->registered); mono_refcount_dec (thread_data); /* thread_data is not valid anymore */ thread_data = NULL; /* Run the actual main function of the thread */ start_routine_res = start_routine (start_routine_arg); mono_thread_info_exit (start_routine_res); g_assert_not_reached (); }
void run_thread(void *(*start_routine)(void *), void *arg) { void *rv; sigprocmask(SIG_UNBLOCK, &alrm, NULL); rv = start_routine(arg); gtthread_exit(rv); }
static void* set_affinity_trampoline(void* arg) { struct affinity_trampoline* trampoline = arg; sched_setaffinity(0, sizeof(cpu_set_t), &trampoline->cpuset); void* trampoline_arg = trampoline->arg; void* (*start_routine)(void*) = trampoline->start_routine; free(trampoline); return start_routine(trampoline_arg); }
int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg) { static int warn = 1; if (warn) { fprintf(stderr, "Sulong does not support threads yet, using pthread stub!\n"); warn = 0; } start_routine(arg); return 0; }
static void start_wrapper(void *(*start_routine)(void *), void *arg) { void *retval; /* Unblock alarms */ sigprocmask(SIG_UNBLOCK, &vtalrm, NULL); retval = start_routine(arg); gtthread_exit(retval); }
static unsigned __stdcall win32_start_routine(void *arg) { QemuThreadData *data = (QemuThreadData *) arg; void *(*start_routine)(void *) = data->start_routine; void *thread_arg = data->arg; qemu_thread_data = data; qemu_thread_exit(start_routine(thread_arg)); abort(); }
int ldap_pvt_thread_create( ldap_pvt_thread_t * thread, int detach, void *(*start_routine)(void *), void *arg) { if( ! detach ) ldap_int_status = NULL; start_routine( arg ); return 0; }
/* Wrapper function for start_routine of pthread_create() */ static void *wrapper(void *warg) { // Initialize malloc library for this thread sf_malloc_thread_init(); // Get the routine and argument for the pthread_create start_fpt start_routine = ((wrapper_arg_t *)warg)->start_fun; void *arg = ((wrapper_arg_t *)warg)->arg; free(warg); void *result = start_routine(arg); return result; }
// using separate function avoid unnecessary copies of local variables // from functions invoking pthread_create, don't inline! void __actual_thread_spawn( void * (*start_routine)(void *), void *arg, unsigned long id) { __CPROVER_HIDE:; __CPROVER_ASYNC_1: __CPROVER_thread_id=id, start_routine(arg), __CPROVER_fence("WWfence", "RRfence", "RWfence", "WRfence", "WWcumul", "RRcumul", "RWcumul", "WRcumul"), __CPROVER_threads_exited[id]=1; }
static void __threadentry (void *(*start_routine)(void*), void *arg) { INFO("hello world! thread successfully created"); TODO("initialize thread data"); TODO("notify DLLs"); TODO("notify psxss"); INFO("about to call start routine at %#x with argument %#x", start_routine, arg); pthread_exit(start_routine(arg)); }
/* The entry-point for new threads. */ static void entry_point (void *(*start_routine)(void *), void *arg) { #ifdef HAVE_USELOCALE /* A fresh thread needs to be bound to the global locale. */ uselocale (LC_GLOBAL_LOCALE); #endif __pthread_startup (); pthread_exit (start_routine (arg)); }
static void* wrapper_routine(void* data) { void* (*start_routine)(void*) = ((wrapper_t*)data)->start_routine; void* arg = ((wrapper_t*)data)->arg; setitimer(ITIMER_PROF, &((wrapper_t*)data)->itimer, NULL); pthread_mutex_lock(&((wrapper_t*)data)->lock); pthread_cond_signal(&((wrapper_t*)data)->cond); pthread_mutex_unlock(&((wrapper_t*)data)->lock); fprintf(stderr, "pthread wrapper, start real routine\n"); return start_routine(arg); }
static unsigned __stdcall win32_start_routine(void *arg) { QemuThreadData *data = (QemuThreadData *) arg; void *(*start_routine)(void *) = data->start_routine; void *thread_arg = data->arg; if (data->mode == QEMU_THREAD_DETACHED) { g_free(data); data = NULL; } qemu_thread_data = data; qemu_thread_exit(start_routine(thread_arg)); abort(); }
//Init 쓰레드의 핸들러 함수 static void PspTaskEntryPoint(void) { PKSTART_ROUTINE start_routine; HANDLE current_thread; DWORD ret_value; current_thread = PsGetCurrentThread(); start_routine = PsGetThreadPtr(current_thread)->start_routine; ret_value = start_routine(PsGetThreadPtr(current_thread)->start_context); PsGetThreadPtr(current_thread)->thread_status = THREAD_STATUS_TERMINATED; HalTaskSwitch(); while(1) ; }
/* The wrapper function in charge for setting the itimer value */ static void * wrapper_routine(void * data) { /* Put user data in thread-local variables */ void * (*start_routine)(void *) = ((wrapper_t*)data)->start_routine; void * arg = ((wrapper_t*)data)->arg; /* Set the profile timer value */ setitimer(ITIMER_PROF, &((wrapper_t*)data)->itimer, NULL); /* Tell the calling thread that we do not need its data anymore */ pthread_mutex_lock(&((wrapper_t*)data)->lock); pthread_cond_signal(&((wrapper_t*)data)->wait); pthread_mutex_unlock(&((wrapper_t*)data)->lock); /* Call the real function */ return start_routine(arg); }
void *threadStartFunc(void *data){ /*This looks weird, but it sets the value associated with dkey to 0x1 * forcing thd_dtr() to run when the thread terminates. */ pthread_setspecific(dkey,(void*)0x1); #ifdef IFRIT_ARRAY curWIFRVar = 0; curRIFRVar = 0; maxWIFRVar = INIT_ACTIVE; maxRIFRVar = INIT_ACTIVE; myWIFRVars = (unsigned long *) malloc(INIT_ACTIVE * sizeof(unsigned long)); myRIFRVars = (unsigned long *) malloc(INIT_ACTIVE * sizeof(unsigned long)); #endif #ifdef IFRIT_HASH_TABLE myWriteIFRs = g_hash_table_new(g_direct_hash, g_direct_equal); myReadIFRs = g_hash_table_new(g_direct_hash, g_direct_equal); #endif pthread_mutex_lock(&allThreadsLock); int i = 0; for(i = 0; i < MAX_THDS; i++){ if( allThreads[i] == (pthread_t)0 ){ allThreads[i] = pthread_self(); break; } } #ifdef SINGLE_THREADED_OPT num_threads++; #endif pthread_mutex_unlock(&allThreadsLock); raceCheckIFR = new_ifr(pthread_self(), 0, 0, 0); #ifdef PROGRAM_POINT_OPT PCTable = g_hash_table_new(g_direct_hash, g_direct_equal); #endif void *(*start_routine)(void*) = ((threadInitData *)data)->start_routine; void *arg = ((threadInitData *) data)->arg; free(data); return (start_routine(arg)); }
static void* NVThreadSpawnProc(void* arg) { NVThreadInitStruct* init = (NVThreadInitStruct*)arg; void *(*start_routine)(void *) = init->m_startRoutine; void* data = init->m_arg; void* ret; free(arg); NVThreadGetCurrentJNIEnv(); ret = start_routine(data); if (s_vm) (*s_vm)->DetachCurrentThread(s_vm); return ret; }
static void * wrapper(void *wargs) { void *result; start_fun_t start_routine = ((wrapper_args_t *) wargs)->app_start; void *arg = ((wrapper_args_t *) wargs)->app_arg; thread_id = atmc_fetch_and_add(&global_id_counter, 1); #ifdef NUMA //discover_cpu(); #endif munmap(wargs, sizeof(wrapper_args_t)); result = start_routine(arg); streamflow_thread_finalize(); return result; }
static gsize WINAPI inner_start_thread (gpointer data) { CreateThreadData *thread_data; MonoThreadInfo *info; MonoThreadStart start_routine; gpointer start_routine_arg; guint32 start_routine_res; gint32 priority; gsize dummy; thread_data = (CreateThreadData*) data; g_assert (thread_data); start_routine = thread_data->start_routine; start_routine_arg = thread_data->start_routine_arg; priority = thread_data->priority; info = mono_thread_info_attach (&dummy); info->runtime_thread = TRUE; mono_threads_platform_set_priority (info, priority); thread_data->handle = mono_thread_info_duplicate_handle (info); mono_coop_sem_post (&thread_data->registered); if (InterlockedDecrement (&thread_data->ref) == 0) { mono_coop_sem_destroy (&thread_data->registered); g_free (thread_data); } /* thread_data is not valid anymore */ thread_data = NULL; /* Run the actual main function of the thread */ start_routine_res = start_routine (start_routine_arg); mono_threads_platform_exit (start_routine_res); g_assert_not_reached (); }
inline int pthread_create( pthread_t *thread, const pthread_attr_t *attr, void * (*start_routine)(void *), void *arg) { __CPROVER_HIDE:; unsigned long this_thread_id; __CPROVER_atomic_begin(); this_thread_id=++__CPROVER_next_thread_id; __CPROVER_atomic_end(); if(thread) { #ifdef __APPLE__ // pthread_t is a pointer type on the Mac *thread=(pthread_t)this_thread_id; #else *thread=this_thread_id; #endif } #ifdef __CPROVER_CUSTOM_BITVECTOR_ANALYSIS __CPROVER_set_must(thread, "pthread-id"); #endif if(attr) (void)*attr; __CPROVER_ASYNC_1: __CPROVER_thread_id=this_thread_id, #ifdef __CPROVER_CUSTOM_BITVECTOR_ANALYSIS // Clear all locked mutexes; locking must happen in same thread. __CPROVER_clear_must(0, "mutex-locked"), __CPROVER_clear_may(0, "mutex-locked"), #endif start_routine(arg), __CPROVER_fence("WWfence", "RRfence", "RWfence", "WRfence", "WWcumul", "RRcumul", "RWcumul", "WRcumul"), __CPROVER_threads_exited[this_thread_id]=1; return 0; }
/* Wrapper de la routine appelé par pthread_create */ static void * wrapper_routine(void * data) { /* Put user data in thread-local variables */ void * (*start_routine)(void *) = ((wrapper_t*)data)->start_routine; void * arg = ((wrapper_t*)data)->arg; pthread_mutex_lock(&inside); // tid = hashid.processes[id(pthread_self())]; // assert(tid != NULL); VERBOSE("[INTERCEPT] --> SET TLS (%d)\n", tid->id); pthread_mutex_unlock(&inside); /* Tell the calling thread that we don't need its data anymore */ pthread_mutex_lock(&((wrapper_t*)data)->lock); pthread_cond_signal(&((wrapper_t*)data)->wait); pthread_mutex_unlock(&((wrapper_t*)data)->lock); /* Call the real function */ // assert(arg != NULL); return start_routine(arg); }
void be_hungry(t_philo *philo) { if (sem_wait(&philo->fork_s)) { fprintf(stderr, "%s\n", ERROR_SEM_WAIT); exit(EXIT_FAILURE); } philo->state = HUNGRY; philo->fork = UNAVAILABLE; if (sem_post(&philo->fork_s)) { fprintf(stderr, "%s\n", ERROR_SEM_POST); exit(EXIT_FAILURE); } sleep(HUNGRY_TIME); if (get_fork_val(philo->next)) you_eat(philo); else start_routine(philo); }
void WrapperFunction(void*(*start_routine)(void *), void* arg){ void *returnval; dlink_t* temp_dlink; returnval = start_routine(arg); BlockSignals(); //Need to fire a new thread schedule_queue->running->thread_block->finished =1; schedule_queue->running->thread_block->returnval = returnval; temp_dlink = FindNode(schedule_queue,schedule_queue->running->thread_block->parent_threadid); if(temp_dlink == NULL){ fprintf(stderr,"gtthread_exit() error: no parent found"); exit(1); } else{ temp_dlink->thread_block->child_count--; UnblockSignals(); raise(SIGVTALRM); } }
int main(void) { #ifndef PTEST_USE_THREAD start_routine(0); #else pthread_t th; int i, status; add1(0, 0); /* this is the main thread */ remaining = PTEST_USE_THREAD; for (i = 0; i < PTEST_USE_THREAD; i++) { status = pthread_create(&th, NULL, start_routine, NULL); assert(status == 0); } pthread_mutex_lock(&mutex1); while (remaining) pthread_cond_wait(&cond1, &mutex1); pthread_mutex_unlock(&mutex1); #endif return 0; }
void* start_routine_wrapper(void *arg) { pthread_t self = pthread_self(); start_routine_t start_routine; retry: { Lock lock(m_threadmap_lock); auto it = threadMap.find(self); if (it == threadMap.end()) { goto sleep_wait; } auto& info = it->second; MemoryManager::TlsWrapper::getCheck(); info.mm = &MM(); assert(info.mm); info.mm->resetExternalStats(); #ifdef __linux__ info.tid = syscall(SYS_gettid); #else info.tid = getpid(); #endif info.pid = getpid(); start_routine = info.start_routine; goto done; } sleep_wait: usleep(100); goto retry; done: auto ret = start_routine(arg); log_pthread_event(PTHREAD_EXIT, &self); return ret; }
void run(void *(*start_routine)(void *),void *arg){ curr->running=1; curr->ret_val=start_routine(arg); curr->completed=1; while(1); }
void QtThread::run() { start_routine(pointer); }
/* Adapter to translate Unix thread start routines to Windows thread start * routines. */ static DWORD WINAPI sctp_create_thread_adapter(void *arg) { start_routine_t start_routine = (start_routine_t)arg; return start_routine(NULL) == NULL; }