timer.c

Go to the documentation of this file.

/*******************************************************************************
  APG Version 6.3
  Copyright (C) 2005 - 2012 Lowell D. Thomas, all rights reserved
 
  author:  Lowell D. Thomas
  email:   lowell@coasttocoastresearch.com
  website: http://www.coasttocoastresearch.com
 
  This program is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 2 of the License, or
  (at your option) any later version.
 
  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
 
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see
  <http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>
  or write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
*******************************************************************************/
#include "ApgUtilities.h"
 
typedef struct
{
  void*     vpMemCtx;
  apg_uint     uiStarted;
  double    dStartTime;
  double    dEndTime;
  double    dDuration; // milliseconds
  double    dClocksPerSec;
  void*     vpValidate;
} APG_TIMER;
void* vpTimerCtor(void* vpMemCtx)
{
  void* vpRet = NULL;
  APG_TIMER* spCtx = NULL;
  while(APG_TRUE)
  {
 
    if(!vpMemCtx){break;}
    if(!uiMemValidate(vpMemCtx)){break;}
    spCtx = (APG_TIMER*)vpMemAlloc(vpMemCtx, sizeof(APG_TIMER));
    if(!spCtx){break;}
    memset((void*)spCtx, 0, sizeof(APG_TIMER));
    spCtx->vpMemCtx = vpMemCtx;
    spCtx->dClocksPerSec = (double)CLOCKS_PER_SEC;
    spCtx->vpValidate = (void*)spCtx;
    vpRet = (void*)spCtx;
    break;
  }
  if(vpMemCtx)
  {
    if(!vpRet && spCtx){vMemFree(vpMemCtx, (void*)spCtx);}
  }
  return vpRet;
}
 
void vTimerDtor(void* vpCtx)
{
  APG_TIMER* spCtx = (APG_TIMER*)vpCtx;
  if(vpCtx && spCtx->vpValidate == vpCtx)
  {
    spCtx->vpValidate = NULL;
    vMemFree(spCtx->vpMemCtx, vpCtx);
  }
}
 
apg_uint uiTimerStart(void* vpCtx)
{
  apg_uint uiRet = APG_FALSE;
  APG_TIMER* spCtx = (APG_TIMER*)vpCtx;
  if(vpCtx && spCtx->vpValidate == vpCtx)
  {
    spCtx->dEndTime = 0.0;
    spCtx->dDuration = 0.0;
    spCtx->dStartTime = (double)clock();
    spCtx->uiStarted = APG_TRUE;
    uiRet = APG_TRUE;
  }
  return uiRet;
}
 
apg_uint uiTimerStop(void* vpCtx)
{
  apg_uint uiRet = APG_FALSE;
  APG_TIMER* spCtx = (APG_TIMER*)vpCtx;
  if(vpCtx && spCtx->vpValidate == vpCtx  && spCtx->uiStarted)
  {
    spCtx->dEndTime = (double)clock();
    spCtx->dDuration = (spCtx->dEndTime - spCtx->dStartTime) / spCtx->dClocksPerSec;
    uiRet = APG_TRUE;
  }
  return uiRet;
}
 
apg_uint uiTimerRates(void* vpCtx, double* dpRates, apg_uint uiLen, double dConversion)
{
  apg_uint uiRet = APG_FALSE;
  APG_TIMER* spCtx = (APG_TIMER*)vpCtx;
  if(vpCtx && spCtx->vpValidate == vpCtx && spCtx->dDuration != 0.0)
  {
    while(uiLen--)
    {
      if(*dpRates != 0.0)
      {
        *dpRates = *dpRates/( dConversion * spCtx->dDuration);
      }
      dpRates++;
    }
    uiRet = APG_TRUE;
  }
  return uiRet;
}
 
double dTimerStartTime(void* vpCtx, double dConversion)
{
  double dRet = 0.0;
  APG_TIMER* spCtx = (APG_TIMER*)vpCtx;
  if(vpCtx && spCtx->vpValidate == vpCtx)
  {
    dRet = dConversion * spCtx->dStartTime;
  }
  return dRet;
}
 
double dTimerStopTime(void* vpCtx, double dConversion)
{
  double dRet = 0.0;
  APG_TIMER* spCtx = (APG_TIMER*)vpCtx;
  if(vpCtx && spCtx->vpValidate == vpCtx)
  {
    dRet = dConversion * spCtx->dEndTime;
  }
  return dRet;
}
 
double dTimerDuration(void* vpCtx, double dConversion)
{
  double dRet = 0.0;
  APG_TIMER* spCtx = (APG_TIMER*)vpCtx;
  if(vpCtx && spCtx->vpValidate == vpCtx)
  {
    dRet = dConversion * spCtx->dDuration;
  }
  return dRet;
}