cmp_time_util.c

Go to the documentation of this file.

/**************************************************************************
 *
 *  $Id: cmp_time_util.c 1.3 2018/12/11 12:01:03 martin REL_M $
 *
 *  Copyright (c) Meinberg Funkuhren, Bad Pyrmont, Germany
 *
 *  Description:
 *    Common device time compare utility functions.
 *
 * -----------------------------------------------------------------------
 *  $Log: cmp_time_util.c $
 *  Revision 1.3  2018/12/11 12:01:03  martin
 *  Fixed compiler warnings on Windows.
 *  Revision 1.2  2018/08/08 08:22:23Z  martin
 *  New function mbg_snprint_hr_time_loc().
 *  Account for renamed library symbols.
 *  Removed obsolete code.
 *  Revision 1.1  2013/07/25 10:42:59  martin
 *  Initial revision.
 *
 **************************************************************************/

#define _CMP_TIME_UTIL
  #include <cmp_time_util.h>
#undef _CMP_TIME_UTIL

#include <mbgdevio.h>
#include <mbgutil.h>
#include <pcpsutil.h>
#include <str_util.h>

#include <toolutil.h>   // for mbg_snprint_hr_tstamp(). FIXME: use function from mbgutil library

#include <stdio.h>


extern MBG_PC_CYCLES_FREQUENCY cyc_freq;  



/*HDR*/
int chk_fast_tstamp_supp( MBG_DEV_HANDLE dh1, const PCPS_DEV *p_dev_1,
                          MBG_DEV_HANDLE dh2, const PCPS_DEV *p_dev_2,
                          MBG_ERR_MSG_FNC err_msg_fnc )
{
  int rc;
  const char n_supp_msg[] = "fast (memory mapped) time stamps";

  rc = chk_feat_supp( dh1, p_dev_1, mbg_chk_dev_has_fast_hr_timestamp,
                      err_msg_fnc, n_supp_msg );

  if ( mbg_rc_is_success( rc ) )
    rc = chk_feat_supp( dh2, p_dev_2, mbg_chk_dev_has_fast_hr_timestamp,
                        err_msg_fnc, n_supp_msg );
  return rc;

}  // chk_fast_tstamp_supp



/*HDR*/
int get_htc_timestamps( MBG_DEV_HANDLE dh1, PCPS_HR_TIME_CYCLES *p_htc1,
                        MBG_DEV_HANDLE dh2, PCPS_HR_TIME_CYCLES *p_htc2,
                        int read_fast )
{
  int rc;

  if ( read_fast )
  {
    PCPS_TIME_STAMP_CYCLES ts_c1;
    PCPS_TIME_STAMP_CYCLES ts_c2;

    rc = mbg_get_fast_hr_timestamp_cycles( dh1, &ts_c1 );

    if ( mbg_cond_err_msg( rc, "mbg_get_fast_hr_timestamp_cycles 1" ) )
      goto done;

    rc = mbg_get_fast_hr_timestamp_cycles( dh2, &ts_c2 );

    if ( mbg_cond_err_msg( rc, "mbg_get_fast_hr_timestamp_cycles 2" ) )
      goto done;

    setup_hr_time_cycles_from_timestamp_cycles( p_htc1, &ts_c1 );
    setup_hr_time_cycles_from_timestamp_cycles( p_htc2, &ts_c2 );
  }
  else
  {
    rc = mbg_get_hr_time_cycles( dh1, p_htc1 );

    if ( mbg_cond_err_msg( rc, "mbg_get_hr_time_cycles 1" ) )
      goto done;

    rc = mbg_get_hr_time_cycles( dh2, p_htc2 );

    if ( mbg_cond_err_msg( rc, "mbg_get_hr_time_cycles 2" ) )
      goto done;
  }

done:
  return rc;

}  // get_htc_timestamps



/*HDR*/
double get_htc_delta( const PCPS_HR_TIME_CYCLES *p_htc,
                      const PCPS_HR_TIME_CYCLES *p_htc_ref,
                      double *p_delta_ts, double *p_delta_cyc )
{
  double delta_ts;
  double delta_cyc;

  delta_ts = (double) p_htc->t.tstamp.sec + dfrac_sec_from_bin( p_htc->t.tstamp.frac )
           - (double) p_htc_ref->t.tstamp.sec - dfrac_sec_from_bin( p_htc_ref->t.tstamp.frac );

  #if defined( MBG_TGT_WIN32 )
  {
    __int64 dt_t = p_htc->cycles - p_htc_ref->cycles;
    delta_cyc = (double) dt_t / (__int64) cyc_freq;
  }
  #else
    delta_cyc = ( (double) ( p_htc->cycles - p_htc_ref->cycles ) ) / cyc_freq;
  #endif

  if ( p_delta_ts )
    *p_delta_ts = delta_ts;

  if ( p_delta_cyc )
    *p_delta_cyc = delta_cyc;

  return delta_ts - delta_cyc;

}  // get_htc_delta



/*HDR*/
int mbg_snprint_hr_tstamp_ext( char *s, int max_len,
                               const PCPS_TIME_STAMP *p, int print_raw )
{
  int n = mbg_snprint_hr_tstamp( s, max_len, p, 0, 0 );

  if ( print_raw )
    n += snprintf( &s[n], max_len - n, " (0x%08lX.%08lX)",
                   (ulong) p->sec,
                   (ulong) p->frac );

  return n;

}  // mbg_snprint_hr_tstamp_ext



/*HDR*/
int mbg_snprint_hr_time_loc( char *s, size_t max_len, const PCPS_HR_TIME *p )
{
  size_t n = mbg_snprint_hr_tstamp( s, max_len, &p->tstamp, p->utc_offs, 0 );

  n += snprintf_safe( &s[n], max_len - n, " UTC" );

  if ( !(p->status & PCPS_UTC ) )
    n += mbg_str_pcps_hr_time_offs( &s[n], (int) ( max_len - n ), p, "" );

#if 0
  if(p->utc_offs != 0)
    n += mbg_snprintf( n, len_s - n, "(%+02luh",
                       ( pt->utc_offs < 0 ) ? '-' : '+',
                       ldt.quot, ldt.rem );
#endif

  return _int_from_size_t( n );

}  // mbg_snprint_hr_time_loc