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);
}
}
