int
main (
int argc,
char *argv[]
)
{
DDS_ConditionSeq *conditionList;
DDS_WaitSet w;
DDS_Condition exp_condition;
pong_handler *active_handler;
DDS_DomainParticipantQos *dpQos;
DDS_TopicQos *tQos;
DDS_PublisherQos *pQos;
DDS_DataWriterQos *dwQos;
DDS_SubscriberQos *sQos;
DDS_DataReaderQos *drQos;
time_t clock = time (NULL);
DDS_Duration_t wait_timeout = {3,0};
DDS_ReturnCode_t result;
DDS_boolean finish_flag = FALSE;
DDS_boolean timeout_flag = FALSE;
DDS_boolean terminate = FALSE;
int imax = 1;
int i;
unsigned int block;
init_clock();
/*
* init timing statistics
*/
init_stats (&roundtrip, "round_trip");
init_stats (&write_access, "write_access");
init_stats (&read_access, "read_access");
/*
* Evaluate cmdline arguments
*/
if (argc != 1) {
if (argc != 6) {
printf ("Invalid.....\n Usage: %s [blocks blocksize topic_id WRITE_PARTITION READ_PARTITION]\n", argv[0]);
exit (1);
}
nof_blocks = atoi (argv[1]);
nof_cycles = atoi (argv[2]);
topic_id = argv[3][0];
write_partition = argv[4];
read_partition = argv[5];
}
/*
* Create WaitSet
*/
w = DDS_WaitSet__alloc ();
/*
* Initialize Qos variables
*/
dpQos = DDS_DomainParticipantQos__alloc();
tQos = DDS_TopicQos__alloc();
pQos = DDS_PublisherQos__alloc();
dwQos = DDS_DataWriterQos__alloc();
sQos = DDS_SubscriberQos__alloc();
drQos = DDS_DataReaderQos__alloc();
/*
* Initialize condition list
*/
conditionList = NULL;
/*
* Create participant
*/
dpf = DDS_DomainParticipantFactory_get_instance ();
dp = DDS_DomainParticipantFactory_create_participant (dpf, myDomain, DDS_PARTICIPANT_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE);
if (dp == DDS_HANDLE_NIL) {
printf ("%s PING: ERROR - Splice Daemon not running", argv[0]);
exit (1);
}
/*
* Create PING publisher
*/
DDS_DomainParticipant_get_default_publisher_qos (dp, pQos);
pQos->partition.name._length = 1;
pQos->partition.name._maximum = 1;
pQos->partition.name._buffer = DDS_StringSeq_allocbuf (1);
pQos->partition.name._buffer[0] = DDS_string_alloc (strlen(write_partition) + 1);
strcpy (pQos->partition.name._buffer[0], write_partition);
p = DDS_DomainParticipant_create_publisher (dp, pQos, NULL, DDS_STATUS_MASK_NONE);
DDS_free (pQos);
/*
* Create PONG subscriber
*/
DDS_DomainParticipant_get_default_subscriber_qos (dp, sQos);
sQos->partition.name._length = 1;
sQos->partition.name._maximum = 1;
sQos->partition.name._buffer = DDS_StringSeq_allocbuf (1);
sQos->partition.name._buffer[0] = DDS_string_alloc (strlen(read_partition) + 1);
strcpy (sQos->partition.name._buffer[0], read_partition);
s = DDS_DomainParticipant_create_subscriber (dp, sQos, NULL, DDS_STATUS_MASK_NONE);
DDS_free (sQos);
/*
* PP_min_msg
*/
/* Create Topic */
PP_min_dt = pingpong_PP_min_msgTypeSupport__alloc ();
pingpong_PP_min_msgTypeSupport_register_type (PP_min_dt, dp, "pingpong::PP_min_msg");
PP_min_topic = DDS_DomainParticipant_create_topic (dp, "PP_min_topic", "pingpong::PP_min_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE);
/* Create datawriter */
PP_min_writer = DDS_Publisher_create_datawriter (p, PP_min_topic, DDS_DATAWRITER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE);
/* Create datareader */
PP_min_reader = DDS_Subscriber_create_datareader (s, PP_min_topic, DDS_DATAREADER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE);
/* Add datareader statuscondition to waitset */
PP_min_sc = DDS_DataReader_get_statuscondition (PP_min_reader);
DDS_StatusCondition_set_enabled_statuses (PP_min_sc, DDS_DATA_AVAILABLE_STATUS);
result = DDS_WaitSet_attach_condition (w, PP_min_sc);
/*
* PP_seq_msg
*/
/* Create Topic */
PP_seq_dt = pingpong_PP_seq_msgTypeSupport__alloc ();
pingpong_PP_seq_msgTypeSupport_register_type (PP_seq_dt, dp, "pingpong::PP_seq_msg");
PP_seq_topic = DDS_DomainParticipant_create_topic (dp, "PP_seq_topic", "pingpong::PP_seq_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE);
/* Create datawriter */
PP_seq_writer = DDS_Publisher_create_datawriter (p, PP_seq_topic, DDS_DATAWRITER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE);
/* Create datareader */
PP_seq_reader = DDS_Subscriber_create_datareader (s, PP_seq_topic, DDS_DATAREADER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE);
/* Add datareader statuscondition to waitset */
PP_seq_sc = DDS_DataReader_get_statuscondition (PP_seq_reader);
DDS_StatusCondition_set_enabled_statuses (PP_seq_sc, DDS_DATA_AVAILABLE_STATUS);
result = DDS_WaitSet_attach_condition (w, PP_seq_sc);
/*
* PP_string_msg
*/
/* Create Topic */
PP_string_dt = pingpong_PP_string_msgTypeSupport__alloc ();
pingpong_PP_string_msgTypeSupport_register_type (PP_string_dt, dp, "pingpong::PP_string_msg");
PP_string_topic = DDS_DomainParticipant_create_topic (dp, "PP_string_topic", "pingpong::PP_string_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE);
/* Create datawriter */
PP_string_writer = DDS_Publisher_create_datawriter (p, PP_string_topic, DDS_DATAWRITER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE);
/* Create datareader */
PP_string_reader = DDS_Subscriber_create_datareader (s, PP_string_topic, DDS_DATAREADER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE);
/* Add datareader statuscondition to waitset */
PP_string_sc = DDS_DataReader_get_statuscondition (PP_string_reader);
DDS_StatusCondition_set_enabled_statuses (PP_string_sc, DDS_DATA_AVAILABLE_STATUS);
result = DDS_WaitSet_attach_condition (w, PP_string_sc);
/*
* PP_fixed_msg
*/
/* Create Topic */
PP_fixed_dt = pingpong_PP_fixed_msgTypeSupport__alloc ();
pingpong_PP_fixed_msgTypeSupport_register_type (PP_fixed_dt, dp, "pingpong::PP_fixed_msg");
PP_fixed_topic = DDS_DomainParticipant_create_topic (dp, "PP_fixed_topic", "pingpong::PP_fixed_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE);
/* Create datawriter */
PP_fixed_writer = DDS_Publisher_create_datawriter (p, PP_fixed_topic, DDS_DATAWRITER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE);
/* Create datareader */
PP_fixed_reader = DDS_Subscriber_create_datareader (s, PP_fixed_topic, DDS_DATAREADER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE);
/* Add datareader statuscondition to waitset */
PP_fixed_sc = DDS_DataReader_get_statuscondition (PP_fixed_reader);
DDS_StatusCondition_set_enabled_statuses (PP_fixed_sc, DDS_DATA_AVAILABLE_STATUS);
result = DDS_WaitSet_attach_condition (w, PP_fixed_sc);
/*
* PP_array_msg
*/
/* Create Topic */
PP_array_dt = pingpong_PP_array_msgTypeSupport__alloc ();
pingpong_PP_array_msgTypeSupport_register_type (PP_array_dt, dp, "pingpong::PP_array_msg");
PP_array_topic = DDS_DomainParticipant_create_topic (dp, "PP_array_topic", "pingpong::PP_array_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE);
/* Create datawriter */
PP_array_writer = DDS_Publisher_create_datawriter (p, PP_array_topic, DDS_DATAWRITER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE);
/* Create datareader */
PP_array_reader = DDS_Subscriber_create_datareader (s, PP_array_topic, DDS_DATAREADER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE);
/* Add datareader statuscondition to waitset */
PP_array_sc = DDS_DataReader_get_statuscondition (PP_array_reader);
DDS_StatusCondition_set_enabled_statuses (PP_array_sc, DDS_DATA_AVAILABLE_STATUS);
result = DDS_WaitSet_attach_condition (w, PP_array_sc);
/*
* PP_quit_msg
*/
/* Create Topic */
PP_quit_dt = pingpong_PP_quit_msgTypeSupport__alloc ();
pingpong_PP_quit_msgTypeSupport_register_type (PP_quit_dt, dp, "pingpong::PP_quit_msg");
PP_quit_topic = DDS_DomainParticipant_create_topic (dp, "PP_quit_topic", "pingpong::PP_quit_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE);
/* Create datawriter */
PP_quit_writer = DDS_Publisher_create_datawriter (p, PP_quit_topic, DDS_DATAWRITER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE);
for (block = 0; block < nof_blocks ; block++) {
while (!finish_flag) {
/*
* Send Initial message
*/
timeout_flag = FALSE;
switch(topic_id) {
case 'm':
{
/* printf ("PING: sending initial ping_min\n"); */
pingpong_PP_min_msg *PPdata = pingpong_PP_min_msg__alloc ();
exp_condition = PP_min_sc;
active_handler = &PP_min_handler;
PPdata->count = 0;
PPdata->block = block;
preWriteTime = timeGet ();
result = pingpong_PP_min_msgDataWriter_write (PP_min_writer, PPdata, DDS_HANDLE_NIL);
postWriteTime = timeGet ();
DDS_free (PPdata);
}
break;
case 'q':
{
/* printf ("PING: sending initial ping_seq\n"); */
pingpong_PP_seq_msg *PPdata = pingpong_PP_seq_msg__alloc ();
exp_condition = PP_seq_sc;
active_handler = &PP_seq_handler;
PPdata->count = 0;
PPdata->block = block;
preWriteTime = timeGet ();
result = pingpong_PP_seq_msgDataWriter_write (PP_seq_writer, PPdata, DDS_HANDLE_NIL);
postWriteTime = timeGet ();
DDS_free (PPdata);
}
break;
case 's':
{
/* printf ("PING: sending initial ping_string\n"); */
pingpong_PP_string_msg *PPdata = pingpong_PP_string_msg__alloc ();
exp_condition = PP_string_sc;
active_handler = &PP_string_handler;
PPdata->count = 0;
PPdata->block = block;
PPdata->a_string = DDS_string_alloc (8);
strcpy (PPdata->a_string, "a_string");
preWriteTime = timeGet ();
result = pingpong_PP_string_msgDataWriter_write (PP_string_writer, PPdata, DDS_HANDLE_NIL);
postWriteTime = timeGet ();
DDS_free (PPdata);
}
break;
case 'f':
{
/* printf ("PING: sending initial ping_fixed\n"); */
pingpong_PP_fixed_msg *PPdata = pingpong_PP_fixed_msg__alloc ();
exp_condition = PP_fixed_sc;
active_handler = &PP_fixed_handler;
PPdata->count = 0;
PPdata->block = block;
PPdata->a_bstring = DDS_string_alloc (9);
strcpy (PPdata->a_bstring, "a_bstring");
preWriteTime = timeGet ();
result = pingpong_PP_fixed_msgDataWriter_write (PP_fixed_writer, PPdata, DDS_HANDLE_NIL);
postWriteTime = timeGet ();
DDS_free (PPdata);
}
break;
case 'a':
{
/* printf ("PING: sending initial ping_array\n"); */
pingpong_PP_array_msg *PPdata = pingpong_PP_array_msg__alloc ();
exp_condition = PP_array_sc;
active_handler = &PP_array_handler;
PPdata->count = 0;
PPdata->block = block;
preWriteTime = timeGet ();
result = pingpong_PP_array_msgDataWriter_write (PP_array_writer, PPdata, DDS_HANDLE_NIL);
postWriteTime = timeGet ();
DDS_free (PPdata);
}
break;
case 't':
{
/* printf ("PING: sending initial ping_quit\n"); */
pingpong_PP_quit_msg *PPdata = pingpong_PP_quit_msg__alloc();
PPdata->quit = TRUE;
terminate = TRUE;
finish_flag = TRUE;
preWriteTime = timeGet ();
result = pingpong_PP_quit_msgDataWriter_write (PP_quit_writer, PPdata, DDS_HANDLE_NIL);
postWriteTime = timeGet ();
DDS_free (PPdata);
}
break;
default:
printf("Invalid topic-id\n");
exit(1);
}
if (!terminate) {
roundTripTime = preWriteTime;
add_stats (&write_access, 1E6 * timeToReal (timeSub (postWriteTime, preWriteTime)));
/*
* Wait for response, calculate timing, and send another data if not ready
*/
while (!(timeout_flag || finish_flag)) {
conditionList = DDS_ConditionSeq__alloc();
result = DDS_WaitSet_wait (w, conditionList, &wait_timeout);
if (conditionList) {
imax = conditionList->_length;
if (imax != 0) {
for (i = 0; i < imax; i++) {
if (conditionList->_buffer[i] == exp_condition) {
finish_flag = active_handler (nof_cycles);
} else {
printf ("PING: unexpected condition triggered: %x\n",
(unsigned int)conditionList->_buffer[i]);
}
}
} else {
printf ("PING: TIMEOUT - message lost\n");
timeout_flag = TRUE;
}
DDS_free(conditionList);
} else {
printf ("PING: TIMEOUT - message lost\n");
timeout_flag = TRUE;
}
}
}
}
if (!terminate) {
finish_flag = FALSE;
if (block == 0) {
printf ("# PING PONG measurements (in us) \n");
printf ("# Executed at: %s", ctime(&clock));
printf ("# Roundtrip time [us] Write-access time [us] Read-access time [us]\n");
printf ("# Block Count mean min max Count mean min max Count mean min max\n");
}
printf ("%6d %10d %6.0f %6.0f %6.0f %10d %6.0f %6.0f %6.0f %10d %6.0f %6.0f %6.0f\n",
block,
roundtrip.count,
roundtrip.average,
roundtrip.min,
roundtrip.max,
write_access.count,
write_access.average,
write_access.min,
write_access.max,
read_access.count,
read_access.average,
read_access.min,
read_access.max);
fflush (NULL);
init_stats (&write_access, "write_access");
init_stats (&read_access, "read_access");
init_stats (&roundtrip, "round_trip");
}
}
result = DDS_Subscriber_delete_datareader (s, PP_min_reader);
result = DDS_Publisher_delete_datawriter (p, PP_min_writer);
result = DDS_Subscriber_delete_datareader (s, PP_seq_reader);
result = DDS_Publisher_delete_datawriter (p, PP_seq_writer);
result = DDS_Subscriber_delete_datareader (s, PP_string_reader);
result = DDS_Publisher_delete_datawriter (p, PP_string_writer);
result = DDS_Subscriber_delete_datareader (s, PP_fixed_reader);
result = DDS_Publisher_delete_datawriter (p, PP_fixed_writer);
result = DDS_Subscriber_delete_datareader (s, PP_array_reader);
result = DDS_Publisher_delete_datawriter (p, PP_array_writer);
result = DDS_Publisher_delete_datawriter (p, PP_quit_writer);
result = DDS_DomainParticipant_delete_subscriber (dp, s);
result = DDS_DomainParticipant_delete_publisher (dp, p);
result = DDS_DomainParticipant_delete_topic (dp, PP_min_topic);
result = DDS_DomainParticipant_delete_topic (dp, PP_seq_topic);
result = DDS_DomainParticipant_delete_topic (dp, PP_string_topic);
result = DDS_DomainParticipant_delete_topic (dp, PP_fixed_topic);
result = DDS_DomainParticipant_delete_topic (dp, PP_array_topic);
result = DDS_DomainParticipant_delete_topic (dp, PP_quit_topic);
result = DDS_DomainParticipantFactory_delete_participant (dpf, dp);
DDS_free (w);
DDS_free (PP_min_dt);
DDS_free (PP_seq_dt);
DDS_free (PP_string_dt);
DDS_free (PP_fixed_dt);
DDS_free (PP_array_dt);
DDS_free (PP_quit_dt);
DDS_free (dpQos);
DDS_free (tQos);
DDS_free (dwQos);
DDS_free (drQos);
return 0;
}
int OSPL_MAIN (int argc, char ** argv)
#endif
{
DDS_ConditionSeq *conditionList;
DDS_WaitSet w;
DDS_DomainParticipantQos *dpQos;
DDS_TopicQos *tQos;
DDS_PublisherQos *pQos;
DDS_DataWriterQos *dwQos;
DDS_SubscriberQos *sQos;
DDS_DataReaderQos *drQos;
DDS_Condition exp_condition = NULL;
pong_handler *active_handler = NULL;
DDS_Duration_t wait_timeout = {3,0};
DDS_boolean finish_flag = FALSE;
DDS_boolean timeout_flag = FALSE;
DDS_boolean terminate = FALSE;
DDS_ReturnCode_t result;
int imax = 1;
int i;
unsigned int block;
printf ("Starting ping example\n");
fflush(stdout);
/*
* init timing statistics
*/
init_stats (&roundtrip, "round_trip");
init_stats (&write_access, "write_access");
init_stats (&read_access, "read_access");
/*
* Evaluate cmdline arguments
*/
#ifdef INTEGRITY
nof_blocks = 100;
nof_cycles = 100;
#if defined (PING1)
topic_id = 'm';
#elif defined (PING2)
topic_id = 'q';
#elif defined (PING3)
topic_id = 's';
#elif defined (PING4)
topic_id = 'f';
#elif defined (PING5)
topic_id = 'b';
#elif defined (PING6)
nof_blocks = 1;
nof_cycles = 10;
topic_id = 't';
#endif
write_partition = "PongRead";
read_partition = "PongWrite";
#else
if (argc != 1) {
if (argc != 6) {
printf ("Invalid.....\n Usage: %s [blocks blocksize topic_id WRITE_PARTITION READ_PARTITION]\n", argv[0]);
exit (1);
}
nof_blocks = atoi (argv[1]);
nof_cycles = atoi (argv[2]);
topic_id = argv[3][0];
write_partition = argv[4];
read_partition = argv[5];
}
#endif
#ifdef _WIN32
init_clock();
#endif
/*
* Create WaitSet
*/
w = DDS_WaitSet__alloc ();
/*
* Initialize Qos variables
*/
dpQos = DDS_DomainParticipantQos__alloc();
tQos = DDS_TopicQos__alloc();
pQos = DDS_PublisherQos__alloc();
dwQos = DDS_DataWriterQos__alloc();
sQos = DDS_SubscriberQos__alloc();
drQos = DDS_DataReaderQos__alloc();
/*
* Initialize condition list
*/
conditionList = NULL;
/*
* Create participant
*/
dpf = DDS_DomainParticipantFactory_get_instance ();
dp = DDS_DomainParticipantFactory_create_participant (dpf, myDomain, DDS_PARTICIPANT_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE);
if (dp == DDS_HANDLE_NIL) {
printf ("%s PING: ERROR - Splice Daemon not running", argv[0]);
exit (1);
}
/*
* Create PING publisher
*/
DDS_DomainParticipant_get_default_publisher_qos (dp, pQos);
pQos->partition.name._length = 1;
pQos->partition.name._maximum = 1;
pQos->partition.name._buffer = DDS_StringSeq_allocbuf (1);
pQos->partition.name._buffer[0] = DDS_string_dup (write_partition);
p = DDS_DomainParticipant_create_publisher (dp, pQos, NULL, DDS_STATUS_MASK_NONE);
DDS_free (pQos);
/*
* Create PONG subscriber
*/
DDS_DomainParticipant_get_default_subscriber_qos (dp, sQos);
sQos->partition.name._length = 1;
sQos->partition.name._maximum = 1;
sQos->partition.name._buffer = DDS_StringSeq_allocbuf (1);
sQos->partition.name._buffer[0] = DDS_string_dup (read_partition);
s = DDS_DomainParticipant_create_subscriber (dp, sQos, NULL, DDS_STATUS_MASK_NONE);
DDS_free (sQos);
/*
* PP_min_msg
*/
/* Create Topic */
PP_min_dt = pingpong_PP_min_msgTypeSupport__alloc ();
pingpong_PP_min_msgTypeSupport_register_type (PP_min_dt, dp, "pingpong::PP_min_msg");
PP_min_topic = DDS_DomainParticipant_create_topic (dp, "PP_min_topic", "pingpong::PP_min_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE);
DDS_Publisher_get_default_datawriter_qos(p, dwQos);
dwQos->reliability.kind = DDS_BEST_EFFORT_RELIABILITY_QOS;
dwQos->history.kind = DDS_KEEP_ALL_HISTORY_QOS;
/* Create datawriter */
PP_min_writer = DDS_Publisher_create_datawriter (p, PP_min_topic, dwQos, NULL, DDS_STATUS_MASK_NONE);
/* Create datareader */
PP_min_reader = DDS_Subscriber_create_datareader (s, PP_min_topic, DDS_DATAREADER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE);
/* Add datareader statuscondition to waitset */
PP_min_sc = DDS_DataReader_get_statuscondition (PP_min_reader);
DDS_StatusCondition_set_enabled_statuses (PP_min_sc, DDS_DATA_AVAILABLE_STATUS);
DDS_WaitSet_attach_condition (w, PP_min_sc);
/*
* PP_seq_msg
*/
/* Create Topic */
PP_seq_dt = pingpong_PP_seq_msgTypeSupport__alloc ();
pingpong_PP_seq_msgTypeSupport_register_type (PP_seq_dt, dp, "pingpong::PP_seq_msg");
PP_seq_topic = DDS_DomainParticipant_create_topic (dp, "PP_seq_topic", "pingpong::PP_seq_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE);
/* Create datawriter */
PP_seq_writer = DDS_Publisher_create_datawriter (p, PP_seq_topic, dwQos, NULL, DDS_STATUS_MASK_NONE);
/* Create datareader */
PP_seq_reader = DDS_Subscriber_create_datareader (s, PP_seq_topic, DDS_DATAREADER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE);
/* Add datareader statuscondition to waitset */
PP_seq_sc = DDS_DataReader_get_statuscondition (PP_seq_reader);
DDS_StatusCondition_set_enabled_statuses (PP_seq_sc, DDS_DATA_AVAILABLE_STATUS);
DDS_WaitSet_attach_condition (w, PP_seq_sc);
/*
* PP_string_msg
*/
/* Create Topic */
PP_string_dt = pingpong_PP_string_msgTypeSupport__alloc ();
pingpong_PP_string_msgTypeSupport_register_type (PP_string_dt, dp, "pingpong::PP_string_msg");
PP_string_topic = DDS_DomainParticipant_create_topic (dp, "PP_string_topic", "pingpong::PP_string_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE);
/* Create datawriter */
PP_string_writer = DDS_Publisher_create_datawriter (p, PP_string_topic, dwQos, NULL, DDS_STATUS_MASK_NONE);
/* Create datareader */
PP_string_reader = DDS_Subscriber_create_datareader (s, PP_string_topic, DDS_DATAREADER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE);
/* Add datareader statuscondition to waitset */
PP_string_sc = DDS_DataReader_get_statuscondition (PP_string_reader);
DDS_StatusCondition_set_enabled_statuses (PP_string_sc, DDS_DATA_AVAILABLE_STATUS);
DDS_WaitSet_attach_condition (w, PP_string_sc);
/*
* PP_fixed_msg
*/
/* Create Topic */
PP_fixed_dt = pingpong_PP_fixed_msgTypeSupport__alloc ();
pingpong_PP_fixed_msgTypeSupport_register_type (PP_fixed_dt, dp, "pingpong::PP_fixed_msg");
PP_fixed_topic = DDS_DomainParticipant_create_topic (dp, "PP_fixed_topic", "pingpong::PP_fixed_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE);
/* Create datawriter */
PP_fixed_writer = DDS_Publisher_create_datawriter (p, PP_fixed_topic, dwQos, NULL, DDS_STATUS_MASK_NONE);
/* Create datareader */
PP_fixed_reader = DDS_Subscriber_create_datareader (s, PP_fixed_topic, DDS_DATAREADER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE);
/* Add datareader statuscondition to waitset */
PP_fixed_sc = DDS_DataReader_get_statuscondition (PP_fixed_reader);
DDS_StatusCondition_set_enabled_statuses (PP_fixed_sc, DDS_DATA_AVAILABLE_STATUS);
DDS_WaitSet_attach_condition (w, PP_fixed_sc);
/*
* PP_array_msg
*/
/* Create Topic */
PP_array_dt = pingpong_PP_array_msgTypeSupport__alloc ();
pingpong_PP_array_msgTypeSupport_register_type (PP_array_dt, dp, "pingpong::PP_array_msg");
PP_array_topic = DDS_DomainParticipant_create_topic (dp, "PP_array_topic", "pingpong::PP_array_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE);
/* Create datawriter */
PP_array_writer = DDS_Publisher_create_datawriter (p, PP_array_topic, dwQos, NULL, DDS_STATUS_MASK_NONE);
/* Create datareader */
PP_array_reader = DDS_Subscriber_create_datareader (s, PP_array_topic, DDS_DATAREADER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE);
/* Add datareader statuscondition to waitset */
PP_array_sc = DDS_DataReader_get_statuscondition (PP_array_reader);
DDS_StatusCondition_set_enabled_statuses (PP_array_sc, DDS_DATA_AVAILABLE_STATUS);
DDS_WaitSet_attach_condition (w, PP_array_sc);
/*
* PP_bseq_msg
*/
/* Create Topic */
PP_bseq_dt = pingpong_PP_bseq_msgTypeSupport__alloc ();
pingpong_PP_bseq_msgTypeSupport_register_type (PP_bseq_dt, dp, "pingpong::PP_bseq_msg");
PP_bseq_topic = DDS_DomainParticipant_create_topic (dp, "PP_bseq_topic", "pingpong::PP_bseq_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE);
/* Create datawriter */
PP_bseq_writer = DDS_Publisher_create_datawriter (p, PP_bseq_topic, dwQos, NULL, DDS_STATUS_MASK_NONE);
/* Create datareader */
PP_bseq_reader = DDS_Subscriber_create_datareader (s, PP_bseq_topic, DDS_DATAREADER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE);
/* Add datareader statuscondition to waitset */
PP_bseq_sc = DDS_DataReader_get_statuscondition (PP_bseq_reader);
DDS_StatusCondition_set_enabled_statuses (PP_bseq_sc, DDS_DATA_AVAILABLE_STATUS);
DDS_WaitSet_attach_condition (w, PP_bseq_sc);
/*
* PP_quit_msg
*/
/* Create Topic */
PP_quit_dt = pingpong_PP_quit_msgTypeSupport__alloc ();
pingpong_PP_quit_msgTypeSupport_register_type (PP_quit_dt, dp, "pingpong::PP_quit_msg");
PP_quit_topic = DDS_DomainParticipant_create_topic (dp, "PP_quit_topic", "pingpong::PP_quit_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE);
/* Create datawriter */
PP_quit_writer = DDS_Publisher_create_datawriter (p, PP_quit_topic, dwQos, NULL, DDS_STATUS_MASK_NONE);
/* Fr: workarround for ticket dds1712 */
conditionList = DDS_ConditionSeq__alloc();
assert(conditionList);
DDS_WaitSet_wait (w, conditionList, &wait_timeout);
DDS_free(conditionList);
for (block = 0; block < nof_blocks && !terminate ; block++) {
while (!finish_flag) {
/*
* Send Initial message
*/
timeout_flag = FALSE;
switch(topic_id) {
case 'm':
{
/* printf ("PING: sending initial ping_min\n"); */
pingpong_PP_min_msg *PPdata = pingpong_PP_min_msg__alloc ();
exp_condition = PP_min_sc;
active_handler = &PP_min_handler;
PPdata->count = 0;
PPdata->block = block;
preWriteTime = timeGet ();
pingpong_PP_min_msgDataWriter_write (PP_min_writer, PPdata, DDS_HANDLE_NIL);
postWriteTime = timeGet ();
DDS_free (PPdata);
}
break;
case 'q':
{
/* printf ("PING: sending initial ping_seq\n"); */
pingpong_PP_seq_msg *PPdata = pingpong_PP_seq_msg__alloc ();
exp_condition = PP_seq_sc;
active_handler = &PP_seq_handler;
PPdata->count = 0;
PPdata->block = block;
{
int i = 0;
PPdata->payload._buffer = pingpong_seq_char_allocbuf(SEQ_PAYLOAD_SIZE);
PPdata->payload._length = SEQ_PAYLOAD_SIZE;
PPdata->payload._maximum = SEQ_PAYLOAD_SIZE;
for (i=0; i<SEQ_PAYLOAD_SIZE; i++) {
PPdata->payload._buffer[i] = (char)i;
}
}
preWriteTime = timeGet ();
pingpong_PP_seq_msgDataWriter_write (PP_seq_writer, PPdata, DDS_HANDLE_NIL);
postWriteTime = timeGet ();
DDS_free (PPdata);
}
break;
case 's':
{
/* printf ("PING: sending initial ping_string\n"); */
pingpong_PP_string_msg *PPdata = pingpong_PP_string_msg__alloc ();
exp_condition = PP_string_sc;
active_handler = &PP_string_handler;
PPdata->count = 0;
PPdata->block = block;
PPdata->a_string = DDS_string_dup ("a_string");
preWriteTime = timeGet ();
pingpong_PP_string_msgDataWriter_write (PP_string_writer, PPdata, DDS_HANDLE_NIL);
postWriteTime = timeGet ();
DDS_free (PPdata);
}
break;
case 'f':
{
/* printf ("PING: sending initial ping_fixed\n"); */
pingpong_PP_fixed_msg *PPdata = pingpong_PP_fixed_msg__alloc ();
exp_condition = PP_fixed_sc;
active_handler = &PP_fixed_handler;
PPdata->count = 0;
PPdata->block = block;
PPdata->a_bstring = DDS_string_dup ("a_bstring");
preWriteTime = timeGet ();
pingpong_PP_fixed_msgDataWriter_write (PP_fixed_writer, PPdata, DDS_HANDLE_NIL);
postWriteTime = timeGet ();
DDS_free (PPdata);
}
break;
case 'a':
{
/* printf ("PING: sending initial ping_array\n"); */
pingpong_PP_array_msg *PPdata = pingpong_PP_array_msg__alloc ();
exp_condition = PP_array_sc;
active_handler = &PP_array_handler;
PPdata->count = 0;
PPdata->block = block;
preWriteTime = timeGet ();
pingpong_PP_array_msgDataWriter_write (PP_array_writer, PPdata, DDS_HANDLE_NIL);
postWriteTime = timeGet ();
DDS_free (PPdata);
}
break;
case 'b':
{
/* printf ("PING: sending initial ping_bseq_msg\n"); */
pingpong_PP_bseq_msg *PPdata = pingpong_PP_bseq_msg__alloc ();
exp_condition = PP_bseq_sc;
active_handler = &PP_bseq_handler;
PPdata->count = 0;
PPdata->block = block;
preWriteTime = timeGet ();
pingpong_PP_bseq_msgDataWriter_write (PP_bseq_writer, PPdata, DDS_HANDLE_NIL);
postWriteTime = timeGet ();
DDS_free (PPdata);
}
break;
case 't':
{
/* printf ("PING: sending initial ping_quit\n"); */
pingpong_PP_quit_msg *PPdata = pingpong_PP_quit_msg__alloc();
PPdata->quit = TRUE;
terminate = TRUE;
finish_flag = TRUE;
sleep(1);
preWriteTime = timeGet ();
pingpong_PP_quit_msgDataWriter_write (PP_quit_writer, PPdata, DDS_HANDLE_NIL);
postWriteTime = timeGet ();
sleep(1);
DDS_free (PPdata);
}
break;
default:
printf("Invalid topic-id\n");
exit(1);
}
if (!terminate) {
roundTripTime = preWriteTime;
add_stats (&write_access, 1E6 * timeToReal (timeSub (postWriteTime, preWriteTime)));
/*
* Wait for response, calculate timing, and send another data if not ready
*/
while (!(timeout_flag || finish_flag)) {
conditionList = DDS_ConditionSeq__alloc();
result = DDS_WaitSet_wait (w, conditionList, &wait_timeout);
if(result == DDS_RETCODE_OK || result == DDS_RETCODE_NO_DATA || result == DDS_RETCODE_TIMEOUT)
{
if (conditionList) {
imax = conditionList->_length;
if (imax != 0) {
for (i = 0; i < imax; i++) {
if (conditionList->_buffer[i] == exp_condition) {
finish_flag = active_handler (nof_cycles);
} else {
printf ("PING: unexpected condition triggered: %lx\n",
(unsigned long)conditionList->_buffer[i]);
}
}
} else {
printf ("PING: TIMEOUT - message lost\n");
timeout_flag = TRUE;
}
DDS_free(conditionList);
} else {
printf ("PING: TIMEOUT - message lost\n");
timeout_flag = TRUE;
}
} else
{
printf ("PING: Waitset wait failed (code %d), terminating.\n", result);
finish_flag = TRUE;
terminate = TRUE;
}
}
}
}
if (!terminate) {
finish_flag = FALSE;
if (block == 0) {
printf ("# PING PONG measurements (in us) \n");
printf ("# Roundtrip time [us] Write-access time [us] Read-access time [us]\n");
printf ("# Block Count mean min max Count mean min max Count mean min max\n");
}
printf ("%6d %10d %6.0f %6.0f %6.0f %10d %6.0f %6.0f %6.0f %10d %6.0f %6.0f %6.0f\n",
block,
roundtrip.count,
roundtrip.average,
roundtrip.min,
roundtrip.max,
write_access.count,
write_access.average,
write_access.min,
write_access.max,
read_access.count,
read_access.average,
read_access.min,
read_access.max);
fflush (stdout);
init_stats (&write_access, "write_access");
init_stats (&read_access, "read_access");
init_stats (&roundtrip, "round_trip");
}
}
DDS_Subscriber_delete_datareader (s, PP_min_reader);
DDS_Publisher_delete_datawriter (p, PP_min_writer);
DDS_Subscriber_delete_datareader (s, PP_seq_reader);
DDS_Publisher_delete_datawriter (p, PP_seq_writer);
DDS_Subscriber_delete_datareader (s, PP_string_reader);
DDS_Publisher_delete_datawriter (p, PP_string_writer);
DDS_Subscriber_delete_datareader (s, PP_fixed_reader);
DDS_Publisher_delete_datawriter (p, PP_fixed_writer);
DDS_Subscriber_delete_datareader (s, PP_array_reader);
DDS_Publisher_delete_datawriter (p, PP_array_writer);
DDS_Subscriber_delete_datareader (s, PP_bseq_reader);
DDS_Publisher_delete_datawriter (p, PP_bseq_writer);
DDS_Publisher_delete_datawriter (p, PP_quit_writer);
DDS_DomainParticipant_delete_subscriber (dp, s);
DDS_DomainParticipant_delete_publisher (dp, p);
DDS_DomainParticipant_delete_topic (dp, PP_min_topic);
DDS_DomainParticipant_delete_topic (dp, PP_seq_topic);
DDS_DomainParticipant_delete_topic (dp, PP_string_topic);
DDS_DomainParticipant_delete_topic (dp, PP_fixed_topic);
DDS_DomainParticipant_delete_topic (dp, PP_array_topic);
DDS_DomainParticipant_delete_topic (dp, PP_bseq_topic);
DDS_DomainParticipant_delete_topic (dp, PP_quit_topic);
DDS_DomainParticipantFactory_delete_participant (dpf, dp);
DDS_free (w);
DDS_free (PP_min_dt);
DDS_free (PP_seq_dt);
DDS_free (PP_string_dt);
DDS_free (PP_fixed_dt);
DDS_free (PP_array_dt);
DDS_free (PP_bseq_dt);
DDS_free (PP_quit_dt);
DDS_free (dpQos);
DDS_free (tQos);
DDS_free (dwQos);
DDS_free (drQos);
printf ("Completed ping example\n");
fflush(stdout);
return 0;
}
