void net_test(test_param_t param) { // int i; if (param == 0) { test_printf("Start Network Characterization - SLAVE\n"); #ifdef __ECOS init_all_network_interfaces(); calibrate_load(DESIRED_BACKGROUND_LOAD); #if 0 // I can see what this is trying to do, but I get "bind: Address already in // use" errors from the 2nd interface - and the parameter is not used // anyway, so one thread does quite well enough (but only tests one i/f at // once). // Comment in the 'int i' above too. for (i = 1; i < CYGHWR_NET_DRIVERS; i++) { cyg_thread_resume(main_thread_handle[i]); // Start other threads } #endif #endif } nc_slave(param); #ifdef CYGDBG_NET_TIMING_STATS show_net_times(); #endif cyg_test_exit(); }
void pexit(char *s) { perror(s); #ifdef CYGDBG_NET_TIMING_STATS show_net_times(); #endif cyg_test_exit(); }
void net_test(void *arg) { test_param_t param = (test_param_t)arg; // int i; if (param == 0) { test_printf("Start Network Characterization - SLAVE\n"); calibrate_load(DESIRED_BACKGROUND_LOAD); } nc_slave(param); #ifdef CYGDBG_NET_TIMING_STATS show_net_times(); #endif #if LWIP_STATS_DISPLAY stats_display(); #endif cyg_test_exit(); }
void net_test(test_param_t param) { #ifdef __ECOS cyg_serial_baud_rate_t old; cyg_ppp_options_t options; cyg_ppp_handle_t ppp_handle; CYG_TEST_INIT(); #endif // int i; if (param == 0) { test_printf("Start Network Characterization - SLAVE\n"); #ifdef __ECOS init_all_network_interfaces(); calibrate_load(DESIRED_BACKGROUND_LOAD); #if 0 // I can see what this is trying to do, but I get "bind: Address already in // use" errors from the 2nd interface - and the parameter is not used // anyway, so one thread does quite well enough (but only tests one i/f at // once). // Comment in the 'int i' above too. for (i = 1; i < CYGHWR_NET_DRIVERS; i++) { cyg_thread_resume(main_thread_handle[i]); // Start other threads } #endif #endif } #ifdef __ECOS old = ppp_test_set_baud( CYGNUM_SERIAL_BAUD_115200 ); ppp_test_announce( "NC_TEST_SLAVE" ); cyg_ppp_options_init( &options ); // options.debug = 1; // options.kdebugflag = 1; // options.script = script; // options.flowctl = CYG_PPP_FLOWCTL_SOFTWARE; ppp_handle = cyg_ppp_up( CYGPKG_PPP_TEST_DEVICE, &options ); CYG_TEST_INFO( "Waiting for PPP to come up"); cyg_ppp_wait_up( ppp_handle ); #endif nc_slave(param); #ifdef CYGDBG_NET_TIMING_STATS show_net_times(); #endif #ifdef __ECOS CYG_TEST_INFO( "Bringing PPP down"); cyg_ppp_down( ppp_handle ); CYG_TEST_INFO( "Waiting for PPP to go down"); cyg_ppp_wait_down( ppp_handle ); cyg_thread_delay( 200 ); ppp_test_set_baud( old ); ppp_test_finish(); CYG_TEST_PASS_FINISH( "Network Characterization - SLAVE" ); #endif cyg_test_exit(); }
static void echo_test(cyg_addrword_t p) { int s_source, s_sink, e_source, e_sink; struct sockaddr_in e_source_addr, e_sink_addr, local; int one = 1; fd_set in_fds; int i, num, len; struct test_params params,nparams; struct test_status status,nstatus; cyg_tick_count_t starttime, stoptime; s_source = socket(AF_INET, SOCK_STREAM, 0); if (s_source < 0) { pexit("stream socket"); } if (setsockopt(s_source, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one))) { pexit("setsockopt /source/ SO_REUSEADDR"); } if (setsockopt(s_source, SOL_SOCKET, SO_REUSEPORT, &one, sizeof(one))) { pexit("setsockopt /source/ SO_REUSEPORT"); } memset(&local, 0, sizeof(local)); local.sin_family = AF_INET; local.sin_len = sizeof(local); local.sin_port = ntohs(SOURCE_PORT); local.sin_addr.s_addr = INADDR_ANY; if(bind(s_source, (struct sockaddr *) &local, sizeof(local)) < 0) { pexit("bind /source/ error"); } listen(s_source, SOMAXCONN); s_sink = socket(AF_INET, SOCK_STREAM, 0); if (s_sink < 0) { pexit("stream socket"); } memset(&local, 0, sizeof(local)); local.sin_family = AF_INET; local.sin_len = sizeof(local); local.sin_port = ntohs(SINK_PORT); local.sin_addr.s_addr = INADDR_ANY; if(bind(s_sink, (struct sockaddr *) &local, sizeof(local)) < 0) { pexit("bind /sink/ error"); } if (setsockopt(s_sink, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one))) { pexit("setsockopt /sink/ SO_REUSEADDR"); } if (setsockopt(s_sink, SOL_SOCKET, SO_REUSEPORT, &one, sizeof(one))) { pexit("setsockopt /sink/ SO_REUSEPORT"); } listen(s_sink, SOMAXCONN); e_source = 0; e_sink = 0; while (true) { // Wait for a connection on either of the ports FD_ZERO(&in_fds); FD_SET(s_source, &in_fds); FD_SET(s_sink, &in_fds); num = select(max(s_sink,s_source)+1, &in_fds, 0, 0, 0); if (FD_ISSET(s_source, &in_fds)) { len = sizeof(e_source_addr); if ((e_source = accept(s_source, (struct sockaddr *)&e_source_addr, &len)) < 0) { pexit("accept /source/"); } diag_printf("SOURCE connection from %s:%d\n", inet_ntoa(e_source_addr.sin_addr), ntohs(e_source_addr.sin_port)); } if (FD_ISSET(s_sink, &in_fds)) { len = sizeof(e_sink_addr); if ((e_sink = accept(s_sink, (struct sockaddr *)&e_sink_addr, &len)) < 0) { pexit("accept /sink/"); } diag_printf("SINK connection from %s:%d\n", inet_ntoa(e_sink_addr.sin_addr), ntohs(e_sink_addr.sin_port)); } // Continue with test once a connection is established in both directions if ((e_source != 0) && (e_sink != 0)) { break; } } // Wait for "source" to tell us the testing paramters if (do_read(e_source, &nparams, sizeof(nparams)) != sizeof(nparams)) { pexit("Can't read initialization parameters"); } params.nbufs = ntohl(nparams.nbufs); params.bufsize = ntohl(nparams.bufsize); params.load = ntohl(nparams.load); diag_printf("Using %d buffers of %d bytes each, %d%% background load\n", params.nbufs, params.bufsize, params.load); // Tell the sink what the parameters are if (do_write(e_sink, &nparams, sizeof(nparams)) != sizeof(nparams)) { pexit("Can't write initialization parameters"); } status.ok = 1; nstatus.ok = htonl(status.ok); // Tell the "source" to start - we're all connected and ready to go! if (do_write(e_source, &nstatus, sizeof(nstatus)) != sizeof(nstatus)) { pexit("Can't send ACK to 'source' host"); } idle_thread_count = 0; cyg_semaphore_post(&idle_thread_sem); // Start idle thread starttime = cyg_current_time(); start_load(params.load); // Echo the data from the source to the sink hosts for (i = 0; i < params.nbufs; i++) { if ((len = do_read(e_source, data_buf, params.bufsize)) != params.bufsize) { diag_printf("Can't read buf #%d: ", i+1); if (len < 0) { perror("I/O error"); } else { diag_printf("short read - only %d bytes\n", len); } } // else diag_printf("Got %d bytes\n",len); if ((len = do_write(e_sink, data_buf, params.bufsize)) != params.bufsize) { diag_printf("Can't write buf #%d: ", i+1); if (len < 0) { perror("I/O error"); } else { diag_printf("short write - only %d bytes\n", len); } } // else diag_printf("Sent %d bytes\n",len); } // Wait for the data to drain and the "sink" to tell us all is OK. if (do_read(e_sink, &status, sizeof(status)) != sizeof(status)) { pexit("Can't receive ACK from 'sink' host"); } start_load(0); cyg_semaphore_wait(&idle_thread_sem); // Stop idle thread stoptime = cyg_current_time(); stoptime -= starttime; // time taken in cS // expected idle loops in that time period for an idle system: starttime = no_load_idle_count_1_second * stoptime / 100; diag_printf( "%d ticks elapsed, %d kloops predicted for an idle system\n", (int)stoptime, (int)(starttime/1000) ); diag_printf( "actual kloops %d, CPU was %d%% idle during transfer\n", (int)(idle_thread_count/1000), (int)(idle_thread_count * 100 / starttime) ); // Now examine how close that loading actually was: start_load(params.load); // Start up a given load idle_thread_count = 0; cyg_semaphore_post(&idle_thread_sem); // Start idle thread cyg_thread_delay(1*100); // Pause for one second cyg_semaphore_wait(&idle_thread_sem); // Stop idle thread start_load(0); // Shut down background load i = 100 - ((idle_thread_count * 100) / no_load_idle_count_1_second ); diag_printf("Final load[%d] = %d => %d%%\n", load_thread_level, (int)idle_thread_count, i); //#ifdef CYGDBG_USE_ASSERTS #ifdef CYGDBG_NET_TIMING_STATS { extern void show_net_times(void); show_net_times(); } #endif //#endif }