time measurement

Ehsan,

To measure latency from a publisher to a subscriber, you can do two different ways if pub/sub entities are located in different machines like your case. 
The main issue is that time is not synchronized in different machines.

First, you can use Precise Time Protocol (PTP) to synchronize time on both machines, which guarantees more accurate time synchronization than NTP. 
If you are using Ubuntu machines, it is easy to install and run on your machines like following. It uses multicast as a default, but if your network does not support multicast, you can use unicast option too. 
# apt-get install ptpd
# ptpd

After installing PTP, what you can do is to get a timestamp on a publisher and stores the timestamp value in your message and send it to a subscriber.
In the subscriber, you can get a timestamp like the publisher and extract the timestamp value of the publisher from the received message and calculate latency with two timestamp values. 

Second, you can measure round-trip time of a message and half the time to measure one-way latency. In this case, you do not need to synchronize time between machines as you use tiemstamps on a single machine. 
RTI DDS Performance Test measures the time in this way. You can refer to this link to try it out. 
https://community.rti.com/kb/example-performance-test-rti-message-service

Thanks,
Kyoungho

Hi Ehsan,

I assume that your work is based on the ordered presentation group example in this link.
https://community.rti.com/examples/ordered-presentation-group

If so, the way to access variables in each type is simple like following. 

ordered_group data;
// skip the code to take data from a DataReader
if (info.valid_data) {  
  int x = data.msg1.x;
  int y = data.msg1.y;  
}    

I am not sure this would be an answer to your question. Please let me know if it was not the question you were asking. 
Could I ask you one thing? For me, It looks like all 3 types (Type1, Type2, Type3) are the same. Why would you have three different types that define the same thing?

Thanks,
Kyoungho

Hello,

Can you describe your publishing scenario a little more?  This may help with a better response to achieve what you are looking for.    Are you publishing each message type independently?  Do you need them grouped together for coherent access?  Have you thought about having a different type that has the following structure:

struct msg {

string type;  //@key

string message; //@key

long var1;

long var2;

};

That way you don't have the msg types that are in the payload that aren't being populated.  You can just collect all messages from all types and have independent history on a per type basis.

Bert

If each DataWriter does not use variables in other types, here is my suggestion. 

struct Y1 {
   unsigned short bit_id;
   octet msg_class;
   unsigned long message_code;
   octet t_mode;
   octet msg_text[64];
   octet msg_text_length;
};
 
struct Z1 {
   // define like Y1  
};
 
struct Z2 {
   // define like Y1 
};  

instance1 = Y1TypeSupport::create_data();
instance2 = Z1TypeSupport::create_data();
instance3 = Z2TypeSupport::create_data();

instance1->bit_id = 0;
// fill up data for Y1
writer1->write (*instance1, instance_handle);        

for(i=0; i<MyDataReaders.length(); i++){

shouldn't that be

for (i = 0; i < MyDataReaders.length(); i += 3) {

(from inspection, it looks like your MyDataReaders array is a 3 column, flat multi-dimensional array).

Hi,

call me rip. 

Here's another problem:

        ordered_group_reader3 =
                bite_iam_reply_tDataReader::narrow(MyDataReaders.get_at(i+2));
       if (ordered_group_reader2 == NULL) {
            printf("DataReader narrow error\n");
            MyDataReaders.ensure_length(0,0);            
            subscriber->end_access();
            return;
        }

cut+paste error.

    // Assumption is that the array is laid out like
    // [i] msg reader
    // [i+1] cmd reader
    // [i+2] reply reader
    // so increment i by 3 each loop.
    for (i = 0; i < MyDataReaders.length(); i += 3) {
        printf("Loop start, i=%d\n", i);
   
        DDS_SampleInfo msgInfo, cmdInfo, replyInfo;
        DDS_Retcode_t  msgRetcode, cmdRetcode, replyRetcode

        bite_msg_tDataReader *goreader_msg = NULL;
        bite_msg_t     msgData;
   
        bite_iam_cmd_tDataReader *goreader_cmd = NULL;
        bite_iam_cmd_t cmdData;

        bite_iam_reply_tDataReader *goreader_reply = NULL;
        bite_iam_reply_t replyData;

        bite_msg_t_initialize(&msgData);
        bite_iam_cmd_t_initialize(&cmdData);
        bite_iam_reply_t_initialize(&replyData);

        goreader_msg =
            bite_msg_tDataReader::narrow(MyDataReaders.get_at(i));
        if (goreader_msg == NULL) {
            printf("msg DataReader narrow error\n");
            MyDataReaders.ensure_length(0,0);
            subscriber->end_access();
            return;
        }

        goreader_cmd =
            bite_iam_cmd_tDataReader::narrow(MyDataReaders.get_at(i+1));
        if (goreader_cmd == NULL) {
            printf("cmd DataReader narrow error\n");
            MyDataReaders.ensure_length(0,0);
            subscriber->end_access();
            return;
        }

        goreader_reply =
            bite_iam_reply_tDataReader::narrow(MyDataReaders.get_at(i+2));
        if (goreader_reply == NULL) {
            printf("reply DataReader narrow error\n");
            MyDataReaders.ensure_length(0,0);
            subscriber->end_access();
            return;
        }

        // group ordered access, assume if you receive on_data_available,
        // then all have data
        // in any case, if you 'continue' out of this loop early, the
        // untaken samples after may interfere with follow on reads?
        msgRetcode = goreader_msg->take_next_sample(msgData, msgInfo);
        cmdRetcode = goreader_cmd->take_next_sample(cmdData, cmdInfo);
        replyRetcode = goreader_reply->take_next_sample(replyData, replyInfo);

        if (msgRetcode == DDS_RETCODE_NO_DATA) {
            continue;
        } else if (msgRetcode != DDS_RETCODE_OK) {
            printf("msg: take error %d\n", msgRetcode);
            continue;
        }

        if (cmdRetcode == DDS_RETCODE_NO_DATA) {
            printf("cmd: msg has, but cmd does not have, data?\n", cmdRetcode);
            continue;
        } else if (cmdRetcode != DDS_RETCODE_OK) {
            printf("cmd: take error %d\n", cmdRetcode);
            continue;
        }

        if (replyRetcode == DDS_RETCODE_NO_DATA) {
            printf("reply: msg,cmd have, but reply does not have, data?\n", cmdRetcode);
            continue;
        } else if (replyRetcode != DDS_RETCODE_OK) {
            printf("reply: take error %d\n", replyRetcode);
            continue;
        }

        /* Print data sample */
        if (msgInfo.valid_data) {
            bite_msg_tTypeSupport::print_data(&msgData);
        }
        if (cmdInfo.valid_data) {
            bite_iam_cmd_tTypeSupport::print_data(&cmdData);
        }
        if (replyInfo.valid_data) {
            bite_iam_reply_tTypeSupport::print_data(&replyData);
        }
    }
    MyDataReaders.ensure_length(0,0);

    subscriber->end_access();

I replaced all the index numbers with names so that I wouldn't get confused about what was what.  Can you please inject that snippit into your code and test it.  NOTE: I do not write c or c++ everyday, so I may have added some other errors here and there, you may need to debug the code a bit to get it to compile and/or run.

Although it was a logical error in the code, I don't think the previous comment was the problem.  Can you please supply the output from the run using this rewritten code.

I think the reason why the ordered group example uses the "for loop" is that it uses the same type for 3 data readers. However, because you made up 3 different data types and you already have the code for 3 data readers for 3 different data types, I don't think you need the "for loop" anymore.. Would you try it again with removing the loop? 

Thanks,
Kyoungho

Regarding your question about a subscriber for multiple data wirters, you can have a subscriber for multiple readers and writers anywhere regardless of using ordered group QoS. I think the ordered group QoS can be used if you want to guarantee ordering of samples of grouped data writers and data readers. 

I see. For testing purpose, let's use a hard coding way like following for indexing data readers. 

ordered_group_reader = bite_msg_tDataReader::narrow(MyDataReaders.get_at(0));

ordered_group_reader2 = bite_iam_cmd_tDataReader::narrow(MyDataReaders.get_at(1));

ordered_group_reader3 = bite_iam_reply_tDataReader::narrow(MyDataReaders.get_at(2));

Would you attach your source code (idl file, publisher, subscirber) here if possible? 

I modified the subscirber code and it works. Please see the attached. I keep the for loop, and add if statement for different typed data readers. 

Hello,

I am using Deadline, Lifespan, Reliability, Durability, Liveliness, Source Redundancy (Ownership) policies and I am implementing it on a CAN protocol which has a Publisher and a Subscriber. Can anyone please let me know how I can generate timestamps, Time synchronization between Pub/Sub and also Acknowledgement mechanisms I can use in order to implement Reliability and others. Also Source redundancy mechanisms. I will be working with virtual can interfaces for now.