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; }