cpu_usage.h

Go to the documentation of this file.

#ifndef _CPU_USAGE_H_
#define _CPU_USAGE_H_



// **************************************************************************
// the includes
#include <math.h>

#include "sw/modules/types/src/types.h"






#ifdef __cplusplus
extern "C" {
#endif


// **************************************************************************
// the defines


// **************************************************************************
// the typedefs

typedef struct _CPU_USAGE_Obj_
{
  uint32_t          timerPeriod_cnts;      
  uint32_t          cnt_z0;                
  uint32_t          cnt_z1;                
  uint32_t          deltaCnt;              

  uint32_t          deltaCntAcc;           
  uint32_t          deltaCntAccNum;           
  uint32_t          deltaCntAccNumMax;        

  uint32_t          minDeltaCntObserved;   
  uint32_t          avgDeltaCntObserved;   
  uint32_t          maxDeltaCntObserved;   
  
  bool              flag_resetStats;       
} CPU_USAGE_Obj;


typedef struct _CPU_USAGE_Obj_ *CPU_USAGE_Handle;


// **************************************************************************
// the globals


// **************************************************************************
// the function prototypes


static inline uint32_t CPU_USAGE_getTimerPeriod(CPU_USAGE_Handle handle)
{
  CPU_USAGE_Obj *obj = (CPU_USAGE_Obj *)handle;

  return(obj->timerPeriod_cnts);
} // end of CPU_USAGE_getTimerPeriod() function


static inline uint32_t CPU_USAGE_getCnt_z0(CPU_USAGE_Handle handle)
{
  CPU_USAGE_Obj *obj = (CPU_USAGE_Obj *)handle;

  return(obj->cnt_z0);
} // end of CPU_USAGE_getCnt_z0() function


static inline uint32_t CPU_USAGE_getCnt_z1(CPU_USAGE_Handle handle)
{
  CPU_USAGE_Obj *obj = (CPU_USAGE_Obj *)handle;

  return(obj->cnt_z1);
} // end of CPU_USAGE_getCnt_z1() function


static inline uint32_t CPU_USAGE_getDeltaCnt(CPU_USAGE_Handle handle)
{
  CPU_USAGE_Obj *obj = (CPU_USAGE_Obj *)handle;

  return(obj->deltaCnt);
} // end of CPU_USAGE_getDeltaCnt() function


static inline uint32_t CPU_USAGE_getDeltaCntAcc(CPU_USAGE_Handle handle)
{
  CPU_USAGE_Obj *obj = (CPU_USAGE_Obj *)handle;

  return(obj->deltaCntAcc);
} // end of CPU_USAGE_getDeltaCntAcc() function


static inline uint32_t CPU_USAGE_getDeltaCntAccNum(CPU_USAGE_Handle handle)
{
  CPU_USAGE_Obj *obj = (CPU_USAGE_Obj *)handle;

  return(obj->deltaCntAccNum);
} // end of CPU_USAGE_getDeltaCntAccNum() function


static inline uint32_t CPU_USAGE_getDeltaCntAccNumMax(CPU_USAGE_Handle handle)
{
  CPU_USAGE_Obj *obj = (CPU_USAGE_Obj *)handle;

  return(obj->deltaCntAccNumMax);
} // end of CPU_USAGE_getDeltaCntAccNumMax() function


static inline uint32_t CPU_USAGE_getMinDeltaCntObserved(CPU_USAGE_Handle handle)
{
  CPU_USAGE_Obj *obj = (CPU_USAGE_Obj *)handle;

  return(obj->minDeltaCntObserved);
} // end of CPU_USAGE_getMinDeltaCntObserved() function


static inline uint32_t CPU_USAGE_getAvgDeltaCntObserved(CPU_USAGE_Handle handle)
{
  CPU_USAGE_Obj *obj = (CPU_USAGE_Obj *)handle;

  return(obj->avgDeltaCntObserved);
} // end of CPU_USAGE_getAvgDeltaCntObserved() function


static inline uint32_t CPU_USAGE_getMaxDeltaCntObserved(CPU_USAGE_Handle handle)
{
  CPU_USAGE_Obj *obj = (CPU_USAGE_Obj *)handle;

  return(obj->maxDeltaCntObserved);
} // end of CPU_USAGE_getMaxDeltaCntObserved() function


static inline bool CPU_USAGE_getFlag_resetStats(CPU_USAGE_Handle handle)
{
  CPU_USAGE_Obj *obj = (CPU_USAGE_Obj *)handle;

  return(obj->flag_resetStats);
} // end of CPU_USAGE_getFlag_resetStats() function


extern CPU_USAGE_Handle CPU_USAGE_init(void *pMemory,const size_t numBytes);


static inline void CPU_USAGE_setTimerPeriod(CPU_USAGE_Handle handle,const uint32_t timerPeriod_cnts)
{
  CPU_USAGE_Obj *obj = (CPU_USAGE_Obj *)handle;

  obj->timerPeriod_cnts = timerPeriod_cnts;

  return;
} // end of CPU_USAGE_setTimerPeriod() function


static inline void CPU_USAGE_setCnt_z0(CPU_USAGE_Handle handle,const uint32_t cnt)
{
  CPU_USAGE_Obj *obj = (CPU_USAGE_Obj *)handle;

  obj->cnt_z0 = cnt;

  return;
} // end of CPU_USAGE_setCnt_z0() function


static inline void CPU_USAGE_setCnt_z1(CPU_USAGE_Handle handle,const uint32_t cnt)
{
  CPU_USAGE_Obj *obj = (CPU_USAGE_Obj *)handle;

  obj->cnt_z1 = cnt;

  return;
} // end of CPU_USAGE_setCnt_z1() function


static inline void CPU_USAGE_setDeltaCnt(CPU_USAGE_Handle handle,const uint32_t deltaCnt)
{
  CPU_USAGE_Obj *obj = (CPU_USAGE_Obj *)handle;

  obj->deltaCnt = deltaCnt;

  return;
} // end of CPU_USAGE_setDeltaCnt() function


static inline void CPU_USAGE_setDeltaCntAcc(CPU_USAGE_Handle handle,const uint32_t deltaCntAcc)
{
  CPU_USAGE_Obj *obj = (CPU_USAGE_Obj *)handle;

  obj->deltaCntAcc = deltaCntAcc;

  return;
} // end of CPU_USAGE_setDeltaCntAcc() function


static inline void CPU_USAGE_setDeltaCntAccNum(CPU_USAGE_Handle handle,const uint32_t deltaCntAccNum)
{
  CPU_USAGE_Obj *obj = (CPU_USAGE_Obj *)handle;

  obj->deltaCntAccNum = deltaCntAccNum;

  return;
} // end of CPU_USAGE_setDeltaCntAccNum() function


static inline void CPU_USAGE_setDeltaCntAccNumMax(CPU_USAGE_Handle handle,const uint32_t deltaCntAccNumMax)
{
  CPU_USAGE_Obj *obj = (CPU_USAGE_Obj *)handle;

  obj->deltaCntAccNumMax = deltaCntAccNumMax;

  return;
} // end of CPU_USAGE_setDeltaCntAccNumMax() function


static inline void CPU_USAGE_setMinDeltaCntObserved(CPU_USAGE_Handle handle,const uint32_t minDeltaCnt)
{
  CPU_USAGE_Obj *obj = (CPU_USAGE_Obj *)handle;

  obj->minDeltaCntObserved = minDeltaCnt;

  return;
} // end of CPU_USAGE_setMinDeltaCntObserved() function


static inline void CPU_USAGE_setAvgDeltaCntObserved(CPU_USAGE_Handle handle,const uint32_t avgDeltaCnt)
{
  CPU_USAGE_Obj *obj = (CPU_USAGE_Obj *)handle;

  obj->avgDeltaCntObserved = avgDeltaCnt;

  return;
} // end of CPU_USAGE_setAvgDeltaCntObserved() function


static inline void CPU_USAGE_setMaxDeltaCntObserved(CPU_USAGE_Handle handle,const uint32_t maxDeltaCnt)
{
  CPU_USAGE_Obj *obj = (CPU_USAGE_Obj *)handle;

  obj->maxDeltaCntObserved = maxDeltaCnt;

  return;
} // end of CPU_USAGE_setMaxDeltaCntObserved() function


static inline void CPU_USAGE_setFlag_resetStats(CPU_USAGE_Handle handle,const bool state)
{
  CPU_USAGE_Obj *obj = (CPU_USAGE_Obj *)handle;

  obj->flag_resetStats = state;

  return;
} // end of CPU_USAGE_setFlag_resetStats() function


void CPU_USAGE_setParams(CPU_USAGE_Handle handle,
                         const uint32_t timerPeriod_cnts,
                         const uint32_t numDeltaCntsAvg);


static inline void CPU_USAGE_run(CPU_USAGE_Handle handle)
{
  uint32_t timerPeriod = CPU_USAGE_getTimerPeriod(handle);
  uint32_t minDeltaCntObserved = CPU_USAGE_getMinDeltaCntObserved(handle);
  uint32_t avgDeltaCntObserved = CPU_USAGE_getAvgDeltaCntObserved(handle);
  uint32_t maxDeltaCntObserved = CPU_USAGE_getMaxDeltaCntObserved(handle);
  uint32_t deltaCntAcc = CPU_USAGE_getDeltaCntAcc(handle);
  uint32_t deltaCntAccNum = CPU_USAGE_getDeltaCntAccNum(handle);
  uint32_t deltaCntAccNumMax = CPU_USAGE_getDeltaCntAccNumMax(handle);
  uint32_t cnt_z0 = CPU_USAGE_getCnt_z0(handle);
  uint32_t cnt_z1 = CPU_USAGE_getCnt_z1(handle);

  bool flag_resetStats = CPU_USAGE_getFlag_resetStats(handle);

  uint32_t deltaCnt;


  // compute the actual delta counts
  // handle wrap around of the timer count
  // NOTE: count down timer
  if(cnt_z0 > cnt_z1)
    {
      deltaCnt = cnt_z1 + timerPeriod - cnt_z0 + 1;
    }
  else
    {
      deltaCnt = cnt_z1 - cnt_z0 + 1;
    }

  // accumulate delta counts for the average calculation
  deltaCntAcc += deltaCnt;

  // increment the number of accumulations
  deltaCntAccNum++;
  
  // calculate average counts if number of accumulations matches the max number
  if(deltaCntAccNum >= deltaCntAccNumMax)
    {
      // compute the average
      avgDeltaCntObserved = deltaCntAcc/deltaCntAccNum;

      // reset accumulation and number of accumulations
      deltaCntAcc = 0;
      deltaCntAccNum = 0;
        }


  // keep track of the minimum delta count observed
  if(deltaCnt < minDeltaCntObserved)
    {
      minDeltaCntObserved = deltaCnt;
    }

  // keep track of the maximum delta count observed
  if(deltaCnt > maxDeltaCntObserved)
    {
      maxDeltaCntObserved = deltaCnt;
    }

  // reset statistics if reset flag is true
  if(flag_resetStats == true)
    {
      cnt_z0 = 0;
      cnt_z1 = 0;
      deltaCnt = 0;

      deltaCntAcc = 0;
      deltaCntAccNum = 0;

      minDeltaCntObserved = timerPeriod;
      avgDeltaCntObserved = 0;
      maxDeltaCntObserved = 0;

      flag_resetStats = false;
    }
          

  // store the values
  CPU_USAGE_setDeltaCnt(handle,deltaCnt);
  CPU_USAGE_setDeltaCntAcc(handle,deltaCntAcc);
  CPU_USAGE_setDeltaCntAccNum(handle,deltaCntAccNum);
  CPU_USAGE_setMinDeltaCntObserved(handle,minDeltaCntObserved);
  CPU_USAGE_setAvgDeltaCntObserved(handle,avgDeltaCntObserved);
  CPU_USAGE_setMaxDeltaCntObserved(handle,maxDeltaCntObserved);
  CPU_USAGE_setFlag_resetStats(handle, flag_resetStats);


  return;
} // end of FEM_run() function


static inline void CPU_USAGE_updateCnts(CPU_USAGE_Handle handle,const uint32_t cnt)
{
  uint32_t cnt_z0 = CPU_USAGE_getCnt_z0(handle);

  CPU_USAGE_setCnt_z1(handle,cnt_z0);
  CPU_USAGE_setCnt_z0(handle,cnt);

  return;
} // end of CPU_USAGE_updateCnts() function


#ifdef __cplusplus
}
#endif // extern "C"


#endif // end of _CPU_USAGE_H_ definition