int main(int argc, char *argv []) { pthread_t t1, t2, t3; pthread_attr_t t1Attr, t2Attr, t3Attr; cpu_set_t t1cpus, t2cpus, t3cpus; CPU_ZERO(&t1cpus); CPU_SET(0, &t1cpus); CPU_ZERO(&t2cpus); CPU_SET(1, &t2cpus); CPU_ZERO(&t2cpus); CPU_SET(0, &t3cpus); CPU_SET(1, &t3cpus); pthread_attr_setaffinity_np(&t1Attr, sizeof(cpu_set_t), &t1cpus); pthread_attr_setaffinity_np(&t2Attr, sizeof(cpu_set_t), &t2cpus); pthread_attr_setaffinity_np(&t3Attr, sizeof(cpu_set_t), &t3cpus); pthread_create(&t1, &t1Attr, func, NULL); pthread_setname_np(t1, "thread1"); pthread_create(&t2, &t2Attr, func, NULL); pthread_setname_np(t2, "thread2"); pthread_create(&t3, &t3Attr, func, NULL); pthread_setname_np(t3, "thread3"); pthread_join(t1, NULL); pthread_join(t2, NULL); pthread_join(t3, NULL); }
int odph_linux_pthread_create(odph_linux_pthread_t *thread_tbl, const odp_cpumask_t *mask, void *(*start_routine)(void *), void *arg, odp_thread_type_t thr_type) { int i; int num; int cpu_count; int cpu; int ret; num = odp_cpumask_count(mask); memset(thread_tbl, 0, num * sizeof(odph_linux_pthread_t)); cpu_count = odp_cpu_count(); if (num < 1 || num > cpu_count) { ODPH_ERR("Invalid number of threads:%d (%d cores available)\n", num, cpu_count); return 0; } cpu = odp_cpumask_first(mask); for (i = 0; i < num; i++) { cpu_set_t cpu_set; CPU_ZERO(&cpu_set); CPU_SET(cpu, &cpu_set); pthread_attr_init(&thread_tbl[i].attr); thread_tbl[i].cpu = cpu; pthread_attr_setaffinity_np(&thread_tbl[i].attr, sizeof(cpu_set_t), &cpu_set); thread_tbl[i].start_args = malloc(sizeof(odp_start_args_t)); if (thread_tbl[i].start_args == NULL) ODPH_ABORT("Malloc failed"); thread_tbl[i].start_args->start_routine = start_routine; thread_tbl[i].start_args->arg = arg; thread_tbl[i].start_args->thr_type = thr_type; ret = pthread_create(&thread_tbl[i].thread, &thread_tbl[i].attr, odp_run_start_routine, thread_tbl[i].start_args); if (ret != 0) { ODPH_ERR("Failed to start thread on cpu #%d\n", cpu); free(thread_tbl[i].start_args); break; } cpu = odp_cpumask_next(mask, cpu); } return i; }
static int thread_attr_init(struct netsniff_ng_thread_context * thread_ctx, const int sched_prio, const int sched_policy, const cpu_set_t * const run_on) { struct sched_param sp = { .sched_priority = sched_prio }; int rc = 0; if ((rc = pthread_attr_setschedparam(&thread_ctx->thread_attr, &sp)) != 0) { warn("Cannot initialize scheduling attributes for priority %i\n", sp.sched_priority); return (rc); } if ((rc = pthread_attr_setschedpolicy(&thread_ctx->thread_attr, sched_policy)) != 0) { warn("Cannot initialize scheduling attributes for policy %i\n", sched_policy); return (rc); } if ((rc = pthread_attr_setaffinity_np(&thread_ctx->thread_attr, sizeof(*run_on), run_on)) != 0) { warn("Cannot initialize scheduling attributes for CPU affinity %s\n", strerror(rc)); return (rc); } pthread_attr_setdetachstate(&thread_ctx->thread_attr, PTHREAD_CREATE_DETACHED); return (rc); }
double *TimeOnCores(struct kmm_struct *kb) { struct kmm_struct *kp; pthread_t *threads; pthread_attr_t *attr; cpu_set_t cpuset; double *mflops; int i, p; p = kb->p; kp = malloc(sizeof(struct kmm_struct)*p); threads = malloc(sizeof(pthread_t)*p); attr = malloc(sizeof(pthread_attr_t)*p); mflops = malloc(sizeof(double)*p); ATL_assert(kp && threads && attr && mflops); for (i=0; i < p; i++) { memcpy(kp+i, kb, sizeof(struct kmm_struct)); kp[i].iam = i; CPU_ZERO(&cpuset); CPU_SET(kp->pids[i], &cpuset); assert(!pthread_attr_setaffinity_np(attr+i, sizeof(cpuset), &cpuset)); pthread_create(threads+i, attr+i, TimeOnCore, kp+i); } for (i=0; i < p; i++) { pthread_join(threads[i], NULL); mflops[i] = kp[i].mf; } free(kp->pids); free(kp); free(threads); free(attr); return(mflops); }
/*------------------------------------------------------------------------- * Function: test_lock_throughput * * Purpose: Test the lock thruput for an empty critical section * * Return: Success: 0 * Failure: 1 *------------------------------------------------------------------------- */ static void test_lock_thruput() { void *res; pthread_t threads[TEST_NTHREADS]; for (int i = 0; i < TEST_NTHREADS; i++) { pnodes[i].p = i; pnodes[i].qnode = NULL; } zm_hmpr_init(&lock); counter = 0; int th; for (th=0; th<TEST_NTHREADS; th++) { pthread_attr_t attr; pthread_attr_init(&attr); cpu_set_t cpuset; CPU_ZERO(&cpuset); CPU_SET(th, &cpuset); pthread_attr_setaffinity_np(&attr, sizeof(cpu_set_t), &cpuset); pthread_create(&threads[th], &attr, run, (void*)(intptr_t)th); pthread_attr_destroy(&attr); } for (th=0; th<TEST_NTHREADS; th++) pthread_join(threads[th], &res); zm_hmpr_destroy(&lock); if (counter == TEST_NTHREADS * TEST_NITER) printf("Pass\n"); else printf("Fail\n"); } /* end test_lock_thruput() */
/** Create a thread on a specific core(s) */ int pthread_create_on( pthread_t *t, pthread_attr_t *attr, void *(*start_routine)(void*), void *arg, size_t cpusetsize, const cpu_set_t *cpuset) { pthread_attr_t thread_attr; int ret; if (attr == NULL) { pthread_attr_init ( &thread_attr ); attr = &thread_attr; } // Set the CPU if ( cpuset != NULL ) { ret = pthread_attr_setaffinity_np( attr, cpusetsize, cpuset ); if (ret) goto cleanup; } // Make sure the thread is joinable ret = pthread_attr_setdetachstate( attr, PTHREAD_CREATE_JOINABLE); if (ret) goto cleanup; // Now create the thread ret = pthread_create(t, attr, start_routine, arg); cleanup: if ( attr == &thread_attr ) pthread_attr_destroy ( &thread_attr ); return ret; }
/* Launch all workers on the mic */ void _starpu_mic_sink_launch_workers(struct _starpu_mp_node *node) { int i, ret; struct arg_sink_thread * arg; cpu_set_t cpuset; starpu_pthread_attr_t attr; starpu_pthread_t thread; /*for each core init the mutex, the task pointer and launch the thread */ for(i=0; i<node->nb_cores; i++) { //init the set CPU_ZERO(&cpuset); CPU_SET(i,&cpuset); ret = starpu_pthread_attr_init(&attr); STARPU_ASSERT(ret == 0); ret = pthread_attr_setaffinity_np(&attr, sizeof(cpu_set_t), &cpuset); STARPU_ASSERT(ret == 0); /*prepare the argument for the thread*/ arg= malloc(sizeof(struct arg_sink_thread)); arg->coreid = i; arg->node = node; ret = starpu_pthread_create(&thread, &attr, _starpu_sink_thread, arg); STARPU_ASSERT(ret == 0); ((starpu_pthread_t *)node->thread_table)[i] = thread; } }
/*! creates a hardware thread running on specific core */ thread_t createThread(thread_func f, void* arg, size_t stack_size, ssize_t threadID) { #ifdef __MIC__ threadID++; // start counting at 1 on MIC #endif /* set stack size */ pthread_attr_t attr; pthread_attr_init(&attr); if (stack_size > 0) pthread_attr_setstacksize (&attr, stack_size); /* set affinity */ #if defined(__LINUX__) if (threadID >= 0) { cpu_set_t cset; CPU_ZERO(&cset); CPU_SET(threadID, &cset); pthread_attr_setaffinity_np(&attr,sizeof(cpu_set_t),&cset); } #endif /* create thread */ pthread_t* tid = new pthread_t; if (pthread_create(tid,&attr,(void*(*)(void*))threadStartup,new ThreadStartupData(f,arg,threadID)) != 0) THROW_RUNTIME_ERROR("pthread_create"); return thread_t(tid); }
void Create (void * (* fn) (void *), void * ) { /* Initialize thread creation attributes */ int s = pthread_attr_init(&m_attr); if (s != 0) handle_error_en(s, "pthread_attr_init"); /*if (stack_size > 0) { s = pthread_attr_setstacksize(&m_attr, stack_size); if (s != 0) handle_error_en(s, "pthread_attr_setstacksize"); }*/ /* Create one thread for each command-line argument */ for (size_t t = 0; t < N; ++t) { m_tinfo[t].thread_num = t + 1; //m_tinfo[t].argv_string = argv[optind + t]; cpu_set_t cpuset; CPU_ZERO(&cpuset); CPU_SET(t, &cpuset); //CPU_SET(atoi(m_tinfo[t].argv_string), &cpuset); pthread_attr_setaffinity_np(&m_attr, sizeof(cpuset), &cpuset); /* The pthread_create() call stores the thread ID into corresponding element of m_tinfo[] */ s = pthread_create(&m_tinfo[t].thread_id, &m_attr, fn, &m_tinfo[t]); if (s != 0) handle_error_en(s, "pthread_create"); } }
NTSTATUS LwRtlResetAffinityThreadAttribute( pthread_attr_t* pAttr ) { NTSTATUS status = STATUS_SUCCESS; CPU_SET_TYPE cpuSet; ULONG numCpus = 0; int i = 0; CPU_ZERO(&cpuSet); numCpus = LwRtlGetCpuCount(); for (i = 0; i < numCpus; i++) { (void) CPU_SET(i, &cpuSet); } status = LwErrnoToNtStatus( pthread_attr_setaffinity_np(pAttr, sizeof(cpuSet), &cpuSet)); GOTO_ERROR_ON_STATUS(status); error: return status; }
int abstraction_thread_start( thread_state_t *thread_state, unsigned int cpu, thread_function_t thread_function, void *thread_user_state ) { int rv = 0, rv_create; pthread_attr_t attr; cpu_set_t cpuset; assert( thread_state != NULL ); // TRD : cpu can be any value in its range assert( thread_function != NULL ); // TRD : thread_user_state can be NULL pthread_attr_init( &attr ); CPU_ZERO( &cpuset ); CPU_SET( cpu, &cpuset ); pthread_attr_setaffinity_np( &attr, sizeof(cpuset), &cpuset ); rv_create = pthread_create( thread_state, &attr, thread_function, thread_user_state ); if( rv_create == 0 ) rv = 1; pthread_attr_destroy( &attr ); return( rv ); }
int test_pal_thread_start( test_pal_thread_state_t *thread_state, struct test_pal_logical_processor *lp, test_pal_thread_return_t (TEST_PAL_CALLING_CONVENTION *thread_function)(void *thread_user_state), void *thread_user_state ) { int rv = 0, rv_create; cpu_set_t cpuset; pthread_attr_t attr; assert( thread_state != NULL ); assert( lp != NULL ); assert( thread_function != NULL ); // TRD : thread_user_state can be NULL pthread_attr_init( &attr ); CPU_ZERO( &cpuset ); CPU_SET( lp->logical_processor_number, &cpuset ); pthread_attr_setaffinity_np( &attr, sizeof(cpuset), &cpuset ); rv_create = pthread_create( thread_state, &attr, thread_function, thread_user_state ); if( rv_create == 0 ) rv = 1; pthread_attr_destroy( &attr ); return( rv ); }
int main(int argc, char **argv) { #if defined(INSCOUNT) || defined(PROFILING) pthread_t threads[MAX_THREADS]; int fd; int n_procs; int i; int profile_stop; char bench_file[40], name[100]; if (argc != 3) { printf("<usage> <0/1> <bench_name>\n"); exit(0); } #ifdef BENCH_FILE snprintf(bench_file, sizeof(bench_file), "/home/piyus/bench/%s.txt", BENCH_FILE); #else snprintf(bench_file, sizeof(bench_file), "/home/piyus/bench/benchmark.txt"); #endif bench_fp = fopen(bench_file, "a"); profile_stop = atoi(argv[1]); assert(profile_stop == 0 || profile_stop == 1); fprintf(bench_fp, "Benchmark %s ", argv[2]); (profile_stop)?fprintf(bench_fp, "Stopped\n"):fprintf(bench_fp, "Started\n"); n_procs = sysconf(_SC_NPROCESSORS_ONLN); snprintf(name, sizeof(name), "/dev/%s", MODULE_NAME); fd = open(name, O_RDONLY); if (fd < 0) { perror("unable to open dev"); return 0; } for (i = 0; i < n_procs; i++) { int *arg = malloc(sizeof(int)*2); pthread_attr_t *tattr = (pthread_attr_t *)malloc(sizeof(pthread_attr_t)); cpu_set_t cpuset; assert(arg); *arg = fd; *(arg + 1) = i; assert(tattr); pthread_attr_init(tattr); CPU_ZERO(&cpuset); CPU_SET(i, &cpuset); pthread_attr_setaffinity_np (tattr, sizeof(cpuset), &cpuset); if (pthread_create(&threads[i], tattr, start_bt, arg)) { fprintf(stderr, "ERROR: Creating Pthread\n"); } } for (i = 0; i < n_procs; i++) { pthread_join(threads[i], NULL); } close(fd); #endif return 0; }
int main () { int i; for (i = 0; i < CPU_SETSIZE; i++) { cpu_set_t set; int ret; pthread_attr_init (&attr[i]); CPU_ZERO_S (sizeof (set), &set); CPU_SET_S (i, sizeof (set), &set); ret = pthread_attr_setaffinity_np (&attr[i], sizeof (set), &set); if (ret != 0) { fprintf (stderr, "set_affinity: %d: %s\n", ret, strerror (ret)); exit (3); } ret = pthread_create (&thr[i], &attr[i], mythread, NULL); /* Should fail with EINVAL at some point. */ if (ret != 0) { unsigned long t; fprintf (stderr, "pthread_create: %d: %s\n", ret, strerror (ret)); /* Wait for all threads to exit. pthread_create spawns a clone thread even in the failing case, as it can only try to set the affinity after creating the thread. That new thread is immediately canceled (because setting the affinity fails), by killing it with a SIGCANCEL signal, which may end up in pthread_cancel/unwind paths, which may trigger a libgcc_s.so load, making the thread hit the solib-event breakpoint. Now, if we would let the program exit without waiting, sometimes it would happen that the inferior exits just while we're handling the solib-event, resulting in errors being thrown due to failing ptrace call fails (with ESCHR), breaking the test. */ t = 16; while (count_tasks (getpid ()) > 1) { usleep (t); if (t < 256) t *= 2; } /* Normal exit, because this is what we are expecting. */ exit (0); } } /* Should not normally be reached. */ exit (1); }
#include "atlas_misc.h" #include "atlas_threads.h" #define ATL_THREAD_AFFINITY_1 1 /* temporary -- will need to probe for this */ int ATL_thread_start(ATL_thread_t *thr, int proc, void *(*rout)(void*), void *arg) /* * Creates a thread that will run only on processor proc. * RETURNS: 0 on success, non-zero on error * NOTE: present implementation dies on error, so 0 is always returned. */ { #ifdef ATL_WINTHREADS DWORD thrID; thr->rank = proc; thr->thrH = CreateThread(NULL, 0, rout, arg, CREATE_SUSPENDED, &thrID); ATL_assert(thr->thrH); ATL_assert(SetThreadAffinityMask(thr->thrH, (1<<proc))); ATL_assert(ResumeThread(thr->thrH) == 1); #else pthread_attr_t attr; #ifdef ATL_PAFF_SETAFFNP unsigned long cpuset; #elif defined(ATL_PAFF_SETPROCNP) #endif #ifdef ATL_PAFF_SELF thr->paff_set = 0; /* affinity must be set by created thread */ #endif thr->rank = proc; ATL_assert(!pthread_attr_init(&attr)); #ifdef IBM_PT_ERROR ATL_assert(!pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_UNDETACHED)); #else ATL_assert(!pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE)); #endif pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM); /* no chk, OK to fail */ #ifdef ATL_PAFF_SETAFFNP #ifdef ATL_RANK_IS_PROCESSORID cpuset = (1<<proc); #else cpuset = (1<<ATL_rank2processorid[proc]); #endif ATL_assert(!pthread_attr_setaffinity_np(&attr, sizeof(cpuset), &cpuset)); #elif defined(ATL_PAFF_SETPROCNP) #ifdef ATL_RANK_IS_PROCESSORID ATL_assert(!pthread_attr_setprocessor_np(&attr, (pthread_spu_t)proc, PTHREAD_BIND_FORCED_NP)); #else ATL_assert(!pthread_attr_setprocessor_np(&attr, (pthread_spu_t) ATL_rank2processorid[proc], PTHREAD_BIND_FORCED_NP)); #endif #endif ATL_assert(!pthread_create(&thr->thrH, &attr, rout, arg)); ATL_assert(!pthread_attr_destroy(&attr)); #endif return(0); }
int main() { unsigned int cpu; pthread_t tid; pthread_attr_t attr1, attr2; cpu_set_t threadCpus; cpu_set_t keepCpus; pthread_t self = pthread_self(); if (pthread_getaffinity_np(self, sizeof(cpu_set_t), &threadCpus) == ENOSYS) { printf("pthread_get/set_affinity_np API not supported for this platform: skipping test."); return 0; } assert(pthread_attr_init(&attr1) == 0); assert(pthread_attr_init(&attr2) == 0); CPU_ZERO(&keepCpus); for (cpu = 1; cpu < sizeof(cpu_set_t)*8; cpu += 2) { CPU_SET(cpu, &keepCpus); /* 0b10101010101010101010101010101010 */ } assert(pthread_getaffinity_np(self, sizeof(cpu_set_t), &threadCpus) == 0); if (CPU_COUNT(&threadCpus) > 1) { assert(pthread_attr_setaffinity_np(&attr1, sizeof(cpu_set_t), &threadCpus) == 0); CPU_AND(&threadCpus, &threadCpus, &keepCpus); assert(pthread_attr_setaffinity_np(&attr2, sizeof(cpu_set_t), &threadCpus) == 0); assert(pthread_create(&tid, &attr1, mythread, (void *) &attr1) == 0); assert(pthread_join(tid, NULL) == 0); assert(pthread_create(&tid, &attr2, mythread, (void *) &attr2) == 0); assert(pthread_join(tid, NULL) == 0); } assert(pthread_attr_destroy(&attr1) == 0); assert(pthread_attr_destroy(&attr2) == 0); return 0; }
int main(void) { int ret = 0; pthread_attr_t thread_attr; pthread_attr_init(&thread_attr); /* don't care abt exact args, just the API itself in libpthread */ ret = pthread_attr_setaffinity_np(&thread_attr, 0, NULL); return ret; }
PetscErrorCode PetscThreadCommSetPThreadAttributes(PetscThreadComm tcomm) { PetscErrorCode ierr; PetscThreadComm_PThread ptcomm=(PetscThreadComm_PThread)tcomm->data; pthread_attr_t *attr =ptcomm->attr; #if defined(PETSC_HAVE_SCHED_CPU_SET_T) PetscInt ncores; cpu_set_t *cpuset; #endif PetscInt i; PetscFunctionBegin; #if defined(PETSC_HAVE_SCHED_CPU_SET_T) ierr = PetscMalloc1(tcomm->nworkThreads,&cpuset);CHKERRQ(ierr); ptcomm->cpuset = cpuset; PetscGetNCores(&ncores); #endif for (i=ptcomm->thread_num_start; i < tcomm->nworkThreads; i++) { ierr = pthread_attr_init(&attr[i]);CHKERRQ(ierr); /* CPU affinity */ #if defined(PETSC_HAVE_SCHED_CPU_SET_T) PetscInt j; switch (ptcomm->aff) { case PTHREADAFFPOLICY_ONECORE: CPU_ZERO(&cpuset[i]); CPU_SET(tcomm->affinities[i]%ncores,&cpuset[i]); pthread_attr_setaffinity_np(&attr[i],sizeof(cpu_set_t),&cpuset[i]); break; case PTHREADAFFPOLICY_ALL: CPU_ZERO(&cpuset[i]); for (j=0; j<ncores; j++) CPU_SET(j,&cpuset[i]); pthread_attr_setaffinity_np(&attr[i],sizeof(cpu_set_t),&cpuset[i]); break; case PTHREADAFFPOLICY_NONE: break; } #endif } PetscFunctionReturn(0); }
void gomp_init_thread_affinity (pthread_attr_t *attr) { unsigned int cpu; cpu_set_t cpuset; cpu = __sync_fetch_and_add (&affinity_counter, 1); cpu %= gomp_cpu_affinity_len; CPU_ZERO (&cpuset); CPU_SET (gomp_cpu_affinity[cpu], &cpuset); pthread_attr_setaffinity_np (attr, sizeof (cpu_set_t), &cpuset); }
int numa_localize(tuple_t * relation, int64_t num_tuples, uint32_t nthreads) { uint32_t i, rv; uint64_t offset = 0; /* we need aligned allocation of items */ create_arg_t args[nthreads]; pthread_t tid[nthreads]; cpu_set_t set; pthread_attr_t attr; unsigned int pagesize; unsigned int npages; unsigned int npages_perthr; uint64_t ntuples_perthr; uint64_t ntuples_lastthr; pagesize = getpagesize(); npages = (num_tuples * sizeof(tuple_t)) / pagesize + 1; npages_perthr = npages / nthreads; ntuples_perthr = npages_perthr * (pagesize/sizeof(tuple_t)); ntuples_lastthr = num_tuples - ntuples_perthr * (nthreads-1); pthread_attr_init(&attr); for( i = 0; i < nthreads; i++ ) { int cpu_idx = get_cpu_id(i); CPU_ZERO(&set); CPU_SET(cpu_idx, &set); pthread_attr_setaffinity_np(&attr, sizeof(cpu_set_t), &set); args[i].firstkey = offset + 1; args[i].rel.tuples = relation + offset; args[i].rel.num_tuples = (i == nthreads-1) ? ntuples_lastthr : ntuples_perthr; offset += ntuples_perthr; rv = pthread_create(&tid[i], &attr, numa_localize_thread, (void*)&args[i]); if (rv){ fprintf(stderr, "[ERROR] pthread_create() return code is %d\n", rv); exit(-1); } } for(i = 0; i < nthreads; i++){ pthread_join(tid[i], NULL); } return 0; }
static void bind_cpu(pthread_attr_t *attr, int cpu) { #ifdef __USE_GNU #ifndef ANDROID cpu_set_t mask; if (cpu == -1) return; CPU_ZERO(&mask); CPU_SET(cpu, &mask); pthread_attr_setaffinity_np(attr, sizeof(mask), &mask); #endif #endif }
int embb_thread_create(embb_thread_t* thread, const embb_core_set_t* core_set, embb_thread_start_t func, void* arg) { pthread_attr_t attr; /* Used to set thread affinities */ int status = pthread_attr_init(&attr); if (status != 0) return EMBB_ERROR; if (core_set != NULL) { #if defined(EMBB_PLATFORM_HAS_GLIB_CPU) || \ defined(EMBB_PLATFORM_HAS_HEADER_CPUSET) assert(embb_core_count_available() < CPU_SETSIZE && "Core sets are only supported up to CPU_SETSIZE processors!"); #ifdef EMBB_PLATFORM_HAS_GLIB_CPU cpu_set_t cpuset; #else cpuset_t cpuset; #endif CPU_ZERO(&cpuset); /* Disable all processors */ for (unsigned int i = 0; i < embb_core_count_available(); i++) { if (embb_core_set_contains(core_set, i)) { CPU_SET(i, &cpuset); } } status = pthread_attr_setaffinity_np(&attr, sizeof(cpuset), &cpuset); if (status != 0) return EMBB_ERROR; #else embb_log_write("base_c", EMBB_LOG_LEVEL_WARNING, "Could not set thread " "affinity, since no implementation available!\n"); #endif } /* Dynamic allocation of thread arguments. Freed on call of join. */ thread->embb_internal_arg = (embb_internal_thread_arg_t*) embb_alloc(sizeof(embb_internal_thread_arg_t)); thread->embb_internal_arg->func = func; thread->embb_internal_arg->arg = arg; status = pthread_create( &(thread->embb_internal_handle), /* pthread handle */ &attr, /* additional attributes, e.g., affinities */ embb_internal_thread_start, /* thread start function */ (void*)(thread->embb_internal_arg)); /* arguments to thread start func. */ if (status != 0) return EMBB_ERROR; status = pthread_attr_destroy(&attr); if (status != 0) return EMBB_ERROR; return EMBB_SUCCESS; }
void benchmark_once_thread(struct thrarg *thrarg, unsigned iters) { const int new_thread = 0; size_t i; unsigned nthreads = thrarg->params.threads; struct thrarg *thrargs; pthread_t threads[nthreads]; pthread_attr_t attr; cpu_set_t c; const bool affinity = true; thrarg->params.iters = iters; if (!shared) shared = alloc_shared(sizeof(struct bench_shared)); thrargs = shared->thrargs; shared->barrier = nthreads; pthread_attr_init(&attr); for (i=0; i < nthreads; i++) { thrargs[i] = *thrarg; thrargs[i].params.id = i; } i = (new_thread) ? 0 : 1; for (; i < nthreads; i++) { if (affinity) { CPU_ZERO(&c); CPU_SET(i, &c); pthread_attr_setaffinity_np(&attr, sizeof(c), &c); } pthread_create(&threads[i], &attr, thread, (void *)i); } if (!new_thread) thread((void *)(size_t)0); i = (new_thread) ? 0 : 1; for (; i < nthreads; i++) pthread_join(threads[i], NULL); thrarg->result.avg = thrargs[0].result.avg; thrarg->result.sum = thrargs[0].result.sum; }
int setup_thread_attr(pthread_attr_t * attr, int prio, cpu_set_t * mask, int schedpolicy) { int status; struct sched_param thread_param; status = pthread_attr_init(attr); if (status) { error ("setup_thread_attr: initializing thread attribute: 0x%x\n", status); return FAILURE; } status = pthread_attr_setschedpolicy(attr, schedpolicy); if (status) { error ("setup_thread_attr: setting attribute policy to %s: 0x%x\n", schedpolicy == SCHED_FIFO ? "SCHED_FIFO" : "SCHED_RR", status); return FAILURE; } status = pthread_attr_setinheritsched(attr, PTHREAD_EXPLICIT_SCHED); if (status) { error ("setup_thread_attr: setting explicit scheduling inheritance: 0x%x\n", status); return FAILURE; } thread_param.sched_priority = prio; status = pthread_attr_setschedparam(attr, &thread_param); if (status) { error("setup_thread_attr: setting scheduler param: 0x%x\n", status); return FAILURE; } status = pthread_attr_setaffinity_np(attr, sizeof(cpu_set_t), mask); if (status) { error("setup_thread_attr: setting affinity attribute: 0x%x\n", status); return FAILURE; } return SUCCESS; }
int main(void) { pthread_t threads[MAX_THREADS]; char name[100]; int fd; int n_procs; int i; snprintf(name, sizeof(name), "/dev/%s", MODULE_NAME); n_procs = sysconf(_SC_NPROCESSORS_ONLN); fd = open(name, O_RDONLY); if (fd < 0) { perror("unable to open dev"); return 0; } for (i = 0; i < n_procs; i++) { int *arg = malloc(sizeof(int)*2); pthread_attr_t *tattr = (pthread_attr_t *)malloc(sizeof(pthread_attr_t)); cpu_set_t cpuset; assert(arg); *arg = fd; *(arg + 1) = i; assert(tattr); pthread_attr_init(tattr); CPU_ZERO(&cpuset); CPU_SET(i, &cpuset); pthread_attr_setaffinity_np (tattr, sizeof(cpuset), &cpuset); if (pthread_create(&threads[i], tattr, load_native_idt, arg)) { fprintf(stderr, "ERROR: Creating Pthread\n"); close(fd); return 0; } } for (i = 0; i < n_procs; i++) { pthread_join(threads[i], NULL); } if (ioctl(fd, STOP_BT, n_procs) != 0) { perror("ioctl STOP_BT"); } close(fd); return 0; }
int main(void) { class server *pserver = new server(); unsigned int recvlength = 25; unsigned int configuredcpuscount = 0; unsigned int onlinecpuscount = 0; pthread_t threadid; pthread_attr_t thread_attr; int ret; int threadcount = 0; struct tcpu_info *ptcpuinfo; struct sched_param tsched_param; cpu_set_t cpuset; configuredcpuscount = sysconf(_SC_NPROCESSORS_CONF); onlinecpuscount = sysconf(_SC_NPROCESSORS_ONLN); tsched_param.sched_priority = sched_get_priority_max(SCHED_RR); threadcount = onlinecpuscount; while(threadcount){ pthread_attr_init(&thread_attr); pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_DETACHED); pthread_attr_setschedpolicy(&thread_attr, SCHED_RR); pthread_attr_setschedparam(&thread_attr, &tsched_param); CPU_ZERO(&cpuset); CPU_SET(threadcount-1, &cpuset); pthread_attr_setaffinity_np(&thread_attr, sizeof(cpuset), &cpuset); ptcpuinfo = (struct tcpu_info *)malloc(sizeof(struct tcpu_info)); memset(ptcpuinfo, 0, sizeof(struct tcpu_info)); ptcpuinfo->listenerfd = pserver->socketfd; if((ret = pthread_create(&threadid, &thread_attr, vizsla_cpu_eventloop_threadfunc, ptcpuinfo) != 0)) { perror("pthread_create failed"); return ret; } threadcount--; } while(1); return 0; }
void viterbi_stream_create_threads(DATA_STREAM* dstream) { int i; pthread_barrier_init(&dstream->barrier, NULL, NTHREADS); for (i = 0; i < NTHREADS-1; i++) sem_init(&semsynch[i], 0, 0); if(NTHREADS == 1) return; pthread_t threads[NTHREADS]; pthr_info_t args; args.dstream = dstream; args.thrid = 0; #ifdef _GNU_SOURCE cpu_set_t cpuset; CPU_ZERO(&cpuset); CPU_SET(MAPIDCPU(NTHREADS-1), &cpuset); threads[NTHREADS-1] = pthread_self(); pthread_setaffinity_np(threads[NTHREADS-1], sizeof(cpu_set_t), &cpuset); #endif for (i = 0; i < NTHREADS-1; i++) { pthr_info_t *argscopy = calloc(1, sizeof(pthr_info_t)); memcpy(argscopy, &args, sizeof(pthr_info_t)); argscopy->thrid = i; pthread_attr_t attr; pthread_attr_init(&attr); #ifdef _GNU_SOURCE CPU_ZERO(&cpuset); CPU_SET(MAPIDCPU(i), &cpuset); pthread_attr_setaffinity_np(&attr, sizeof(cpu_set_t), &cpuset); #endif if (pthread_create(&threads[i], &attr, viterbi_stream_thread_loop, argscopy)) exit(fprintf(stderr, "ERROR could not create worker thread\n")); } #ifdef _GNU_SOURCE printf("THR %d running on cpu %d\n", NTHREADS-1, sched_getcpu()); #endif }
/** * @brief Set the thread cpu affinity attribute to the * supplied cpu number. * Specifying a cpu number that does not exist, or is * offline will cause pthread_create() to fail with * EINVAL. * * @param pAttr pointer to the pthread_att_t * @param CpuNumber the cpu number */ NTSTATUS LwRtlSetAffinityThreadAttribute( pthread_attr_t* pAttr, ULONG CpuNumber ) { NTSTATUS status = STATUS_SUCCESS; CPU_SET_TYPE cpuSet; CPU_ZERO(&cpuSet); (void) CPU_SET(CpuNumber, &cpuSet); status = LwErrnoToNtStatus( pthread_attr_setaffinity_np(pAttr, sizeof(cpuSet), &cpuSet)); GOTO_ERROR_ON_STATUS(status); error: return status; }
/* * Creates a worker thread. */ static void create_worker(void *(*func)(void *), void *arg, int i) { pthread_t thread; pthread_attr_t attr; int ret; #ifdef __linux__ cpu_set_t cpuset; int coreid; coreid = 6 + i; CPU_ZERO(&cpuset); CPU_SET(coreid, &cpuset); pthread_attr_init(&attr); pthread_attr_setaffinity_np(&attr, sizeof(cpu_set_t), &cpuset); #endif if ((ret = pthread_create(&thread, &attr, func, arg)) != 0) { fprintf(stderr, "Can't create thread: %s\n", strerror(ret)); exit(1); } }
static void geopm_proc_cpuset_once(void) { int err = 0; int num_cpu = geopm_sched_num_cpu(); pthread_t tid; pthread_attr_t attr; g_proc_cpuset = CPU_ALLOC(num_cpu); if (g_proc_cpuset == NULL) { err = ENOMEM; } if (!err) { g_proc_cpuset_size = CPU_ALLOC_SIZE(num_cpu); for (int i = 0; i < num_cpu; ++i) { CPU_SET_S(i, g_proc_cpuset_size, g_proc_cpuset); } err = pthread_attr_init(&attr); } if (!err) { err = pthread_attr_setaffinity_np(&attr, g_proc_cpuset_size, g_proc_cpuset); } if (!err) { err = pthread_create(&tid, &attr, geopm_proc_cpuset_pthread, NULL); } if (!err) { void *result = NULL; err = pthread_join(tid, &result); if (!err && result) { err = (int)(size_t)result; } } if (err && err != ENOMEM) { for (int i = 0; i < num_cpu; ++i) { CPU_SET_S(i, g_proc_cpuset_size, g_proc_cpuset); } } if (!err) { err = pthread_attr_destroy(&attr); } }