up_down_4() //Sequence= 4 4444
{
int i;
//printf("Running sequence 4 locking Speed at -1\n");
Speed = -1;
for (i=0;i<16;i++)
{
//printf("i = %d for HIGH writen\n",i);
digitalWrite(Pins[i],HIGH);
if (((i+1) > 0) && ((i+1) < 16)) //0-15
{
//printf("digitalWrite going LOW\n");
digitalWrite(Pins[i+1],LOW);
}
test_delay(1);
}
for (i=15;i>-1;i--)
{
//printf("i = %d for LOW writen\n",i);
digitalWrite(Pins[i],HIGH);
if (((i-1) > -1) && ((i-1) < 16))
{
digitalWrite(Pins[i-1],LOW);
}
test_delay(1);
}
//test_delay(2);
}
blink_all() //Sequence = 1 11111
{
int i;
for (i=0;i<16;i++) //bbbbb
{
//printf ("blink_all: ledpin = %d\n",i);
digitalWrite(Pins[i],HIGH);
if (( i - 4) > -1)
{
digitalWrite(Pins[i-4],LOW);
}
//test_delay(Dealy);
//test_delay(FDealy);
test_delay(5);
}
for (i=16;i>-1;i--)
{
digitalWrite(Pins[i],HIGH);
if (( i + 4) < 16)
{
digitalWrite(Pins[i+4],LOW);
}
//test_delay(Dealy);
//test_delay(FDealy);
test_delay(5);
}
}
int main()
{
OrangutanBuzzer::play(">>a16");
delay(500); // warming up
lcd.initPrintf();
lcd.print("Assert");
assert(1 == 1); // make sure assert works
test_qtr();
test_analog();
test_pushbuttons();
test_buzzer();
test_motors();
test_lcd();
test_leds();
test_delay();
lcd.clear();
lcd.print("Success");
buzzer.play("O5 c16");
return 0;
}
test_dim() //Sequence = 2
{
/*
digitalWrite(ledPin5, HIGH);
//delay(VDim);
test_delay(1);
digitalWrite(ledPin5, LOW);
//delay(FDealy);
test_delay(2);
digitalWrite(ledPin6, HIGH);
//delay(VDim);
test_delay(1);
digitalWrite(ledPin6, LOW);
//delay(FDealy);
test_delay(2);
digitalWrite(ledPin7, HIGH);
//delay(VDim);
test_delay(1);
digitalWrite(ledPin7, LOW);
//delay(FDealy);
test_delay(2);
digitalWrite(ledPin8, HIGH);
//delay(VDim);
test_delay(1);
digitalWrite(ledPin8, LOW);
//delay(FDealy);
*/
test_delay(2);
}
/* IMPLEMENTATION */
static int testdelay_init(void)
{
printk(KERN_ALERT "HZ in current system: %dHZ\n",HZ);
test_short_delay();
test_delay();
test_schedule_timeout();
return 0;
}
all_on() //Sequence = 6 66666
{
int i;
for (i=0;i<16;i++)
{
digitalWrite(Pins[i], HIGH);
}
test_delay(4);
}
TEST(semaphore, one_semaphore_few_threads)
{
// Preparation
// Counts how many threads completed
int counter = 0;
// Counts how many signals sent
int signalled = 0;
// Semaphore itself
ecl::semaphore entry_semaphore;
ecl::semaphore exit_semaphore;
auto single_thread = [&counter, &entry_semaphore, &exit_semaphore]() {
std::cout << "entry wait!" << std::endl;
bool ret;
while ((ret = entry_semaphore.try_wait()) == false) {
std::this_thread::yield();
}
counter++;
exit_semaphore.signal();
};
std::array< std::thread, threads_count > threads;
// Test itself
// Start threads
test_for_each(threads, [&single_thread](auto &thread) {
thread = std::thread(single_thread);
});
// Let thread wait on semaphore
test_delay(20);
// Threads are started and should wait for orders
CHECK_EQUAL(0, counter);
// Unblock threads one by one
test_for_each(threads, [&](auto &thread) {
(void) thread; // We don't need this
entry_semaphore.signal();
signalled++;
bool ret;
while ((ret = exit_semaphore.try_wait()) == false) {
std::this_thread::yield();
}
CHECK_EQUAL(signalled, counter); // Check that only one thread is finished
});
// Wait for threads to finish
test_for_each(threads, [](auto &thread) { thread.join(); });
}
blink_none() //default sequence.....Sequence = 0
{
//printf("running blink_none....all lights out\n");
int i;
for (i=0;i<16;i++)
{
digitalWrite(Pins[i], LOW);
}
test_delay(1);
}
TEST(semaphore, multiple_threads)
{
// Preparation
// Object associated with a thread
struct test_object
{
ecl::semaphore semaphore;
std::thread thread;
volatile bool flag;
};
std::array< test_object, threads_count > objs;
auto single_thread = [](auto *obj) {
obj->semaphore.wait();
obj->flag = true; // Rise a flag only if semaphore signaled
};
// Test itself
// Start threads
test_for_each(objs, [&single_thread](auto &obj) {
obj.flag = false;
obj.thread = std::thread(single_thread, &obj);
});
// Let them wait on semaphore
test_delay(100);
// Threads are started and should wait for orders
test_for_each(objs, [](auto &obj) { CHECK(!obj.flag); } );
// Unblock threads
test_for_each(objs, [](auto &obj) { obj.semaphore.signal(); });
// Let threads do the work
test_delay(50);
// Check that work is done
test_for_each(objs, [](auto &obj) { CHECK(obj.flag); });
// Wait for threads to finish
test_for_each(objs, [](auto &obj) { obj.thread.join(); });
}
static void task(rtems_task_argument arg)
{
rtems_status_code sc;
while (true) {
sc = rtems_semaphore_obtain (task_sem, RTEMS_NO_WAIT, 0);
if (sc == RTEMS_SUCCESSFUL) {
task_data[arg].ran = true;
task_data[arg].actual_cpu = rtems_get_current_processor();
rtems_semaphore_release(task_sem);
test_delay(1);
}
}
}
time_display() //Sequence = 3
{
time_t tt,tloc;
struct tm *stm;
int min,hr,num_lights;
tt=time(&tloc);
stm = localtime(&tloc);
min = stm->tm_min;
hr = stm->tm_hour;
/*
digitalWrite(ledPin5, LOW);
digitalWrite(ledPin6, LOW);
digitalWrite(ledPin7, LOW);
digitalWrite(ledPin8, LOW);
num_lights = (min/15) + 1;
switch (num_lights)
{
case(1):
digitalWrite(ledPin5, HIGH);
break;
case(2):
digitalWrite(ledPin5, HIGH);
digitalWrite(ledPin6, HIGH);
break;
case(3):
digitalWrite(ledPin5, HIGH);
digitalWrite(ledPin6, HIGH);
digitalWrite(ledPin7, HIGH);
break;
case(4):
digitalWrite(ledPin5, HIGH);
digitalWrite(ledPin6, HIGH);
digitalWrite(ledPin7, HIGH);
digitalWrite(ledPin8, HIGH);
break;
default:
printf("Error: time out of range %d\n",num_lights);
break;
}
*/
test_delay(2); //do this so we can change display type
}
int main()
{
delay_ms(500); // warming up
lcd_init_printf();
printf("\nAssert");
assert(1 == 1); // make sure assert works
test_qtr();
test_pushbuttons();
test_buzzer();
test_motors();
test_lcd();
test_leds();
test_analog();
test_delay();
clear();
printf("\nSuccess");
play("O5 c16");
while(1);
}
static void
nc_master_test(struct sockaddr *slave, int test_tcp, int test_udp,
int test_slave_loads, int test_master_loads)
{
int s, i;
struct sockaddr_storage my_addr;
struct pause pause_times[] = {
{0,0}, {1,10}, {5,10}, {10,10}, {1,1} };
s = socket(slave->sa_family, SOCK_DGRAM, 0);
if (s < 0) {
pexit("datagram socket");
}
memset(&my_addr, 0, sizeof(my_addr));
((struct sockaddr *)&my_addr)->sa_family = slave->sa_family;
#ifndef __linux
((struct sockaddr *)&my_addr)->sa_len = slave->sa_len;
#endif
switch (slave->sa_family) {
case AF_INET:
((struct sockaddr_in *)&my_addr)->sin_addr.s_addr = htonl(INADDR_ANY);
((struct sockaddr_in *)&my_addr)->sin_port = htons(NC_MASTER_PORT);
break;
case AF_INET6:
((struct sockaddr_in6 *)&my_addr)->sin6_addr = in6addr_any;
((struct sockaddr_in6 *)&my_addr)->sin6_port = htons(NC_MASTER_PORT);
break;
default:
pexit("strange sockaddr family");
}
if (bind(s, (struct sockaddr *) &my_addr, sa_len((struct sockaddr *)&my_addr)) < 0) {
pexit("UDP bind <main>");
}
test_printf("================== No load, master at 100%% ========================\n");
if (test_udp) {
do_udp_test(s, NC_REQUEST_UDP_ECHO, slave, 640, 1024, 0, 0);
do_udp_test(s, NC_REQUEST_UDP_SEND, slave, 640, 1024, 0, 0);
do_udp_test(s, NC_REQUEST_UDP_RECV, slave, 640, 1024, 0, 0);
}
if (test_tcp) {
do_tcp_test(s, NC_REQUEST_TCP_ECHO, slave, 640, 1024, 0, 0);
do_tcp_test(s, NC_REQUEST_TCP_SEND, slave, 640, 1024, 0, 0);
do_tcp_test(s, NC_REQUEST_TCP_RECV, slave, 640, 1024, 0, 0);
do_tcp_test(s, NC_REQUEST_TCP_ECHO, slave, 64, 10240, 0, 0);
}
if (test_slave_loads) {
if (do_set_load(s, slave, 0)) {
test_printf("\n====================== Various slave compute loads ===================\n");
for (i = 0; i < 60; i += 10) {
test_printf(">>>>>>>>>>>> slave processing load at %d%%\n", i);
do_set_load(s, slave, i);
if (test_udp) {
do_udp_test(s, NC_REQUEST_UDP_ECHO, slave, 2048, 1024, 0, 0);
}
if (test_tcp) {
do_tcp_test(s, NC_REQUEST_TCP_ECHO, slave, 2048, 1024, 0, 0);
}
}
}
}
if (test_master_loads) {
if (do_start_idle(s, slave)) {
test_printf("\n====================== Various master loads ===================\n");
test_printf("Testing IDLE for %d seconds\n", IDLE_TEST_TIME);
test_delay(IDLE_TEST_TIME*100);
do_stop_idle(s, slave, true);
for (i = 0; i < LENGTH(pause_times); i++) {
if (test_udp) {
do_start_idle(s, slave);
do_udp_test(s, NC_REQUEST_UDP_ECHO, slave, 2048, 1024,
pause_times[i].pause_ticks, pause_times[i].pause_threshold);
do_stop_idle(s, slave, false);
}
if (test_tcp) {
do_start_idle(s, slave);
do_tcp_test(s, NC_REQUEST_TCP_ECHO, slave, 2048, 1024,
pause_times[i].pause_ticks, pause_times[i].pause_threshold);
do_stop_idle(s, slave, false);
}
}
}
}
// do_disconnect(s, slave);
close(s);
}
void
do_tcp_test(int s1, int type, struct sockaddr *slave,
int nbufs, int buflen, int pause_time, int pause_threshold)
{
int i, s, td_len, tot_len, wlen, len, seq, seq_errors, total_packets, res;
struct sockaddr_storage test_chan_slave;
struct timeval start_time, end_time;
struct nc_request req;
struct nc_reply reply;
struct nc_test_results results;
struct nc_test_data *tdp;
int lost_packets = 0;
int conn_failures = 0;
int need_send, need_recv;
const char *type_name;
int pkt_ctr = 0;
unsigned char *dp;
need_recv = true; need_send = true; type_name = "TCP echo";
switch (type) {
case NC_REQUEST_TCP_RECV:
need_recv = false;
need_send = true;
type_name = "TCP recv";
break;
case NC_REQUEST_TCP_SEND:
need_recv = true;
need_send = false;
type_name = "TCP send";
break;
case NC_REQUEST_TCP_ECHO:
break;
}
new_test();
req.type = htonl(type);
req.nbufs = htonl(nbufs);
req.buflen = htonl(buflen);
req.slave_port = htonl(NC_TESTING_SLAVE_PORT);
req.master_port = htonl(NC_TESTING_MASTER_PORT);
nc_message(s1, &req, &reply, slave);
if (reply.response != ntohl(NC_REPLY_ACK)) {
test_printf("Slave denied %s [%d,%d] test\n", type_name, nbufs, buflen);
return;
}
s = socket(slave->sa_family, SOCK_STREAM, 0);
if (s < 0) {
pexit("datagram socket");
}
test_printf("Start %s [%d,%d]", type_name, nbufs, buflen);
if (pause_time) {
test_printf(" - %dms delay after %d packet%s\n", pause_time*10,
pause_threshold, pause_threshold > 1 ? "s" : "");
} else {
test_printf(" - no delays\n");
}
test_delay(3*100);
memcpy(&test_chan_slave, slave, sa_len(slave));
switch (slave->sa_family) {
case AF_INET:
((struct sockaddr_in *)&test_chan_slave)->sin_port = htons(ntohl(req.slave_port));
break;
case AF_INET6:
((struct sockaddr_in6 *)&test_chan_slave)->sin6_port = htons(ntohl(req.slave_port));
break;
default:
pexit("strange TCP sockaddr");
}
while (connect(s, (struct sockaddr *)&test_chan_slave, sa_len(slave)) < 0) {
perror("Can't connect to slave");
if (++conn_failures > MAX_ERRORS) {
test_printf("Too many connection failures - giving up\n");
return;
}
if (errno == ECONNREFUSED) {
// Give the slave a little time
test_delay(100); // 1 second
} else {
return;
}
}
gettimeofday(&start_time, 0);
seq = 0; seq_errors = 0; total_packets = 0;
for (i = 0; i < nbufs; i++) {
td_len = buflen + sizeof(struct nc_test_data);
if (need_send) {
tdp = (struct nc_test_data *)out_buf;
tdp->key1 = htonl(NC_TEST_DATA_KEY1);
tdp->key2 = htonl(NC_TEST_DATA_KEY2);
tdp->seq = htonl(i);
tdp->len = htonl(td_len);
tot_len = 0;
dp = (unsigned char *)tdp;
while (tot_len < td_len) {
len = td_len - tot_len;
if ((wlen = write(s, dp, len)) != len) {
if (wlen < 0) {
test_printf("Slave connection broken\n");
perror("write");
close(s);
return;
} else {
test_printf("block: %d, short write - only %d of %d\n",
total_packets, wlen, len);
}
}
tot_len += wlen;
dp += wlen;
}
total_packets++;
}
if (need_recv) {
tdp = (struct nc_test_data *)in_buf;
res = do_read(s, tdp, td_len);
if (res != td_len) {
lost_packets++;
if (res < 0) {
test_printf("Slave connection broken\n");
perror("read");
break;
} else {
test_printf("Slave timed out after %d buffers [read %d bytes]\n", i, res);
}
} else {
if ((ntohl(tdp->key1) == NC_TEST_DATA_KEY1) &&
(ntohl(tdp->key2) == NC_TEST_DATA_KEY2)) {
if (ntohl(tdp->seq) != seq) {
test_printf("Packets out of sequence - recvd: %d, expected: %d\n",
ntohl(tdp->seq), seq);
seq_errors++;
if (!need_send) {
// Reset sequence to what the slave wants
seq = ntohl(tdp->seq);
}
}
} else {
test_printf("Bad data packet - key: %x/%x, seq: %d\n",
ntohl(tdp->key1), ntohl(tdp->key2),
ntohl(tdp->seq));
}
total_packets++;
}
seq++;
if (seq == nbufs) {
break;
}
if (pause_time && (++pkt_ctr == pause_threshold)) {
pkt_ctr = 0;
test_delay(pause_time);
}
}
}
gettimeofday(&end_time, 0);
show_results(type_name, &start_time, &end_time, total_packets, buflen,
lost_packets, seq_errors);
// Fetch results record
if (do_read(s, &results, sizeof(results)) != sizeof(results)) {
test_printf("No results record sent\n");
} else {
show_test_results(&results);
}
close(s);
}
void
do_udp_test(int s1, int type, struct sockaddr *slave,
int nbufs, int buflen, int pause_time, int pause_threshold)
{
int i, s, td_len, seq, seq_errors, total_packets;
struct sockaddr_storage test_chan_master, test_chan_slave;
struct timeval start_time, end_time;
struct nc_request req;
struct nc_reply reply;
struct nc_test_results results;
struct nc_test_data *tdp;
fd_set fds;
struct timeval timeout;
int lost_packets = 0;
int need_send, need_recv;
const char *type_name;
int pkt_ctr = 0;
need_recv = true; need_send = true; type_name = "UDP echo";
switch (type) {
case NC_REQUEST_UDP_RECV:
need_recv = false;
need_send = true;
type_name = "UDP recv";
break;
case NC_REQUEST_UDP_SEND:
need_recv = true;
need_send = false;
type_name = "UDP send";
break;
case NC_REQUEST_UDP_ECHO:
break;
}
new_test();
req.type = htonl(type);
req.nbufs = htonl(nbufs);
req.buflen = htonl(buflen);
req.slave_port = htonl(NC_TESTING_SLAVE_PORT);
req.master_port = htonl(NC_TESTING_MASTER_PORT);
nc_message(s1, &req, &reply, slave);
if (reply.response != ntohl(NC_REPLY_ACK)) {
test_printf("Slave denied %s [%d,%d] test\n", type_name, nbufs, buflen);
return;
}
s = socket(slave->sa_family, SOCK_DGRAM, 0);
if (s < 0) {
pexit("datagram socket");
}
memset(&test_chan_master, 0, sizeof(test_chan_master));
((struct sockaddr *)&test_chan_master)->sa_family = slave->sa_family;
memcpy(&test_chan_slave, slave, sa_len(slave));
#ifndef __linux
((struct sockaddr *)&test_chan_master)->sa_len = slave->sa_len;
#endif
switch (slave->sa_family) {
case AF_INET:
((struct sockaddr_in *)&test_chan_master)->sin_addr.s_addr = htonl(INADDR_ANY);
((struct sockaddr_in *)&test_chan_master)->sin_port = htons(ntohl(req.master_port));
((struct sockaddr_in *)&test_chan_slave)->sin_port = htons(ntohl(req.slave_port));
break;
case AF_INET6:
((struct sockaddr_in6 *)&test_chan_master)->sin6_addr = in6addr_any;
((struct sockaddr_in6 *)&test_chan_master)->sin6_port = htons(ntohl(req.master_port));
((struct sockaddr_in6 *)&test_chan_slave)->sin6_port = htons(ntohl(req.slave_port));
break;
default:
pexit("strange TCP sockaddr");
}
if (bind(s, (struct sockaddr *)&test_chan_master,
sa_len((struct sockaddr *)&test_chan_master)) < 0) {
perror("UDP bind <do_udp_test>");
close(s);
return;
}
test_printf("Start %s [%d,%d]", type_name, nbufs, buflen);
if (pause_time) {
test_printf(" - %dms delay after %d packet%s\n", pause_time*10,
pause_threshold, pause_threshold > 1 ? "s" : "");
} else {
test_printf(" - no delays\n");
}
gettimeofday(&start_time, 0);
seq = 0; seq_errors = 0; total_packets = 0;
for (i = 0; i < nbufs; i++) {
td_len = buflen + sizeof(struct nc_test_data);
if (need_send) {
tdp = (struct nc_test_data *)out_buf;
tdp->key1 = htonl(NC_TEST_DATA_KEY1);
tdp->key2 = htonl(NC_TEST_DATA_KEY2);
tdp->seq = htonl(i);
tdp->len = htonl(td_len);
if (sendto(s, tdp, td_len, 0,
(struct sockaddr *)&test_chan_slave,
sa_len((struct sockaddr *)&test_chan_slave)) < 0) {
perror("sendto");
close(s);
return;
}
total_packets++;
}
if (need_recv) {
FD_ZERO(&fds);
FD_SET(s, &fds);
timeout.tv_sec = NC_TEST_TIMEOUT;
timeout.tv_usec = 0;
if (select(s+1, &fds, 0, 0, &timeout) <= 0) {
test_printf("Slave timed out after %d buffers\n", i);
lost_packets++;
} else {
tdp = (struct nc_test_data *)in_buf;
if (recvfrom(s, tdp, td_len, 0, 0, 0) < 0) {
perror("recvfrom");
close(s);
return;
}
if ((ntohl(tdp->key1) == NC_TEST_DATA_KEY1) &&
(ntohl(tdp->key2) == NC_TEST_DATA_KEY2)) {
if (ntohl(tdp->seq) != seq) {
test_printf("Packets out of sequence - recvd: %d, expected: %d\n",
ntohl(tdp->seq), seq);
seq_errors++;
if (!need_send) {
// Reset sequence to what the slave wants
seq = ntohl(tdp->seq);
}
}
} else {
test_printf("Bad data packet - key: %x/%x, seq: %d\n",
ntohl(tdp->key1), ntohl(tdp->key2),
ntohl(tdp->seq));
}
total_packets++;
}
seq++;
if (seq == nbufs) {
break;
}
if (pause_time && (++pkt_ctr == pause_threshold)) {
pkt_ctr = 0;
test_delay(pause_time);
}
}
}
gettimeofday(&end_time, 0);
show_results(type_name, &start_time, &end_time, total_packets, buflen,
lost_packets, seq_errors);
// Fetch results record
FD_ZERO(&fds);
FD_SET(s, &fds);
timeout.tv_sec = NC_RESULTS_TIMEOUT;
timeout.tv_usec = 0;
if (select(s+1, &fds, 0, 0, &timeout) <= 0) {
test_printf("No results record sent\n");
} else {
if (recvfrom(s, &results, sizeof(results), 0, 0, 0) < 0) {
perror("recvfrom");
}
show_test_results(&results);
}
close(s);
}
static void test(void)
{
rtems_status_code sc;
rtems_task_argument i;
size_t size;
uint32_t cpu_count;
rtems_task_priority priority;
/* Get the number of processors that we are using. */
cpu_count = rtems_get_processor_count();
if (cpu_count != 4) {
printf("Test requires a minimum of 4 cores\n");
return;
}
size = sizeof(cpu_set_t);
task_data[0].id = rtems_task_self();
printf("Create Semaphore\n");
sc = rtems_semaphore_create(
rtems_build_name('S', 'E', 'M', '0'),
1, /* initial count = 1 */
RTEMS_LOCAL |
RTEMS_SIMPLE_BINARY_SEMAPHORE |
RTEMS_NO_INHERIT_PRIORITY |
RTEMS_NO_PRIORITY_CEILING |
RTEMS_FIFO,
0,
&task_sem
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
/* Create and start tasks on each cpu with the appropriate affinity. */
for (i = 1; i < TASK_COUNT; i++) {
sc = rtems_task_create(
rtems_build_name('T', 'A', '0', '0'+i),
task_data[ i ].priority,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&task_data[ i ].id
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_set_affinity(
task_data[ i ].id,
size,
&task_data[i].cpuset
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
printf(
"Start TA%d at priority %d on cpu %d\n",
i,
task_data[i].priority,
task_data[i].expected_cpu
);
sc = rtems_task_start( task_data[ i ].id, task, i );
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
/* spin for 100 ticks */
test_delay(100);
verify_tasks();
i = TASK_COUNT - 1;
task_data[ i ].priority = 4;
printf("Set TA%d priority %d\n", i,task_data[i].priority );
sc = rtems_task_set_priority(
task_data[ i ].id,
task_data[ i ].priority,
&priority
);
test_delay(25);
while( rtems_semaphore_obtain (task_sem, RTEMS_NO_WAIT, 0) != RTEMS_SUCCESSFUL );
for (i = 0; i < TASK_COUNT; i++) {
task_data[ i ].expected_cpu = task_data[ i ].migrate_cpu;
task_data[ i ].actual_cpu = -1;
task_data[ i ].ran = false;
}
rtems_semaphore_release(task_sem);
test_delay(25);
verify_tasks();
}
static void
nc_master(struct test_params *p)
{
int s, i;
struct sockaddr_in slave, my_addr;
struct hostent *host;
struct pause pause_times[] = {
{0,0}, {1,10}, {5,10}, {10,10}, {1,1} };
if (p->argc != 2) {
test_printf("Need exactly 'master <host>'\n");
return;
}
s = socket(AF_INET, SOCK_DGRAM, 0);
if (s < 0) {
pexit("datagram socket");
}
memset(&my_addr, 0, sizeof(my_addr));
my_addr.sin_family = AF_INET;
#ifdef __ECOS
my_addr.sin_len = sizeof(my_addr);
#endif
my_addr.sin_port = htons(NC_MASTER_PORT);
my_addr.sin_addr.s_addr = INADDR_ANY;
if (bind(s, (struct sockaddr *) &my_addr, sizeof(my_addr)) < 0) {
pexit("bind");
}
host = gethostbyname(p->argv[1]);
if (host == (struct hostent *)NULL) {
pexit("gethostbyname");
}
memset(&slave, 0, sizeof(slave));
slave.sin_family = AF_INET;
#ifdef __ECOS
slave.sin_len = sizeof(slave);
#endif
slave.sin_port = htons(NC_SLAVE_PORT);
memcpy(&slave.sin_addr.s_addr, host->h_addr, host->h_length);
test_printf("================== No load, master at 100%% ========================\n");
#if 0
do_udp_test(s, NC_REQUEST_UDP_ECHO, &slave, 640, 1024, 0, 0);
do_udp_test(s, NC_REQUEST_UDP_SEND, &slave, 640, 1024, 0, 0);
do_udp_test(s, NC_REQUEST_UDP_RECV, &slave, 640, 1024, 0, 0);
do_tcp_test(s, NC_REQUEST_TCP_ECHO, &slave, 640, 1024, 0, 0);
do_tcp_test(s, NC_REQUEST_TCP_SEND, &slave, 640, 1024, 0, 0);
do_tcp_test(s, NC_REQUEST_TCP_RECV, &slave, 640, 1024, 0, 0);
#endif
do_tcp_test(s, NC_REQUEST_TCP_ECHO, &slave, 64, 10240, 0, 0);
if (do_set_load(s, &slave, 0)) {
test_printf("\n====================== Various slave compute loads ===================\n");
for (i = 0; i < 60; i += 10) {
test_printf(">>>>>>>>>>>> slave processing load at %d%%\n", i);
do_set_load(s, &slave, i);
do_udp_test(s, NC_REQUEST_UDP_ECHO, &slave, 2048, 1024, 0, 0);
do_tcp_test(s, NC_REQUEST_TCP_ECHO, &slave, 2048, 1024, 0, 0);
}
}
if (do_start_idle(s, &slave)) {
test_printf("\n====================== Various master loads ===================\n");
test_printf("Testing IDLE for %d seconds\n", IDLE_TEST_TIME);
test_delay(IDLE_TEST_TIME*100);
do_stop_idle(s, &slave, true);
for (i = 0; i < LENGTH(pause_times); i++) {
do_start_idle(s, &slave);
do_udp_test(s, NC_REQUEST_UDP_ECHO, &slave, 2048, 1024,
pause_times[i].pause_ticks, pause_times[i].pause_threshold);
do_stop_idle(s, &slave, false);
do_start_idle(s, &slave);
do_tcp_test(s, NC_REQUEST_TCP_ECHO, &slave, 2048, 1024,
pause_times[i].pause_ticks, pause_times[i].pause_threshold);
do_stop_idle(s, &slave, false);
}
}
do_disconnect(s, &slave);
close(s);
}
static void test(void)
{
rtems_status_code sc;
uint32_t cpu_count;
int cpu;
int i;
cpu_set_t cpuset;
/* Get the number of processors that we are using. */
cpu_count = rtems_get_processor_count();
if (cpu_count < 2) {
printf("Error: Test requires at least 2 cpus\n");
return;
}
printf("Create Semaphore\n");
sc = rtems_semaphore_create(
rtems_build_name('S', 'E', 'M', '0'),
1, /* initial count = 1 */
RTEMS_LOCAL |
RTEMS_SIMPLE_BINARY_SEMAPHORE |
RTEMS_NO_INHERIT_PRIORITY |
RTEMS_NO_PRIORITY_CEILING |
RTEMS_FIFO,
0,
&task_sem
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
/*
* Create and start TA1 at a higher priority
* than the init task.
*/
sc = rtems_task_create(
rtems_build_name('T', 'A', '0', '1'),
4,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&task_data.id
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
printf("Start TA1\n");
sc = rtems_task_start( task_data.id, task, 0 );
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
/*
* Verify the Init task is running on the max core.
*/
printf("Verify Init task is on cpu %ld\n",cpu_count-1);
cpu = rtems_get_current_processor();
rtems_test_assert(cpu == (cpu_count-1));
/* Walk TA1 across all of the cores */
for(i=0; i < cpu_count; i++) {
/* Set the Affinity to core i */
CPU_ZERO(&cpuset);
CPU_SET(i, &cpuset);
printf("Set Affinity TA1 to cpu %d\n", i);
sc = rtems_task_set_affinity( task_data.id, sizeof(cpuset), &cpuset );
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
/* Wait a bit to be sure it has switched cores then clear the task data */
test_delay(50);
while( rtems_semaphore_obtain (task_sem, RTEMS_NO_WAIT, 0) != RTEMS_SUCCESSFUL );
task_data.ran = false;
task_data.expected_cpu = i;
rtems_semaphore_release(task_sem);
test_delay(50);
/* Verify the task ran on core i */
while( rtems_semaphore_obtain (task_sem, RTEMS_NO_WAIT, 0) != RTEMS_SUCCESSFUL );
if (task_data.ran != true)
printf("Error: TA01 never ran.\n");
else
printf(
"TA1 expected cpu: %d actual cpu %d\n",
task_data.expected_cpu,
task_data.actual_cpu
);
rtems_test_assert(task_data.ran == true);
rtems_test_assert(task_data.expected_cpu == task_data.actual_cpu);
rtems_semaphore_release(task_sem);
}
}
static void
do_udp_test(int s1, struct nc_request *req, struct sockaddr_in *master)
{
int i, s, td_len, seq, seq_errors, lost;
struct sockaddr_in test_chan_slave, test_chan_master;
fd_set fds;
struct timeval timeout;
struct nc_test_results results;
struct nc_test_data *tdp;
int nsent, nrecvd;
int need_recv, need_send;
need_recv = true; need_send = true;
switch (ntohl(req->type)) {
case NC_REQUEST_UDP_SEND:
need_recv = false;
need_send = true;
break;
case NC_REQUEST_UDP_RECV:
need_recv = true;
need_send = false;
break;
case NC_REQUEST_UDP_ECHO:
break;
}
s = socket(AF_INET, SOCK_DGRAM, 0);
if (s < 0) {
pexit("datagram socket");
}
memset((char *) &test_chan_slave, 0, sizeof(test_chan_slave));
test_chan_slave.sin_family = AF_INET;
test_chan_slave.sin_len = sizeof(test_chan_slave);
test_chan_slave.sin_addr.s_addr = htonl(INADDR_ANY);
test_chan_slave.sin_port = htons(ntohl(req->slave_port));
if (bind(s, (struct sockaddr *) &test_chan_slave, sizeof(test_chan_slave)) < 0) {
perror("bind");
close(s);
}
memcpy(&test_chan_master, master, sizeof(*master));
test_chan_master.sin_port = htons(ntohl(req->master_port));
nsent = 0; nrecvd = 0; seq = 0; seq_errors = 0; lost = 0;
for (i = 0; i < ntohl(req->nbufs); i++) {
if (need_recv) {
FD_ZERO(&fds);
FD_SET(s, &fds);
timeout.tv_sec = NC_TEST_TIMEOUT;
timeout.tv_usec = 0;
if (select(s+1, &fds, 0, 0, &timeout) <= 0) {
test_printf("recvfrom timeout, expecting seq #%d\n", seq);
if (++lost > MAX_ERRORS) {
test_printf("... giving up\n");
break;
}
} else {
nrecvd++;
tdp = (struct nc_test_data *)in_buf;
td_len = ntohl(req->buflen) + sizeof(struct nc_test_data);
if (recvfrom(s, tdp, td_len, 0, 0, 0) < 0) {
perror("recvfrom");
close(s);
return;
}
if ((ntohl(tdp->key1) == NC_TEST_DATA_KEY1) &&
(ntohl(tdp->key2) == NC_TEST_DATA_KEY2)) {
if (ntohl(tdp->seq) != seq) {
test_printf("Packets out of sequence - recvd: %d, expected: %d\n",
ntohl(tdp->seq), seq);
seq = ntohl(tdp->seq);
seq_errors++;
}
} else {
test_printf("Bad data packet - key: %lx/%lx, seq: %d\n",
ntohl(tdp->key1), ntohl(tdp->key2),
ntohl(tdp->seq));
}
}
}
if (need_send) {
int retries = 10;
int sent = false;
int res;
tdp = (struct nc_test_data *)out_buf;
tdp->key1 = htonl(NC_TEST_DATA_KEY1);
tdp->key2 = htonl(NC_TEST_DATA_KEY2);
tdp->seq = htonl(seq);
td_len = ntohl(req->buflen) + sizeof(struct nc_test_data);
tdp->len = htonl(td_len);
while (!sent && (--retries >= 0)) {
res = sendto(s, tdp, td_len, 0,
(struct sockaddr *)&test_chan_master, sizeof(test_chan_master));
if (res > 0) {
sent = true;
break;
}
if (errno == ENOBUFS) {
// Saturated the system
test_delay(1); // Time for 200 500 byte 10-baseT packets
} else {
// What else to do?
close(s);
return;
}
}
if (sent) {
nsent++;
} else {
perror("sendto");
}
}
seq++;
}
results.key1 = htonl(NC_TEST_RESULT_KEY1);
results.key2 = htonl(NC_TEST_RESULT_KEY2);
results.seq = req->seq;
results.nsent = htonl(nsent);
results.nrecvd = htonl(nrecvd);
if (sendto(s, &results, sizeof(results), 0,
(struct sockaddr *)&test_chan_master, sizeof(test_chan_master)) < 0) {
perror("sendto results");
}
close(s);
}
static void
do_tcp_test(int s1, struct nc_request *req, struct sockaddr_in *master)
{
int i, s, len, td_len, seq, seq_errors, lost, test_chan, res;
struct sockaddr_in test_chan_slave, test_chan_master;
struct nc_test_results results;
struct nc_test_data *tdp;
int nsent, nrecvd;
int need_recv, need_send;
int one = 1;
static int slave_tcp_port = -1;
need_recv = true; need_send = true;
switch (ntohl(req->type)) {
case NC_REQUEST_TCP_SEND:
need_recv = false;
need_send = true;
break;
case NC_REQUEST_TCP_RECV:
need_recv = true;
need_send = false;
break;
case NC_REQUEST_TCP_ECHO:
break;
}
if (slave_tcp_port < 0) {
s = socket(AF_INET, SOCK_STREAM, 0);
if (s < 0) {
pexit("datagram socket");
}
if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one))) {
perror("setsockopt SO_REUSEADDR");
return;
}
#ifdef SO_REUSEPORT
if (setsockopt(s, SOL_SOCKET, SO_REUSEPORT, &one, sizeof(one))) {
perror("setsockopt SO_REUSEPORT");
return;
}
#endif
memset((char *) &test_chan_slave, 0, sizeof(test_chan_slave));
test_chan_slave.sin_family = AF_INET;
test_chan_slave.sin_len = sizeof(test_chan_slave);
test_chan_slave.sin_addr.s_addr = htonl(INADDR_ANY);
test_chan_slave.sin_port = htons(ntohl(req->slave_port));
if (bind(s, (struct sockaddr *) &test_chan_slave, sizeof(test_chan_slave)) < 0) {
perror("bind");
close(s);
}
listen(s, 128);
slave_tcp_port = s;
}
s = slave_tcp_port;
len = sizeof(test_chan_master);
if ((test_chan = accept(s, (struct sockaddr *)&test_chan_master, &len)) < 0) {
pexit("accept");
}
len = sizeof(test_chan_master);
getpeername(test_chan, (struct sockaddr *)&test_chan_master, &len);
// test_printf("connection from %s.%d\n", inet_ntoa(test_chan_master.sin_addr),
// ntohs(test_chan_master.sin_port));
nsent = 0; nrecvd = 0; seq = 0; seq_errors = 0; lost = 0;
for (i = 0; i < ntohl(req->nbufs); i++) {
if (need_recv) {
tdp = (struct nc_test_data *)in_buf;
td_len = ntohl(req->buflen) + sizeof(struct nc_test_data);
res = do_read(test_chan, tdp, td_len);
if (res != td_len) {
test_printf("recvfrom timeout, expecting seq #%d\n", seq);
if (++lost > MAX_ERRORS) {
test_printf("... giving up\n");
break;
}
} else {
nrecvd++;
if ((ntohl(tdp->key1) == NC_TEST_DATA_KEY1) &&
(ntohl(tdp->key2) == NC_TEST_DATA_KEY2)) {
if (ntohl(tdp->seq) != seq) {
test_printf("Packets out of sequence - recvd: %d, expected: %d\n",
ntohl(tdp->seq), seq);
seq = ntohl(tdp->seq);
seq_errors++;
}
} else {
test_printf("Bad data packet - key: %lx/%lx, seq: %d\n",
ntohl(tdp->key1), ntohl(tdp->key2),
ntohl(tdp->seq));
}
}
}
if (need_send) {
tdp = (struct nc_test_data *)out_buf;
tdp->key1 = htonl(NC_TEST_DATA_KEY1);
tdp->key2 = htonl(NC_TEST_DATA_KEY2);
tdp->seq = htonl(seq);
td_len = ntohl(req->buflen) + sizeof(struct nc_test_data);
tdp->len = htonl(td_len);
if (write(test_chan, tdp, td_len) != td_len) {
perror("write");
if (errno == ENOBUFS) {
// Saturated the system
test_delay(25);
} else {
// What else to do?
close(test_chan);
return;
}
} else {
nsent++;
}
}
seq++;
}
results.key1 = htonl(NC_TEST_RESULT_KEY1);
results.key2 = htonl(NC_TEST_RESULT_KEY2);
results.seq = req->seq;
results.nsent = htonl(nsent);
results.nrecvd = htonl(nrecvd);
if (write(test_chan, &results, sizeof(results)) != sizeof(results)) {
perror("write");
}
close(test_chan);
}
int main(int argc, char **argv) {
struct delay_s {
int64_t delay_us;
int64_t delay_loops;
} delay_params;
int mynode, nodes, iters=0;
int64_t start,total,delay_us,baseline_us;
int64_t min_time, max_time, avg_time;
int64_t delay_loops = 0;
int j, i = 0;
int pause_len;
int pollcnt = 0;
GASNET_Safe(gasnet_init(&argc, &argv));
GASNET_Safe(gasnet_attach(NULL, 0, TEST_SEGSZ_REQUEST, TEST_MINHEAPOFFSET));
test_init("testbarrierlate",1,"(iters) (pollcnt)");
mynode = gasnet_mynode();
nodes = gasnet_nodes();
if (argc > 1) iters = atoi(argv[1]);
if (!iters) iters = 10000;
if (argc > 2) pollcnt = atoi(argv[2]);
if (argc > 3) test_usage();
if (mynode == 0) {
printf("Running barrier late arrival test with %i iterations, pollcnt=%i...\n",iters, pollcnt);
fflush(stdout);
}
BARRIER();
/* warmup */
for (i=0; i < MIN(100,iters/100); i++) {
gasnet_barrier_notify(0, GASNET_BARRIERFLAG_ANONYMOUS);
GASNET_Safe(gasnet_barrier_wait(0, GASNET_BARRIERFLAG_ANONYMOUS));
}
BARRIER();
start = TIME();
for (i=0; i < iters; i++) {
gasnet_barrier_notify(0, GASNET_BARRIERFLAG_ANONYMOUS);
GASNET_Safe(gasnet_barrier_wait(0, GASNET_BARRIERFLAG_ANONYMOUS));
}
baseline_us = TIME() - start;
BARRIER();
if (mynode == 0) {
printf("Total time: %8.3f sec Avg Anon. Barrier latency: %8.3f us\n",
((float)baseline_us)/1000000, ((float)baseline_us)/iters);
fflush(stdout);
}
/* Calibrate a delay loop. Given "iters" and "delay_us", we determine the argument
* we need when calling test_delay() iters times, to get a _total_ delay no less than
* delay_us. The value of delay_us is overwritten with the achieved delay.
* We calibrate the delay on exactly one node to avoid spoiling timings on
* overcommitted CPUs. Nodes not performing the calibration sleep for at least twice
* the time we are calibrating for. (No way to be sure this is enough, since
* calibration is iterative.)
*/
BARRIER();
pause_len = 1 + 4 * (baseline_us + 999999)/1000000;
if (mynode == 0) {
struct delay_s *p = (struct delay_s *)TEST_MYSEG();
start = TIME();
printf("Calibrating delay loop (expect at least a %d sec pause)...\n", pause_len);
fflush(stdout);
p->delay_us = 2*baseline_us; /* delay at least two full barrier times */
p->delay_loops = test_calibrate_delay(iters, pollcnt, &(p->delay_us));
} else {
sleep(pause_len);
}
BARRIER();
gasnet_get(&delay_params, 0, TEST_SEG(0), sizeof(struct delay_s));
delay_us = delay_params.delay_us;
delay_loops = delay_params.delay_loops;
if (mynode == 0) {
printf("Calibration complete (actual pause = %5.3f sec).\n", (float)((TIME()-start)/1000000.0));
printf("Ideal loop time = %8.3f sec.\n", (float)(delay_us)/1000000.0);
fflush(stdout);
}
/* Take turns being late to notify
* We insert a delay before the _notify() on one node.
* This simulates a load imbalance between barriers.
* The time reported is how much the barrier costs excluding the delay.
* This reported time will often be less than the full barrier because
* some progress was made by the other nodes.
*/
avg_time = 0;
max_time = 0;
min_time = (int64_t)1 << 62; /* good enough */
for (j=0; j < nodes; j++) {
BARRIER();
start = TIME();
for (i=0; i < iters; i++) {
if (j == mynode) {
test_delay(delay_loops, pollcnt);
}
gasnet_barrier_notify(0, GASNET_BARRIERFLAG_ANONYMOUS);
GASNET_Safe(gasnet_barrier_wait(0, GASNET_BARRIERFLAG_ANONYMOUS));
}
total = TIME() - start;
if (mynode == 0) {
printf("Total time: %8.3f sec Late-notify test on node %d\n", ((float)total)/1000000, j);
fflush(stdout);
}
total -= delay_us;
avg_time += total;
min_time = MIN(min_time, total);
max_time = MAX(max_time, total);
}
avg_time /= nodes;
if (mynode == 0) {
printf("Total difference: %8.3f sec Late notify() Anon. Barrier net latency, minimum: %8.3f us (%6.2f%%)\n", ((float)min_time)/1000000, ((float)min_time)/iters, ((float)min_time * 100.)/baseline_us);
printf("Total difference: %8.3f sec Late notify() Anon. Barrier net latency, maximum: %8.3f us (%6.2f%%)\n", ((float)max_time)/1000000, ((float)max_time)/iters, ((float)max_time * 100.)/baseline_us);
printf("Total difference: %8.3f sec Late notify() Anon. Barrier net latency, average: %8.3f us (%6.2f%%)\n", ((float)avg_time)/1000000, ((float)avg_time)/iters, ((float)avg_time * 100.)/baseline_us);
fflush(stdout);
}
/* Take turns being late to wait
* We insert a delay between the _notify() and _wait() on one node.
* This simulates a load imbalance between barrier notify and wait.
* The time reported is how much the barrier costs excluding the delay.
* This reported time will often be less than the full barrier because
* some progress was made by the other nodes.
*/
avg_time = 0;
max_time = 0;
min_time = (int64_t)1 << 62; /* good enough */
for (j=0; j < nodes; j++) {
BARRIER();
start = TIME();
for (i=0; i < iters; i++) {
gasnet_barrier_notify(0, GASNET_BARRIERFLAG_ANONYMOUS);
if (j == mynode) {
test_delay(delay_loops, pollcnt);
}
GASNET_Safe(gasnet_barrier_wait(0, GASNET_BARRIERFLAG_ANONYMOUS));
}
total = TIME() - start;
if (mynode == 0) {
printf("Total time: %8.3f sec Late-wait test on node %d\n", ((float)total)/1000000, j);
fflush(stdout);
}
total -= delay_us;
avg_time += total;
min_time = MIN(min_time, total);
max_time = MAX(max_time, total);
}
avg_time /= nodes;
if (mynode == 0) {
printf("Total difference: %8.3f sec Late wait() Anon. Barrier net latency, minimum: %8.3f us (%6.2f%%)\n", ((float)min_time)/1000000, ((float)min_time)/iters, ((float)min_time * 100.)/baseline_us);
printf("Total difference: %8.3f sec Late wait() Anon. Barrier net latency, maximum: %8.3f us (%6.2f%%)\n", ((float)max_time)/1000000, ((float)max_time)/iters, ((float)max_time * 100.)/baseline_us);
printf("Total difference: %8.3f sec Late wait() Anon. Barrier net latency, average: %8.3f us (%6.2f%%)\n", ((float)avg_time)/1000000, ((float)avg_time)/iters, ((float)avg_time * 100.)/baseline_us);
fflush(stdout);
}
BARRIER();
MSG("done.");
gasnet_exit(0);
return 0;
}
