1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
|
/**********************************************************
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 <ti/sysbios/knl/Task.h>
#include <xdc/runtime/Error.h>
#include <xdc/runtime/System.h>
#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 <cr>");
rc|=MN_BindCommand("GetLoad",idleMenuEntry,mn_get_load,"GetLoad - Get averege system load (since last time you changed interval or since initiation)\r\nGetLoad <cr>");
rc|=MN_BindCommand("IdleTbl",idleMenuEntry,mn_get_load_table,"IdleTbl - Get load table(since last time you changed interval or since initiation)\r\nGetLoad <cr>");
rc|=MN_BindCommand("ChangeInt",idleMenuEntry,mn_change_interval,"ChangeInt - change interval of system load chack\r\nChangeInterval <New Interval in Tics (~100 in second)>");
return(RET_OK);
}
*/
|
