// ***************************************************** // main // ***************************************************** int main( int argc, char **argv ) { // polysync return status int ret = DTC_NONE; // node reference ps_node_ref node_ref = PSYNC_NODE_REF_INVALID; // 'ps_byte_array_msg' type identifier ps_msg_type byte_array_msg_type = PSYNC_MSG_TYPE_INVALID; // 'ps_byte_array_msg' message reference ps_msg_ref msg = PSYNC_MSG_REF_INVALID; // cast of our msg varible ps_byte_array_msg *byte_array_msg = NULL; // init core API if( (ret = psync_init( NODE_NAME, PSYNC_NODE_TYPE_API_USER, PSYNC_DEFAULT_DOMAIN, PSYNC_SDF_ID_INVALID, PSYNC_INIT_FLAG_STDOUT_LOGGING, &node_ref )) != DTC_NONE ) { psync_log_message( LOG_LEVEL_ERROR, "main -- psync_init - ret: %d", ret ); return EXIT_FAILURE; } // nodes typically should shutdown after handling SIGINT // hook up the control-c signal handler, sets exit signaled flag signal( SIGINT, sig_handler ); // allow signals to interrupt siginterrupt( SIGINT, 1 ); // get byte array message type if( (ret = psync_message_get_type_by_name( node_ref, "ps_byte_array_msg", &byte_array_msg_type )) != DTC_NONE ) { psync_log_message( LOG_LEVEL_ERROR, "main -- psync_message_get_type_by_name - ret: %d", ret ); goto GRACEFUL_EXIT_STMNT; } // allocate a byte array message if( (ret = psync_message_alloc( node_ref, byte_array_msg_type, &msg )) != DTC_NONE ) { psync_log_message( LOG_LEVEL_ERROR, "main -- psync_message_alloc - ret: %d", ret ); goto GRACEFUL_EXIT_STMNT; } // initialize logfile API resources if( (ret = psync_logfile_init( node_ref )) != DTC_NONE ) { psync_log_message( LOG_LEVEL_ERROR, "main -- psync_logfile_init - ret: %d", ret ); goto GRACEFUL_EXIT_STMNT; } // set the logfile path, over rides the default file name logic if( (ret = psync_logfile_set_file_path( node_ref, LOGFILE_PATH )) != DTC_NONE ) { psync_log_message( LOG_LEVEL_ERROR, "main -- psync_logfile_set_file_path - ret: %d", ret ); goto GRACEFUL_EXIT_STMNT; } // enable record/write mode, the example session ID value 1 is not used when a manual file path is set if( (ret = psync_logfile_set_mode( node_ref, LOGFILE_MODE_WRITE, 1 )) != DTC_NONE ) { psync_log_message( LOG_LEVEL_ERROR, "main -- psync_logfile_set_mode - ret: %d", ret ); goto GRACEFUL_EXIT_STMNT; } // enable the current logfile state - allows messages to be logged/written if( (ret = psync_logfile_set_state( node_ref, LOGFILE_STATE_ENABLED, 0 )) != DTC_NONE ) { psync_log_message( LOG_LEVEL_ERROR, "main -- psync_logfile_set_state - ret: %d", ret ); goto GRACEFUL_EXIT_STMNT; } // cast our message byte_array_msg = (ps_byte_array_msg*) msg; // allocate the buffer byte_array_msg->bytes._buffer = DDS_sequence_octet_allocbuf( BUFFER_SIZE ); byte_array_msg->bytes._maximum = (DDS_unsigned_long) BUFFER_SIZE; byte_array_msg->bytes._length = byte_array_msg->bytes._maximum; byte_array_msg->bytes._release = 1; // used to index our example message in the logfile, starts at 1 byte_array_msg->data_type = 0; // main event loop // loop until signaled (control-c) while( global_exit_signal == 0 ) { // increment our message counter byte_array_msg->data_type += 1; // update the publish/logged timestamp if( (ret = psync_get_timestamp( &byte_array_msg->header.timestamp )) != DTC_NONE ) { psync_log_message( LOG_LEVEL_ERROR, "main -- psync_get_timestamp - ret: %d", ret ); goto GRACEFUL_EXIT_STMNT; } // give a copy to the logfile API for writing if( (ret = psync_logfile_write_message( node_ref, msg )) != DTC_NONE ) { psync_log_message( LOG_LEVEL_ERROR, "main -- psync_logfile_write_message - ret: %d", ret ); goto GRACEFUL_EXIT_STMNT; } // print a message every 20 writes if( (byte_array_msg->data_type % 20) == 0 ) { printf( "logged message ID: %lu\n", (unsigned long) byte_array_msg->data_type ); } // wait for the next write psync_sleep_micro( 1000000ULL / WRITE_FREQ ); } // print printf( "wrote %lu messages to file: '%s'\n", (unsigned long) byte_array_msg->data_type, LOGFILE_PATH ); // using 'goto' to allow for an easy example exit GRACEFUL_EXIT_STMNT: global_exit_signal = 1; // release our byte array message if( (ret = psync_message_free( node_ref, &msg )) != DTC_NONE ) { psync_log_message( LOG_LEVEL_ERROR, "main -- psync_message_free - ret: %d", ret ); } // disable current mode if( (ret = psync_logfile_set_mode( node_ref, LOGFILE_MODE_OFF, PSYNC_RNR_SESSION_ID_INVALID )) != DTC_NONE ) { psync_log_message( LOG_LEVEL_ERROR, "main -- psync_logfile_set_mode - ret: %d", ret ); } // release logfile API resources if( (ret = psync_logfile_release( node_ref )) != DTC_NONE ) { psync_log_message( LOG_LEVEL_ERROR, "main -- psync_logfile_release - ret: %d", ret ); } // release core API if( (ret = psync_release( &node_ref )) != DTC_NONE ) { psync_log_message( LOG_LEVEL_ERROR, "main -- psync_release - ret: %d", ret ); } return EXIT_SUCCESS; }
int main (int argc, char *argv[]) { dds_entity_t writer; dds_entity_t reader; dds_entity_t participant; dds_entity_t topic; dds_entity_t publisher; dds_entity_t subscriber; dds_waitset_t waitSet; const char *pubPartitions[] = { "ping" }; const char *subPartitions[] = { "pong" }; dds_qos_t *pubQos; dds_qos_t *dwQos; dds_qos_t *drQos; dds_qos_t *subQos; ExampleTimeStats roundTrip; ExampleTimeStats writeAccess; ExampleTimeStats readAccess; ExampleTimeStats roundTripOverall; ExampleTimeStats writeAccessOverall; ExampleTimeStats readAccessOverall; unsigned long payloadSize = 0; unsigned long long numSamples = 0; dds_time_t timeOut = 0; dds_time_t startTime; dds_time_t time; dds_time_t preWriteTime; dds_time_t postWriteTime; dds_time_t preTakeTime; dds_time_t postTakeTime; dds_time_t difference = 0; dds_time_t elapsed = 0; RoundTripModule_DataType pub_data; RoundTripModule_DataType sub_data[MAX_SAMPLES]; void *samples[MAX_SAMPLES]; dds_sample_info_t info[MAX_SAMPLES]; dds_attach_t wsresults[1]; size_t wsresultsize = 1U; dds_time_t waitTimeout = DDS_SECS (1); unsigned long i; int status; bool invalid = false; bool warmUp = true; dds_condition_t readCond; /* Register handler for Ctrl-C */ #ifdef _WIN32 SetConsoleCtrlHandler ((PHANDLER_ROUTINE)CtrlHandler, TRUE); #else struct sigaction sat, oldAction; sat.sa_handler = CtrlHandler; sigemptyset (&sat.sa_mask); sat.sa_flags = 0; sigaction (SIGINT, &sat, &oldAction); #endif exampleInitTimeStats (&roundTrip); exampleInitTimeStats (&writeAccess); exampleInitTimeStats (&readAccess); exampleInitTimeStats (&roundTripOverall); exampleInitTimeStats (&writeAccessOverall); exampleInitTimeStats (&readAccessOverall); memset (&sub_data, 0, sizeof (sub_data)); memset (&pub_data, 0, sizeof (pub_data)); for (i = 0; i < MAX_SAMPLES; i++) { samples[i] = &sub_data[i]; } status = dds_init (argc, argv); DDS_ERR_CHECK (status, DDS_CHECK_REPORT | DDS_CHECK_EXIT); status = dds_participant_create (&participant, DDS_DOMAIN_DEFAULT, NULL, NULL); DDS_ERR_CHECK (status, DDS_CHECK_REPORT | DDS_CHECK_EXIT); /* A DDS_Topic is created for our sample type on the domain participant. */ status = dds_topic_create (participant, &topic, &RoundTripModule_DataType_desc, "RoundTrip", NULL, NULL); DDS_ERR_CHECK (status, DDS_CHECK_REPORT | DDS_CHECK_EXIT); /* A DDS_Publisher is created on the domain participant. */ pubQos = dds_qos_create (); dds_qset_partition (pubQos, 1, pubPartitions); status = dds_publisher_create (participant, &publisher, pubQos, NULL); DDS_ERR_CHECK (status, DDS_CHECK_REPORT | DDS_CHECK_EXIT); dds_qos_delete (pubQos); /* A DDS_DataWriter is created on the Publisher & Topic with a modified Qos. */ dwQos = dds_qos_create (); dds_qset_reliability (dwQos, DDS_RELIABILITY_RELIABLE, DDS_SECS (10)); dds_qset_writer_data_lifecycle (dwQos, false); status = dds_writer_create (publisher, &writer, topic, dwQos, NULL); DDS_ERR_CHECK (status, DDS_CHECK_REPORT | DDS_CHECK_EXIT); dds_qos_delete (dwQos); /* A DDS_Subscriber is created on the domain participant. */ subQos = dds_qos_create (); dds_qset_partition (subQos, 1, subPartitions); status = dds_subscriber_create (participant, &subscriber, subQos, NULL); DDS_ERR_CHECK (status, DDS_CHECK_REPORT | DDS_CHECK_EXIT); dds_qos_delete (subQos); /* A DDS_DataReader is created on the Subscriber & Topic with a modified QoS. */ drQos = dds_qos_create (); dds_qset_reliability (drQos, DDS_RELIABILITY_RELIABLE, DDS_SECS(10)); status = dds_reader_create (subscriber, &reader, topic, drQos, NULL); DDS_ERR_CHECK (status, DDS_CHECK_REPORT | DDS_CHECK_EXIT); dds_qos_delete (drQos); terminated = dds_guardcondition_create (); waitSet = dds_waitset_create (); readCond = dds_readcondition_create (reader, DDS_ANY_STATE); status = dds_waitset_attach (waitSet, readCond, reader); DDS_ERR_CHECK (status, DDS_CHECK_REPORT | DDS_CHECK_EXIT); status = dds_waitset_attach (waitSet, terminated, terminated); DDS_ERR_CHECK (status, DDS_CHECK_REPORT | DDS_CHECK_EXIT); setvbuf(stdout, NULL, _IONBF, 0); if (argc == 2 && strcmp (argv[1], "quit") == 0) { printf ("Sending termination request.\n"); /* pong uses a waitset which is triggered by instance disposal, and quits when it fires. */ dds_sleepfor (DDS_SECS (1)); pub_data.payload._length = 0; pub_data.payload._buffer = NULL; pub_data.payload._release = true; pub_data.payload._maximum = 0; status = dds_instance_writedispose (writer, &pub_data); DDS_ERR_CHECK (status, DDS_CHECK_REPORT | DDS_CHECK_EXIT); dds_sleepfor (DDS_SECS (1)); goto done; } if (argc == 1) { invalid = true; } if (argc >= 2) { payloadSize = atol (argv[1]); if (payloadSize > 65536) { invalid = true; } } if (argc >= 3) { numSamples = atol (argv[2]); } if (argc >= 4) { timeOut = atol (argv[3]); } if (invalid || (argc == 2 && (strcmp (argv[1], "-h") == 0 || strcmp (argv[1], "--help") == 0))) { printf ("Usage (parameters must be supplied in order):\n" "./ping [payloadSize (bytes, 0 - 65536)] [numSamples (0 = infinite)] [timeOut (seconds, 0 = infinite)]\n" "./ping quit - ping sends a quit signal to pong.\n" "Defaults:\n" "./ping 0 0 0\n"); return (1); } printf ("# payloadSize: %lu | numSamples: %llu | timeOut: %llu\n\n", payloadSize, numSamples, timeOut); pub_data.payload._length = payloadSize; pub_data.payload._buffer = payloadSize ? DDS_sequence_octet_allocbuf (payloadSize) : NULL; pub_data.payload._release = true; pub_data.payload._maximum = 0; for (i = 0; i < payloadSize; i++) { pub_data.payload._buffer[i] = 'a'; } startTime = dds_time (); printf ("# Waiting for startup jitter to stabilise\n"); while (!dds_condition_triggered (terminated) && difference < DDS_SECS(5)) { status = dds_write (writer, &pub_data); DDS_ERR_CHECK (status, DDS_CHECK_REPORT | DDS_CHECK_EXIT); status = dds_waitset_wait (waitSet, wsresults, wsresultsize, waitTimeout); DDS_ERR_CHECK (status, DDS_CHECK_REPORT | DDS_CHECK_EXIT); if (status > 0) /* data */ { status = dds_take (reader, samples, MAX_SAMPLES, info, 0); DDS_ERR_CHECK (status, DDS_CHECK_REPORT | DDS_CHECK_EXIT); } time = dds_time (); difference = time - startTime; } if (!dds_condition_triggered (terminated)) { warmUp = false; printf("# Warm up complete.\n\n"); printf("# Round trip measurements (in us)\n"); printf("# Round trip time [us] Write-access time [us] Read-access time [us]\n"); printf("# Seconds Count median min Count median min Count median min\n"); } startTime = dds_time (); for (i = 0; !dds_condition_triggered (terminated) && (!numSamples || i < numSamples); i++) { /* Write a sample that pong can send back */ preWriteTime = dds_time (); status = dds_write (writer, &pub_data); DDS_ERR_CHECK (status, DDS_CHECK_REPORT | DDS_CHECK_EXIT); postWriteTime = dds_time (); /* Wait for response from pong */ status = dds_waitset_wait (waitSet, wsresults, wsresultsize, waitTimeout); DDS_ERR_CHECK (status, DDS_CHECK_REPORT | DDS_CHECK_EXIT); if (status != 0) { /* Take sample and check that it is valid */ preTakeTime = dds_time (); status = dds_take (reader, samples, MAX_SAMPLES, info, 0); DDS_ERR_CHECK (status, DDS_CHECK_REPORT | DDS_CHECK_EXIT); postTakeTime = dds_time (); if (!dds_condition_triggered (terminated)) { if (status != 1) { fprintf (stdout, "%s%d%s", "ERROR: Ping received ", status, " samples but was expecting 1. Are multiple pong applications running?\n"); return (0); } else if (!info[0].valid_data) { printf ("ERROR: Ping received an invalid sample. Has pong terminated already?\n"); return (0); } } /* Update stats */ difference = (postWriteTime - preWriteTime)/DDS_NSECS_IN_USEC; writeAccess = *exampleAddTimingToTimeStats (&writeAccess, difference); writeAccessOverall = *exampleAddTimingToTimeStats (&writeAccessOverall, difference); difference = (postTakeTime - preTakeTime)/DDS_NSECS_IN_USEC; readAccess = *exampleAddTimingToTimeStats (&readAccess, difference); readAccessOverall = *exampleAddTimingToTimeStats (&readAccessOverall, difference); difference = (postTakeTime - preWriteTime)/DDS_NSECS_IN_USEC; roundTrip = *exampleAddTimingToTimeStats (&roundTrip, difference); roundTripOverall = *exampleAddTimingToTimeStats (&roundTripOverall, difference); /* Print stats each second */ difference = (postTakeTime - startTime)/DDS_NSECS_IN_USEC; if (difference > US_IN_ONE_SEC || (i && i == numSamples)) { printf ( "%9llu %9lu %8.0f %8llu %10lu %8.0f %8llu %10lu %8.0f %8llu\n", elapsed + 1, roundTrip.count, exampleGetMedianFromTimeStats (&roundTrip), roundTrip.min, writeAccess.count, exampleGetMedianFromTimeStats (&writeAccess), writeAccess.min, readAccess.count, exampleGetMedianFromTimeStats (&readAccess), readAccess.min ); exampleResetTimeStats (&roundTrip); exampleResetTimeStats (&writeAccess); exampleResetTimeStats (&readAccess); startTime = dds_time (); elapsed++; } } else { elapsed += waitTimeout / DDS_NSECS_IN_SEC; } if (timeOut && elapsed == timeOut) { dds_guard_trigger (terminated); } } if (!warmUp) { printf ( "\n%9s %9lu %8.0f %8llu %10lu %8.0f %8llu %10lu %8.0f %8llu\n", "# Overall", roundTripOverall.count, exampleGetMedianFromTimeStats (&roundTripOverall), roundTripOverall.min, writeAccessOverall.count, exampleGetMedianFromTimeStats (&writeAccessOverall), writeAccessOverall.min, readAccessOverall.count, exampleGetMedianFromTimeStats (&readAccessOverall), readAccessOverall.min ); } done: #ifdef _WIN32 SetConsoleCtrlHandler (0, FALSE); #else sigaction (SIGINT, &oldAction, 0); #endif /* Disable callbacks */ dds_status_set_enabled (reader, 0); /* Clean up */ exampleDeleteTimeStats (&roundTrip); exampleDeleteTimeStats (&writeAccess); exampleDeleteTimeStats (&readAccess); exampleDeleteTimeStats (&roundTripOverall); exampleDeleteTimeStats (&writeAccessOverall); exampleDeleteTimeStats (&readAccessOverall); status = dds_waitset_detach (waitSet, readCond); DDS_ERR_CHECK (status, DDS_CHECK_REPORT | DDS_CHECK_EXIT); status = dds_waitset_detach (waitSet, terminated); DDS_ERR_CHECK (status, DDS_CHECK_REPORT | DDS_CHECK_EXIT); dds_condition_delete (readCond); dds_condition_delete (terminated); status = dds_waitset_delete (waitSet); DDS_ERR_CHECK (status, DDS_CHECK_REPORT | DDS_CHECK_EXIT); dds_entity_delete (participant); for (i = 0; i < MAX_SAMPLES; i++) { RoundTripModule_DataType_free (&sub_data[i], DDS_FREE_CONTENTS); } RoundTripModule_DataType_free (&pub_data, DDS_FREE_CONTENTS); dds_fini (); return 0; }