URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
Compare Revisions
- This comparison shows the changes necessary to convert path
/openrisc/trunk/rtos/ecos-2.0/packages/services/cpuload/v2_0
- from Rev 27 to Rev 174
- ↔ Reverse comparison
Rev 27 → Rev 174
/cdl/cpuload.cdl
0,0 → 1,73
# ==================================================================== |
# |
# cpuload.cdl |
# |
# cpu load measurements |
# |
# ==================================================================== |
#####ECOSGPLCOPYRIGHTBEGIN#### |
## ------------------------------------------- |
## This file is part of eCos, the Embedded Configurable Operating System. |
## Copyright (C) 2002 Andrew Lunn |
## |
## eCos 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 or (at your option) any later version. |
## |
## eCos 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 eCos; if not, write to the Free Software Foundation, Inc., |
## 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
## |
## As a special exception, if other files instantiate templates or use macros |
## or inline functions from this file, or you compile this file and link it |
## with other works to produce a work based on this file, this file does not |
## by itself cause the resulting work to be covered by the GNU General Public |
## License. However the source code for this file must still be made available |
## in accordance with section (3) of the GNU General Public License. |
## |
## This exception does not invalidate any other reasons why a work based on |
## this file might be covered by the GNU General Public License. |
## |
## Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. |
## at http://sources.redhat.com/ecos/ecos-license/ |
## ------------------------------------------- |
#####ECOSGPLCOPYRIGHTEND#### |
# ==================================================================== |
######DESCRIPTIONBEGIN#### |
# |
# Author(s): Andrew Lunn |
# Original data: Andrew Lunn |
# Contributors: |
# Date: 2002-08-12 |
# |
#####DESCRIPTIONEND#### |
# |
# ==================================================================== |
|
cdl_package CYGPKG_CPULOAD { |
display "Measure the current CPU load" |
requires CYGPKG_KERNEL |
requires !CYGPKG_KERNEL_SMP_SUPPORT |
include_dir cyg/cpuload |
|
compile cpuload.cxx |
description " |
This package measures the CPU load over the last 100ms, 1second |
and 10 second. All loads are returned as a percentage, ie 0-100. |
This is only a rough measure. Any clever power management, sleep |
modes etc, will cause these results to be wrong." |
doc ref/services-cpuload.html |
|
cdl_option CYGPKG_CPULOAD_TESTS { |
display "CPU load measurement tests" |
flavor data |
no_define |
calculated { "tests/cpuload" } |
} |
} |
|
/tests/cpuload.c
0,0 → 1,132
//================================================================= |
// |
// cpuload.c |
// |
// test case for the cpuload code. |
// |
//========================================================================== |
//####ECOSGPLCOPYRIGHTBEGIN#### |
// ------------------------------------------- |
// This file is part of eCos, the Embedded Configurable Operating System. |
// Copyright (C) 2002 Andrew Lunn |
// |
// eCos 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 or (at your option) any later version. |
// |
// eCos 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 eCos; if not, write to the Free Software Foundation, Inc., |
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
// |
// As a special exception, if other files instantiate templates or use macros |
// or inline functions from this file, or you compile this file and link it |
// with other works to produce a work based on this file, this file does not |
// by itself cause the resulting work to be covered by the GNU General Public |
// License. However the source code for this file must still be made available |
// in accordance with section (3) of the GNU General Public License. |
// |
// This exception does not invalidate any other reasons why a work based on |
// this file might be covered by the GNU General Public License. |
// |
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. |
// at http://sources.redhat.com/ecos/ecos-license/ |
// ------------------------------------------- |
//####ECOSGPLCOPYRIGHTEND#### |
//========================================================================== |
//#####DESCRIPTIONBEGIN#### |
// |
// Author(s): asl |
// Contributors: asl |
// Date: 2002-08-06 |
// Description: Tests the calculation code |
//####DESCRIPTIONEND#### |
|
#include <cyg/hal/hal_arch.h> |
#include <cyg/kernel/kapi.h> |
#include <cyg/infra/testcase.h> |
#include <cyg/infra/diag.h> |
#include <cyg/cpuload/cpuload.h> |
|
void |
do_test(cyg_addrword_t data) { |
cyg_uint32 calibration; |
cyg_cpuload_t cpuload; |
cyg_handle_t handle; |
cyg_uint32 average_point1s; |
cyg_uint32 average_1s; |
cyg_uint32 average_10s; |
cyg_uint32 i,j; |
|
CYG_TEST_INFO("About to calibrate cpuload"); |
|
cyg_cpuload_calibrate(&calibration); |
|
CYG_TEST_INFO("Performing 100% load test"); |
|
cyg_cpuload_create(&cpuload,calibration,&handle); |
|
/* Busy loop doing useless work. This will cause the cpu load to be |
100%. After all these iterations, check the measured load really |
is 100%. */ |
|
for (i=250; i--; ) { |
for (j=calibration*10; j-- ; ) |
; |
cyg_cpuload_get(handle,&average_point1s,&average_1s,&average_10s); |
/* diag_printf("%d %d %d\n",average_point1s,average_1s,average_10s);*/ |
} |
|
/* Rounding errors mean it will probably never reach 100% */ |
if ((average_point1s == 100) && |
(average_1s >= 99) && (average_1s <=100) && |
(average_10s >= 98) && (average_10s <= 100)) |
CYG_TEST_PASS("100% load o.k."); |
else { |
CYG_TEST_FAIL("100% load"); |
} |
|
/* Sleeping doing nothing. This will cause the cpuload to be |
0%. After all these iterations, check the measured load really is |
0%. */ |
CYG_TEST_INFO("Performing 0% load test"); |
for (i=350; i-- ; ) { |
cyg_thread_delay(10); |
cyg_cpuload_get(handle,&average_point1s,&average_1s,&average_10s); |
/* diag_printf("%d %d %d\n",average_point1s,average_1s,average_10s);*/ |
} |
|
if ((average_point1s == 0) && |
(average_1s == 0) && |
(average_10s >= 0) && (average_10s <= 2)) |
CYG_TEST_PASS_FINISH("0% load o.k."); |
else { |
CYG_TEST_FAIL_FINISH("0% load"); |
} |
} |
|
|
externC void |
cyg_start(void) { |
|
#ifdef CYGPKG_HAL_SYNTH |
|
CYG_TEST_NA("Not applicable to Synth target"); |
#else |
static char stack[CYGNUM_HAL_STACK_SIZE_MINIMUM]; |
static cyg_handle_t handle; |
static cyg_thread thread; |
|
CYG_TEST_INIT(); |
|
cyg_thread_create(4,do_test,0,"cpuload", |
stack,sizeof(stack),&handle,&thread); |
cyg_thread_resume(handle); |
|
cyg_scheduler_start(); |
#endif |
} |
/include/cpuload.h
0,0 → 1,94
//========================================================================== |
// |
// cpuload.h |
// |
// Interface for the cpuload code. |
// |
//========================================================================== |
//####ECOSGPLCOPYRIGHTBEGIN#### |
// ------------------------------------------- |
// This file is part of eCos, the Embedded Configurable Operating System. |
// Copyright (C) 2002 Andrew Lunn |
// |
// eCos 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 or (at your option) any later version. |
// |
// eCos 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 eCos; if not, write to the Free Software Foundation, Inc., |
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
// |
// As a special exception, if other files instantiate templates or use macros |
// or inline functions from this file, or you compile this file and link it |
// with other works to produce a work based on this file, this file does not |
// by itself cause the resulting work to be covered by the GNU General Public |
// License. However the source code for this file must still be made available |
// in accordance with section (3) of the GNU General Public License. |
// |
// This exception does not invalidate any other reasons why a work based on |
// this file might be covered by the GNU General Public License. |
// |
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. |
// at http://sources.redhat.com/ecos/ecos-license/ |
// ------------------------------------------- |
//####ECOSGPLCOPYRIGHTEND#### |
//========================================================================== |
//#####DESCRIPTIONBEGIN#### |
// |
// Author(s): Andrew Lunn |
// Contributors: Andrew Lunn |
// Date: 2002-08-12 |
// Purpose: |
// Description: |
// API for the cpuload measurement code |
// |
// This code is part of eCos (tm). |
// |
//####DESCRIPTIONEND#### |
// |
//========================================================================== |
|
#ifndef _SERVICES_CPULOAD_CPULOAD_H |
#define _SERVICES_CPULOAD_CPULOAD_H |
|
#ifdef __cplusplus |
externC |
{ |
#endif |
|
typedef struct cyg_cpuload_s { |
cyg_alarm alarm_s; |
cyg_handle_t alarmH; |
cyg_uint32 last_idle_loops; |
cyg_uint32 average_point1s; |
cyg_uint32 average_1s; |
cyg_uint32 average_10s; |
cyg_uint32 calibration; |
} cyg_cpuload_t; |
|
/* Calibrate the CPU load measurement code */ |
void cyg_cpuload_calibrate(cyg_uint32 *calibration); |
|
/* Create a measurement object and start the measurements */ |
void cyg_cpuload_create(cyg_cpuload_t *cpuload, |
cyg_uint32 calibrate, |
cyg_handle_t *handle); |
|
/* Stop the measurements so the object can be freed */ |
void cyg_cpuload_delete(cyg_handle_t handle); |
|
/* Get the current CPU load */ |
void cyg_cpuload_get(cyg_handle_t handle, |
cyg_uint32 *average_point1s, |
cyg_uint32 *average_1s, |
cyg_uint32 *average_10s); |
|
#ifdef __cplusplus |
} |
#endif |
#endif /* _SERVICES_CPULOAD_CPULOAD_H */ |
/doc/cpuload.sgml
0,0 → 1,149
<PART ID="services-cpuload"> |
<TITLE>CPU load measurements</TITLE> |
<PARTINTRO> |
<PARA> |
The cpuload package provides a way to estimate the cpuload. It gives |
an estimated percentage load for the last 100 milliseconds, 1 second |
and 10 seconds. |
</PARA> |
</PARTINTRO> |
<CHAPTER id="cpuload-functions"> |
<TITLE>CPU Load Measurements</TITLE> |
<SECT1 id="services-cpuload-api"> |
<TITLE>CPU Load API</TITLE> |
<para> |
The package allows the CPU load to be estimated. The measurement code |
must first be calibrated to the target it is running on. Once this |
has been performed the measurement process can be started. This is a |
continuous process, so always providing the most up to data |
measurements. The process can be stopped at any time if required. Once |
the process is active, the results can be retrieved. |
</para> |
<para> |
Note that if the target/processor performs any power saving actions, |
such as reducing the clock speed, or halting until the next interrupt |
etc, these will interfere with the CPU load measurement. Under these |
conditions the measurement results are undefined. The synthetic target |
is one such system. See the implementation details at the foot of this |
page for further information. </para> |
<para> |
SMP systems are not supported, only uniprocessor system. |
</para> |
<para> The API for load measuring functions can be |
found in the file <filename>cyg/cpuload/cpuload.h</filename>. |
</para> |
<sect2 id="services-cpuload-api-cyg-cpuload-calibrate"> |
<title>cyg_cpuload_calibrate</title> |
<para> |
This function is used to calibrate the cpu load measurement code. It |
makes a measurement to determine the CPU properties while idle. |
</para> |
<programlisting> |
void cyg_cpuload_calibrate(cyg_uint32 *calibration); |
</programlisting> |
<para> |
The function returns the calibration value at the location pointed to |
by <parameter>calibration</parameter>. |
</para> |
<para> |
This function is quite unusual. For it to work correctly a few |
conditions must be met. The function makes use of the two highest |
thread priorities. No other threads must be using these priorities |
while the function is being used. The kernel scheduler must be started |
and not disabled. The function takes 100ms to complete during which |
time no other threads will be run. |
</para> |
</sect2> |
<sect2 id="services-cpuload-api-cyg-cpuload-create"> |
<title>cyg_cpuload_create</title> |
<para> |
This function starts the CPU load measurments. |
</para> |
<programlisting> |
void cyg_cpuload_create(cyg_cpuload_t *cpuload, |
cyg_uint32 calibrate, |
cyg_handle_t *handle); |
</programlisting> |
<para> |
The measurement process is started and a handle to it is returned in |
<parameter>*handle</parameter>. This handle is used to access the |
results and the stop the measurement process. </para> |
</sect2> |
|
<sect2 id="services-cpuload-api-cyg-cpuload-delete"> |
<title>cyg_cpuload_delete</title> |
<para> |
This function stops the measurement process. |
</para> |
<programlisting> |
void cyg_cpuload_delete(cyg_handle_t handle); |
</programlisting> |
<para> |
<parameter>handle</parameter> should be the value returned by the create function.</para> |
</sect2> |
|
<sect2 id="services-cpuload-api-cyg-cpuload-get"> |
<title>cyg_cpuload_get</title> |
<para> |
This function returns the latest measurements. |
</para> |
<programlisting> |
void cyg_cpuload_get(cyg_handle_t handle, |
cyg_uint32 *average_point1s, |
cyg_uint32 *average_1s, |
cyg_uint32 *average_10s); |
</programlisting> |
<para> |
<parameter>handle</parameter> should be the value returned by the |
create function. The load measurements for the last 100ms, 1s and 10s |
are returned in |
<parameter>*average_point1s</parameter>,<parameter>*average_1s</parameter> |
and <parameter>*average_10s</parameter> respectively. |
</para> |
</sect2> |
<sect2 id="services-cpuload-api-implementation"> |
<title>Implementation details</title> |
<para> |
This section gives a few details of how the measurements are |
made. This should help to understand what the results mean. |
</para> |
<para> |
When there are no other threads runnable, eCos will execute the idle |
thread. This thread is always runnable and uses the lowest thread |
priority. The idle thread does little. It is an endless loop which |
increments the variable, <literal>idle_thread_loops</literal> and |
executes the macro <literal>HAL_IDLE_THREAD_ACTION</literal>. The cpu |
load measurement code makes use of the variable. It periodically |
examines the value of the variable and sees how much it has |
changed. The idler the system, the more it will have incremented. From |
this it is simple to determine the load of the system. |
</para> |
<para> |
The function <literal>cyg_cpuload_calibrate</literal> executes the |
idle thread for 100ms to determine how much |
<literal>idle_thread_loops</literal> is incremented on a system idle |
for 100ms. <literal>cyg_cpuload_create</literal> starts an alarm which |
every 100ms calls an alarm function. This function looks at the |
difference in <literal>idle_thread_loops</literal> since the last |
invocation of the alarm function and so calculated how idle or busy |
the system has been. The structure <literal>cyg_cpuload</literal> is |
updated during the alarm functions with the new results. The 100ms |
result is simply the result from the last measurement period. A simple |
filter is used to average the load over a period of time, namely 1s |
and 10s. Due to rounding errors, the 1s and 10s value will probably |
never reach 100% on a fully loaded system, but 99% is often seen. |
</para> |
<para> |
As stated above, clever power management code will interfere with |
these measurements. The basic assumption is that the idle thread will |
be executed un-hindered and under the same conditions as when the |
calibration function was executed. If the CPU clock rate is reduced, |
the idle thread counter will be incremented less and so the CPU load |
measurements will give values too high. If the CPU is halted entirely, |
100% cpu load will be measured. |
</para> |
</sect2> |
</SECT1> |
</CHAPTER> |
</PART> |
|
/ChangeLog
0,0 → 1,48
2003-02-24 Jonathan Larmour <jifl@eCosCentric.com> |
|
* cdl/cpuload.cdl: Add doc link. |
|
2003-02-20 Bart Veer <bartv@ecoscentric.com> |
|
* cdl/cpuload.cdl: identify test binaries, not test sources |
|
2002-08-15 Andrew Lunn <andrew.lunn@ascom.ch> |
|
* Created a new package with my CPU load measurement code which |
has been sitting in the ecos-discuss archive for 2 and a bit |
years. |
|
//=========================================================================== |
//####ECOSGPLCOPYRIGHTBEGIN#### |
// ------------------------------------------- |
// This file is part of eCos, the Embedded Configurable Operating System. |
// Copyright (C) 2002 Andrew Lunn |
// |
// eCos 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 or (at your option) any later version. |
// |
// eCos 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 eCos; if not, write to the Free Software Foundation, Inc., |
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
// |
// As a special exception, if other files instantiate templates or use macros |
// or inline functions from this file, or you compile this file and link it |
// with other works to produce a work based on this file, this file does not |
// by itself cause the resulting work to be covered by the GNU General Public |
// License. However the source code for this file must still be made available |
// in accordance with section (3) of the GNU General Public License. |
// |
// This exception does not invalidate any other reasons why a work based on |
// this file might be covered by the GNU General Public License. |
// |
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. |
// at http://sources.redhat.com/ecos/ecos-license/ |
// ------------------------------------------- |
//####ECOSGPLCOPYRIGHTEND#### |
//=========================================================================== |
/src/cpuload.cxx
0,0 → 1,206
//========================================================================== |
// |
// cpuload.cxx |
// |
// Estimate the current CPU load. |
// |
//========================================================================== |
//####ECOSGPLCOPYRIGHTBEGIN#### |
// ------------------------------------------- |
// This file is part of eCos, the Embedded Configurable Operating System. |
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. |
// Copyright (C) 2002 Gary Thomas |
// |
// eCos 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 or (at your option) any later version. |
// |
// eCos 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 eCos; if not, write to the Free Software Foundation, Inc., |
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
// |
// As a special exception, if other files instantiate templates or use macros |
// or inline functions from this file, or you compile this file and link it |
// with other works to produce a work based on this file, this file does not |
// by itself cause the resulting work to be covered by the GNU General Public |
// License. However the source code for this file must still be made available |
// in accordance with section (3) of the GNU General Public License. |
// |
// This exception does not invalidate any other reasons why a work based on |
// this file might be covered by the GNU General Public License. |
// |
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. |
// at http://sources.redhat.com/ecos/ecos-license/ |
// ------------------------------------------- |
//####ECOSGPLCOPYRIGHTEND#### |
//========================================================================== |
//#####DESCRIPTIONBEGIN#### |
// |
// Author(s): Andrew Lunn |
// Contributors: Andrew Lunn |
// Date: 2002-08-12 |
// Purpose: |
// Description: |
// This provides a simple CPU load meter. All loads are returned |
// as a percentage, ie 0-100. This is only a rough measure. Any clever |
// power management, sleep modes etc, will cause these results to be |
// wrong. |
// |
// This code is part of eCos (tm). |
// |
//####DESCRIPTIONEND#### |
// |
//========================================================================== |
|
#include <cyg/kernel/kapi.h> |
#include <cyg/hal/hal_arch.h> |
#include <cyg/cpuload/cpuload.h> |
|
/* Here we run the idle thread as a high priority thread for 0.1 |
second. We see how much the counter in the idle loop is |
incremented. This will only work if there are no other threads |
running at priority 1 and 2 */ |
|
static cyg_thread thread; |
externC cyg_uint32 idle_thread_loops; |
char idle_stack[CYGNUM_HAL_STACK_SIZE_MINIMUM]; |
|
extern void idle_thread_main( CYG_ADDRESS data ); |
|
// ------------------------------------------------------------------------- |
/* We are playing ping-pong with the cpuload_calibrate function and |
the idle thread. First cpuload_calibrate runs. Next the idle |
thread, then this alarm function and then back to the |
cpuload_calibrate function. */ |
|
void static |
alarm_func(cyg_handle_t alarm,cyg_addrword_t data) { |
cyg_handle_t idleH = (cyg_handle_t) data; |
cyg_thread_suspend(idleH); |
} |
|
|
/* Calibrate the cpuload measurements.*/ |
externC void |
cyg_cpuload_calibrate(cyg_uint32 *calibration) { |
cyg_handle_t counter; |
cyg_alarm alarm_s; |
cyg_handle_t alarmH; |
cyg_uint32 idle_loops_start; |
cyg_handle_t idleH; |
cyg_priority_t old_priority; |
|
cyg_thread_create(1, |
idle_thread_main, |
0, |
"Calibration idle thread", |
idle_stack, |
sizeof(idle_stack), |
&idleH, |
&thread); |
|
cyg_clock_to_counter(cyg_real_time_clock(),&counter); |
cyg_alarm_create(counter,alarm_func,(cyg_addrword_t)idleH,&alarmH,&alarm_s); |
|
cyg_alarm_initialize(alarmH,cyg_current_time()+10,0); |
cyg_alarm_enable(alarmH); |
|
idle_loops_start = idle_thread_loops; |
|
/* Dont be decieved, remember this is a multithreaded system ! */ |
old_priority = cyg_thread_get_priority(cyg_thread_self()); |
cyg_thread_set_priority(cyg_thread_self(),2); |
cyg_thread_resume(idleH); |
cyg_thread_set_priority(cyg_thread_self(),old_priority); |
|
*calibration = idle_thread_loops - idle_loops_start; |
cyg_alarm_delete(alarmH); |
cyg_thread_kill(idleH); |
cyg_thread_delete(idleH); |
} |
|
static void |
cpuload_alarm_func(cyg_handle_t alarm,cyg_addrword_t data) { |
cyg_cpuload_t * cpuload = (cyg_cpuload_t *)data; |
cyg_uint32 idle_loops_now = idle_thread_loops; |
cyg_uint32 idle_loops; |
cyg_uint32 load; |
|
if (idle_loops_now >= cpuload->last_idle_loops) { |
idle_loops = idle_loops_now - cpuload->last_idle_loops; |
} else { |
idle_loops = ~0 - (cpuload->last_idle_loops - idle_loops_now); |
} |
|
/* We need 64 bit arithmatic to prevent wrap around */ |
load = (cyg_uint32) (((cyg_uint64) idle_loops * (cyg_uint64)100) / |
(cyg_uint64)cpuload->calibration); |
if (load > 100) { |
load = 100; |
} |
load = 100 - load; |
|
cpuload->average_point1s = load; |
cpuload->average_1s = load + ((cpuload->average_1s * 90)/100); |
cpuload->average_10s = load + ((cpuload->average_10s * 99)/100); |
cpuload->last_idle_loops = idle_loops_now; |
} |
|
/* Create a CPU load measurements object and start the |
measurements. */ |
externC void |
cyg_cpuload_create(cyg_cpuload_t *cpuload, |
cyg_uint32 calibration, |
cyg_handle_t *handle) |
{ |
cyg_handle_t counter; |
|
cpuload->average_point1s = 0; |
cpuload->average_1s = 0; |
cpuload->average_10s = 0; |
cpuload->calibration = calibration; |
cpuload->last_idle_loops = idle_thread_loops; |
|
cyg_clock_to_counter(cyg_real_time_clock(),&counter); |
cyg_alarm_create(counter, |
cpuload_alarm_func, |
(cyg_addrword_t)cpuload, |
&cpuload->alarmH, |
&cpuload->alarm_s); |
|
cyg_alarm_initialize(cpuload->alarmH,cyg_current_time()+10,10); |
cyg_alarm_enable(cpuload->alarmH); |
|
*handle = (cyg_handle_t) cpuload; |
} |
|
/* Stop measurements of the cpuload. The cyg_cpuload_t object can then |
be freed. */ |
externC void |
cyg_cpuload_delete(cyg_handle_t handle) { |
cyg_cpuload_t * cpuload = (cyg_cpuload_t *) handle; |
|
cyg_alarm_delete(cpuload->alarmH); |
} |
|
/* Return the cpuload for the last 100ms, 1seconds and 10 second */ |
externC void |
cyg_cpuload_get(cyg_handle_t handle, |
cyg_uint32 *average_point1s, |
cyg_uint32 *average_1s, |
cyg_uint32 *average_10s) { |
|
cyg_cpuload_t * cpuload = (cyg_cpuload_t *) handle; |
*average_point1s = cpuload->average_point1s; |
*average_1s = cpuload->average_1s/10; |
*average_10s = cpuload->average_10s/100; |
} |
|
|
|
|