void* thread_pool::loop(void* arg)
{
thread_arg_t* thread_arg = (thread_arg_t*)arg;
assert (thread_arg);
thread_func thread_func;
thread_pool* pool = thread_arg->pool;
thread_loc& loc = thread_arg->loc;
void *thread_func_arg;
if(loc.cpu >= 0)
proc_bind_thread (loc.cpu);
loc.lgrp = loc_get_lgrp();
while (!pool->die)
{
thread_arg->sem_run.wait();
if (pool->die)
break;
thread_func = *(pool->thread_function);
thread_func_arg = pool->args[loc.thread];
// Run thread function.
(*thread_func)(thread_func_arg, loc);
int num_workers_done = fetch_and_inc(&pool->num_workers_done) + 1;
if (num_workers_done == pool->num_workers) {
// Everybody's done.
pool->sem_all_workers_done.post();
}
}
int num_workers_done = fetch_and_inc(&pool->num_workers_done) + 1;
if (num_workers_done == pool->num_workers) {
// Everybody's done.
pool->sem_all_workers_done.post();
}
return NULL;
}
static void* thread_loop (void *arg)
{
thread_arg_t *thread_arg = arg;
thread_func thread_func;
void *thread_func_arg;
void **ret;
int num_workers_done;
assert (thread_arg);
while (1)
{
CHECK_ERROR (sem_wait (&thread_arg->sem_run));
if (*thread_arg->die)
break;
thread_func = *(thread_arg->thread_func);
thread_func_arg = *(thread_arg->thread_func_arg);
ret = thread_arg->ret;
/* Run thread function. */
*ret = (*thread_func)(thread_func_arg);
num_workers_done = fetch_and_inc(thread_arg->num_workers_done) + 1;
if (num_workers_done == *thread_arg->num_workers)
{
/* Everybody's done. */
CHECK_ERROR (sem_post (thread_arg->sem_all_workers_done));
}
}
sem_destroy (&thread_arg->sem_run);
num_workers_done = fetch_and_inc(thread_arg->num_workers_done) + 1;
if (num_workers_done == *thread_arg->num_workers)
{
/* Everybody's done. */
CHECK_ERROR (sem_post (thread_arg->sem_all_workers_done));
}
return NULL;
}
static void __add_timestamp_user(struct timestamp *pre_recorded)
{
unsigned int seq_no;
struct timestamp *ts;
seq_no = fetch_and_inc((int *) &ts_seq_no);
if (ft_buffer_start_write(trace_ts_buf, (void**) &ts)) {
*ts = *pre_recorded;
ts->seq_no = seq_no;
__save_irq_flags(ts);
ft_buffer_finish_write(trace_ts_buf, ts);
}
}
// Each worker computes the, sum, min & max values for tasks from taken from bag
// while there are still tasks left to be computed
void *Worker(void *arg) {
long myid = (long) arg;
int total, i, j, first, last;
ThreadData *my_min_max = malloc(sizeof (ThreadData));
my_min_max-> max = INT_MIN;
my_min_max-> min = INT_MAX;
my_min_max->sum = 0;
my_min_max->max_col = -1;
my_min_max->max_row = -1;
my_min_max->min_col = -1;
my_min_max->min_row = -1;
#ifdef DEBUG
// printf("worker %d (pthread id %d) has started\n", myid, pthread_self());
#endif
/* sum values in my strip */
total = 0;
#ifdef DEBUG
printf("T: %d started\n", (int) myid);
#endif
int my_row;
while ((my_row = fetch_and_inc()) < size) {
#ifdef DEBUG
printf("T: %d started with row %d\n", (int) myid, my_row);
#endif
for (j = 0; j < size; j++) {
total += matrix[my_row][j];
if (matrix[my_row][j] > my_min_max->max) {
my_min_max->max = matrix[my_row][j];
my_min_max->max_row = my_row;
my_min_max->max_col = j;
}
if (matrix[my_row][j] < my_min_max->min) {
my_min_max->min = matrix[my_row][j];
my_min_max->min_row = my_row;
my_min_max->min_col = j;
}
my_min_max->sum = total;
}
}
#ifdef DEBUG
printf("T: %d done with total %d\n", (int) myid, my_min_max->sum);
#endif
pthread_exit(my_min_max);
}
static inline void __save_timestamp_cpu(unsigned long event,
uint8_t type, uint8_t cpu)
{
unsigned int seq_no;
struct timestamp *ts;
seq_no = fetch_and_inc((int *) &ts_seq_no);
if (ft_buffer_start_write(trace_ts_buf, (void**) &ts)) {
ts->event = event;
ts->seq_no = seq_no;
ts->cpu = cpu;
ts->task_type = type;
__save_irq_flags(ts);
barrier();
/* prevent re-ordering of ft_timestamp() */
ts->timestamp = ft_timestamp();
ft_buffer_finish_write(trace_ts_buf, ts);
}
}
void LpelSpmdRequest(lpel_task_t *task, lpel_spmdfunc_t fun, void *arg)
{
int tail;
spmdreq_t *req;
workerctx_t *wc = task->worker_context;
assert(wc != NULL && wc->wid >= 0 && wc->wid < num_workers);
/* set pending flag */
assert( 0 == worker_data[wc->wid].pending);
worker_data[wc->wid].pending = 1;
/* append */
tail = fetch_and_inc(&qtail) % num_workers;
req = &req_queue[tail];
req->wctx = wc;
req->func = fun;
req->arg = arg;
req->task = task;
}
feather_callback void save_task_latency(unsigned long event,
unsigned long when_ptr)
{
lt_t now = litmus_clock();
lt_t *when = (lt_t*) when_ptr;
unsigned int seq_no;
int cpu = raw_smp_processor_id();
struct timestamp *ts;
seq_no = fetch_and_inc((int *) &ts_seq_no);
if (ft_buffer_start_write(trace_ts_buf, (void**) &ts)) {
ts->event = event;
ts->timestamp = now - *when;
ts->seq_no = seq_no;
ts->cpu = cpu;
ts->task_type = TSK_RT;
__save_irq_flags(ts);
ft_buffer_finish_write(trace_ts_buf, ts);
}
}
