The Best of Mecomp Multimedia 1/Mecomp-CD.iso/amiga/tools/utillities/tinymeter/source/tinymeter_main/idle.c

C/C++ Source or Header | 1996-06-01 | 4.8 KB | 216 lines

/*****************************************************************

    SystemIdler V1.0 (Idle counter module for TinyMeter 3.6)  by
    Tinic Urou in 1995, FreeWare, orginal code by Thomas Radtke.
    Use this at your own risk. Please leave me a mail if you are
    using this code in your programs:

    EMail: [e-mail]

    I modified the code from cpuload2. The routines to count the
    maximum  are  much  more  better I think, since they use the
    exact same  number  of  cycles  as  the  normal  idle  count
    routine.
    On a A4000/030, disabling the startup-sequence, you will now
    get  1%  usage.  With  all my tools I get 9-12% usage. These
    results should be correct.

    Bugs: None known.
    ¯¯¯¯
    Invoking:
    ¯¯¯¯¯¯¯¯
    init_idle(); to setup the idle task
    free_idle(); to remove the idle Task

    unsigned long idle;      is the actual idlecount
    unsigned long maximum;   is the maximum idlecount

    To get f.ex. the percentage of system usage simply use:

    __________________________________________________________

    extern unsigned long maximum,idle;

    showusage()
    {
        int percent,n;

        if(init_idle())
        {
        for(n=0;n<25;n++)
        {
            percent=(int)((idle*100)/maximum);
            printf("%d percent free\n",percent);
            Delay(50L);
        }
        free_idle();
        }
    }

    ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯

    Used compiler:  gcc  2.7.0  with  libnix  1.0  Look  at  the
    makefile for the used options.

*******************************************************************/

#include <intuition/IntuitionBase.h>
#include <exec/nodes.h>
#include <exec/tasks.h>
#include <libraries/dos.h>
#include <exec/types.h>
#include <exec/memory.h>
#include <stdlib.h>
#include <signal.h>
#include <exec/libraries.h>
#include <dos/dos.h>
#include <clib/all_protos.h>

struct          Task *task2,*met;

BOOL            quit_setidle,
        quit_getidle,
        start_count=TRUE;

unsigned long   maximum,
        cnt,
        idle;

__saveds void getidle(void)
{
    struct          timeval updateval;
    struct MsgPort  *timerport;
    struct          timerequest *tr;
    struct          Task *met2;

    /* use "__geta4 getidle()" for DICE or SAS and remove geta4(); */

    met2=FindTask(NULL);

    if ((timerport=(struct MsgPort *)CreatePort (0,0)))
    {
    if ((tr=(struct timerequest *)CreateExtIO(timerport,sizeof(struct timerequest))))
    {
        if ((OpenDevice (TIMERNAME,UNIT_MICROHZ,(struct IORequest *)tr,0))!=0)
        {
        DeleteExtIO((struct IORequest *)tr);
        DeletePort(timerport);
        goto error;
        }
    }
    else
    {
        DeletePort(timerport);
        goto error;
    }
    }
    else goto error;

    updateval.tv_secs =1;
    updateval.tv_micro=0;

    while((met2->tc_SigRecvd & SIGBREAKF_CTRL_D)==0)
    {
    /* signal setidle()-task, that we can start counting */

    start_count=FALSE;

    cnt=0;
    tr->tr_node.io_Command=TR_ADDREQUEST;
    tr->tr_time=updateval;
    DoIO((struct IORequest *)tr);
    idle=cnt;

    /* check if we have to setup maximum */
    if(maximum==0)
    {
        maximum=idle;
        Signal(met,SIGBREAKF_CTRL_D);
    }
    }

    CloseDevice((struct IORequest *)tr);
    DeleteExtIO((struct IORequest *)tr);
    DeletePort(timerport);

    error:

    quit_getidle=FALSE;
    start_count =FALSE;

    idle   =100000;    /* to avoid divisions by zero from the application */
    maximum=100000;

    /* Do nothing and wait for DeleteTask() */

    Wait(0L);

}

__saveds void setidle(void)
{
    char *taskname_1 = "CPU_GET";
    struct Task *task;

    /* use "__geta4 setidle()" for DICE or SAS and remove geta4(); */

    if(met=FindTask(NULL))
    if(task=(struct Task *)CreateTask(taskname_1,127,getidle,4096))
    {
    quit_getidle=TRUE;

    /* Wait for beginning. Allocating a timerequest may take a while */

    while (start_count) cnt=0;

    /* maximum counter */
    while ((met->tc_SigRecvd & SIGBREAKF_CTRL_D)==0) cnt++;
    SetSignal(0,SIGBREAKF_CTRL_D);

    met->tc_Node.ln_Pri=-127;

    /* idle counter */
    while ((met->tc_SigRecvd & SIGBREAKF_CTRL_D)==0) cnt++;

    met->tc_Node.ln_Pri=0;

    Signal(task,SIGBREAKF_CTRL_D);
    while(quit_getidle) cnt=0;

    /* remove getidle()-task */

    Forbid();
    DeleteTask(task);
    Permit();
    }

    idle   =100000;    /* to avoid divisions by zero from the       */
    maximum=100000;    /* application, if creation of task failed.  */

    quit_setidle=FALSE;
    Wait(0L);
}

struct Task *init_idle(void)
{
    char *taskname_2 = "CPU_SET";
    if( task2=(struct Task *)CreateTask(taskname_2,126,setidle,4096))
    {
    Delay(50L); /* To avoid the use of idle and maximum before they're initialized */
    }
    return(task2);
}

void free_idle(void)
{
    quit_setidle=TRUE;
    Signal(task2,SIGBREAKF_CTRL_D);
    while(quit_setidle) Delay(10L);

    /* remove setidle()-task */

    Forbid();
    DeleteTask(task2);
    Permit();
}