URL
https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k
Compare Revisions
- This comparison shows the changes necessary to convert path
/or1k/trunk/ecos-2.0/packages/services/cpuload
- from Rev 1254 to Rev 1765
- ↔ Reverse comparison
Rev 1254 → Rev 1765
/v2_0/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 |
} |
/v2_0/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" } |
} |
} |
|
/v2_0/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 */ |
/v2_0/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> |
|
v2_0/doc/cpuload.sgml
Property changes :
Added: svn:executable
## -0,0 +1 ##
+*
\ No newline at end of property
Index: v2_0/ChangeLog
===================================================================
--- v2_0/ChangeLog (nonexistent)
+++ v2_0/ChangeLog (revision 1765)
@@ -0,0 +1,48 @@
+2003-02-24 Jonathan Larmour
+
+ * cdl/cpuload.cdl: Add doc link.
+
+2003-02-20 Bart Veer
+
+ * cdl/cpuload.cdl: identify test binaries, not test sources
+
+2002-08-15 Andrew Lunn
+
+ * 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####
+//===========================================================================
Index: v2_0/src/cpuload.cxx
===================================================================
--- v2_0/src/cpuload.cxx (nonexistent)
+++ v2_0/src/cpuload.cxx (revision 1765)
@@ -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
+#include
+#include
+
+/* 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;
+}
+
+
+
+