Question

我已经实现了两个单线程进程A＆amp; B有两个msg队列[单独的队列用于发送和接收]。进程A将向B发送消息并等待接收队列中的回复。

我想从进程A向进程B发送时间戳。如果进程B在10秒后收到消息，我想从进程B向A发送一个错误字符串。

准确度应该以毫秒为单位。

在我使用过程中，

  struct timespec   msg_dispatch_time;
  clock_gettime(CLOCK_REALTIME, &msg_dispatch_time);
  :
  :
  add_timestamp_in_msg(msg, msg_dispatch_time);
  :
  if (msgsnd(msqid, msg, sizeof(msg), msgflg) == -1)
      perror("msgop: msgsnd failed");

在流程B中，

  struct timespec   msg_dispatch_time;
  struct timespec  msg_receive_time;
  :
  clock_gettime(CLOCK_REALTIME, &msg_received_time);
  :
  if( !(time_diff(msg_received_time, msg_dispatch_time) >= 10 ))
      msgsnd(msqid, &sbuf, buf_length, msg_flag)
  else
  {
      /*send the error string.*/
      //msgsnd(msgid,)
  }

我的问题是，

1）如何在这里写一个time_diff函数，毫秒精度与10秒进行比较？

   if( !(time_diff(msg_received_time, msg_dispatch_time) >= 10 ))



    /********Existing time diff code******************/
  long int time_diff (struct timeval time1, struct timeval time2)
  {
      struct timeval diff, 

      if (time1.tv_usec < time2.tv_usec) {
          time1.tv_usec += 1000000;
          time1.tv_sec--;
      }
      diff.tv_usec = time1.tv_usec - time2.tv_usec;
      diff.tv_sec = time1.tv_sec - time2.tv_sec;    
      return diff.tv_sec; //return the diff in second
  }

2）在同一系统中跨进程使用clock_gettime是否合适？

Answer 1

如果您希望继续使用struct timespec类型，那么我建议使用difftime()类似struct timespec类型，即。

double difftimespec(const struct timespec after, const struct timespec before)
{
    return (double)(after.tv_sec - before.tv_sec)
         + (double)(after.tv_nsec - before.tv_nsec) / 1000000000.0;
}

但是，我认为对您的整体用例存在更好的选择。

如果您对您的程序工作到2242年感到满意，您可以使用64位有符号整数来保存自Epoch以来的纳秒数。对于二进制消息，它比struct timespec更容易处理。基本上：

#define _POSIX_C_SOURCE 200809L
#include <stdint.h>
#include <time.h>

typedef  int64_t     nstime;
#define  NSTIME_MIN  INT64_MIN
#define  NSTIME_MAX  INT64_MAX

nstime nstime_realtime(void)
{
    struct timespec  ts;

    if (clock_gettime(CLOCK_REALTIME, &ts))
        return NSTIME_MIN;

    return ((nstime)ts.tv_sec * 1000000000)
         + (nstime)ts.tv_nsec;
}

double nstime_secs(const nstime ns)
{
    return (double)ns / 1000000000.0;
}

struct timespec nstime_timespec(const nstime ns)
{
    struct timespec  ts;

    if (ns < 0) {
        ts.tv_sec = (time_t)(ns / -1000000000);
        ts.tv_nsec = -(long)((-ns) % 1000000000);
        if (ts.tv_nsec < 0L) {
            ts.tv_sec--;
            ts.tv_nsec += 1000000000L;
        }
    } else {
        ts.tv_sec = (time_t)(ns / 1000000000);
        ts.tv_nsec = (long)(ns % 1000000000);
    }
}

您可以按照您希望的方式添加和减去nstime个时间戳，它们也适用于二进制存储（尽管有字节顺序（也就是字节顺序）问题）。

（请注意，上面的代码未经测试，我认为它是公共领域/ CC0。）

使用clock_gettime()很好。 CLOCK_REALTIME和CLOCK_MONOTONIC都是系统范围的，即如果在同一物理时刻执行，则应在不同进程中报告完全相同的结果。

所有POSIXy系统都提供

CLOCK_REALTIME，但CLOCK_MONOTONIC是可选的。两者都不受夏令时变化的影响。增量NTP调整会影响两者。管理员手动更改系统时间只会影响CLOCK_REALTIME。 CLOCK_REALTIME的时期目前是1970年1月1日00:00:00，但未指定CLOCK_MONOTONIC。

就个人而言，我建议使用clock_gettime(CLOCK_REALTIME,)，因为您的应用程序可以跨群集中的进程进行通信，而不仅仅是在本地计算机上进行通信;群集节点可以使用CLOCK_MONOTONIC的不同时期。

哪个时钟应该用于linux中的进程间通信？

1 个答案: