workbench/system/SysMon/processor_graph.c

   1 /*
   2     Copyright © 2017, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #define DEBUG 0
   7 #include <aros/debug.h>
   8
   9 #include <proto/utility.h>
  10 #include <proto/intuition.h>
  11 #include <proto/muimaster.h>
  12 #include <proto/processor.h>
  13
  14 #include <clib/alib_protos.h>
  15
  16 #include <resources/processor.h>
  17 #include <zune/graph.h>
  18
  19 #include "sysmon_intern.h"
  20
  21 #include "processor.h"
  22
  23 struct ProcessorGraph_DATA
  24 {
  25     IPTR        pg_Flags;
  26     IPTR        pg_CPUCount;
  27     Object      **pg_Graphs;
  28     struct Hook *pg_GraphReadHooks;
  29 };
  30
  31 struct cpuPen {
  32     ULONG r;
  33     ULONG g;
  34     ULONG b;
  35 };
  36
  37 #define PROCESSORPEN_COUNT 8
  38 struct cpuPen processorPens[PROCESSORPEN_COUNT] =
  39 {
  40   { 0x9B9B9B9B, 0xDEDEDEDE, 0xC0C0C0C0 },
  41   { 0x9E9E9E9E, 0x9B9B9B9B, 0xDEDEDEDE },
  42   { 0xDEDEDEDE, 0x9B9B9B9B, 0xBABABABA },
  43   { 0xDEDEDEDE, 0xB5B5B5B5, 0x9B9B9B9B },
  44   { 0xDEDEDEDE, 0x9B9B9B9B, 0x9E9E9E9E },
  45   { 0xA6A6A6A6, 0xDEDEDEDE, 0x9B9B9B9B },
  46   { 0x9B9B9B9B, 0xB2B2B2B2, 0xDEDEDEDE },
  47   { 0xE4E4E4E4, 0xEBEBEBEB, 0x2A2A2A2A }
  48 };
  49
  50 #define PROCGF_SINGLE   (1 << 1)
  51
  52 #define SETUP_PROCGRAPH_INST_DATA       struct ProcessorGraph_DATA *data = INST_DATA(CLASS, self)
  53
  54 AROS_UFH3(IPTR, GraphReadProcessorValueFunc,
  55         AROS_UFHA(struct Hook *, procHook, A0),
  56         AROS_UFHA(IPTR *, storage, A2),
  57         AROS_UFHA(IPTR, cpuNo, A1))
  58 {
  59     AROS_USERFUNC_INIT
  60
  61     struct TagItem tags [] =
  62     {
  63         { GCIT_SelectedProcessor, cpuNo },
  64         { GCIT_ProcessorLoad, (IPTR)storage },
  65         { TAG_DONE, TAG_DONE }
  66     };
  67
  68    D(bug("[SysMon:ProcGraph] %s(%d)\n", __func__, cpuNo);)
  69
  70     *storage = 0;
  71
  72     GetCPUInfo(tags);
  73
  74     *storage = ((*storage >> 16) * 1000) >> 16;
  75
  76     D(bug("[SysMon:ProcGraph] %s: 0x%p = %d\n", __func__, storage, *storage);)
  77
  78     return TRUE;
  79
  80     AROS_USERFUNC_EXIT
  81 }
  82
  83 ULONG cpusperrow(ULONG x)
  84 {
  85     register unsigned long op = x, res = 0, one;
  86
  87     one = 1 << 30;
  88     while (one > op)
  89         one >>= 2;
  90
  91     while (one != 0)
  92     {
  93         if (op >= res + one)
  94         {
  95             op -= res + one;
  96             res += one << 1;
  97         }
  98         res >>= 1;
  99         one >>= 2;
 100     }
 101     return res;
 102 }
 103
 104 Object *ProcessorGraph__GraphObject()
 105 {
 106     return GraphObject,
 107                     MUIA_Graph_InfoText, (IPTR) CPU_DEFSTR,
 108                     MUIA_Graph_ValueCeiling,    1000,
 109                     MUIA_Graph_ValueStep,       100,
 110                     MUIA_Graph_PeriodCeiling,   100000,
 111                     MUIA_Graph_PeriodStep,      10000,
 112                     MUIA_Graph_PeriodInterval,  1000,
 113                 End;
 114 }
 115
 116 Object *ProcessorGraph__OM_NEW(Class *CLASS, Object *self, struct opSet *message)
 117 {
 118     BOOL singlemode = (BOOL)GetTagData(MUIA_ProcessorGrp_SingleMode, TRUE, message->ops_AttrList);
 119     ULONG processorcount = (ULONG)GetTagData(MUIA_ProcessorGrp_CPUCount, 1, message->ops_AttrList);
 120     Object *procGuage = NULL;
 121     ULONG cpupr = 1;
 122
 123     D(bug("[SysMon:ProcGraph] %s()\n", __func__));
 124
 125     if ((singlemode) || (processorcount == 1))
 126     {
 127         self = (Object *) DoSuperNewTags(CLASS, self, NULL,
 128                 Child, (IPTR)(procGuage = ProcessorGraph__GraphObject()),
 129             TAG_MORE, (IPTR) message->ops_AttrList
 130         );
 131     }
 132     else
 133     {
 134         if (processorcount <= 4)
 135             cpupr = processorcount;
 136         else if ((cpupr = cpusperrow(processorcount)) < 4)
 137         {
 138             if (processorcount <= 4)
 139                 cpupr = processorcount;
 140             else
 141                 cpupr = 4;
 142         }
 143
 144         self = (Object *) DoSuperNewTags(CLASS, self, NULL,
 145                 MUIA_Group_Columns, cpupr,
 146             TAG_MORE, (IPTR) message->ops_AttrList
 147         );
 148     }
 149
 150     if (self != NULL)
 151     {
 152         APTR procDataSource;
 153         IPTR i;
 154
 155         SETUP_PROCGRAPH_INST_DATA;
 156
 157         data->pg_Flags = 0;
 158         data->pg_CPUCount = processorcount;
 159         data->pg_GraphReadHooks = AllocVec(sizeof(struct Hook) * processorcount, MEMF_ANY | MEMF_CLEAR);
 160
 161         if ((!singlemode) && (processorcount > 1))
 162             data->pg_Graphs = AllocVec(sizeof(Object *) * processorcount, MEMF_ANY | MEMF_CLEAR);
 163         else
 164         {
 165             data->pg_Graphs = (Object **)procGuage;
 166             data->pg_Flags |= PROCGF_SINGLE;
 167         }
 168
 169         for (i = 0; i < processorcount; i++)
 170         {
 171             if (!(data->pg_Flags & PROCGF_SINGLE))
 172             {
 173                 data->pg_Graphs[i] = GraphObject,
 174                                     MUIA_Graph_InfoText,        (IPTR) CPU_DEFSTR,
 175                                     MUIA_Graph_ValueCeiling,    1000,
 176                                     MUIA_Graph_ValueStep,       100,
 177                                     MUIA_Graph_PeriodCeiling,   100000,
 178                                     MUIA_Graph_PeriodStep,      10000,
 179                                     MUIA_Graph_PeriodInterval,  1000,
 180                                     MUIA_UserData,              i,
 181                                 End;
 182
 183                 procGuage = data->pg_Graphs[i];
 184                 procDataSource = (APTR)DoMethod(procGuage, MUIM_Graph_GetSourceHandle, 0);
 185
 186                 DoMethod(self, OM_ADDMEMBER, procGuage);
 187             }
 188             else
 189             {
 190                 procDataSource = (APTR)DoMethod(procGuage, MUIM_Graph_GetSourceHandle, i);
 191                 DoMethod(procGuage, MUIM_Graph_SetSourceAttrib, procDataSource, MUIV_Graph_Source_PenSrc, &processorPens[i % PROCESSORPEN_COUNT]);
 192             }
 193
 194             data->pg_GraphReadHooks[i].h_Entry = (APTR)GraphReadProcessorValueFunc;
 195             data->pg_GraphReadHooks[i].h_Data = (APTR)i;
 196
 197             DoMethod(procGuage, MUIM_Graph_SetSourceAttrib, procDataSource, MUIV_Graph_Source_ReadHook, &data->pg_GraphReadHooks[i]);
 198         }
 199         for (i %= cpupr; (i > 0) && (i < cpupr); i ++)
 200         {
 201             DoMethod(self, OM_ADDMEMBER, (IPTR)HVSpace);
 202         }
 203     }
 204
 205     return self;
 206 }
 207
 208 IPTR ProcessorGraph__OM_DISPOSE(Class *CLASS, Object *self, Msg message)
 209 {
 210     SETUP_PROCGRAPH_INST_DATA;
 211     BOOL singlemode = (BOOL)(data->pg_Flags & PROCGF_SINGLE);
 212     IPTR retVal;
 213
 214     D(bug("[SysMon:ProcGraph] %s()\n", __func__));
 215
 216     retVal = DoSuperMethodA(CLASS, self, message);
 217
 218     FreeVec(data->pg_GraphReadHooks);
 219     if (!singlemode)
 220         FreeVec(data->pg_Graphs);
 221
 222     return retVal;
 223 }
 224
 225 IPTR ProcessorGraph__OM_SET(Class *CLASS, Object *self, struct opSet *message)
 226 {
 227 //    SETUP_PROCGRAPH_INST_DATA;
 228     struct TagItem  *tstate = message->ops_AttrList, *tag;
 229
 230     D(bug("[SysMon:ProcGraph] %s()\n", __func__));
 231
 232     while ((tag = NextTagItem((struct TagItem **)&tstate)) != NULL)
 233     {
 234         switch (tag->ti_Tag)
 235         {
 236         }
 237     }
 238     return DoSuperMethodA(CLASS, self, (Msg) message);
 239 }
 240
 241 IPTR ProcessorGraph__OM_GET(Class *CLASS, Object *self, struct opGet *message)
 242 {
 243     SETUP_PROCGRAPH_INST_DATA;
 244     IPTR *store = message->opg_Storage;
 245     IPTR retval = 0;
 246
 247     D(bug("[SysMon:ProcGraph] %s()\n", __func__));
 248
 249     switch (message->opg_AttrID)
 250     {
 251         case MUIA_ProcessorGrp_CPUCount:
 252             *store = (IPTR)data->pg_CPUCount;
 253             break;
 254
 255         case MUIA_ProcessorGrp_SingleMode:
 256             *store = (IPTR)(data->pg_Flags & PROCGF_SINGLE);
 257             break;
 258     }
 259
 260     if (!retval)
 261         retval = DoSuperMethodA(CLASS, self, (Msg) message);
 262
 263     return retval;
 264 }
 265
 266 IPTR ProcessorGraph__MUIM_ProcessorGrp_Update(Class *CLASS, Object *self, Msg message)
 267 {
 268     SETUP_PROCGRAPH_INST_DATA;
 269     TEXT buffer[128];
 270     ULONG totaluse = 0;
 271     ULONG i;
 272
 273     D(bug("[SysMon:ProcGraph] %s()\n", __func__));
 274
 275     for (i = 0; i < data->pg_CPUCount; i++)
 276     {
 277         ULONG usage = 0;
 278         struct TagItem tags [] =
 279         {
 280             { GCIT_SelectedProcessor, (IPTR)i },
 281             { GCIT_ProcessorLoad, (IPTR)&usage },
 282             { TAG_DONE, TAG_DONE }
 283         };
 284
 285         GetCPUInfo(tags);
 286         usage = ((usage >> 16) * 1000) >> 16;
 287
 288         if (!(data->pg_Flags & PROCGF_SINGLE))
 289         {
 290             __sprintf(buffer, "CPU %d\n%d.%d %%", i, usage / 10, usage % 10);
 291             SET(data->pg_Graphs[i], MUIA_Graph_InfoText, (IPTR)buffer);
 292         }
 293         else
 294             totaluse += usage;
 295     }
 296
 297     if (data->pg_Flags & PROCGF_SINGLE)
 298     {
 299         totaluse /= data->pg_CPUCount;
 300         __sprintf(buffer, "%d CPU's\n%d.%d %%", data->pg_CPUCount, totaluse / 10, totaluse % 10);
 301         SET((Object *)data->pg_Graphs, MUIA_Graph_InfoText, (IPTR)buffer);
 302     }
 303     return 0;
 304 }
 305
 306 /*** Setup ******************************************************************/
 307 PROCESSORGRP_CUSTOMCLASS
 308 (
 309   ProcessorGraph, NULL, MUIC_Group, NULL,
 310   OM_NEW,                             struct opSet *,
 311   OM_DISPOSE,                         Msg,
 312   OM_SET,                             struct opSet *,
 313   OM_GET,                             struct opGet *,
 314   MUIM_ProcessorGrp_Update,           Msg
 315 );