void read_cpu_list(const char *str) {
char *tmp = strdup(str);
if (tmp == NULL)
errExit("strdup");
char *ptr = tmp;
while (*ptr != '\0') {
if (*ptr == ',' || isdigit(*ptr))
;
else {
fprintf(stderr, "Error: invalid cpu list\n");
exit(1);
}
ptr++;
}
char *start = tmp;
ptr = tmp;
while (*ptr != '\0') {
if (*ptr == ',') {
*ptr = '\0';
set_cpu(start);
start = ptr + 1;
}
ptr++;
}
set_cpu(start);
free(tmp);
}
void *player(void *p)
{
long player_id = (long)p;
set_cpu(player_id);
if (config.flags & FL_MUTEX)
if ((errno = pthread_mutex_lock(&mutex)) != 0)
handle_error("pthread_mutex_lock player");
/* infinite loop */
for(;;)
{
wait_referee(player_id);
player_play(player_id);
notify_referee();
if (hand[player_id] == STOP)
{
if (config.flags & FL_MUTEX)
if ((errno = pthread_mutex_unlock(&mutex)) != 0)
handle_error("pthread_mutex_unlock player");
pthread_exit(NULL);
}
}
}
void gui_load()
{
debug_start();
pnd_app_get_list();
cfg_gui_read();
gui_load_skin();
if ( ! ( nh = pnd_notify_init() ) )
{
debug_error ( "PND INOTIFY init problem spotted\n" );
}
if ( ! ( nh2 = pnd_dbusnotify_init() ) )
{
debug_error ( "PND DBUSINOTIFY init problem spotted\n" );
}
initStatusCalls();
cpuUsage();
getCPULoad();
set_cpu( pmenu->cpu_mhz );
debug_end();
}
void* add(void* x)
{
unsigned long long sum=0;
struct timeval tpstart,tpend;
float timeuse;
if(-1 == set_cpu(1))
{
return NULL;
}
gettimeofday(&tpstart,NULL);
for(sum=0;sum<APPLE_MAX_VALUE;sum++)
{
((struct apple *)x)->a += sum;
((struct apple *)x)->b += sum;
}
gettimeofday(&tpend,NULL);
timeuse=MSECOND*(tpend.tv_sec-tpstart.tv_sec)+tpend.tv_usec-tpstart.tv_usec;
timeuse/=MSECOND;
printf("add thread:%x,Used Time:%f\n",pthread_self(),timeuse);
return NULL;
}
void *prepare_and_bench_blocking(void *arg)
{
struct dpdk_test_args *args = (struct dpdk_test_args *) arg;
pthread_mutex_lock(&args->mutex);
pthread_t t = pthread_self();
set_cpu(t, args->cpu);
args->started = true;
pthread_cond_wait(args->cond, &args->mutex);
auto& ctx = uhd::transport::uhd_dpdk_ctx::get();
uhd::transport::dpdk_zero_copy::sptr eth_data[1];
uhd::transport::zero_copy_xport_params buff_args;
buff_args.recv_frame_size = 8000;
buff_args.send_frame_size = 8000;
buff_args.num_send_frames = 8;
buff_args.num_recv_frames = 8;
auto dev_addr = uhd::device_addr_t();
eth_data[0] = uhd::transport::dpdk_zero_copy::make(
ctx,
args->portid,
args->dst_ip,
"48888",
"48888",
buff_args,
dev_addr
);
bench(eth_data, 1, 0.1);
return 0;
}
void threads::worker() {
/*run all threads on the same CPU so we don't cause the system to lag too bad*/
set_cpu(0); /*TODO: option to set specific CPU*/
/*initialize the indexes*/
std::vector<size_t> block_indexes(blocks.size());
std::vector<size_t> prng_indexes(blocks.size());
for (size_t i = 0; i < blocks.size(); i++) {
block_indexes[i] = i;
prng_indexes[i] = i % prng_count;
}
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wmissing-noreturn"
while (true) {
/*shuffle the indexes*/
std::shuffle(block_indexes.begin(), block_indexes.end(), primary_rng);
std::shuffle(worker_threads.begin(), worker_threads.end(), primary_rng);
/*generate random data in the buffer*/
for (size_t i = 0; i < blocks.size(); i++) {
/*TODO: put in ISAAC crypto algorithm?*/
/*fill the block with data*/
for (size_t j = 0; j < blocksize; j++) {
blocks[block_indexes[i]].data[j] = prngs[prng_indexes[i]]();
}
/*advance the block count*/
blocks[block_indexes[i]].count++;
}
}
#pragma clang diagnostic pop
}
hclh_local_params* init_hclh_local(uint32_t phys_core, hclh_global_params* the_params) {
//assign the thread to the correct core
set_cpu(phys_core);
hclh_local_params* local_params;
// local_params = (hclh_local_params**)malloc(num_locks * sizeof(hclh_local_params));
uint32_t i;
__sync_synchronize();
uint32_t real_core_num = 0;
for (i = 0; i < (NUMBER_OF_SOCKETS * CORES_PER_SOCKET); i++) {
if (the_cores[i]==phys_core) {
real_core_num = i;
break;
}
}
phys_core=real_core_num;
__sync_synchronize();
MEM_BARRIER;
local_params=(hclh_local_params*) malloc(sizeof(hclh_local_params));
local_params->my_qnode = (qnode*) malloc(sizeof(qnode));
local_params->my_qnode->data = 0;
local_params->my_qnode->fields.cluster_id = phys_core/CORES_PER_SOCKET;
local_params->my_qnode->fields.successor_must_wait=1;
local_params->my_pred = NULL;
if (phys_core%CORES_PER_SOCKET==0) {
the_params->local_queues[phys_core/CORES_PER_SOCKET] = (local_queue*)malloc(sizeof(local_queue));
*(the_params->local_queues[phys_core/CORES_PER_SOCKET]) = NULL;
the_params->init_done[phys_core/CORES_PER_SOCKET]=INIT_VAL;
}
while(the_params->init_done[phys_core/CORES_PER_SOCKET]!=INIT_VAL) {}
local_params->my_queue = the_params->local_queues[phys_core/CORES_PER_SOCKET];
return local_params;
}
void threads::output() {
set_cpu(1);
/*fill the indexes*/
std::vector<size_t> indexes(blocks.size());
for (size_t i = 0; i < blocks.size(); i++) { indexes[i] = i; }
/*initialize stored last-output counts*/
std::vector<size_t> counts(blocks.size(), 0);
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wmissing-noreturn"
while (true) {
/*mix around the indexes*/
std::shuffle(indexes.begin(), indexes.end(), primary_rng);
for (size_t i = 0; i < blocks.size(); i++) {
/*if the block is new*/
if (blocks[indexes[i]].count > counts[indexes[i]]) {
/*update the block count*/
counts[indexes[i]] = blocks[indexes[i]].count;
output_stream.write((const char *) blocks[indexes[i]].data,
blocksize);
output_stream.flush();
}
}
}
#pragma clang diagnostic pop
}
void *referee()
{
set_cpu(0);
if (config.flags & FL_MUTEX)
if ((errno = pthread_mutex_lock(&mutex)) != 0)
handle_error("pthread_mutex_lock referee");
/* infinite loop */
for (;;)
{
if ((rand_r(&seed)) < config.referee_end_prob)
{
prtflu("REFEREE: game is over\n");
if (config.flags & FL_MUTEX)
if ((errno = pthread_mutex_unlock(&mutex)) != 0)
handle_error("pthread_mutex_unlock referee");
pthread_exit(NULL);
}
else
{
hand[0] = hand[1] = NONE;
prtflu("REFEREE: game is starting...\n");
notify_players();
wait_players();
evaluate_player();
game_response();
}
wait_key();
}
}
/*
* Actually perform cpuid operation.
*/
static int
cpuctl_do_cpuid_count(int cpu, cpuctl_cpuid_count_args_t *data,
struct thread *td)
{
int is_bound = 0;
int oldcpu;
KASSERT(cpu >= 0 && cpu <= mp_maxid,
("[cpuctl,%d]: bad cpu number %d", __LINE__, cpu));
/* Explicitly clear cpuid data to avoid returning stale info. */
bzero(data->data, sizeof(data->data));
DPRINTF("[cpuctl,%d]: retrieving cpuid lev %#0x type %#0x for %d cpu\n",
__LINE__, data->level, data->level_type, cpu);
#ifdef __i386__
if (cpu_id == 0)
return (ENODEV);
#endif
oldcpu = td->td_oncpu;
is_bound = cpu_sched_is_bound(td);
set_cpu(cpu, td);
cpuid_count(data->level, data->level_type, data->data);
restore_cpu(oldcpu, is_bound, td);
return (0);
}
int main(int argc, char *argv[])
{
// taking options : number of task
//int ntask = 100;
int pid_d, pid_c1, pid_c2, status;
char buffer[10];
// Creates consumers & dispatcher
pid_d = fork();
if( pid_d == 0 ){
// Becomes dispatcher
execlp("./dispatcher",
"dispatcher", (char*)NULL);
printf("Exec fallita!\n");
exit(1);
}
else{
pid_c1 = fork();
if( pid_c1 == 0 ){
// Becomes consumer 1
execlp("./consumer1", "consumer1",
buffer, "/tmp/myfifo1", (char*)NULL);
printf("Exec fallita!\n");
exit(1);
}
else{
pid_c2 = fork();
if( pid_c2 == 0 ){
// Becomes consumer2
execlp("./consumer2", "consumer2",
buffer, "/tmp/myfifo2", (char*)NULL);
printf("Exec fallita!\n");
exit(1);
}
else{
// Setting affinity
set_cpu(pid_d, pid_c1, pid_c2);
// Waits children
wait(&status);
}
}
}
return 0;
}
void disturb( void ){
set_cpu(CPU_USED);
int someVar = 0;
while(1){
someVar++;
}
}
// Performs a test of the pid_table module:
int main(int argc, char *argv[])
{
int n, pid, cpu, new_cpu;
pid_t pids[num_entry];
pid_table table;
// Create table:
printf("creating pid_table index size: %i buckets: %i\n", index_size, bucket_count);
table = create_pid_table(index_size, bucket_count);
if (table == NULL)
{
printf("failed!\n");
return 1;
}
printf("OK!\n");
// Seed rand():
srand(time(NULL ));
// Add entries:
printf("adding %i entries\n", num_entry);
for (n = 0; n < num_entry; n++)
{
pid = rand();
pids[n] = pid;
cpu = rand() % num_cpu;
if (add_pid_to_pid_table(table, pid, cpu) != 0)
{
printf("failed!\n");
return 1;
}
}
printf("OK!\n");
printf("switching all cpus\n");
for (n = 0; n < num_entry; n++)
{
new_cpu = rand() % 64;
if (set_cpu(table, pids[n], new_cpu) != 0)
{
printf("failed!\n");
return 1;
}
}
printf("OK!\n");
// Remove elements:
printf("removing each entry\n");
for (n = 0; n < num_entry; n++)
{
if (remove_pid_from_pid_table(table, pids[n]) != 0)
{
printf("failed!\n");
return 1;
}
}
printf("OK!\n");
printf("destroying table\n");
destroy_pid_table(table);
printf("OK!\n");
return 0;
}
mcs_qnode* init_mcs_local(uint32_t thread_num) {
set_cpu(thread_num);
mcs_qnode* the_qnodes=(mcs_qnode*)malloc(sizeof(mcs_qnode));
MEM_BARRIER;
return the_qnodes;
}
int init_spinlock_local(uint32_t thread_num, uint32_t* limit)
{
//assign the thread to the correct core
set_cpu(thread_num);
*limit = 1;
spinlock_seeds = seed_rand();
MEM_BARRIER;
return 0;
}
int init_mcs_local(uint32_t thread_num, mcs_qnode** the_qnode) {
set_cpu(thread_num);
(*the_qnode)=(mcs_qnode*)malloc(sizeof(mcs_qnode));
MEM_BARRIER;
return 0;
}
void *test(void *data) {
fprintf(stderr, "Starting test\n");
//get the per-thread data
thread_data_t *d = (thread_data_t *)data;
//place the thread on the apropriate cpu
set_cpu(the_cores[d->id]);
int op_count = 10000;
ssalloc_init();
bst_init_local(d->id);
/* Wait on barrier */
barrier_cross(d->barrier);
int i;
bool_t added;
for ( i = 1; i <= op_count; i++){
added = bst_insert(i, root, d->id);
// fprintf(stderr, "[%d] Added %d? %d\n", d->id, i, added==TRUE);
if (added == TRUE) {
d->num_insert++;
}
}
// printf("Root right node: %d", root->right->key);
for ( i = 1; i <= op_count; i++){
node_t* found = bst_find(i, root, d->id);
// printf("Contains %d? %d\n", i, found==FOUND);
if (found != NULL) {
d->num_search ++;
}
}
for ( i = 1; i <= op_count; i++){
bool_t removed = bst_delete(i, root, d->id);
// printf("Removed %d? %d\n", i, removed==TRUE);
if (removed == TRUE) {
d->num_remove ++;
}
}
// for ( i = 1; i < 10; i++){
// bool_t found = bst_contains(i);
// printf("Contains %d? %d\n", i, found==FOUND);
// }
return NULL;
}
array_lock_t* init_alock_local(uint32_t thread_num, lock_shared_t* the_lock) {
//assign the thread to the correct core
set_cpu(thread_num);
uint32_t i;
array_lock_t* local_lock = (array_lock_t*) malloc(sizeof(array_lock_t));
local_lock->my_index=0;
local_lock->shared_data = the_lock;
return local_lock;
}
void* disturbance() {
set_cpu(CPU_CORE);
double i, j, k;
while(1) {
i++;
j++;
k = i*j;
k++;
}
}
uint32_t* init_rw_ttas_array_local(uint32_t thread_num, uint32_t size){
set_cpu(thread_num);
rw_seeds = seed_rand();
uint32_t* limits;
limits = (uint32_t*)malloc(size * sizeof(uint32_t));
uint32_t i;
for (i = 0; i < size; i++) {
limits[i]=1;
}
return limits;
}
void* test(void* num_param) {
int num = (long) num_param;
set_cpu(CPU_CORE);
io_write(num, 1);
while(1) {
while (io_read(num));
io_write(num, 0);
usleep(5);
io_write(num, 1);
}
}
uint32_t* init_ttas_array_local(uint32_t thread_num, uint32_t size){
//assign the thread to the correct core
set_cpu(thread_num);
ttas_seeds = seed_rand();
uint32_t* limits;
limits = (uint32_t*)malloc(size * sizeof(uint32_t));
uint32_t i;
for (i = 0; i < size; i++) {
limits[i]=1;
}
return limits;
}
void checkChannel ( int channel ) {
set_cpu(CPU_USED);
while(1){
while(io_read(channel)) // wait
{}
io_write(channel,LOW);
usleep(5);
io_write(channel,HIGH);
}
}
clh_local_params init_clh_local(uint32_t thread_num) {
set_cpu(thread_num);
//init its qnodes
uint32_t i;
clh_local_params local_params;
// local_params[i]=(clh_local_params*)malloc(sizeof(clh_local_params));
local_params.my_qnode = (clh_qnode*) malloc(sizeof(clh_qnode));
local_params.my_qnode->locked=0;
local_params.my_pred = NULL;
return local_params;
}
void *test(void *data)
{
int rand_max;
thread_data_t *d = (thread_data_t *)data;
uint64_t res;
phys_id= the_cores[d->id];
set_cpu(phys_id);
seeds = seed_rand();
rand_max = num_entries - 1;
/* Init of local data if necessary */
/* Wait on barrier */
barrier_cross(d->barrier);
int entry;
while (stop == 0) {
if (num_entries==1) {
entry=0;
} else {
entry =(int) my_random(&(seeds[0]),&(seeds[1]),&(seeds[2])) & rand_max;
}
// entry = (int)(erand48(seed) * rand_max) + rand_min;
#ifdef TEST_CAS
do {
res = CAS_U8(&(the_data[entry].data),0,1);
} while(res!=0);
#elif defined(TEST_TAS)
do {
res = TAS_U8(&(the_data[entry].data));
} while (res!=0);
#elif defined(TEST_FAI)
FAI_U8(&(the_data[entry].data));
#else
perror("No test primitive specified");
#endif
MEM_BARRIER;
the_data[entry].data = 0;
d->num_operations++;
if (op_pause>0) {
cpause(op_pause);
}
}
/* Free any local data if necessary */
return NULL;
}
int main(int argc, char *argv[])
{
sigset_t allsigs;
int cur_val = 0;
int s32CPUNo = 0;
int s32CHDNo = 0;
int s32i = 0;
int s32pid = 0;
if(argc != 3)
{
printf("Error!\n");
exit(EXIT_FAILURE);
}
s32CPUNo = atoi(argv[1]);
s32CHDNo = atoi(argv[2]) - 1;
if(s32CPUNo < 0 || s32CPUNo > MAX_CORE_NO)
{
printf("OUT of Range\n");
exit(EXIT_FAILURE);
}
printf("CPU bind: %d\n", s32CPUNo);
set_cpu(s32CPUNo);
printf("Set Sched:RR\n");
set_sched();
for(s32i = 0; s32i < s32CHDNo; s32i++)
{
s32pid = fork();
if(0 == s32pid)
{
/* Child */
break;
}
else
{
/* Parent */
}
}
for(s32i = 0; s32i < IRT_NUM; s32i++)
{
}
exit(EXIT_SUCCESS);
}
clh_local_params* init_clh_array_local(uint32_t thread_num, uint32_t num_locks) {
set_cpu(thread_num);
//init its qnodes
uint32_t i;
clh_local_params* local_params = (clh_local_params*)malloc(num_locks * sizeof(clh_local_params));
for (i=0; i<num_locks; i++) {
// local_params[i]=(clh_local_params*)malloc(sizeof(clh_local_params));
local_params[i].my_qnode = (clh_qnode*) malloc(sizeof(clh_qnode));
local_params[i].my_qnode->locked=0;
local_params[i].my_pred = NULL;
}
return local_params;
}
/*
* Actually perform MSR operations.
*/
static int
cpuctl_do_msr(int cpu, cpuctl_msr_args_t *data, u_long cmd, struct thread *td)
{
uint64_t reg;
int is_bound = 0;
int oldcpu;
int ret;
KASSERT(cpu >= 0 && cpu <= mp_maxid,
("[cpuctl,%d]: bad cpu number %d", __LINE__, cpu));
/*
* Explicitly clear cpuid data to avoid returning stale
* info
*/
DPRINTF("[cpuctl,%d]: operating on MSR %#0x for %d cpu\n", __LINE__,
data->msr, cpu);
#ifdef __i386__
if ((cpu_feature & CPUID_MSR) == 0)
return (ENODEV);
#endif
oldcpu = td->td_oncpu;
is_bound = cpu_sched_is_bound(td);
set_cpu(cpu, td);
if (cmd == CPUCTL_RDMSR) {
data->data = 0;
ret = rdmsr_safe(data->msr, &data->data);
} else if (cmd == CPUCTL_WRMSR) {
ret = wrmsr_safe(data->msr, data->data);
} else if (cmd == CPUCTL_MSRSBIT) {
critical_enter();
ret = rdmsr_safe(data->msr, ®);
if (ret == 0)
ret = wrmsr_safe(data->msr, reg | data->data);
critical_exit();
} else if (cmd == CPUCTL_MSRCBIT) {
critical_enter();
ret = rdmsr_safe(data->msr, ®);
if (ret == 0)
ret = wrmsr_safe(data->msr, reg & ~data->data);
critical_exit();
} else
panic("[cpuctl,%d]: unknown operation requested: %lu",
__LINE__, cmd);
restore_cpu(oldcpu, is_bound, td);
return (ret);
}
void* periodicTest(void* num_param) {
int num = (long) num_param;
set_cpu(CPU_CORE);
io_write(num, 1);
struct timespec next;
clock_gettime(CLOCK_REALTIME, &next);
while(1) {
while (io_read(num));
io_write(num, 0);
clock_nanosleep(CLOCK_REALTIME, TIMER_ABSTIME, &next, NULL);
timespec_add_us(&next, 100);
io_write(num, 1);
}
}
int main (int argc, const char * argv[]) {
// insert code here...
struct apple test;
struct orange test1={{0},{0}};
pthread_t ThreadA;
unsigned long long sum=0,index=0;
struct timeval tpstart,tpend;
float timeuse;
test.a= 0;
test.b= 0;
cpu_nums = sysconf(_SC_NPROCESSORS_CONF);
if(-1 == set_cpu(0))
{
return -1;
}
gettimeofday(&tpstart,NULL);
pthread_create(&ThreadA,NULL,add,&test);
for(index=0;index<ORANGE_MAX_VALUE;index++)
{
sum+=test1.a[index]+test1.b[index];
}
pthread_join(ThreadA,NULL);
gettimeofday(&tpend,NULL);
timeuse=MSECOND*(tpend.tv_sec-tpstart.tv_sec)+tpend.tv_usec-tpstart.tv_usec;
timeuse/=MSECOND;
printf("main thread:%x,Used Time:%f\n",pthread_self(),timeuse);
printf("a = %llu,b = %llu,sum=%llu\n",test.a,test.b,sum);
return 0;
}
