/********************************************************** File name :Idle.c Title :Idle task for cpu load measuring Project :Hi-Mux 100 Subsystem :IDLE Date created :12 November 1996 Revision :Rev 0.0 Author :Shay Mamon & Sharon Melamed History : Description :This module contains two tasks that works in the system Idle time. 1) In initialization the tasks comute referance load when the system is unloaded. 2) Computing the current load according to the referance load. ************************************************************/ /******************* Include Files ************************/ #include "include.h" #include #include #include #include "Modules/Control/Control.h" #include "Modules/Control/MillisecTask.h" #define MAX_PRIORITY 24 #define SECOND_MAX_PRIORITY 23 #define MIN_PRIORITY 0 #define SECOND_MIN_PRIORITY 1 #define TICKS_IN_SECOND 1000 /**********************************************************/ /*#define DEBUG*/ /******************* Function Prototypes *****************/ void idle_task (UArg arg0, UArg arg1); void IDLE_statistics_task(UArg arg0, UArg arg1); static void calculate_system_load (int current_load); /**********************************************************/ /******************* Globals ***************************/ static uint32_t idle_counter; static long next_interval; /*by ticks*/ static bool first_time_after_init; static int system_load; static int Load; static int max_system_load; static int max_load; static uint32_t idle_load_table[101]; static uint32_t idle_sequence_table[11]; static uint32_t idle_max_sequence_table[11]; /**********************************************************/ Task_Handle IdleTaskHandle; Task_Handle IdleStTaskHandle; char IdleTaskName[11] = "timeKeeper"; char IdleStTaskName[11] = "timeManager"; /********************************************************** Name : IDLE_package_init Function : Initilize global vars Parameters : None Return value : None Note : None Description : Initilize global vars, sets the new interval and reset the samples number. ***********************************************************/ extern void IDLE_TASK_package_init(void) { Task_Params taskParams; Error_Block eb; /* Make sure Error_Block is initialized */ Error_init(&eb); Task_Params_init(&taskParams); system_load=0; max_load = 0; max_system_load = 0; first_time_after_init=TRUE; next_interval = 1000 /*10 mSec*/ /*TICKS_IN_SECOND*/; idle_counter=0; taskParams.instance->name = IdleTaskName; taskParams.priority = SECOND_MIN_PRIORITY; taskParams.stackSize = 512; IdleTaskHandle = Task_create((Task_FuncPtr)idle_task, &taskParams, &eb); Error_init(&eb); Task_Params_init(&taskParams); taskParams.instance->name = IdleStTaskName; taskParams.priority = MAX_PRIORITY; taskParams.stackSize = 512; IdleStTaskHandle = Task_create((Task_FuncPtr)IDLE_statistics_task, &taskParams, &eb); //if (IdleTaskHandle == NULL) { // System_printf("netOpenHook: Failed to create tcpHandler Task\n"); //} } /********************************************************** Name : idle_task Function : Task that runs on idle time Parameters : NONE Return value : None Note : None Description : This task contain one loop and each pass on the loop inc counter by 1 ***********************************************************/ void idle_task (UArg arg0, UArg arg1) { while(1) idle_counter++; } /********************************************************** Name : IDLE_statistic_task Function : Calculate the presentege of idle time Parameters : NONE Return value : None Note : None Description : This task rize every x (according to user define) seconds and calculate the presentege of idle time by comparing the idle conter when the system is load and when the system is unload. ***********************************************************/ void IDLE_statistics_task(UArg arg0, UArg arg1) { uint32_t current_load; uint32_t prev_load = 0; uint32_t old_idle_counter=0; uint32_t delta_idle_counter = 0; long time_interval; /*by ticks*/ uint32_t unload_max_count=0; //taskPrioritySet (idle_task_id ,SECOND_MAX_PRIORITY); Task_setPri(IdleTaskHandle, SECOND_MAX_PRIORITY); Task_sleep(TICKS_IN_SECOND); /* stablize the idle_task */ old_idle_counter=idle_counter; Task_sleep(TICKS_IN_SECOND); //taskPrioritySet (idle_task_id ,MIN_PRIORITY); Task_setPri(IdleTaskHandle, SECOND_MIN_PRIORITY); unload_max_count = idle_counter - old_idle_counter + ULONG_MAX; /* compute circular counter */ old_idle_counter=idle_counter; time_interval = next_interval; while(1) { Task_sleep(time_interval); delta_idle_counter = abs((uint32_t)(idle_counter - old_idle_counter + ULONG_MAX)); /* compute circular counter */ current_load = ((100 - (((delta_idle_counter/time_interval)*TICKS_IN_SECOND)/ (unload_max_count/100)))%101); if(prev_load == (current_load / 10)) { idle_sequence_table[prev_load]++; } else { if(idle_max_sequence_table[prev_load] < idle_sequence_table[prev_load]) { idle_max_sequence_table[prev_load] = idle_sequence_table[prev_load]; } idle_sequence_table[prev_load] = 0; idle_sequence_table[current_load/10] = 1; } calculate_system_load(current_load); old_idle_counter = idle_counter; time_interval = next_interval; Load=current_load; prev_load = current_load / 10; idle_load_table[Load]++; if(Load > max_load) max_load = Load; //REPORT_MSG(Load,"Real time load"); #ifdef DEBUG printf("c_ld=%d\n",Load); #endif } } void IdleTaskGetLoadTable (uint32_t *aBuffer) { memcpy (aBuffer,idle_load_table,sizeof(idle_load_table)); } uint32_t MillisecCounter = 0; uint32_t ControlCounter = 0; Void mySwitchFxn(Task_Handle from, Task_Handle to) { if (to == Control_Task_Handle) ControlCounter++; if (to == Millisecond_Task_Handle) MillisecCounter++; //idle_counter // System_printf("mySwitchFxn: from = 0x%x, to = 0x%x", from, to); } /********************************************************** Name : calculate_system_load Function : calculate the average system load Parameters : current load (int) Return value : None Note : the average resets when the number_of_load_samples = 0 Description : The function calculate and change the system load variable ***********************************************************/ static void calculate_system_load (int current_load) { static int sum_of_previous_load=0; static uint32_t number_of_load_samples; if (first_time_after_init) { first_time_after_init = FALSE; system_load = current_load; max_system_load = system_load; max_load = Load; number_of_load_samples = 1; sum_of_previous_load = current_load; } else { sum_of_previous_load = sum_of_previous_load + current_load; number_of_load_samples = number_of_load_samples + 1; system_load = ( sum_of_previous_load / number_of_load_samples); if(system_load > max_system_load) max_system_load = system_load; } } /*********************************************************** Name : IDLE_change_parameters Function : starts new statistic with new time interval Parameters : new time interval Return value : None Note : None Description : sets the new interval and reset the samples number. ***********************************************************/ extern void IDLE_change_parameters(uint32_t new_interval) { next_interval = new_interval; memset(idle_load_table,0,sizeof(idle_load_table)); memset(idle_max_sequence_table,0,sizeof(idle_max_sequence_table)); memset(idle_sequence_table,0,sizeof(idle_sequence_table)); first_time_after_init=TRUE; /* reset the avarage calculation */ } /********************************************************** Name : IDEL_get_load Function : returns the system load Parameters : None Return value : system load Note : External function Description : Trivial ***********************************************************/ extern int IDLE_TASK_get_load(void) { return system_load; } /***********************************************************/ extern int IDLE_TASK_get_current_load(void) { return Load; } /***********************************************************/ /*export MN_uint32_t mn_get_load(char *pParams) { int i; MN_printf("\n\r\n\rSystem load\n\r-------------"); for(i=0;i<10;i++) MN_printf("\n\r %3d-%-3d Max Continuous Load is %4d intervals = %5d mSec", i*10, (i * 10 + 9),idle_max_sequence_table[i], 10*next_interval*idle_max_sequence_table[i]); MN_printf("\n\r %3d Max Continuous Load is %4d intervals = %5d mSec", (i * 10),idle_max_sequence_table[i], 10*next_interval*idle_max_sequence_table[i]); MN_printf("\n\r\n\rSystem avarege load=%d , max avarege load = %d",system_load, max_system_load); return(RET_OK); }*/ /***********************************************************/ /*export MN_uint32_t mn_get_curent_load(char *pParams) { MN_printf("\n\rload=%d,max Load=%d", Load, max_load); return(RET_OK); } */ /***********************************************************/ /*export MN_uint32_t mn_get_load_table(char *pParams) { int i; uint32_t interval_count; uint32_t avarege; int total_avarege; interval_count = 0; total_avarege = 0; MN_printf("\n\ridle_load_table\n\r---------------\n\r"); for ( i=0;i<=100;i++) { interval_count+=idle_load_table[i]; } for ( i=0;i<=100;i++) { avarege = (100*idle_load_table[i])/interval_count; MN_printf("|%3d-%-7d(%-2d)", i, idle_load_table[i], avarege); total_avarege+=(idle_load_table[i]*i); taskDelay(2); } total_avarege = total_avarege/interval_count; MN_printf("\n\rTotal avarege = %ld",total_avarege); return(RET_OK); } */ /***********************************************************/ /*export MN_uint32_t mn_change_interval(char *pParams) { MN_uint32_t rc; MN_WORD new_interval; MN_WORD index; index = 0; rc = MN_ParseWord(pParams ,&index ,&new_interval); if(rc == RET_OK) { IDLE_change_parameters((long)new_interval); } else { MN_printf("\r\nrc = %d Illegal parameter" ,rc); } return(RET_OK); }*/ /***********************************************************/ /*extern uint32_t IDLE_TASK_monitor_init(void) { MN_uint32_t rc=RET_OK; MN_WORD idleMenuEntry; rc|=MN_BindMenu("Idle_task menu","Monitor system load",&idleMenuEntry); rc|=MN_BindCommand("GetCurLoad",idleMenuEntry,mn_get_curent_load,"GetCurLoad - Get Curent System CPU load\r\nGetCurLoad "); rc|=MN_BindCommand("GetLoad",idleMenuEntry,mn_get_load,"GetLoad - Get averege system load (since last time you changed interval or since initiation)\r\nGetLoad "); rc|=MN_BindCommand("IdleTbl",idleMenuEntry,mn_get_load_table,"IdleTbl - Get load table(since last time you changed interval or since initiation)\r\nGetLoad "); rc|=MN_BindCommand("ChangeInt",idleMenuEntry,mn_change_interval,"ChangeInt - change interval of system load chack\r\nChangeInterval "); return(RET_OK); } */