void *thr_reader(void *data)
{
unsigned long tidx = (unsigned long)data;
printf_verbose("thread_begin %s, thread id : %lx, tid %lu\n",
"reader", pthread_self(), (unsigned long)gettid());
set_affinity();
while (!test_go)
{
}
for (;;) {
pthread_mutex_lock(&lock);
assert(test_array.a == 8);
if (unlikely(rduration))
loop_sleep(rduration);
pthread_mutex_unlock(&lock);
nr_reads++;
if (unlikely(!test_duration_read()))
break;
}
tot_nr_reads[tidx] = nr_reads;
printf_verbose("thread_end %s, thread id : %lx, tid %lu\n",
"reader", pthread_self(), (unsigned long)gettid());
return ((void*)1);
}
void *thr_writer(void *_count)
{
unsigned long long *count = _count;
printf_verbose("thread_begin %s, thread id : %lx, tid %lu\n",
"writer", (unsigned long) pthread_self(),
(unsigned long) gettid());
set_affinity();
while (!test_go)
{
}
cmm_smp_mb();
for (;;) {
pthread_rwlock_wrlock(&lock);
test_array.a = 0;
test_array.a = 8;
if (caa_unlikely(wduration))
loop_sleep(wduration);
pthread_rwlock_unlock(&lock);
URCU_TLS(nr_writes)++;
if (caa_unlikely(!test_duration_write()))
break;
if (caa_unlikely(wdelay))
loop_sleep(wdelay);
}
printf_verbose("thread_end %s, thread id : %lx, tid %lu\n",
"writer", (unsigned long) pthread_self(),
(unsigned long) gettid());
*count = URCU_TLS(nr_writes);
return ((void*)2);
}
static void reset(test_context *ctx)
{
rtems_status_code sc;
size_t i;
for (i = 0; i < TASK_COUNT; ++i) {
set_priority(ctx->task_ids[i], P(i));
set_affinity(ctx->task_ids[i], A(1, 1));
}
for (i = CPU_COUNT; i < TASK_COUNT; ++i) {
sc = rtems_task_suspend(ctx->task_ids[i]);
rtems_test_assert(sc == RTEMS_SUCCESSFUL || sc == RTEMS_ALREADY_SUSPENDED);
}
for (i = 0; i < CPU_COUNT; ++i) {
sc = rtems_task_resume(ctx->task_ids[i]);
rtems_test_assert(sc == RTEMS_SUCCESSFUL || sc == RTEMS_INCORRECT_STATE);
}
/* Order the idle threads explicitly */
for (i = 0; i < CPU_COUNT; ++i) {
const Per_CPU_Control *c;
const Thread_Control *h;
c = _Per_CPU_Get_by_index(CPU_COUNT - 1 - i);
h = c->heir;
sc = rtems_task_suspend(h->Object.id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
}
void *thr_reader(void *data)
{
unsigned long tidx = (unsigned long)data;
printf_verbose("thread_begin %s, tid %lu\n",
"reader", urcu_get_thread_id());
set_affinity();
while (!test_go)
{
}
for (;;) {
pthread_mutex_lock(&per_thread_lock[tidx].lock);
assert(test_array.a == 8);
if (caa_unlikely(rduration))
loop_sleep(rduration);
pthread_mutex_unlock(&per_thread_lock[tidx].lock);
URCU_TLS(nr_reads)++;
if (caa_unlikely(!test_duration_read()))
break;
}
tot_nr_reads[tidx] = URCU_TLS(nr_reads);
printf_verbose("thread_end %s, tid %lu\n",
"reader", urcu_get_thread_id());
return ((void*)1);
}
void *thr_writer(void *data)
{
unsigned long wtidx = (unsigned long)data;
printf_verbose("thread_begin %s, tid %lu\n",
"writer", urcu_get_thread_id());
set_affinity();
while (!test_go)
{
}
cmm_smp_mb();
for (;;) {
pthread_mutex_lock(&lock);
test_array.a = 0;
test_array.a = 8;
if (caa_unlikely(wduration))
loop_sleep(wduration);
pthread_mutex_unlock(&lock);
URCU_TLS(nr_writes)++;
if (caa_unlikely(!test_duration_write()))
break;
if (caa_unlikely(wdelay))
loop_sleep(wdelay);
}
printf_verbose("thread_end %s, tid %lu\n",
"writer", urcu_get_thread_id());
tot_nr_writes[wtidx] = URCU_TLS(nr_writes);
return ((void*)2);
}
void *thr_reader(void *_count)
{
unsigned long long *count = _count;
printf_verbose("thread_begin %s, thread id : %lx, tid %lu\n",
"reader", (unsigned long) pthread_self(),
(unsigned long) gettid());
set_affinity();
while (!test_go)
{
}
for (;;) {
pthread_rwlock_rdlock(&lock);
assert(test_array.a == 8);
if (caa_unlikely(rduration))
loop_sleep(rduration);
pthread_rwlock_unlock(&lock);
URCU_TLS(nr_reads)++;
if (caa_unlikely(!test_duration_read()))
break;
}
*count = URCU_TLS(nr_reads);
printf_verbose("thread_end %s, thread id : %lx, tid %lu\n",
"reader", (unsigned long) pthread_self(),
(unsigned long) gettid());
return ((void*)1);
}
/**
* start_counting
*
* Arguments: <context_id> <event_set_id>
*
* Call the pfm_start system-call to start counting for a perfmon context
* that was previously stopped.
**/
static int start_counting(int argc, char **argv)
{
pfarg_start_t start_arg;
struct context *ctx;
struct event_set *evt;
cpu_set_t old_cpu_set;
int ctx_id, event_set_id;
int system_wide, rc;
memset(&start_arg, 0, sizeof(start_arg));
ctx_id = strtoul(argv[1], NULL, 0);
event_set_id = strtoul(argv[2], NULL, 0);
if (ctx_id <= 0 || event_set_id < 0) {
LOG_ERROR("context ID and event-set ID must be "
"positive integers.");
return EINVAL;
}
ctx = find_context(ctx_id);
if (!ctx) {
LOG_ERROR("Can't find context with ID %d.", ctx_id);
return EINVAL;
}
evt = find_event_set(ctx, event_set_id);
if (!evt) {
LOG_ERROR("Can't find event-set with ID %d in context %d.",
event_set_id, ctx_id);
return EINVAL;
}
start_arg.start_set = evt->id;
system_wide = ctx->ctx_arg.ctx_flags & PFM_FL_SYSTEM_WIDE;
if (system_wide && ctx->cpu >= 0) {
rc = set_affinity(ctx->cpu, &old_cpu_set);
if (rc) {
return rc;
}
}
rc = pfm_start(ctx->fd, &start_arg);
if (rc) {
rc = errno;
LOG_ERROR("pfm_start system call returned an error: %d.", rc);
return rc;
}
if (system_wide && ctx->cpu >= 0) {
revert_affinity(&old_cpu_set);
}
LOG_INFO("Started counting for context %d, event-set %d.",
ctx_id, event_set_id);
return 0;
}
static void run_child(size_t cpu)
{
struct child * self = &children[cpu];
self->pid = getpid();
self->sigusr1 = 0;
self->sigusr2 = 0;
self->sigterm = 0;
inner_child = self;
if (atexit(close_pipe)){
close_pipe();
exit(EXIT_FAILURE);
}
umask(0);
/* Change directory to allow directory to be removed */
if (chdir("/") < 0) {
perror("Unable to chdir to \"/\"");
exit(EXIT_FAILURE);
}
setup_signals();
set_affinity(cpu);
create_context(self);
write_pmu(self);
load_context(self);
notify_parent(self, cpu);
/* Redirect standard files to /dev/null */
freopen( "/dev/null", "r", stdin);
freopen( "/dev/null", "w", stdout);
freopen( "/dev/null", "w", stderr);
for (;;) {
sigset_t sigmask;
sigfillset(&sigmask);
sigdelset(&sigmask, SIGUSR1);
sigdelset(&sigmask, SIGUSR2);
sigdelset(&sigmask, SIGTERM);
if (self->sigusr1) {
perfmon_start_child(self->ctx_fd);
self->sigusr1 = 0;
}
if (self->sigusr2) {
perfmon_stop_child(self->ctx_fd);
self->sigusr2 = 0;
}
sigsuspend(&sigmask);
}
}
void worker (unsigned name, unsigned mask) {
std::lock_guard<std::mutex> lock(m);
std::cout << "thread #" << name << "(" << mask << ")";
if (!set_affinity (mask))
std::cout << ": error set affinity\n";
else
std::cout << " is running with mask " << get_affinity () << std::endl;
}
void *perftest_thread(void *arg)
{
thread_data_t *thread_data = (thread_data_t *)arg;
int thread_index = thread_data->thread_index;
int write_elem = thread_data->write_elem;
int read_elem;
unsigned long random_seed = 1234;
unsigned long *value_ptr;
unsigned long *new_value_ptr;
unsigned long value;
unsigned long long reads = 0;
unsigned long long writes = 0;
set_affinity(thread_index);
rcu_register_thread();
rcu_defer_register_thread();
lock_mb();
while (goflag == GOFLAG_INIT)
poll(NULL, 0, 10);
switch (thread_data->mode)
{
case MODE_READONLY:
while (goflag == GOFLAG_RUN)
{
read_elem = get_random(&random_seed) % Tree_Scale;
value = *Values[read_elem];
reads++;
}
break;
case MODE_WRITE:
while (goflag == GOFLAG_RUN)
{
write_elem = get_random(&random_seed) % Tree_Size;
value_ptr = Values[write_elem];
value = get_random(&random_seed) % Tree_Scale + 1;
new_value_ptr = (unsigned long *)malloc(sizeof(unsigned long *));
*new_value_ptr = value;
rcu_assign_pointer(Values[write_elem], new_value_ptr);
defer_rcu(free, value_ptr);
writes++;
}
break;
}
rcu_unregister_thread();
rcu_defer_unregister_thread();
printf("thread %d reads %lld writes %lld\n", thread_index, reads, writes);
return NULL;
}
void *test_hash_rw_thr_reader(void *_count)
{
unsigned long long *count = _count;
struct lfht_test_node *node;
struct cds_lfht_iter iter;
printf_verbose("thread_begin %s, tid %lu\n",
"reader", urcu_get_thread_id());
URCU_TLS(rand_lookup) = urcu_get_thread_id() ^ time(NULL);
set_affinity();
rcu_register_thread();
while (!test_go)
{
}
cmm_smp_mb();
for (;;) {
rcu_read_lock();
cds_lfht_test_lookup(test_ht,
(void *)(((unsigned long) rand_r(&URCU_TLS(rand_lookup)) % lookup_pool_size) + lookup_pool_offset),
sizeof(void *), &iter);
node = cds_lfht_iter_get_test_node(&iter);
if (node == NULL) {
if (validate_lookup) {
printf("[ERROR] Lookup cannot find initial node.\n");
exit(-1);
}
URCU_TLS(lookup_fail)++;
} else {
URCU_TLS(lookup_ok)++;
}
rcu_debug_yield_read();
if (caa_unlikely(rduration))
loop_sleep(rduration);
rcu_read_unlock();
URCU_TLS(nr_reads)++;
if (caa_unlikely(!test_duration_read()))
break;
if (caa_unlikely((URCU_TLS(nr_reads) & ((1 << 10) - 1)) == 0))
rcu_quiescent_state();
}
rcu_unregister_thread();
*count = URCU_TLS(nr_reads);
printf_verbose("thread_end %s, tid %lu\n",
"reader", urcu_get_thread_id());
printf_verbose("read tid : %lx, lookupfail %lu, lookupok %lu\n",
urcu_get_thread_id(),
URCU_TLS(lookup_fail),
URCU_TLS(lookup_ok));
return ((void*)1);
}
static int init_realtime(void)
{
struct sched_param schedparm;
memset(&schedparm, 0, sizeof(schedparm));
schedparm.sched_priority = thread_info.thread_prio;
sched_setscheduler(0, SCHED_FIFO, &schedparm);
set_affinity();
return 0;
}
/**
* @brief Execute command (fork, exec, wait)
*
* @param [in] argc number of cmd args
* @param [in] argv cmd args
*
* @return Operation status
* @retval 0 on success
* @retval -1 on error
*/
static int
execute_cmd(int argc, char **argv)
{
int i = 0;
if (0 >= argc || NULL == argv)
return -1;
if (g_cfg.verbose) {
printf("Trying to execute ");
for (i = 0; i < argc; i++)
printf("%s ", argv[i]);
printf("\n");
}
pid_t pid = fork();
if (-1 == pid) {
fprintf(stderr, "%s,%s:%d Failed to execute %s !"
" fork failed\n", __FILE__, __func__, __LINE__,
argv[0]);
return -1;
} else if (0 < pid) {
int status = EXIT_FAILURE;
/* Wait for child */
waitpid(pid, &status, 0);
if (EXIT_SUCCESS != status)
return -1;
} else {
/* set cpu affinity */
if (0 != set_affinity(0)) {
fprintf(stderr, "%s,%s:%d Failed to set core "
"affinity!\n", __FILE__, __func__,
__LINE__);
_Exit(EXIT_FAILURE);
}
/* drop elevated root privileges */
if (0 == g_cfg.sudo_keep && 0 != sudo_drop())
_Exit(EXIT_FAILURE);
errno = 0;
/* execute command */
execvp(argv[0], argv);
fprintf(stderr, "%s,%s:%d Failed to execute %s, %s (%i) !\n",
__FILE__, __func__, __LINE__,
argv[0], strerror(errno), errno);
_Exit(EXIT_FAILURE);
}
return 0;
}
/*
* Use a timer to execute the actions, since it runs with thread dispatching
* disabled. This is necessary to check the expected processor allocations.
*/
static void timer(rtems_id id, void *arg)
{
test_context *ctx;
rtems_status_code sc;
size_t i;
ctx = arg;
i = ctx->action_index;
if (i == 0) {
sc = rtems_task_suspend(ctx->master_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
if (i < RTEMS_ARRAY_SIZE(test_actions)) {
const test_action *action = &test_actions[i];
rtems_id task;
ctx->action_index = i + 1;
task = ctx->task_ids[action->index];
switch (action->kind) {
case KIND_SET_PRIORITY:
set_priority(task, action->data.priority);
break;
case KIND_SET_AFFINITY:
set_affinity(task, action->data.cpu_set);
break;
case KIND_BLOCK:
sc = rtems_task_suspend(task);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
break;
case KIND_UNBLOCK:
sc = rtems_task_resume(task);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
break;
default:
rtems_test_assert(action->kind == KIND_RESET);
reset(ctx);
break;
}
check_cpu_allocations(ctx, action);
sc = rtems_timer_reset(id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
} else {
sc = rtems_task_resume(ctx->master_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_event_transient_send(ctx->master_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
}
void *
Query_queue::threadInitQuery(void * This) {
Query_queue * query_queue = (Query_queue *)This;
uint32_t tid = ATOM_FETCH_ADD(_next_tid, 1);
// set cpu affinity
set_affinity(tid);
query_queue->init_per_thread(tid);
return NULL;
}
void *thr_dequeuer(void *_count)
{
unsigned long long *count = _count;
int ret;
printf_verbose("thread_begin %s, thread id : %lx, tid %lu\n",
"dequeuer", pthread_self(), (unsigned long)gettid());
set_affinity();
ret = rcu_defer_register_thread();
if (ret) {
printf("Error in rcu_defer_register_thread\n");
exit(-1);
}
rcu_register_thread();
while (!test_go)
{
}
cmm_smp_mb();
for (;;) {
struct cds_lfq_node_rcu *qnode;
struct test *node;
rcu_read_lock();
qnode = cds_lfq_dequeue_rcu(&q);
node = caa_container_of(qnode, struct test, list);
rcu_read_unlock();
if (node) {
call_rcu(&node->rcu, free_node_cb);
nr_successful_dequeues++;
}
nr_dequeues++;
if (caa_unlikely(!test_duration_dequeue()))
break;
if (caa_unlikely(rduration))
loop_sleep(rduration);
}
rcu_unregister_thread();
rcu_defer_unregister_thread();
printf_verbose("dequeuer thread_end, thread id : %lx, tid %lu, "
"dequeues %llu, successful_dequeues %llu\n",
pthread_self(), (unsigned long)gettid(), nr_dequeues,
nr_successful_dequeues);
count[0] = nr_dequeues;
count[1] = nr_successful_dequeues;
return ((void*)2);
}
/**
* unload_context
*
* Arguments: <context_id>
*
* Call the pfm_unload_context system-call to unload a perfmon context from
* the system's performance monitoring unit.
**/
static int unload_context(int argc, char **argv)
{
struct context *ctx;
cpu_set_t old_cpu_set;
int system_wide;
int ctx_id;
int rc;
ctx_id = strtoul(argv[1], NULL, 0);
if (ctx_id <= 0) {
LOG_ERROR("context ID must be a positive integer.");
return EINVAL;
}
ctx = find_context(ctx_id);
if (!ctx) {
LOG_ERROR("Can't find context with ID %d.", ctx_id);
return EINVAL;
}
system_wide = ctx->ctx_flags & PFM_FL_SYSTEM_WIDE;
if (system_wide) {
if (ctx->cpu < 0) {
/* This context isn't loaded on any CPU. */
LOG_ERROR("Trying to unload context %d that isn't "
"loaded.\n", ctx_id);
return EINVAL;
}
rc = set_affinity(ctx->cpu, &old_cpu_set);
if (rc) {
return rc;
}
}
rc = pfm_attach(ctx->fd, 0, PFM_NO_TARGET);
if (rc) {
rc = errno;
LOG_ERROR("pfm_attach(detach) system call returned "
"an error: %d.", rc);
return rc;
}
if (system_wide) {
ctx->cpu = -1;
revert_affinity(&old_cpu_set);
}
LOG_INFO("Unloaded context %d.", ctx_id);
return 0;
}
static void *thr_dequeuer(void *_count)
{
unsigned long long *count = _count;
unsigned int counter = 0;
printf_verbose("thread_begin %s, tid %lu\n",
"dequeuer", urcu_get_thread_id());
set_affinity();
rcu_register_thread();
while (!test_go)
{
}
cmm_smp_mb();
assert(test_pop || test_pop_all);
for (;;) {
if (test_pop && test_pop_all) {
/* both pop and pop all */
if (counter & 1)
do_test_pop(test_sync);
else
do_test_pop_all(test_sync);
counter++;
} else {
if (test_pop)
do_test_pop(test_sync);
else
do_test_pop_all(test_sync);
}
if (caa_unlikely(!test_duration_dequeue()))
break;
if (caa_unlikely(rduration))
loop_sleep(rduration);
}
rcu_unregister_thread();
printf_verbose("dequeuer thread_end, tid %lu, "
"dequeues %llu, successful_dequeues %llu\n",
urcu_get_thread_id(),
URCU_TLS(nr_dequeues),
URCU_TLS(nr_successful_dequeues));
count[0] = URCU_TLS(nr_dequeues);
count[1] = URCU_TLS(nr_successful_dequeues);
return ((void*)2);
}
static int do_set_affinity(const char* protos, struct sockaddr_in la,
struct sockaddr_in ra, int rxq, int cpu)
{
int proto = str_to_proto(protos);
int i, ifindex;
refresh_ip_list();
if( la.sin_addr.s_addr == 0 ) {
for( i = 0; i < ip_list_n; ++i )
if( interface_driver_is(ip_list_name(i), "sfc") )
set_affinity(interface_to_ifindex(ip_list_name(i)), proto,
ip_list_ip(i), la.sin_port,
ra.sin_addr.s_addr, ra.sin_port, rxq, cpu);
return 1;
}
else if( CI_IP_IS_MULTICAST(la.sin_addr.s_addr) ) {
for( i = 0; i < ip_list_n; ++i )
if( interface_is(ip_list_name(i), "sfc") )
set_affinity(interface_to_ifindex(ip_list_name(i)), proto,
la.sin_addr.s_addr, la.sin_port,
ra.sin_addr.s_addr, ra.sin_port, rxq, cpu);
return 1;
}
else {
ifindex = ip_to_ifindex(la.sin_addr.s_addr);
if( ifindex < 0 ) {
err("%s: ERROR: Can't find interface for IP %s\n",
me, inet_ntoa(la.sin_addr));
return 0;
}
set_affinity(ifindex, proto,
la.sin_addr.s_addr, la.sin_port,
ra.sin_addr.s_addr, ra.sin_port, rxq, cpu);
return 1;
}
}
static void *thr_enqueuer(void *_count)
{
unsigned long long *count = _count;
bool was_nonempty;
printf_verbose("thread_begin %s, thread id : %lx, tid %lu\n",
"enqueuer", (unsigned long) pthread_self(),
(unsigned long) gettid());
set_affinity();
while (!test_go)
{
}
cmm_smp_mb();
for (;;) {
struct cds_wfs_node *node = malloc(sizeof(*node));
if (!node)
goto fail;
cds_wfs_node_init(node);
was_nonempty = cds_wfs_push(&s, node);
URCU_TLS(nr_successful_enqueues)++;
if (!was_nonempty)
URCU_TLS(nr_empty_dest_enqueues)++;
if (caa_unlikely(wdelay))
loop_sleep(wdelay);
fail:
URCU_TLS(nr_enqueues)++;
if (caa_unlikely(!test_duration_enqueue()))
break;
}
uatomic_inc(&test_enqueue_stopped);
count[0] = URCU_TLS(nr_enqueues);
count[1] = URCU_TLS(nr_successful_enqueues);
count[2] = URCU_TLS(nr_empty_dest_enqueues);
printf_verbose("enqueuer thread_end, thread id : %lx, tid %lu, "
"enqueues %llu successful_enqueues %llu, "
"empty_dest_enqueues %llu\n",
pthread_self(),
(unsigned long) gettid(),
URCU_TLS(nr_enqueues),
URCU_TLS(nr_successful_enqueues),
URCU_TLS(nr_empty_dest_enqueues));
return ((void*)1);
}
static void try_set_affinity_full(const char* caller, int fd)
{
struct sockaddr_in sa_local, sa_peer;
socklen_t sa_len;
int errno_save = errno;
int rc, type;
T(fprintf(stderr, LPF "%s(%s(%d))\n", __FUNCTION__, caller, fd));
if( is_inet_sock(fd, &type, &sa_local) )
if( type == SOCK_STREAM || type == SOCK_DGRAM ) {
sa_len = sizeof(sa_peer);
rc = do_sys_getpeername(fd, (struct sockaddr*) &sa_peer, &sa_len);
if( rc == 0 )
set_affinity(type, sa_local.sin_addr.s_addr, sa_local.sin_port,
sa_peer.sin_addr.s_addr, sa_peer.sin_port);
else if( type == SOCK_DGRAM )
/* ?? TODO: We'll sometimes want a full-match for UDP. */
set_affinity(type, sa_local.sin_addr.s_addr,
sa_local.sin_port, 0, 0);
}
errno = errno_save;
}
pid_t fork(void) {
pid_t ret;
// When a new process is forked, the refcounter must be incremented
pthread_mutex_lock(&get_shm()->pin_lock);
get_shm()->refcount++;
pthread_mutex_unlock(&get_shm()->pin_lock);
ret = old_fork();
if(ret > 0) {
set_affinity(ret, get_next_core());
}
return ret;
}
void *thr_dequeuer(void *_count)
{
unsigned long long *count = _count;
printf_verbose("thread_begin %s, tid %lu\n",
"dequeuer", urcu_get_thread_id());
set_affinity();
rcu_register_thread();
while (!test_go)
{
}
cmm_smp_mb();
for (;;) {
struct cds_lfq_node_rcu *qnode;
rcu_read_lock();
qnode = cds_lfq_dequeue_rcu(&q);
rcu_read_unlock();
if (qnode) {
struct test *node;
node = caa_container_of(qnode, struct test, list);
call_rcu(&node->rcu, free_node_cb);
URCU_TLS(nr_successful_dequeues)++;
}
URCU_TLS(nr_dequeues)++;
if (caa_unlikely(!test_duration_dequeue()))
break;
if (caa_unlikely(rduration))
loop_sleep(rduration);
}
rcu_unregister_thread();
printf_verbose("dequeuer thread_end, tid %lu, "
"dequeues %llu, successful_dequeues %llu\n",
urcu_get_thread_id(),
URCU_TLS(nr_dequeues),
URCU_TLS(nr_successful_dequeues));
count[0] = URCU_TLS(nr_dequeues);
count[1] = URCU_TLS(nr_successful_dequeues);
return ((void*)2);
}
pid_t fork(void) {
pid_t ret;
// Increment refcount on fork to avoid parent dying before child and destroying the shm
__sync_fetch_and_add(&get_shm()->refcount, 1);
ret = old_fork();
if(ret > 0) {
set_affinity(ret, get_next_core());
} else if (ret < 0) {
// fork failed, decrement
__sync_fetch_and_sub(&get_shm()->refcount, 1);
}
return ret;
}
void *thr_enqueuer(void *_count)
{
unsigned long long *count = _count;
printf_verbose("thread_begin %s, tid %lu\n",
"enqueuer", urcu_get_thread_id());
set_affinity();
rcu_register_thread();
while (!test_go)
{
}
cmm_smp_mb();
for (;;) {
struct test *node = malloc(sizeof(*node));
if (!node)
goto fail;
cds_lfq_node_init_rcu(&node->list);
rcu_read_lock();
cds_lfq_enqueue_rcu(&q, &node->list);
rcu_read_unlock();
URCU_TLS(nr_successful_enqueues)++;
if (caa_unlikely(wdelay))
loop_sleep(wdelay);
fail:
URCU_TLS(nr_enqueues)++;
if (caa_unlikely(!test_duration_enqueue()))
break;
}
rcu_unregister_thread();
count[0] = URCU_TLS(nr_enqueues);
count[1] = URCU_TLS(nr_successful_enqueues);
printf_verbose("enqueuer thread_end, tid %lu, "
"enqueues %llu successful_enqueues %llu\n",
urcu_get_thread_id(),
URCU_TLS(nr_enqueues),
URCU_TLS(nr_successful_enqueues));
return ((void*)1);
}
static void try_set_affinity_wild(const char* caller, int fd)
{
struct sockaddr_in sa;
int errno_save = errno;
int type;
T(fprintf(stderr, LPF "%s(%s(%d))\n", __FUNCTION__, caller, fd));
if( is_inet_sock(fd, &type, &sa) ) {
if( type == SOCK_STREAM )
set_affinity_wild_tcp(type, sa.sin_addr.s_addr, sa.sin_port);
else if( type == SOCK_DGRAM )
set_affinity(type, sa.sin_addr.s_addr, sa.sin_port, 0, 0);
}
errno = errno_save;
}
static void run_child(size_t cpu)
{
struct child * self = &children[cpu];
self->pid = getpid();
self->sigusr1 = 0;
self->sigusr2 = 0;
self->sigterm = 0;
setup_signals();
set_affinity(cpu);
create_context(self);
write_pmu(self);
load_context(self);
notify_parent(self, cpu);
for (;;) {
sigset_t sigmask;
sigfillset(&sigmask);
sigdelset(&sigmask, SIGUSR1);
sigdelset(&sigmask, SIGUSR2);
sigdelset(&sigmask, SIGTERM);
if (self->sigusr1) {
printf("PFM_START on CPU%d\n", (int)cpu);
fflush(stdout);
perfmon_start_child(self->ctx_fd);
self->sigusr1 = 0;
}
if (self->sigusr2) {
printf("PFM_STOP on CPU%d\n", (int)cpu);
fflush(stdout);
perfmon_stop_child(self->ctx_fd);
self->sigusr2 = 0;
}
sigsuspend(&sigmask);
}
}
_CALLCONV stm_tx_t *stm_pre_init_thread(int id){
stm_tx_t *tx;
tx=stm_init_thread();
tx->thread_identifier=id;
if (tx->thread_identifier<active_threads) {
tx->thread_gate=0;
} else {
tx->thread_gate=1;
if (scheduling_policy==2) {
struct sembuf *sop = (struct sembuf *) malloc(sizeof(struct sembuf));
sop[0].sem_num = tx->thread_identifier;
sop[0].sem_op = 1; /* increment semaphore to become one */
sop[0].sem_flg = SEM_UNDO | IPC_NOWAIT; /* take off semaphore */
if (semop(semid, sop, 1) == -1) {
printf("Semop failed on thread %i on stm_pre_init_thread",tx->thread_identifier);
exit(0);
}
}
}
//printf("\nThread %i thread_gate % i", tx->thread_identifier, tx->thread_gate);
tx->committed_transactions=0;
set_affinity(id);
char filename[512];
int cpu_id=sched_getcpu();
sprintf(filename, "/sys/devices/system/cpu/cpu%i/cpufreq/scaling_setspeed",cpu_id);
//printf("Filename: %s", filename);
tx->scaling_setspeed_fd=open(filename, O_WRONLY);
if(tx->scaling_setspeed_fd==-1){
printf("\nError opening file %s \n", filename);
exit(1);
}
char target_freq[]="2000000";
write(tx->scaling_setspeed_fd, &target_freq, sizeof(target_freq));
return tx;
}
/**
* restart_counting
*
* Arguments: <context_id>
*
* Call the pfm_restart system-call to clear the data counters and start
* counting from zero for a perfmon context that was previously loaded.
**/
static int restart_counting(int argc, char **argv)
{
struct context *ctx;
cpu_set_t old_cpu_set;
int system_wide;
int ctx_id;
int rc;
ctx_id = strtoul(argv[1], NULL, 0);
if (ctx_id <= 0) {
LOG_ERROR("context ID must be a positive integer.");
return EINVAL;
}
ctx = find_context(ctx_id);
if (!ctx) {
LOG_ERROR("Can't find context with ID %d.", ctx_id);
return EINVAL;
}
system_wide = ctx->ctx_flags & PFM_FL_SYSTEM_WIDE;
if (system_wide && ctx->cpu >= 0) {
rc = set_affinity(ctx->cpu, &old_cpu_set);
if (rc) {
return rc;
}
}
rc = pfm_set_state(ctx->fd, 0, PFM_ST_RESTART);
if (rc) {
rc = errno;
LOG_ERROR("pfm_set_state(restart) system call returned an error: %d.", rc);
return rc;
}
if (system_wide && ctx->cpu >= 0) {
revert_affinity(&old_cpu_set);
}
LOG_INFO("Restarted counting for context %d.", ctx_id);
return 0;
}
void hash_init()
{
int i;
hash.heads = calloc(sizeof(struct node_t*), nbbuckets);
hash.locks = calloc(sizeof(lock_t), nbbuckets);
for(i=0; i < nbbuckets; i++)
{
lock_init(&hash.locks[i]);
}
//populate
node_t **hd;
lock_t *lck;
#ifdef POPULATE
unsigned nbcores = get_nbcores();
unsigned percorekeys = (nbkeys/nbcores)+1;
unsigned nextcore = 1;
//printf("npn %d %d %d\n", nbcores, percorekeys, nextcore);
for(i=0; i< nbkeys; i++)
{
if(!(i%percorekeys))
{
//printf("switching to core %d at %d keys\n", nextcore, i);
set_affinity(nextcore%nbcores);
nextcore++;
}
get_buckets(i, &hd, &lck);
insert(i, hd, lck);
}
//printf("empty = %d, total = %d\n", empty, nbkeys);
#endif
#ifdef SET_TAIL
printf("SET TAIL\n");
//insert max key
get_buckets(i, &hd, &lck);
insert(nbkeys+1, hd, lck);
#endif
}
