void func_worker_1(void* arg) {
// Cast and load the parameter
int worker_1_param = *((int*)arg);
// Create the queuing ports
spd_t * chan = mp_create_sport(MP_CHAN_1_ID, SOURCE, MP_CHAN_1_MSG_SIZE);
if (chan == NULL) {
DEBUGF(chan);
abort();
}
volatile unsigned long long _SPM * time_sample = mp_alloc(MP_CHAN_1_MSG_SIZE);
// Initialize the communication channels
int retval = mp_init_ports();
// TODO: check on retval
slave= 1;
for (unsigned long long start = get_cpu_usecs(); start + RUNTIME > get_cpu_usecs(); ) {
*time_sample = get_cpu_usecs();
mp_write(chan,time_sample);
}
int ret = 0;
corethread_exit(&ret);
return;
}
/*---------------------------------------------------------------------------*/
static void process_response(struct test_params *test_params,
struct xio_msg *rsp)
{
struct xio_iovec_ex *isglist = vmsg_sglist(&rsp->in);
int inents = vmsg_sglist_nents(&rsp->in);
if (test_params->stat.first_time) {
struct xio_iovec_ex *osglist = vmsg_sglist(&rsp->out);
int onents = vmsg_sglist_nents(&rsp->out);
size_t data_len = 0;
int i;
for (i = 0; i < onents; i++)
data_len += osglist[i].iov_len;
test_params->stat.txlen = rsp->out.header.iov_len + data_len;
data_len = 0;
for (i = 0; i < inents; i++)
data_len += isglist[i].iov_len;
test_params->stat.rxlen = rsp->in.header.iov_len + data_len;
test_params->stat.start_time = get_cpu_usecs();
test_params->stat.first_time = 0;
data_len = test_params->stat.txlen > test_params->stat.rxlen ?
test_params->stat.txlen : test_params->stat.rxlen;
data_len = data_len/1024;
test_params->stat.print_counter = (data_len ?
PRINT_COUNTER/data_len : PRINT_COUNTER);
if (test_params->stat.print_counter < 1000)
test_params->stat.print_counter = 1000;
test_params->disconnect_nr =
test_params->stat.print_counter * DISCONNECT_FACTOR;
}
if (++test_params->stat.cnt == test_params->stat.print_counter) {
char timeb[40];
uint64_t delta = get_cpu_usecs() - test_params->stat.start_time;
uint64_t pps = (test_params->stat.cnt*USECS_IN_SEC)/delta;
double txbw = (1.0*pps*test_params->stat.txlen/ONE_MB);
double rxbw = (1.0*pps*test_params->stat.rxlen/ONE_MB);
printf("transactions per second: %lu, bandwidth: " \
"TX %.2f MB/s, RX: %.2f MB/s, length: TX: %zd B, RX: %zd B\n",
pps, txbw, rxbw,
test_params->stat.txlen, test_params->stat.rxlen);
get_time(timeb, 40);
printf("**** [%s] - message [%zd] %s - %s\n",
timeb, (rsp->request->sn + 1),
(char *)rsp->in.header.iov_base,
(char *)(inents > 0 ? isglist[0].iov_base : NULL));
test_params->stat.cnt = 0;
test_params->stat.start_time = get_cpu_usecs();
}
}
/*---------------------------------------------------------------------------*/
static void process_response(struct xio_msg *rsp)
{
static uint64_t cnt = 0;
static int first_time = 1;
static uint64_t start_time;
static size_t txlen, rxlen;
if (first_time) {
size_t data_len = 0;
int i;
for (i = 0; i < rsp->out.data_iovlen; i++)
data_len += rsp->out.data_iov[i].iov_len;
txlen = rsp->out.header.iov_len + data_len;
data_len = 0;
for (i = 0; i < rsp->in.data_iovlen; i++)
data_len += rsp->in.data_iov[i].iov_len;
rxlen = rsp->in.header.iov_len + data_len;
start_time = get_cpu_usecs();
first_time = 0;
data_len = txlen > rxlen ? txlen : rxlen;
data_len = data_len/1024;
print_counter = (data_len ?
PRINT_COUNTER/data_len : PRINT_COUNTER);
}
if (++cnt == print_counter) {
char timeb[40];
uint64_t delta = get_cpu_usecs() - start_time;
uint64_t pps = (cnt*USECS_IN_SEC)/delta;
double txbw = (1.0*pps*txlen/ONE_MB);
double rxbw = (1.0*pps*rxlen/ONE_MB);
printf("transactions per second: %"PRIu64", bandwidth: " \
"TX %.2f MB/s, RX: %.2f MB/s, length: TX: %zd B, RX: %zd B\n",
pps, txbw, rxbw, txlen, rxlen);
get_time(timeb, 40);
printf("**** [%s] - response complete [%"PRIu64"] %s - %s\n",
timeb, (rsp->request->sn + 1),
(char *)rsp->in.header.iov_base,
(char *)rsp->in.data_iov[0].iov_base);
cnt = 0;
start_time = get_cpu_usecs();
}
}
void mem_load_test() {
int size = (main_mem_size-MINADDR)/get_cpucnt();
volatile _UNCACHED unsigned int *addr = TEST_START + get_cpuid()*size;
for(unsigned int start_time = get_cpu_usecs(); get_cpu_usecs() - start_time < 2000 ;) {
if (get_cpuid() == NOC_MASTER) {
ABORT_IF_FAIL(mem_area_test_uncached(addr,size)<0,"FAIL");
} else {
mem_area_test_uncached(addr,size);
}
}
}
/*---------------------------------------------------------------------------*/
static void process_tx_message(struct ow_test_params *ow_params,
struct xio_msg *msg)
{
struct xio_iovec_ex *osglist = vmsg_sglist(&msg->out);
int onents = vmsg_sglist_nents(&msg->out);
if (ow_params->tx_stat.first_time) {
size_t data_len = 0;
int i;
for (i = 0; i < onents; i++)
data_len += osglist[i].iov_len;
ow_params->tx_stat.xlen = msg->out.header.iov_len + data_len;
ow_params->tx_stat.start_time = get_cpu_usecs();
ow_params->tx_stat.first_time = 0;
data_len = ow_params->tx_stat.xlen/1024;
ow_params->tx_stat.print_counter = data_len ?
PRINT_COUNTER/data_len : PRINT_COUNTER;
if (ow_params->tx_stat.print_counter < 1000)
ow_params->tx_stat.print_counter = 1000;
ow_params->disconnect_nr =
ow_params->tx_stat.print_counter * DISCONNECT_FACTOR;
}
if (++ow_params->tx_stat.cnt == ow_params->tx_stat.print_counter) {
char timeb[40];
uint64_t delta =
get_cpu_usecs() - ow_params->tx_stat.start_time;
uint64_t pps = (ow_params->tx_stat.cnt*USECS_IN_SEC)/delta;
double txbw = (1.0*pps*ow_params->tx_stat.xlen/ONE_MB);
printf("transactions per second: %lu, bandwidth: " \
"TX %.2f MB/s,length: TX: %zd B\n",
pps, txbw, ow_params->tx_stat.xlen);
get_time(timeb, 40);
printf("**** [%s] - message [%lu] %s - %s\n",
timeb, (msg->sn + 1),
(char *)msg->out.header.iov_base,
(char *)(onents > 0 ? osglist[0].iov_base : NULL));
ow_params->tx_stat.cnt = 0;
ow_params->tx_stat.start_time = get_cpu_usecs();
}
}
/*---------------------------------------------------------------------------*/
static void process_rx_message(struct xio_msg *msg)
{
static uint64_t cnt = 0;
static int first_time = 1;
static uint64_t start_time;
static size_t rxlen;
static uint64_t print_counter = PRINT_COUNTER;
if (first_time) {
size_t data_len = 0;
int i;
data_len = 0;
for (i = 0; i < msg->in.data_iovlen; i++)
data_len += msg->in.data_iov[i].iov_len;
rxlen = msg->in.header.iov_len + data_len;
start_time = get_cpu_usecs();
first_time = 0;
data_len = rxlen/1024;
print_counter = data_len ?
PRINT_COUNTER/data_len : PRINT_COUNTER;
}
if (++cnt == print_counter) {
char timeb[40];
uint64_t delta = get_cpu_usecs() - start_time;
uint64_t pps = (cnt*USECS_IN_SEC)/delta;
double rxbw = (1.0*pps*rxlen/ONE_MB);
printf("transactions per second: %"PRIu64", bandwidth: " \
"RX: %.2f MB/s, RX: %zd B\n",
pps, rxbw, rxlen);
get_time(timeb, 40);
printf("**** [%s] - message [%"PRIu64"] %s - %s\n",
timeb, (msg->sn + 1),
(char *)msg->in.header.iov_base,
(char *)msg->in.data_iov[0].iov_base);
cnt = 0;
start_time = get_cpu_usecs();
}
}
/*---------------------------------------------------------------------------*/
static void process_message(struct test_params *test_params,
struct xio_msg *msg)
{
struct xio_iovec_ex *osglist = vmsg_sglist(&msg->out);
int onents = vmsg_sglist_nents(&msg->out);
if (test_params->stat.first_time) {
size_t data_len = 0;
int i;
for (i = 0; i < onents; i++)
data_len += osglist[i].iov_len;
test_params->stat.txlen = msg->out.header.iov_len + data_len;
test_params->stat.start_time = get_cpu_usecs();
test_params->stat.first_time = 0;
data_len = test_params->stat.txlen/1024;
test_params->stat.print_counter = (data_len ?
PRINT_COUNTER/data_len : PRINT_COUNTER);
if (test_params->stat.print_counter < 1000)
test_params->stat.print_counter = 1000;
test_params->disconnect_nr =
test_params->stat.print_counter * DISCONNECT_FACTOR;
}
if (++test_params->stat.cnt == test_params->stat.print_counter) {
uint64_t delta = get_cpu_usecs() - test_params->stat.start_time;
uint64_t pps = (test_params->stat.cnt*USECS_IN_SEC)/delta;
double txbw = (1.0*pps*test_params->stat.txlen/ONE_MB);
printf("transactions per second: %lu, bandwidth: " \
"TX %.2f MB/s, length: TX: %zd B\n",
pps, txbw,
test_params->stat.txlen);
test_params->stat.cnt = 0;
test_params->stat.start_time = get_cpu_usecs();
}
}
/*---------------------------------------------------------------------------*/
static void process_rx_message(struct ow_test_params *ow_params,
struct xio_msg *msg)
{
if (ow_params->rx_stat.first_time) {
size_t data_len = 0;
int i;
data_len = 0;
for (i = 0; i < msg->in.data_iovlen; i++)
data_len += msg->in.data_iov[i].iov_len;
ow_params->rx_stat.xlen = msg->in.header.iov_len + data_len;
ow_params->rx_stat.start_time = get_cpu_usecs();
ow_params->rx_stat.first_time = 0;
data_len = ow_params->rx_stat.xlen/1024;
ow_params->rx_stat.print_counter = data_len ?
PRINT_COUNTER/data_len : PRINT_COUNTER;
}
if (++ow_params->rx_stat.cnt == ow_params->rx_stat.print_counter) {
char timeb[40];
uint64_t delta = get_cpu_usecs() - ow_params->rx_stat.start_time;
uint64_t pps = (ow_params->rx_stat.cnt*USECS_IN_SEC)/delta;
double rxbw = (1.0*pps*ow_params->rx_stat.xlen/ONE_MB);
printf("transactions per second: %"PRIu64", bandwidth: " \
"RX: %.2f MB/s, RX: %zd B\n",
pps, rxbw, ow_params->rx_stat.xlen);
get_time(timeb, 40);
printf("**** [%s] - message [%"PRIu64"] %s - %s\n",
timeb, (msg->sn + 1),
(char *)msg->in.header.iov_base,
(char *)msg->in.data_iov[0].iov_base);
ow_params->rx_stat.cnt = 0;
ow_params->rx_stat.start_time = get_cpu_usecs();
}
}
int main() {
puts("Master");
corethread_t worker_1 = 1; // For now the core ID
int worker_1_param = 1;
corethread_create(&worker_1,&func_worker_1,(void*)&worker_1_param);
// Create the queuing ports
spd_t * chan = mp_create_sport(MP_CHAN_1_ID, SINK, MP_CHAN_1_MSG_SIZE);
volatile unsigned long long _SPM * time_sample = mp_alloc(MP_CHAN_1_MSG_SIZE);
if (chan == NULL || time_sample == NULL) {
DEBUGF(chan);
abort();
}
// Initialize the communication channels
int retval = mp_init_ports();
// TODO: check on retval
puts("Initialized ports");
while(slave != 1) {
;
}
puts("Slave is ready");
unsigned long long min_time_diff = -1;
unsigned long long max_time_diff = 0;
unsigned long long accum_time_diff = 0;
unsigned long long cnt_time_diff = 0;
unsigned long long percent = 0;
int done = 0;
unsigned long long start = get_cpu_usecs();
while(!done) {
int success = mp_read(chan,time_sample);
unsigned long long time_diff = get_cpu_usecs() - (*time_sample);
if (success == 0) {
printf("No sample received\n");
} else if ((*time_sample) == 0) {
printf("Received empty sample, newest: %u, sample size: %u\n",chan->newest,chan->sample_size);
} else {
if (time_diff > 2000 ) {
// Time difference is larger than a micro second
printf("Time sample: %llu\tdiff: %llu\n",*time_sample,time_diff);
}
cnt_time_diff++;
if (time_diff < min_time_diff) {
min_time_diff = time_diff;
}
if (time_diff > max_time_diff) {
max_time_diff = time_diff;
}
accum_time_diff += time_diff;
}
if (start + percent < get_cpu_usecs()) {
percent += RUNTIME/10;
printf("+");
fflush(stdout);
}
if ( start + RUNTIME < get_cpu_usecs()) {
done = 1;
}
}
printf("\n");
printf("Status:\n\tMin time diff: %llu\n\tMax time diff: %llu\n\tAvg time diff: %llu\n", min_time_diff,max_time_diff,accum_time_diff/cnt_time_diff);
int* res;
corethread_join(worker_1,&res);
return *res;
}
/*---------------------------------------------------------------------------*/
static void process_response(struct xio_msg *rsp)
{
struct scatterlist *in_sgl, *out_sgl;
static uint64_t cnt;
static int first_time = 1;
static uint64_t start_time;
static size_t txlen, rxlen;
if (first_time) {
size_t data_len = 0;
int i;
out_sgl = rsp->out.data_tbl.sgl;
for (i = 0; i < rsp->out.data_tbl.nents; i++) {
data_len += out_sgl->length;
out_sgl = sg_next(out_sgl);
}
txlen = rsp->out.header.iov_len + data_len;
data_len = 0;
in_sgl = rsp->in.data_tbl.sgl;
for (i = 0; i < rsp->in.data_tbl.nents; i++) {
data_len += in_sgl->length;
in_sgl = sg_next(in_sgl);
}
rxlen = rsp->in.header.iov_len + data_len;
start_time = get_cpu_usecs();
first_time = 0;
disconnect_nr = print_counter * DISCONNECT_FACTOR;
}
if (++cnt == print_counter) {
char timeb[40];
uint64_t delta = get_cpu_usecs() - start_time;
uint64_t pps = (cnt * USECS_IN_SEC) / delta;
double txbw = (1.0 * pps * txlen / ONE_MB);
double rxbw = (1.0 * pps * rxlen / ONE_MB);
double lat = (1000000.0 / pps);
pr_info("transactions per second: %llu, lat: %d us, " \
"bandwidth: TX %d MB/s, RX: %d MB/s, length: " \
"TX: %zd B, RX: %zd B\n",
pps, (int)lat, (int)txbw, (int)rxbw,
txlen, rxlen);
get_time(timeb, 40);
/*
in_sgl = rsp->in.data_tbl.sgl;
pr_info("**** [%s] - message [%llu] %s - %s\n",
timeb, (rsp->request->sn + 1),
(char *)rsp->in.header.iov_base,
(char *)(rsp->in.data_tbl.nents > 0 ?
sg_virt(in_sgl) : NULL));
*/
cnt = 0;
start_time = get_cpu_usecs();
}
}
int main() {
corethread_t worker_1 = SLAVE_CORE; // For now the core ID
corethread_create(&worker_1,&func_worker_1,(void*)&worker_1);
puts("Corethread created");
unsigned short int local_phase = 0;
min_time = ULONG_MAX;
max_time = 0;
accum_time = 0;
cnt_time = 0;
unsigned long long int start = 0;
unsigned long long int stop = 0;
spd_t * sport1 = mp_create_sport(CHAN_ID_ONE,SINK,SAMPLE_SIZE*sizeof(short));
spd_t * sport2 = mp_create_sport(CHAN_ID_TWO,SOURCE,SAMPLE_SIZE*sizeof(short));
if (sport1 == NULL || sport2 == NULL) {
//exit(1);
}
volatile short _SPM * sample = mp_alloc(SAMPLE_SIZE*sizeof(short));
mp_init_ports();
done = 1;
int balance = 0;
for (int i = 0; i < SAMPLE_SIZE; ++i) {
sample[i] = i;
}
for (int i = 0; i < ITERATIONS/2; ++i) {
mp_write(sport2,sample);
for (int i = 0; i < SAMPLE_SIZE; ++i) {
sample[i] = i;
}
}
for (int i = 0; i < ITERATIONS/2; ++i) {
mp_write(sport2,sample);
for (int i = 0; i < SAMPLE_SIZE; ++i) {
sample[SAMPLE_SIZE-1-i] = i;
}
}
for (int i = 0; i < ITERATIONS; ++i) {
start = get_cpu_usecs();
int ret = mp_read(sport1,sample);
stop = get_cpu_usecs();
if (ret == 0)
{
puts("No value written yet.");
} else {
unsigned long long int exe_time = stop - start;
min_time = (exe_time < min_time) ? exe_time : min_time;
max_time = (exe_time > max_time) ? exe_time : max_time;
accum_time += exe_time;
cnt_time++;
if (sample[0] == 0) {
balance++;
for (int i = 0; i < SAMPLE_SIZE; ++i) {
if(sample[i] != i) {
printf("Error: sample[%i] = %i\n",i,sample[i]);
break;
}
}
} else if (sample[0] == SAMPLE_SIZE-1) {
balance--;
for (int i = 0; i < SAMPLE_SIZE; ++i) {
if(sample[SAMPLE_SIZE-1-i] != i) {
printf("Error: sample[%i] = %i\n",i,sample[i]);
break;
}
}
} else {
printf("Wrong sample values sample[0] = %i\n",sample[0]);
}
}
}
printf("Local phase: %d\n",local_phase);
inval_dcache();
int* res;
corethread_join(worker_1,&res);
printf("Balance: %i\n",balance);
printf("Min time: %llu\tMax time: %llu\tAccumulated time: %llu\nCount time: %llu\tAverage time: %llu\n", min_time,max_time,accum_time,cnt_time,accum_time/cnt_time);
puts("Corethread joined");
return *res;
}
