ssp_cputick.c

abstract rtos

#ifdef __cplusplus
extern "C"{
#endif

#include "syscfg.h"
#include "sys/sys_pub.h"
#include "aos.h"
#include "ssp_event.h"
#include "ssp_task.h"
#include "ssp_cputick.h"


CPU_TICK_S g_stCpuTickStart;


U32 g_ulCpuTickBase = U32_BUTT;
U64  g_cputAllowed, g_cputStarve;


CPU_TICK_S g_aTaskCpuTick_Cur [CONFIG_TASK_NUMBER];
CPU_TICK_S g_aTaskCpuTick_5s  [CONFIG_TASK_NUMBER];
CPU_TICK_S g_aTaskCpuTick_60s [CONFIG_TASK_NUMBER];
CPU_TICK_S g_aTaskCpuTick_600s[CONFIG_TASK_NUMBER];

CPU_TICK_S g_stCpuTickLast_Cur;
CPU_TICK_S g_stCpuTickLast_5s;
CPU_TICK_S g_stCpuTickLast_60s;
CPU_TICK_S g_stCpuTickLast_600s;

U32 g_aTaskPerformance_Cur [CONFIG_TASK_NUMBER];
U32 g_aTaskPerformance_5s  [CONFIG_TASK_NUMBER];
U32 g_aTaskPerformance_60s [CONFIG_TASK_NUMBER];
U32 g_aTaskPerformance_600s[CONFIG_TASK_NUMBER];

#if( CONFIG_CPU_ARM == TRUE || CONFIG_CPU_MIPS == TRUE )
extern CPU_TICK_S g_GlobalCpuTimeBase;
extern U32 g_SysCpuTimeBase;
#endif








U32 m_cputick_init()
{    
    aos_cputick_get(&g_stCpuTickStart);
    g_ulCpuTickBase = 0;

    aos_memzero((VOID *)g_aTaskCpuTick_Cur ,CONFIG_TASK_NUMBER*sizeof(CPU_TICK_S));
    aos_memzero((VOID *)g_aTaskCpuTick_5s  ,CONFIG_TASK_NUMBER*sizeof(CPU_TICK_S));
    aos_memzero((VOID *)g_aTaskCpuTick_60s ,CONFIG_TASK_NUMBER*sizeof(CPU_TICK_S));
    aos_memzero((VOID *)g_aTaskCpuTick_600s,CONFIG_TASK_NUMBER*sizeof(CPU_TICK_S));

    aos_memzero((VOID *)g_aTaskPerformance_Cur ,CONFIG_TASK_NUMBER*sizeof(U32));
    aos_memzero((VOID *)g_aTaskPerformance_5s  ,CONFIG_TASK_NUMBER*sizeof(U32));
    aos_memzero((VOID *)g_aTaskPerformance_60s ,CONFIG_TASK_NUMBER*sizeof(U32));
    aos_memzero((VOID *)g_aTaskPerformance_600s,CONFIG_TASK_NUMBER*sizeof(U32));

    g_stCpuTickLast_Cur.ulHigh  = 0;
    g_stCpuTickLast_Cur.ulLow   = 0;
    g_stCpuTickLast_5s.ulHigh   = 0;
    g_stCpuTickLast_5s.ulLow    = 0;
    g_stCpuTickLast_60s.ulHigh  = 0;
    g_stCpuTickLast_60s.ulLow   = 0;
    g_stCpuTickLast_600s.ulHigh = 0;
    g_stCpuTickLast_600s.ulLow  = 0;
    
    return AOS_SUCC;
}








U32 aos_cputick_get(CPU_TICK_S *pstCpuTick)
{
    #if CONFIG_OS_VXWORKS
    #if( CONFIG_CPU_ARM == TRUE || CONFIG_CPU_MIPS == TRUE)
    U32 high,low;
    #endif
    #endif
    
    if(pstCpuTick == NULL)
    {
        return AOS_FAIL;
    }

    #if CONFIG_OS_WINDOWS
    pstCpuTick->ulHigh = 0;
    pstCpuTick->ulLow  = 0;

    return AOS_FAIL;
    #endif
    
    #if CONFIG_OS_VXWORKS
    #if( CONFIG_CPU_PPC == TRUE )
    
    ppc_get_time(&(pstCpuTick->ulLow),&(pstCpuTick->ulHigh));
    #elif( CONFIG_CPU_ARM == TRUE )  
    *pstCpuTick = g_GlobalCpuTimeBase;
    sysGetTimeBase( &low, &high );
    AOS_U64_ADD32( pstCpuTick, (g_SysCpuTimeBase-low)&0xffffff );
    #elif(CONFIG_CPU_MIPS == TRUE )
    *pstCpuTick = g_GlobalCpuTimeBase;
    sysGetTimeBase( &low, &high );
    AOS_U64_ADD32( pstCpuTick, (low-g_SysCpuTimeBase)&0xffffff );
    #elif( CONFIG_CPU_X86 == TRUE )   
    pstCpuTick->ulHigh = 0;
    pstCpuTick->ulLow  = 0;
    #endif

    return AOS_SUCC;
    #endif
}








U32 aos_cputick_start(CPU_TICK_S *pstCpuTick)
{
    if(pstCpuTick == NULL)
    {
        return AOS_FAIL;
    }

    pstCpuTick->ulLow  = g_stCpuTickStart.ulLow;
    pstCpuTick->ulHigh = g_stCpuTickStart.ulHigh;
    
    return AOS_SUCC;
}








U32 aos_cputick_total(CPU_TICK_S *pstCpuTick)
{
    CPU_TICK_S stStart;
    
    if(pstCpuTick == NULL)
    {
        return AOS_FAIL;
    }
    
    aos_cputick_get(pstCpuTick);
    
    aos_cputick_start(&stStart);
    
    aos_cputick_sub(pstCpuTick,&stStart);

    return AOS_SUCC;
}








U32 aos_cputick_getbase(U32 *pulCpuTickBase)
{

    if (pulCpuTickBase == NULL)
    {
        return AOS_FAIL;
    }
    
    if (g_ulCpuTickBase == 0)
    {
        return AOS_FAIL;
    }
    
    *pulCpuTickBase = g_ulCpuTickBase;

    return AOS_SUCC;
}









U32 aos_cputick_2tick(CPU_TICK_S *pstCpuTick,U32 *pulTick,U32 *pulOddment)
{
    CPU_TICK_S value;
    U32 ulCpuTickReviseVal;

    if (NULL == pstCpuTick || NULL == pulTick)
    {
        return AOS_FAIL;
    }

    if (0 == g_ulCpuTickBase)
    {
        return AOS_FAIL;
    }

    value = *pstCpuTick;
    aos_cputick_div32revise(&value,g_ulCpuTickBase,&ulCpuTickReviseVal);
    *pulTick = value.ulLow;
    if (NULL != pulOddment)
    {
        *pulOddment = ulCpuTickReviseVal;
    }

    return AOS_SUCC;
}









U32 aos_cputick_2us(CPU_TICK_S *pstCpuTick,U32 *pulSec,U32 *pulUSec)
{
    CPU_TICK_S value;    
    U32 res1,res2;

#define US_PER_TICK (1000000/CONFIG_TICKS_PER_SECOND)

    if( NULL == pstCpuTick || NULL == pulSec )
    {
        return AOS_FAIL;
    }
    if (0 == g_ulCpuTickBase)
    {
        return AOS_FAIL;
    }

    value = *pstCpuTick;
    aos_cputick_div32revise(&value,g_ulCpuTickBase,&res1);
    aos_cputick_div32revise(&value,CONFIG_TICKS_PER_SECOND,&res2);
    
    *pulSec = value.ulLow;
    if (NULL != pulUSec)
    {
		value.ulHigh = 0;
		value.ulLow  = res1;
		aos_cputick_mul32(&value,US_PER_TICK);
		aos_cputick_div32(&value, g_ulCpuTickBase);
		AOS_ASSERT( 0 == value.ulHigh );

        *pulUSec = res2*US_PER_TICK + value.ulLow;
    }

    return AOS_SUCC;    

}








U32 aos_cputick_lshift2(CPU_TICK_S *pstCpuTick)
{
    if(pstCpuTick == NULL)
    {
        return AOS_FAIL;
    }

	pstCpuTick->ulHigh = pstCpuTick->ulHigh<<1;
	if(pstCpuTick->ulLow & 0x80000000)
	{
        pstCpuTick->ulHigh |= 0x01;
	}
    pstCpuTick->ulLow = pstCpuTick->ulLow<<1;

    return AOS_SUCC;
}








U32 aos_cputick_rshift2(CPU_TICK_S *pstCpuTick)
{
    if(pstCpuTick == NULL)
    {
        return AOS_FAIL;
    }

	pstCpuTick->ulLow = pstCpuTick->ulLow>>1;
	if((pstCpuTick->ulHigh & 0x01) == 0x01)
	{
        pstCpuTick->ulLow |= 0x80000000 ;
	}
    pstCpuTick->ulHigh = pstCpuTick->ulHigh>>1;

    return AOS_FAIL;
}









U32 aos_cputick_div32(CPU_TICK_S *pstCpuTick,U32 ul32bit)
{
    CPU_TICK_S value;
    U32 tmp;
    U32 tmphi0;
    U32 tmphi1;
    U32 tmplo0;
    U32 tmplo1;

    if((NULL == pstCpuTick) || (0 == ul32bit))
    {
        return AOS_FAIL;
    }

    if (pstCpuTick->ulHigh >= ul32bit)
    {
        value.ulHigh = pstCpuTick->ulHigh/ul32bit;
        tmp = pstCpuTick->ulHigh%ul32bit;
    }
    else
    {
        value.ulHigh = 0;
        tmp = pstCpuTick->ulHigh;
    }

    tmphi0 = U32_BUTT/ul32bit;
    tmphi1 = U32_BUTT%ul32bit;
    tmplo0 = pstCpuTick->ulLow/ul32bit;
    tmplo1 = pstCpuTick->ulLow%ul32bit;

    value.ulLow  = tmphi0*tmp + tmplo0;
    value.ulLow += ((tmphi1 + 1)*tmp + tmplo1)/ul32bit;

    if (((tmphi1 + 1)*tmp + tmplo1)%ul32bit >= ul32bit/2)
    {
        value.ulLow += 1;
    }
    
    *pstCpuTick = value;
    
    return AOS_SUCC;
}











U32 aos_cputick_div32revise(CPU_TICK_S *pstCpuTick,U32 ul32bit,U32 *pulReviseVal)
{
    CPU_TICK_S value;
    U32 tmp;
    U32 tmphi0;
    U32 tmphi1;
    U32 tmplo0;
    U32 tmplo1;

    if (NULL == pstCpuTick || 0 == ul32bit)
    {
        return AOS_FAIL;
    }

    if (pstCpuTick->ulHigh >= ul32bit)
    {
        value.ulHigh = pstCpuTick->ulHigh/ul32bit;
        tmp = pstCpuTick->ulHigh%ul32bit;
    }
    else
    {
        value.ulHigh = 0;
        tmp = pstCpuTick->ulHigh;
    }

    tmphi0 = U32_BUTT/ul32bit;
    tmphi1 = U32_BUTT%ul32bit;
    tmplo0 = pstCpuTick->ulLow/ul32bit;
    tmplo1 = pstCpuTick->ulLow%ul32bit;

    value.ulLow  = tmphi0*tmp + tmplo0;
    value.ulLow += ((tmphi1 + 1)*tmp + tmplo1)/ul32bit;

    if (NULL != pulReviseVal)
    {
        *pulReviseVal = ((tmphi1 + 1)*tmp + tmplo1)%ul32bit;
    }

    *pstCpuTick = value;
    
    return AOS_SUCC;
}









U32 aos_cputick_div64(CPU_TICK_S *pDividend,CPU_TICK_S *pDivisor)
{
    CPU_TICK_S result = {0,0};
    CPU_TICK_S temp[64];
    CPU_TICK_S tmp;
    U32 i;

    if(NULL == pDividend || NULL == pDivisor)
    {
        return AOS_FAIL;
    }

    if((0 == pDivisor->ulHigh) && 
       (0 == pDivisor->ulLow))
    {
        return AOS_FAIL;
    }

    if(aos_cputick_compare(pDividend,pDivisor) < 0)
    {
        pDividend->ulHigh = 0;
        pDividend->ulLow = 0;
        
        return AOS_SUCC;
    }

    tmp = *pDivisor;
    for(i = 0; i < 64; i++)
    {
        temp[i] = tmp;
		aos_cputick_lshift2(&tmp); 
		if(aos_cputick_compare(&tmp,pDividend) > 0)
        {
            i++;
            break;
        }
        
		if(aos_cputick_compare(&temp[i],&tmp) > 0)
        {
            i++;
            break;
        }
    }

    for( ;i > 0;i--)
    {
        if(aos_cputick_compare(&temp[i-1],pDividend) <= 0)
        {
            aos_cputick_sub(pDividend,&temp[i-1]);
            if(i > 32)
            {
                result.ulHigh |= (0x01 <<(i - 32 -1));
            }
            else
            {
                result.ulLow |= (0x01 << (i - 1));
            }
        }
    }

	*pDividend = result;

    return AOS_SUCC;
}









U32 aos_cputick_mul32(CPU_TICK_S *pstCpuTick,U32 ul32bit)
{
    CPU_TICK_S value;
    CPU_TICK_S tmpval;
    U32 count;
    U32 xbit;
    U32 record;

    if (NULL == pstCpuTick)
    {
        return AOS_FAIL;
    }

    value.ulHigh = 0;
    value.ulLow  = 0;

    for (count = 32, xbit = CPUTICK_BIT32MASK;
         count > 1;  xbit >>= 1, count--)
    {
        if (ul32bit & xbit)
        {
            record = pstCpuTick->ulLow & CPUTICK_BITNMASK(count -1);
            record >>= (32 - (count -1));
            tmpval.ulHigh = pstCpuTick->ulHigh << (count -1) | record;
            tmpval.ulLow  = pstCpuTick->ulLow << (count -1);
            aos_cputick_add(&value, &tmpval);
        }
    }

    if (ul32bit & CPUTICK_BIT01MASK)
    {
        aos_cputick_add(&value, pstCpuTick);
    }

    *pstCpuTick = value;
    
    return AOS_SUCC;
}









U32 aos_cputick_sub(CPU_TICK_S *pstMinuend,CPU_TICK_S *pstSubtrahend)
{
    if(pstMinuend == NULL || pstSubtrahend == NULL)
    {
        return AOS_FAIL;
    }
    
    if(pstMinuend->ulLow >= pstSubtrahend->ulLow)
    {
       pstMinuend->ulHigh = pstMinuend->ulHigh - pstSubtrahend->ulHigh;
    }
    else 
    {
       pstMinuend->ulHigh = pstMinuend->ulHigh - pstSubtrahend->ulHigh -1;
    }
   pstMinuend->ulLow = pstMinuend->ulLow - pstSubtrahend->ulLow;

   return AOS_SUCC;
}









U32 aos_cputick_add(CPU_TICK_S *pstSummand,CPU_TICK_S *pstAddend)
{
    if(pstSummand == NULL || pstAddend == NULL)
    {
        return AOS_FAIL;
    }
    
    if(U32_BUTT - pstAddend->ulLow < pstSummand->ulLow)
    {
        pstSummand->ulHigh = pstSummand->ulHigh + pstAddend->ulHigh + 1;
    }
    else
    {
        pstSummand->ulHigh = pstSummand->ulHigh + pstAddend->ulHigh;
    }
    pstSummand->ulLow = pstSummand->ulLow + pstAddend->ulLow;

    return AOS_SUCC;
}











S32 aos_cputick_compare(CPU_TICK_S *pstFirst,CPU_TICK_S *pstSecond)
{
	AOS_ASSERT_FUNC( (pstFirst != NULL)&&(pstSecond != NULL), return 0 );

	if(pstFirst->ulHigh == pstSecond->ulHigh)
	{
		if( pstFirst->ulLow == pstSecond->ulLow )
		{
		    return 0;
		}
		else
		{
		    return pstFirst->ulLow>pstSecond->ulLow?1:-1;
		}
	}
   	else
	{
		return pstFirst->ulHigh > pstSecond->ulHigh?1:-1;
	}
}









U32 aos_cputick_percent(CPU_TICK_S *pstCpuTick,CPU_TICK_S *pstBase)
{
    CPU_TICK_S tmp1;
    CPU_TICK_S tmp2;

    if(pstCpuTick == NULL || pstBase == NULL)
    {
        return 0;
    }
    
    tmp1 = *pstCpuTick;
    tmp2 = *pstBase;

	if((tmp1.ulHigh & 0xfe000000) == 0)
    {
        aos_cputick_mul32(&tmp1,100);
        aos_cputick_div64(&tmp1, &tmp2);
    }
    else
    {
        aos_cputick_div32(&tmp2, 1000);
        aos_cputick_div64(&tmp1, &tmp2);
        tmp1.ulLow /= 10;
    }

    if(tmp1.ulHigh > 0)
    {
        tmp1.ulLow = 100;
    }

    if(tmp1.ulLow > 100)
    {
        tmp1.ulLow = 100;
    }

    return tmp1.ulLow;
}








U32 aos_task_performance(U32 ulType)
{
    CPU_TICK_S mTick;
    CPU_TICK_S mBase;
    CPU_TICK_S mTemp;
    CPU_TICK_S *mLast, *pCurCpuTickHead;
    U32        ulTaskID;
    U32        ulPercent, *pCurTaskPercent;
    TASK_S    *pTCB;

    if((ulType != 0) && (ulType != 5) && (ulType != 60) && (ulType != 600))
    {
        return AOS_FAIL;
    }

    
    if(ulType == 0)
    {
        mLast = &g_stCpuTickLast_Cur;
        pCurCpuTickHead = &g_aTaskCpuTick_Cur[0];
        pCurTaskPercent = &g_aTaskPerformance_Cur[0];
    }
    else if(ulType == 5)
    {
        mLast = &g_stCpuTickLast_5s;
        pCurCpuTickHead = &g_aTaskCpuTick_5s[0];        
        pCurTaskPercent = &g_aTaskPerformance_5s[0];
    }
    else if(ulType == 60)
    {
        mLast = &g_stCpuTickLast_60s;
        pCurCpuTickHead = &g_aTaskCpuTick_60s[0];
        pCurTaskPercent = &g_aTaskPerformance_60s[0];
    }
    else 
    {
        mLast = &g_stCpuTickLast_600s;
        pCurCpuTickHead = &g_aTaskCpuTick_600s[0];
        pCurTaskPercent = &g_aTaskPerformance_600s[0];
    }

    if((mLast->ulHigh == 0) && (mLast->ulLow == 0))
    {
        aos_cputick_start(mLast);
    }
    
    aos_cputick_get(&mBase); 
    mTemp.ulLow  = mBase.ulLow;
    mTemp.ulHigh = mBase.ulHigh;
    aos_cputick_sub(&mBase,mLast);
    mLast->ulLow  = mTemp.ulLow;
    mLast->ulHigh = mTemp.ulHigh;

    
    for (ulTaskID = 0;ulTaskID < CONFIG_TASK_NUMBER; ulTaskID++)
    {
        ulPercent = 0;

        
        pTCB      = &(g_pstTask[ulTaskID]);
        if(TASK_STATUS_NULL != pTCB->status) 
        {
            mTick.ulLow  = pTCB->cputicktotal.ulLow;
            mTick.ulHigh = pTCB->cputicktotal.ulHigh;
            
            mTemp.ulLow  = mTick.ulLow;
            mTemp.ulHigh = mTick.ulHigh;

            mLast = pCurCpuTickHead+ulTaskID;

            
            aos_cputick_sub(&mTick,mLast);
            mLast->ulLow   = mTemp.ulLow;
            mLast->ulHigh  = mTemp.ulHigh;

                        
            ulPercent = aos_cputick_percent(&mTick,&mBase);
            if( ulPercent > 100 )
            {
                ulPercent = 100;
            }            
        }
        
        
        pCurTaskPercent[ulTaskID] = ulPercent;
    }

    return AOS_SUCC;
}











U32 aos_task_performance_get(U32 ulTaskID,
                             U32 *pulPerCur,
                             U32 *pulPer5s,
                             U32 *pulPer60s,
                             U32 *pulPer600s)
{
    if((pulPerCur  == NULL) || 
       (pulPer5s   == NULL) || 
       (pulPer60s  == NULL) || 
       (pulPer600s == NULL))
    {
        return AOS_FAIL;
    }

    if(ulTaskID >= CONFIG_TASK_NUMBER)
    {
        return AOS_FAIL;
    }

    if(g_pstTask[ulTaskID].status == TASK_STATUS_NULL)
    {
        *pulPerCur  = 0;
        *pulPer5s   = 0;
        *pulPer60s  = 0;
        *pulPer600s = 0;

        return AOS_SUCC;
    }
    
    *pulPerCur  = g_aTaskPerformance_Cur[ulTaskID];
    *pulPer5s   = g_aTaskPerformance_5s[ulTaskID];
    *pulPer60s  = g_aTaskPerformance_60s[ulTaskID];
    *pulPer600s = g_aTaskPerformance_600s[ulTaskID];

    return AOS_SUCC;
}

#ifdef __cplusplus
}
#endif