int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { ACE_Time_Value timeout (ACE_DEFAULT_TIMEOUT); //unsigned char selector = ACE_ATM_Addr::DEFAULT_SELECTOR; //int selector_specified = 0; if (argc > 2) ACE_ERROR_RETURN ((LM_ERROR, "Usage: %s [selector]\n", argv[0]), 1); // Create a server address. ACE_ATM_Addr addr; //if (selector_specified) unsigned char selector = ( argc == 2 ) ? ACE_OS::atoi( argv[ 1 ]) : ACE_ATM_Addr::DEFAULT_SELECTOR; addr.set_selector( selector ); ACE_OS::printf( "ATM_Server: selector changed to %d\n", addr.get_selector()); // Create a server, reuse the addr. ACE_ATM_Acceptor peer_acceptor; ACE_ATM_Params params; // Not sure why but reuse_addr set to true/1 causes problems for // FORE/XTI/ATM - this is now handled in ACE_ATM_Acceptor::open() ACE_HANDLE ret = peer_acceptor.open (addr, 5, params); if ( ret == ACE_INVALID_HANDLE ) ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "open"), -1); ACE_ATM_Stream new_stream; ACE_ATM_Addr local_addr; local_addr.set_selector( selector ); peer_acceptor.get_local_addr( local_addr ); ACE_DEBUG ((LM_DEBUG, "starting server at address %s\n", local_addr.addr_to_string ())); // Performs the iterative server activities char buf[BUFSIZ]; ACE_High_Res_Timer timer; int total; ACE_Time_Value tv; double real_time; double actual_rate; for (;;) { // Create a new ACE_ATM_Stream endpoint (note automatic restart // if errno == EINTR). ACE_OS::printf( "ATM_Server: expecting clients\n" ); if (peer_acceptor.accept (new_stream, &addr, &timeout) == -1) { ACE_ERROR ((LM_ERROR, "%p\n", "accept")); continue; } ACE_OS::printf( "ATM_Server: got a connection\n" ); ACE_UINT16 vpi, vci; vpi = vci = 0; // This has problem on PMP connections on NT //new_stream.get_vpi_vci(vpi, vci); ACE_DEBUG ((LM_DEBUG, "connected to VPI %d VCI %d\n", vpi, vci)); ACE_OS::printf( "ATM_Server: connection accepted\n" ); ACE_DEBUG ((LM_DEBUG, "client %s connected\n", addr.addr_to_string ())); ACE_DEBUG ((LM_DEBUG, "client %s connected to host\n", new_stream.get_peer_name ())); // Read data from client (terminate on error). int recvd = 0; for ( ;; ) { total = 0; timer.start_incr(); for (int r_bytes; (r_bytes = new_stream.recv (buf, sizeof buf, 0)) > 0; ) { // ACE_OS::printf( "ATM_Server: received %dB\n", r_bytes ); // if (ACE_OS::write (ACE_STDOUT, // buf, // r_bytes) != r_bytes) // ACE_ERROR ((LM_ERROR, // "%p\n", // "ACE::send_n")); total += r_bytes; if ( total > 10000000 ) break; } timer.stop_incr(); timer.elapsed_time_incr( tv ); real_time = tv.sec() * ACE_ONE_SECOND_IN_USECS + tv.usec(); recvd += total; actual_rate = ( double )recvd * ( double )8 / real_time; ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) bytes = %d, usec = %f, rate = %0.00f Mbps\n"), recvd, real_time, actual_rate < 0 ? 0 : actual_rate )); } // Close new endpoint (listening endpoint stays open). if (new_stream.close () == -1) ACE_ERROR ((LM_ERROR, "%p\n", "close")); } /* NOTREACHED */ return 0; }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { if ( argc < 2 ) ACE_ERROR_RETURN ((LM_ERROR, "Usage: %s <rate> <PDU> <session> <host> <selector> [ host sel ] ...\n" "\tUse 0 for default values\n", argv[0]), 1); int rate = ACE_OS::atoi( argv[ 1 ]); rate = ( rate != 0 ) ? rate : 170000; int pdu_size = ACE_OS::atoi( argv[ 2 ]) * 1024; pdu_size = ( pdu_size != 0 ) ? pdu_size : 8192; int session = ACE_OS::atoi( argv[ 3 ]); session = ( session != 0 ) ? session : 100; ACE_OS::printf( "ATM_Client: rate: %d c/s, PDU: %dB, session: %d pkts\n", rate, pdu_size, session ); // Record all hosts/selectors ACE_ATM_Addr hosts[ MAX_LEAVES ]; int num_leaves = argc / 2 - 2; ACE_OS::printf( "ATM_Client: Connecting to ...\n" ); for ( int i = 0; i < num_leaves; i++ ) { hosts[ i ].set( argv[ i*2 + 4 ], ( argv[ i*2 + 5 ] != 0 ) ? ACE_OS::atoi( argv[ i*2 + 5 ]) : ACE_ATM_Addr::DEFAULT_SELECTOR ); ACE_OS::printf( "ATM_Client: leaf: %s (%s), sel: %d\n", argv[ i*2 + 4 ], hosts[ i ].addr_to_string(), hosts[ i ].get_selector()); } // The timeout really gets ignored since FORE's drivers don't work when // ioctl or fcntl calls are made on the transport id/file descriptor int timeout = ACE_DEFAULT_TIMEOUT; char buf[BUFSIZ]; ACE_ATM_Stream atm_stream; char hostname[ MAXNAMELEN ]; ACE_OS::hostname( hostname, MAXNAMELEN ); ACE_ATM_Addr local_addr( hostname, hosts[ 0 ].get_selector()); ACE_OS::printf( "ATM_Client: local host: %s(%s)\n", hostname, local_addr.addr_to_string()); // In order to construct connections options the file handle is // needed. Therefore, we need to open the ATM_Stream before we // construct the options. ACE_OS::printf( "ATM_Client: to open a stream\n" ); if (atm_stream.open () == -1) ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "open failed"), 1); ACE_DEBUG ((LM_DEBUG, "ATM_Client: starting non-blocking connection\n")); // Initiate timed, non-blocking connection with server. ACE_ATM_Connector con; // Construct QoS options - currently FORE only supports bandwidth ACE_OS::printf( "ATM_Client: specify cell rate at %d c/s\n", rate ); ACE_ATM_QoS qos; qos.set_rate(atm_stream.get_handle (), rate, ACE_ATM_QoS::OPT_FLAGS_CPID); if ( num_leaves == 1 ) { // Point-to-point connection // Not sure why but reuse_addr set to true/1 causes problems for // FORE/XTI/ATM - this is now handled in ACE_ATM_Connector::connect() ACE_OS::printf( "ATM_Client: to open a connection \n" ); ACE_ATM_Params params = ACE_ATM_Params(); if (con.connect (atm_stream, hosts[ 0 ], params, qos, (ACE_Time_Value *) &ACE_Time_Value::zero, local_addr, 0, 0 ) == -1) { if (errno != EWOULDBLOCK) ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "ATM_Client: connection failed"), 1); ACE_DEBUG ((LM_DEBUG, "ATM_Client: starting timed connection\n")); // Check if non-blocking connection is in progress, and wait up // to timeout seconds for it to complete. ACE_Time_Value tv (timeout); ACE_OS::printf( "ATM_Client: connection completed\n" ); if (con.complete (atm_stream, &hosts[ 0 ], &tv) == -1) ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "ATM_Client: connection failed"), 1); else ACE_DEBUG ((LM_DEBUG, "ATM_Client: connected to %s\n", hosts[ 0 ].addr_to_string())); } } else { // Point-to-multipoint connection for ( int i = 0; i < num_leaves; i++ ) { con.add_leaf( atm_stream, hosts[ i ], i, 0 ); } } /* if num_leaves == 1 */ ACE_UINT16 vpi, vci; atm_stream.get_vpi_vci(vpi, vci); ACE_DEBUG ((LM_DEBUG, "ATM_Client: connected to VPI %d VCI %d\n", vpi, vci)); // Send data to server (correctly handles "incomplete writes"). int s_bytes; int total; int xmit = 0; ACE_High_Res_Timer timer; ACE_Time_Value elapsed; double real_time; double actual_rate; for ( ;; ) { total = 0; timer.start_incr(); for ( ;; ) { s_bytes = atm_stream.send_n( buf, BUFSIZ, 0 ); if ( s_bytes == -1 ) ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "send_n"), 1); total += s_bytes; if ( total >= session * pdu_size ) break; } timer.stop_incr(); timer.elapsed_time_incr( elapsed ); real_time = elapsed.sec() * ACE_ONE_SECOND_IN_USECS + elapsed.usec(); xmit += total; actual_rate = ( double )xmit * ( double )8 / real_time; ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) bytes = %d, usec = %f, rate = %0.00f Mbps\n"), xmit, real_time, actual_rate < 0 ? 0 : actual_rate )); } // Explicitly close the connection. ACE_OS::printf( "ATM_Client: close connection\n" ); if (atm_stream.close () == -1) ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "close"), -1); return 0; }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { int n = 100; int low = 64; int hi = 4096; int s = 4; int quiet = 0; ACE_Get_Opt get_opt (argc, argv, ACE_TEXT("dn:l:h:s:q")); int opt; while ((opt = get_opt ()) != EOF) { switch (opt) { case 'd': TAO_debug_level++; break; case 'n': n = ACE_OS::atoi (get_opt.opt_arg ()); break; case 'l': low = ACE_OS::atoi (get_opt.opt_arg ()); break; case 'h': hi = ACE_OS::atoi (get_opt.opt_arg ()); break; case 's': s = ACE_OS::atoi (get_opt.opt_arg ()); break; case 'q': quiet = 1; break; case '?': default: ACE_DEBUG ((LM_DEBUG, "Usage: %s " "-d debug" "-l low " "-h high " "-s step " "-n n " "\n" "Writes and then reads longs to a CDR stream " "starting from <low> up to <high> incrementing " "by <step>, at each step run <n> iterations to " "average." "\n", argv[0])); return -1; } } for (int x = low; x <= hi; x += s) { ACE_High_Res_Timer writing; ACE_High_Res_Timer reading; if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG, "\nx= %d\n", x)); for (int i = 0; i < n; ++i) { writing.start_incr (); TAO_OutputCDR output; if (test_write (output, x) != 0) { return 1; } writing.stop_incr (); reading.start_incr (); TAO_InputCDR input (output); if (test_read (input, x) != 0) { return 1; } reading.stop_incr (); } double m = n * x; ACE_Time_Value wtv; writing.elapsed_time_incr (wtv); ACE_hrtime_t wusecs = wtv.sec (); wusecs *= static_cast<ACE_UINT32> (ACE_ONE_SECOND_IN_USECS); wusecs += wtv.usec (); ACE_Time_Value rtv; reading.elapsed_time_incr (rtv); ACE_hrtime_t rusecs = rtv.sec (); rusecs *= static_cast<ACE_UINT32> (ACE_ONE_SECOND_IN_USECS); rusecs += rtv.usec (); double write_average = ACE_HRTIME_CONVERSION(wusecs) / m; double read_average = ACE_HRTIME_CONVERSION(rusecs) / m; if (!quiet) ACE_OS::printf ("AVE: %d %f %f\n", x, write_average, read_average); } return 0; }