From 8e4ce16e5fc0b84455d87fe76f662c83ffaa9e0d Mon Sep 17 00:00:00 2001 From: NicJA Date: Sun, 26 Feb 2017 06:16:00 +0000 Subject: [PATCH] wip commit. # rework the separate processor graph/gauge support into 2 new "ProcessorGrp" custom classes, to facilitate runtime selection. # add context sensitive menus to select the displayed mode (crashes currently...) # allocate specific pens for the processors when using the graph group in single graph mode. git-svn-id: https://svn.aros.org/svn/aros/trunk/AROS@53915 fb15a70f-31f2-0310-bbcc-cdcc74a49acc --- workbench/system/SysMon/main.c | 156 ++++----------- workbench/system/SysMon/mmakefile.src | 2 +- workbench/system/SysMon/processor.c | 194 ++++++++++++------ workbench/system/SysMon/processor.h | 50 +++++ workbench/system/SysMon/processor_gauge.c | 161 +++++++++++++++ workbench/system/SysMon/processor_graph.c | 315 ++++++++++++++++++++++++++++++ workbench/system/SysMon/sysmon_intern.h | 85 ++++---- 7 files changed, 750 insertions(+), 213 deletions(-) create mode 100644 workbench/system/SysMon/processor.h create mode 100644 workbench/system/SysMon/processor_gauge.c create mode 100644 workbench/system/SysMon/processor_graph.c diff --git a/workbench/system/SysMon/main.c b/workbench/system/SysMon/main.c index dc10cb0e2d..05932fb413 100644 --- a/workbench/system/SysMon/main.c +++ b/workbench/system/SysMon/main.c @@ -17,9 +17,9 @@ #include "locale.h" -#define VERSION "$VER: SysMon 1.4 (23.01.2017) ©2011-2017 The AROS Development Team" +#define VERSION "$VER: SysMon 1.9 (26.02.2017) ©2011-2017 The AROS Development Team" -#define CPU_DEFSTR "CPU --\n--.- %" +CONST_STRPTR CPU_DEFSTR = "CPU --\n--.- %"; //#define NOTYET_USED @@ -68,60 +68,23 @@ AROS_UFH3(VOID, pageactivefunction, } #endif -#if !defined(PROCDISPLAY_USEGAUGE) -ULONG cpusperrow(ULONG x) -{ - register unsigned long op = x, res = 0, one; - - one = 1 << 30; - while (one > op) - one >>= 2; - - while (one != 0) - { - if (op >= res + one) - { - op -= res + one; - res += one << 1; - } - res >>= 1; - one >>= 2; - } - return res; -} -#endif - BOOL CreateApplication(struct SysMonData * smdata) { Object * menuitemfast, * menuitemnormal, - * menuitemslow; + * menuitemslow, + * cmenucpugauge, + * cmenucpugraph, + * cmenucpugraphpcpu = NULL; -#if !defined(PROCDISPLAY_SINGLEGRAPH) - Object * cpucolgroup; -#endif Object * cpuusagegroup, * cpufreqgroup, * cpufreqcntnr; IPTR i; ULONG processorcount; -#if !defined(PROCDISPLAY_USEGAUGE) - ULONG cpupr; -#endif processorcount = GetProcessorCount(); -#if !defined(PROCDISPLAY_USEGAUGE) - if (processorcount <= 4) - cpupr = processorcount; - else if ((cpupr = cpusperrow(processorcount)) < 4) - { - if (processorcount <= 4) - cpupr = processorcount; - else - cpupr = 4; - } -#endif smdata->tabs[0] = _(MSG_TAB_TASKS); smdata->tabs[1] = _(MSG_TAB_CPU); @@ -212,24 +175,19 @@ BOOL CreateApplication(struct SysMonData * smdata) Child, (VGroup, Child, (cpuusagegroup = HGroup, GroupFrameT(_(MSG_USAGE)), - Child, -#if defined(PROCDISPLAY_SINGLEGRAPH) - smdata->cpuusagegauge = GraphObject, - MUIA_Graph_InfoText, (IPTR) CPU_DEFSTR, - MUIA_Graph_ValueCeiling, 1000, - MUIA_Graph_ValueStep, 100, - MUIA_Graph_PeriodCeiling, 100000, - MUIA_Graph_PeriodStep, 10000, - MUIA_Graph_PeriodInterval, 1000, -#else - cpucolgroup = -#if defined(PROCDISPLAY_USEGAUGE) - ColGroup(processorcount + 2), -#else - ColGroup(cpupr), -#endif -#endif - End, + MUIA_ContextMenu, (MenustripObject, + MUIA_Family_Child, (MenuObject, + MUIA_Menu_Title, (IPTR)"Processor Load", + MUIA_Family_Child, (MenuitemObject, + MUIA_Menuitem_Title, (IPTR)"Display Mode", + MUIA_Family_Child, (cmenucpugauge = MenuitemObject, MUIA_Menuitem_Title, (IPTR)"Gauge", MUIA_Menuitem_Shortcut, (IPTR)"G",End), + MUIA_Family_Child, (cmenucpugraph = MenuitemObject, MUIA_Menuitem_Title, (IPTR)"Graph", MUIA_Menuitem_Shortcut, (IPTR)"S",End), + (processorcount > 1) ? MUIA_Family_Child : TAG_IGNORE, + (cmenucpugraphpcpu = MenuitemObject, MUIA_Menuitem_Title, (IPTR)"Graph Per Processor", MUIA_Menuitem_Shortcut, (IPTR)"P",End), + End), + End), + End), + Child, (IPTR)(smdata->cpuusageobj = ProcessorGroupObject(smdata, processorcount)), End), Child, cpufreqcntnr, End), @@ -321,61 +279,27 @@ BOOL CreateApplication(struct SysMonData * smdata) smdata->pages, 2, MUIM_CallHook, (IPTR)&smdata->pageactivehook); #endif -#if !defined(PROCDISPLAY_USEGAUGE) - smdata->cpureadhooks = AllocVec(sizeof(struct Hook) * processorcount, MEMF_ANY | MEMF_CLEAR); -#endif -#if !defined(PROCDISPLAY_SINGLEGRAPH) - smdata->cpuusagegauges = AllocVec(sizeof(Object *) * processorcount, MEMF_ANY | MEMF_CLEAR); -#elif defined(PROCDISPLAY_USEGAUGE) - DoMethod(cpucolgroup, OM_ADDMEMBER, (IPTR)HVSpace); -#endif - - for (i = 0; i < processorcount; i++) + smdata->cpuusagecmhooks[0].h_Entry = (APTR)processorgaugehookfunc; + smdata->cpuusagecmhooks[0].h_Data = (APTR)smdata; + smdata->cpuusagecmhooks[1].h_Entry = (APTR)processorgraphhookfunc; + smdata->cpuusagecmhooks[1].h_Data = (APTR)smdata; + + DoMethod(cmenucpugauge, MUIM_Notify, MUIA_Menuitem_Trigger, MUIV_EveryTime, + smdata->application, 5, MUIM_Application_PushMethod, + smdata->application, 2, MUIM_CallHook, (IPTR)&smdata->cpuusagecmhooks[0]); + DoMethod(cmenucpugraph, MUIM_Notify, MUIA_Menuitem_Trigger, MUIV_EveryTime, + smdata->application, 5, MUIM_Application_PushMethod, + smdata->application, 2, MUIM_CallHook, (IPTR)&smdata->cpuusagecmhooks[1]); + if (cmenucpugraphpcpu) { -#if defined(PROCDISPLAY_USEGAUGE) - smdata->cpuusagegauges[i] = GaugeObject, - GaugeFrame, - MUIA_Gauge_InfoText, (IPTR) CPU_DEFSTR, - MUIA_Gauge_Horiz, FALSE, MUIA_Gauge_Current, 0, - MUIA_Gauge_Max, 1000, - End; -#else - Object *procGuage; - APTR procDataSource; -#if !defined(PROCDISPLAY_SINGLEGRAPH) - smdata->cpuusagegauges[i] = GraphObject, - MUIA_Graph_InfoText, (IPTR) CPU_DEFSTR, - MUIA_Graph_ValueCeiling, 1000, - MUIA_Graph_ValueStep, 100, - MUIA_Graph_PeriodCeiling, 100000, - MUIA_Graph_PeriodStep, 10000, - MUIA_Graph_PeriodInterval, 1000, - End; - procGuage = smdata->cpuusagegauges[i]; - procDataSource = (APTR)DoMethod(procGuage, MUIM_Graph_GetSourceHandle, 0); -#else - procGuage = smdata->cpuusagegauge; - procDataSource = (APTR)DoMethod(procGuage, MUIM_Graph_GetSourceHandle, i); -#endif - smdata->cpureadhooks[i].h_Entry = (APTR)GraphReadProcessorValueFunc; - smdata->cpureadhooks[i].h_Data = (APTR)i; + smdata->cpuusagecmhooks[2].h_Entry = (APTR)processorgraphpercpuhookfunc; + smdata->cpuusagecmhooks[2].h_Data = (APTR)smdata; - DoMethod(procGuage, MUIM_Graph_SetSourceAttrib, procDataSource, MUIV_Graph_Source_ReadHook, &smdata->cpureadhooks[i]); -#endif -#if !defined(PROCDISPLAY_SINGLEGRAPH) - DoMethod(cpucolgroup, OM_ADDMEMBER, smdata->cpuusagegauges[i]); -#endif + DoMethod(cmenucpugraphpcpu, MUIM_Notify, MUIA_Menuitem_Trigger, MUIV_EveryTime, + smdata->application, 5, MUIM_Application_PushMethod, + smdata->application, 2, MUIM_CallHook, (IPTR)&smdata->cpuusagecmhooks[2]); } -#if defined(PROCDISPLAY_USEGAUGE) - DoMethod(cpucolgroup, OM_ADDMEMBER, (IPTR)HVSpace); -#elif !defined(PROCDISPLAY_SINGLEGRAPH) - for (i %= cpupr; (i > 0) && (i < cpupr); i ++) - { - DoMethod(cpucolgroup, OM_ADDMEMBER, (IPTR)HVSpace); - } -#endif - /* Adding cpu frequency labels */ smdata->cpufreqlabels = AllocVec(sizeof(Object *) * processorcount, MEMF_ANY | MEMF_CLEAR); smdata->cpufreqvalues = AllocVec(sizeof(Object *) * processorcount, MEMF_ANY | MEMF_CLEAR); @@ -406,10 +330,6 @@ VOID DisposeApplication(struct SysMonData * smdata) MUI_DisposeObject(smdata->application); FreeVec(smdata->tasklistinfobuf); - -#if !defined(PROCDISPLAY_SINGLEGRAPH) - FreeVec(smdata->cpuusagegauges); -#endif FreeVec(smdata->cpufreqlabels); FreeVec(smdata->cpufreqvalues); } @@ -426,6 +346,9 @@ LONG InitModules(struct SysMonModule ** modules, struct SysMonData *smdata) { LONG lastinitedmodule = -1; + /* Make sure we initialize values ..*/ + smdata->cpuusageclass = NULL; + while(modules[lastinitedmodule + 1] != NULL) { if (modules[lastinitedmodule + 1]->Init(smdata)) @@ -450,7 +373,6 @@ int main() if ((lastinitedmodule = InitModules(modules, &smdata)) == -1) return 1; - if (!CreateApplication(&smdata)) return 1; diff --git a/workbench/system/SysMon/mmakefile.src b/workbench/system/SysMon/mmakefile.src index 409977e190..34e13336f6 100644 --- a/workbench/system/SysMon/mmakefile.src +++ b/workbench/system/SysMon/mmakefile.src @@ -3,7 +3,7 @@ include $(SRCDIR)/config/aros.cfg -FILES := main locale memory video processor tasks timer +FILES := main locale memory video processor processor_gauge processor_graph tasks timer EXEDIR := $(AROSDIR)/System #MM- workbench-system : workbench-system-sysmon diff --git a/workbench/system/SysMon/processor.c b/workbench/system/SysMon/processor.c index 1862ec1609..bf3a1e03e6 100644 --- a/workbench/system/SysMon/processor.c +++ b/workbench/system/SysMon/processor.c @@ -3,7 +3,7 @@ $Id$ */ -#define DEBUG 0 +#define DEBUG 1 #include #include "sysmon_intern.h" @@ -14,49 +14,36 @@ #include -#include - +#include "processor.h" #include "locale.h" +extern struct MUI_CustomClass *ProcessorGauge_CLASS; +extern struct MUI_CustomClass *ProcessorGraph_CLASS; + /* Processor information */ static IPTR processorcount; APTR ProcessorBase; #define SIMULATE_USAGE_FREQ 0 -#if !defined(PROCDISPLAY_USEGAUGE) -AROS_UFH3(IPTR, GraphReadProcessorValueFunc, - AROS_UFHA(struct Hook *, procHook, A0), - AROS_UFHA(IPTR *, storage, A2), - AROS_UFHA(IPTR, cpuNo, A1)) +/* Processor functions */ +static BOOL InitProcessor(struct SysMonData *smdata) { - AROS_USERFUNC_INIT - - struct TagItem tags [] = + if (!smdata->cpuusageclass) { - { GCIT_SelectedProcessor, cpuNo }, - { GCIT_ProcessorLoad, (IPTR)storage }, - { TAG_DONE, TAG_DONE } - }; - - D(bug("[SysMon] %s(%d)\n", __func__, cpuNo);) - - *storage = 0; - - GetCPUInfo(tags); - - *storage = ((*storage >> 16) * 1000) >> 16; - - D(bug("[SysMon] %s: 0x%p = %d\n", __func__, storage, *storage);) - - return TRUE; - - AROS_USERFUNC_EXIT -} + smdata->cpuusageclass = +#if defined(PROCDISPLAY_USEGAUGE) + ProcessorGauge_CLASS; +#else + ProcessorGraph_CLASS; #endif + smdata->cpuusagesinglemode = +#if defined(PROCDISPLAY_SINGLEGRAPH) + TRUE; +#else + FALSE; +#endif + } -/* Processor functions */ -static BOOL InitProcessor(struct SysMonData *smdata) -{ #if SIMULATE_USAGE_FREQ processorcount = 4; return TRUE; @@ -76,7 +63,6 @@ static BOOL InitProcessor(struct SysMonData *smdata) return TRUE; } - return FALSE; #endif } @@ -85,6 +71,24 @@ static VOID DeInitProcessor(struct SysMonData *smdata) { } +Object *ProcessorGroupObject(struct SysMonData *smdata, int count) +{ + Object *newGroupObj; + + if (smdata->cpuusageobj) + { + MUI_DisposeObject(smdata->cpuusageobj); + smdata->cpuusageobj = NULL; + } + + newGroupObj = NewObject(smdata->cpuusageclass->mcc_Class, NULL, + MUIA_ProcessorGrp_CPUCount, count, + MUIA_ProcessorGrp_SingleMode, (IPTR)smdata->cpuusagesinglemode, + TAG_DONE); + + return newGroupObj; +} + ULONG GetProcessorCount() { return processorcount; @@ -94,54 +98,31 @@ VOID UpdateProcessorInformation(struct SysMonData * smdata) { ULONG i; TEXT buffer[128]; -#if defined(PROCDISPLAY_SINGLEGRAPH) - ULONG totaluse = 0; -#endif + + DoMethod(smdata->cpuusageobj, MUIM_ProcessorGrp_Update); for (i = 0; i < processorcount; i++) { - ULONG usage = 0; UQUAD frequency = 0; #if SIMULATE_USAGE_FREQ struct DateStamp ds; DateStamp(&ds); - usage = (ds.ds_Tick * (i + 1)) % 100; - frequency = usage * 10; + frequency = ((ds.ds_Tick * (i + 1)) % 100) * 10; #else struct TagItem tags [] = { { GCIT_SelectedProcessor, (IPTR)i }, { GCIT_ProcessorSpeed, (IPTR)&frequency }, - { GCIT_ProcessorLoad, (IPTR)&usage }, { TAG_DONE, TAG_DONE } }; GetCPUInfo(tags); - usage = ((usage >> 16) * 1000) >> 16; frequency /= 1000000; #endif -#if !defined(PROCDISPLAY_SINGLEGRAPH) - __sprintf(buffer, "CPU %d\n%d.%d %%", i, usage / 10, usage % 10); -#endif -#if (PROCDISPLAY_USEGAUGE) - set(smdata->cpuusagegauges[i], MUIA_Gauge_Current, usage); - set(smdata->cpuusagegauges[i], MUIA_Gauge_InfoText, (IPTR)buffer); -#else -#if !defined(PROCDISPLAY_SINGLEGRAPH) - set(smdata->cpuusagegauges[i], MUIA_Graph_InfoText, (IPTR)buffer); -#else - totaluse += usage; -#endif -#endif __sprintf(buffer, "%d MHz", (ULONG)frequency); set(smdata->cpufreqvalues[i], MUIA_Text_Contents, (IPTR)buffer); } -#if defined(PROCDISPLAY_SINGLEGRAPH) - totaluse /= processorcount; - __sprintf(buffer, "%d CPU's\n%d.%d %%", processorcount, totaluse / 10, totaluse % 10); - set(smdata->cpuusagegauge, MUIA_Graph_InfoText, (IPTR)buffer); -#endif } VOID UpdateProcessorStaticInformation(struct SysMonData * smdata) @@ -169,6 +150,99 @@ VOID UpdateProcessorStaticInformation(struct SysMonData * smdata) } } +AROS_UFH3(VOID, processorgaugehookfunc, + AROS_UFHA(struct Hook *, h, A0), + AROS_UFHA(Object *, object, A2), + AROS_UFHA(APTR, msg, A1)) +{ + AROS_USERFUNC_INIT + + struct SysMonData * smdata = h->h_Data; + IPTR cpuCount = 0; + Object *cpuGrp; + + D(bug("[SysMon:Processor] %s(0x%p)\n", __func__, object)); + + if (smdata->cpuusageclass != ProcessorGauge_CLASS) + { + smdata->cpuusageclass = ProcessorGauge_CLASS; + GET(smdata->cpuusageobj, MUIA_ProcessorGrp_CPUCount, &cpuCount); + if (DoMethod(smdata->cpuusagegroup, MUIM_Group_InitChange)) + { + DoMethod(smdata->cpuusagegroup, OM_REMMEMBER, (IPTR)smdata->cpuusageobj); + cpuGrp = ProcessorGroupObject(smdata, cpuCount); + DoMethod(smdata->cpuusagegroup, OM_ADDMEMBER, (IPTR)cpuGrp); + DoMethod(smdata->cpuusagegroup, MUIM_Group_InitChange); + } + } + + AROS_USERFUNC_EXIT +} + +AROS_UFH3(VOID, processorgraphhookfunc, + AROS_UFHA(struct Hook *, h, A0), + AROS_UFHA(Object *, object, A2), + AROS_UFHA(APTR, msg, A1)) +{ + AROS_USERFUNC_INIT + + struct SysMonData * smdata = h->h_Data; + IPTR cpuCount = 0, graphMode = 0; + Object *cpuGrp; + + D(bug("[SysMon:Processor] %s(0x%p)\n", __func__, object)); + + GET(smdata->cpuusageobj, MUIA_ProcessorGrp_CPUCount, &cpuCount); + GET(smdata->cpuusageobj, MUIA_ProcessorGrp_SingleMode, &graphMode); + + if ((smdata->cpuusageclass != ProcessorGraph_CLASS) || ((cpuCount > 1) && (!graphMode))) + { + smdata->cpuusageclass = ProcessorGraph_CLASS; + if (DoMethod(smdata->cpuusagegroup, MUIM_Group_InitChange)) + { + DoMethod(smdata->cpuusagegroup, OM_REMMEMBER, (IPTR)smdata->cpuusageobj); + cpuGrp = ProcessorGroupObject(smdata, cpuCount); + DoMethod(smdata->cpuusagegroup, OM_ADDMEMBER, (IPTR)cpuGrp); + DoMethod(smdata->cpuusagegroup, MUIM_Group_InitChange); + } + } + + AROS_USERFUNC_EXIT +} + +AROS_UFH3(VOID, processorgraphpercpuhookfunc, + AROS_UFHA(struct Hook *, h, A0), + AROS_UFHA(Object *, object, A2), + AROS_UFHA(APTR, msg, A1)) +{ + AROS_USERFUNC_INIT + IPTR cpuCount = 0, graphMode = 0; + Object *cpuGrp; + + struct SysMonData * smdata = h->h_Data; + + D(bug("[SysMon:Processor] %s(0x%p)\n", __func__, object)); + + GET(smdata->cpuusageobj, MUIA_ProcessorGrp_CPUCount, &cpuCount); + GET(smdata->cpuusageobj, MUIA_ProcessorGrp_SingleMode, &graphMode); + + if ((smdata->cpuusageclass != ProcessorGauge_CLASS) || (graphMode)) + { + smdata->cpuusageclass = ProcessorGraph_CLASS; + if (DoMethod(smdata->cpuusagegroup, MUIM_Group_InitChange)) + { + DoMethod(smdata->cpuusagegroup, OM_REMMEMBER, (IPTR)smdata->cpuusageobj); + cpuGrp = ProcessorGroupObject(smdata, cpuCount); + DoMethod(smdata->cpuusagegroup, OM_ADDMEMBER, (IPTR)cpuGrp); + DoMethod(smdata->cpuusagegroup, MUIM_Group_InitChange); + } + } + + AROS_USERFUNC_EXIT +} + + + struct SysMonModule processormodule = { .Init = InitProcessor, diff --git a/workbench/system/SysMon/processor.h b/workbench/system/SysMon/processor.h new file mode 100644 index 0000000000..00eb788697 --- /dev/null +++ b/workbench/system/SysMon/processor.h @@ -0,0 +1,50 @@ +#ifndef _SYSMON_PROCESSORGRP_H_ +#define _SYSMON_PROCESSORGRP_H_ + +/* + Copyright © 2017, The AROS Development Team. All rights reserved. + $Id$ +*/ + +#include +#include +#include + +/* default InfoText to display */ +extern CONST_STRPTR CPU_DEFSTR; + +/*** Identifier Base ********************************************************/ +#define MUIB_ProcessorGrp (TAG_USER | 0x20000000) + +/*** Public Attributes ******************************************************/ +#define MUIA_ProcessorGrp_SingleMode (MUIB_ProcessorGrp | 0x00000001) // BOOL +#define MUIA_ProcessorGrp_CPUCount (MUIB_ProcessorGrp | 0x00000002) // BOOL + +/*** Public Methods *********************************************************/ +#define MUIM_ProcessorGrp_Update (MUIB_ProcessorGrp | 0x00000001) + +/*** Private Methods ********************************************************/ + +/*** Public Constants ********************************************************/ + +/*** Private Constants ********************************************************/ + +/*** Macros *****************************************************************/ + +/* this macro is based on the ZUNE_CUSTOMCLASS_xx macros from zune/customclasses.h +and temporarily placed here */ +#define PROCESSORGRP_CUSTOMCLASS(name, base, parent_name, parent_class, \ + m1, m1_msg_type, \ + m2, m2_msg_type, \ + m3, m3_msg_type, \ + m4, m4_msg_type, \ + m5, m5_msg_type) \ + __ZUNE_CUSTOMCLASS_START(name) \ + __ZUNE_CUSTOMCLASS_METHOD(name ## __ ## m1, m1, m1_msg_type); \ + __ZUNE_CUSTOMCLASS_METHOD(name ## __ ## m2, m2, m2_msg_type); \ + __ZUNE_CUSTOMCLASS_METHOD(name ## __ ## m3, m3, m3_msg_type); \ + __ZUNE_CUSTOMCLASS_METHOD(name ## __ ## m4, m4, m4_msg_type); \ + __ZUNE_CUSTOMCLASS_METHOD(name ## __ ## m5, m5, m5_msg_type); \ + __ZUNE_CUSTOMCLASS_END(name, base, parent_name, parent_class) \ + +#endif /* _SYSMON_PROCESSORGRP_H_ */ diff --git a/workbench/system/SysMon/processor_gauge.c b/workbench/system/SysMon/processor_gauge.c new file mode 100644 index 0000000000..a8a36415b1 --- /dev/null +++ b/workbench/system/SysMon/processor_gauge.c @@ -0,0 +1,161 @@ +/* + Copyright © 2017, The AROS Development Team. All rights reserved. + $Id$ +*/ + +#define DEBUG 0 +#include + +#include +#include +#include +#include + +#include + +#include + +#include "sysmon_intern.h" + +#include "processor.h" + +struct ProcessorGauge_DATA +{ + IPTR pg_CPUCount; + Object **pg_Gauges; +}; + +#define SETUP_PROCGAUGE_INST_DATA struct ProcessorGauge_DATA *data = INST_DATA(CLASS, self) + +Object *ProcessorGauge__OM_NEW(Class *CLASS, Object *self, struct opSet *message) +{ + ULONG processorcount = (ULONG)GetTagData(MUIA_ProcessorGrp_CPUCount, 1, message->ops_AttrList); + + D(bug("[SysMon:ProcGauge] %s()\n", __func__)); + + self = (Object *) DoSuperNewTags(CLASS, self, NULL, + MUIA_Group_Columns, processorcount + 2, + TAG_MORE, (IPTR) message->ops_AttrList + ); + + if (self != NULL) + { + int i; + + SETUP_PROCGAUGE_INST_DATA; + + data->pg_CPUCount = processorcount; + data->pg_Gauges = AllocMem(sizeof(Object *) * processorcount, MEMF_ANY | MEMF_CLEAR); + + DoMethod(self, OM_ADDMEMBER, (IPTR)HVSpace); + + for (i = 0; i < processorcount; i++) + { + data->pg_Gauges[i] = GaugeObject, + GaugeFrame, + MUIA_Gauge_InfoText, (IPTR) CPU_DEFSTR, + MUIA_Gauge_Horiz, FALSE, MUIA_Gauge_Current, 0, + MUIA_Gauge_Max, 1000, + MUIA_UserData, i, + End; + + DoMethod(self, OM_ADDMEMBER, data->pg_Gauges[i]); + } + + DoMethod(self, OM_ADDMEMBER, (IPTR)HVSpace); + } + + return self; +} + +IPTR ProcessorGauge__OM_DISPOSE(Class *CLASS, Object *self, Msg message) +{ + D(bug("[SysMon:ProcGauge] %s()\n", __func__)); + + return DoSuperMethodA(CLASS, self, message); +} + +IPTR ProcessorGauge__OM_SET(Class *CLASS, Object *self, struct opSet *message) +{ +// SETUP_PROCGAUGE_INST_DATA; + struct TagItem *tstate = message->ops_AttrList, *tag; + + D(bug("[SysMon:ProcGauge] %s()\n", __func__)); + + while ((tag = NextTagItem((struct TagItem **)&tstate)) != NULL) + { + switch (tag->ti_Tag) + { + } + } + return DoSuperMethodA(CLASS, self, (Msg) message); +} + +IPTR ProcessorGauge__OM_GET(Class *CLASS, Object *self, struct opGet *message) +{ + SETUP_PROCGAUGE_INST_DATA; + IPTR *store = message->opg_Storage; + IPTR retval = 0; + + D(bug("[SysMon:ProcGauge] %s()\n", __func__)); + + switch (message->opg_AttrID) + { + case MUIA_ProcessorGrp_CPUCount: + *store = (IPTR)data->pg_CPUCount; + break; + + case MUIA_ProcessorGrp_SingleMode: + *store = (IPTR)FALSE; + break; + } + + if (!retval) + retval = DoSuperMethodA(CLASS, self, (Msg) message); + + return retval; +} + +IPTR ProcessorGauge__MUIM_ProcessorGrp_Update(Class *CLASS, Object *self, Msg message) +{ + SETUP_PROCGAUGE_INST_DATA; + TEXT buffer[128]; + ULONG i, usage; + + D(bug("[SysMon:ProcGauge] %s()\n", __func__)); + + for (i = 0; i < data->pg_CPUCount; i++) + { +#if SIMULATE_USAGE_FREQ + struct DateStamp ds; + DateStamp(&ds); + usage = (ds.ds_Tick * (i + 1)) % 100; +#else + struct TagItem tags [] = + { + { GCIT_SelectedProcessor, (IPTR)i }, + { GCIT_ProcessorLoad, (IPTR)&usage }, + { TAG_DONE, TAG_DONE } + }; + + usage = 0; + GetCPUInfo(tags); + usage = ((usage >> 16) * 1000) >> 16; +#endif + __sprintf(buffer, "CPU %d\n%d.%d %%", i, usage / 10, usage % 10); + set(data->pg_Gauges[i], MUIA_Gauge_Current, usage); + set(data->pg_Gauges[i], MUIA_Gauge_InfoText, (IPTR)buffer); + } + return 0; +} + +/*** Setup ******************************************************************/ +PROCESSORGRP_CUSTOMCLASS +( + ProcessorGauge, NULL, MUIC_Group, NULL, + OM_NEW, struct opSet *, + OM_DISPOSE, Msg, + OM_SET, struct opSet *, + OM_GET, struct opGet *, + MUIM_ProcessorGrp_Update, Msg +); diff --git a/workbench/system/SysMon/processor_graph.c b/workbench/system/SysMon/processor_graph.c new file mode 100644 index 0000000000..f8ced7ec0b --- /dev/null +++ b/workbench/system/SysMon/processor_graph.c @@ -0,0 +1,315 @@ +/* + Copyright © 2017, The AROS Development Team. All rights reserved. + $Id$ +*/ + +#define DEBUG 0 +#include + +#include +#include +#include +#include + +#include + +#include +#include + +#include "sysmon_intern.h" + +#include "processor.h" + +struct ProcessorGraph_DATA +{ + IPTR pg_Flags; + IPTR pg_CPUCount; + Object **pg_Graphs; + struct Hook *pg_GraphReadHooks; +}; + +struct cpuPen { + ULONG r; + ULONG g; + ULONG b; +}; + +#define PROCESSORPEN_COUNT 8 +struct cpuPen processorPens[PROCESSORPEN_COUNT] = +{ + { 0x9B9B9B9B, 0xDEDEDEDE, 0xC0C0C0C0 }, + { 0x9E9E9E9E, 0x9B9B9B9B, 0xDEDEDEDE }, + { 0xDEDEDEDE, 0x9B9B9B9B, 0xBABABABA }, + { 0xDEDEDEDE, 0xB5B5B5B5, 0x9B9B9B9B }, + { 0xDEDEDEDE, 0x9B9B9B9B, 0x9E9E9E9E }, + { 0xA6A6A6A6, 0xDEDEDEDE, 0x9B9B9B9B }, + { 0x9B9B9B9B, 0xB2B2B2B2, 0xDEDEDEDE }, + { 0xE4E4E4E4, 0xEBEBEBEB, 0x2A2A2A2A } +}; + +#define PROCGF_SINGLE (1 << 1) + +#define SETUP_PROCGRAPH_INST_DATA struct ProcessorGraph_DATA *data = INST_DATA(CLASS, self) + +AROS_UFH3(IPTR, GraphReadProcessorValueFunc, + AROS_UFHA(struct Hook *, procHook, A0), + AROS_UFHA(IPTR *, storage, A2), + AROS_UFHA(IPTR, cpuNo, A1)) +{ + AROS_USERFUNC_INIT + + struct TagItem tags [] = + { + { GCIT_SelectedProcessor, cpuNo }, + { GCIT_ProcessorLoad, (IPTR)storage }, + { TAG_DONE, TAG_DONE } + }; + + D(bug("[SysMon:ProcGraph] %s(%d)\n", __func__, cpuNo);) + + *storage = 0; + + GetCPUInfo(tags); + + *storage = ((*storage >> 16) * 1000) >> 16; + + D(bug("[SysMon:ProcGraph] %s: 0x%p = %d\n", __func__, storage, *storage);) + + return TRUE; + + AROS_USERFUNC_EXIT +} + +ULONG cpusperrow(ULONG x) +{ + register unsigned long op = x, res = 0, one; + + one = 1 << 30; + while (one > op) + one >>= 2; + + while (one != 0) + { + if (op >= res + one) + { + op -= res + one; + res += one << 1; + } + res >>= 1; + one >>= 2; + } + return res; +} + +Object *ProcessorGraph__GraphObject() +{ + return GraphObject, + MUIA_Graph_InfoText, (IPTR) CPU_DEFSTR, + MUIA_Graph_ValueCeiling, 1000, + MUIA_Graph_ValueStep, 100, + MUIA_Graph_PeriodCeiling, 100000, + MUIA_Graph_PeriodStep, 10000, + MUIA_Graph_PeriodInterval, 1000, + End; +} + +Object *ProcessorGraph__OM_NEW(Class *CLASS, Object *self, struct opSet *message) +{ + BOOL singlemode = (BOOL)GetTagData(MUIA_ProcessorGrp_SingleMode, TRUE, message->ops_AttrList); + ULONG processorcount = (ULONG)GetTagData(MUIA_ProcessorGrp_CPUCount, 1, message->ops_AttrList); + Object *procGuage = NULL; + ULONG cpupr = 1; + + D(bug("[SysMon:ProcGraph] %s()\n", __func__)); + + if ((singlemode) || (processorcount == 1)) + { + self = (Object *) DoSuperNewTags(CLASS, self, NULL, + Child, (IPTR)(procGuage = ProcessorGraph__GraphObject()), + TAG_MORE, (IPTR) message->ops_AttrList + ); + } + else + { + if (processorcount <= 4) + cpupr = processorcount; + else if ((cpupr = cpusperrow(processorcount)) < 4) + { + if (processorcount <= 4) + cpupr = processorcount; + else + cpupr = 4; + } + + self = (Object *) DoSuperNewTags(CLASS, self, NULL, + MUIA_Group_Columns, cpupr, + TAG_MORE, (IPTR) message->ops_AttrList + ); + } + + if (self != NULL) + { + APTR procDataSource; + IPTR i; + + SETUP_PROCGRAPH_INST_DATA; + + data->pg_Flags = 0; + data->pg_CPUCount = processorcount; + data->pg_GraphReadHooks = AllocVec(sizeof(struct Hook) * processorcount, MEMF_ANY | MEMF_CLEAR); + + if ((!singlemode) && (processorcount > 1)) + data->pg_Graphs = AllocVec(sizeof(Object *) * processorcount, MEMF_ANY | MEMF_CLEAR); + else + { + data->pg_Graphs = (Object **)procGuage; + data->pg_Flags |= PROCGF_SINGLE; + } + + for (i = 0; i < processorcount; i++) + { + if (!(data->pg_Flags & PROCGF_SINGLE)) + { + data->pg_Graphs[i] = GraphObject, + MUIA_Graph_InfoText, (IPTR) CPU_DEFSTR, + MUIA_Graph_ValueCeiling, 1000, + MUIA_Graph_ValueStep, 100, + MUIA_Graph_PeriodCeiling, 100000, + MUIA_Graph_PeriodStep, 10000, + MUIA_Graph_PeriodInterval, 1000, + MUIA_UserData, i, + End; + + procGuage = data->pg_Graphs[i]; + procDataSource = (APTR)DoMethod(procGuage, MUIM_Graph_GetSourceHandle, 0); + + DoMethod(self, OM_ADDMEMBER, procGuage); + } + else + { + procDataSource = (APTR)DoMethod(procGuage, MUIM_Graph_GetSourceHandle, i); + DoMethod(procGuage, MUIM_Graph_SetSourceAttrib, procDataSource, MUIV_Graph_Source_PenSrc, &processorPens[i % PROCESSORPEN_COUNT]); + } + + data->pg_GraphReadHooks[i].h_Entry = (APTR)GraphReadProcessorValueFunc; + data->pg_GraphReadHooks[i].h_Data = (APTR)i; + + DoMethod(procGuage, MUIM_Graph_SetSourceAttrib, procDataSource, MUIV_Graph_Source_ReadHook, &data->pg_GraphReadHooks[i]); + } + for (i %= cpupr; (i > 0) && (i < cpupr); i ++) + { + DoMethod(self, OM_ADDMEMBER, (IPTR)HVSpace); + } + } + + return self; +} + +IPTR ProcessorGraph__OM_DISPOSE(Class *CLASS, Object *self, Msg message) +{ + SETUP_PROCGRAPH_INST_DATA; + BOOL singlemode = (BOOL)(data->pg_Flags & PROCGF_SINGLE); + IPTR retVal; + + D(bug("[SysMon:ProcGraph] %s()\n", __func__)); + + retVal = DoSuperMethodA(CLASS, self, message); + + FreeVec(data->pg_GraphReadHooks); + if (!singlemode) + FreeVec(data->pg_Graphs); + + return retVal; +} + +IPTR ProcessorGraph__OM_SET(Class *CLASS, Object *self, struct opSet *message) +{ +// SETUP_PROCGRAPH_INST_DATA; + struct TagItem *tstate = message->ops_AttrList, *tag; + + D(bug("[SysMon:ProcGraph] %s()\n", __func__)); + + while ((tag = NextTagItem((struct TagItem **)&tstate)) != NULL) + { + switch (tag->ti_Tag) + { + } + } + return DoSuperMethodA(CLASS, self, (Msg) message); +} + +IPTR ProcessorGraph__OM_GET(Class *CLASS, Object *self, struct opGet *message) +{ + SETUP_PROCGRAPH_INST_DATA; + IPTR *store = message->opg_Storage; + IPTR retval = 0; + + D(bug("[SysMon:ProcGraph] %s()\n", __func__)); + + switch (message->opg_AttrID) + { + case MUIA_ProcessorGrp_CPUCount: + *store = (IPTR)data->pg_CPUCount; + break; + + case MUIA_ProcessorGrp_SingleMode: + *store = (IPTR)(data->pg_Flags & PROCGF_SINGLE); + break; + } + + if (!retval) + retval = DoSuperMethodA(CLASS, self, (Msg) message); + + return retval; +} + +IPTR ProcessorGraph__MUIM_ProcessorGrp_Update(Class *CLASS, Object *self, Msg message) +{ + SETUP_PROCGRAPH_INST_DATA; + TEXT buffer[128]; + ULONG totaluse = 0; + ULONG i; + + D(bug("[SysMon:ProcGraph] %s()\n", __func__)); + + for (i = 0; i < data->pg_CPUCount; i++) + { + ULONG usage = 0; + struct TagItem tags [] = + { + { GCIT_SelectedProcessor, (IPTR)i }, + { GCIT_ProcessorLoad, (IPTR)&usage }, + { TAG_DONE, TAG_DONE } + }; + + GetCPUInfo(tags); + usage = ((usage >> 16) * 1000) >> 16; + + if (!(data->pg_Flags & PROCGF_SINGLE)) + { + __sprintf(buffer, "CPU %d\n%d.%d %%", i, usage / 10, usage % 10); + SET(data->pg_Graphs[i], MUIA_Graph_InfoText, (IPTR)buffer); + } + else + totaluse += usage; + } + + if (data->pg_Flags & PROCGF_SINGLE) + { + totaluse /= data->pg_CPUCount; + __sprintf(buffer, "%d CPU's\n%d.%d %%", data->pg_CPUCount, totaluse / 10, totaluse % 10); + SET((Object *)data->pg_Graphs, MUIA_Graph_InfoText, (IPTR)buffer); + } + return 0; +} + +/*** Setup ******************************************************************/ +PROCESSORGRP_CUSTOMCLASS +( + ProcessorGraph, NULL, MUIC_Group, NULL, + OM_NEW, struct opSet *, + OM_DISPOSE, Msg, + OM_SET, struct opSet *, + OM_GET, struct opGet *, + MUIM_ProcessorGrp_Update, Msg +); diff --git a/workbench/system/SysMon/sysmon_intern.h b/workbench/system/SysMon/sysmon_intern.h index fe6f1a0c18..ac32d90425 100644 --- a/workbench/system/SysMon/sysmon_intern.h +++ b/workbench/system/SysMon/sysmon_intern.h @@ -12,6 +12,7 @@ #include "tasks.h" +/* uncomment to change the default processorgrp options */ //#define PROCDISPLAY_USEGAUGE //#define PROCDISPLAY_SINGLEGRAPH @@ -40,20 +41,18 @@ struct SysMonData CONST_STRPTR tabs[SYSMON_TABCOUNT + 1]; struct Hook pageactivehook; - struct Hook tasklistrefreshhook; - STRPTR tasklistinfobuf; + struct Hook tasklistrefreshhook; + STRPTR tasklistinfobuf; - Object *tasklist; - Object *tasklistinfo; + Object *tasklist; + Object *tasklistinfo; + + struct MUI_CustomClass *cpuusageclass; + Object *cpuusagegroup, + *cpuusageobj; + BOOL cpuusagesinglemode; + struct Hook cpuusagecmhooks[3]; -#if defined (PROCDISPLAY_SINGLEGRAPH) - Object *cpuusagegauge; -#else - Object **cpuusagegauges; -#endif -#if !defined(PROCDISPLAY_USEGAUGE) - struct Hook *cpureadhooks; -#endif Object **cpufreqlabels; Object **cpufreqvalues; @@ -80,45 +79,61 @@ extern struct SysMonModule processormodule; extern struct SysMonModule timermodule; extern struct SysMonModule tasksmodule; -VOID UpdateMemoryInformation(struct SysMonData * smdata); -VOID UpdateMemoryStaticInformation(struct SysMonData * smdata); +VOID UpdateMemoryInformation(struct SysMonData *); +VOID UpdateMemoryStaticInformation(struct SysMonData *); -VOID UpdateVideoInformation(struct SysMonData * smdata); -VOID UpdateVideoStaticInformation(struct SysMonData * smdata); +VOID UpdateVideoInformation(struct SysMonData *); +VOID UpdateVideoStaticInformation(struct SysMonData *); ULONG GetProcessorCount(); -VOID UpdateProcessorInformation(struct SysMonData * smdata); -VOID UpdateProcessorStaticInformation(struct SysMonData * smdata); +VOID UpdateProcessorInformation(struct SysMonData *); +VOID UpdateProcessorStaticInformation(struct SysMonData *); +Object *ProcessorGroupObject(struct SysMonData *, int); -VOID UpdateTasksInformation(struct SysMonData * smdata); -VOID UpdateTasksStaticInformation(struct SysMonData * smdata); +VOID UpdateTasksInformation(struct SysMonData *); +VOID UpdateTasksStaticInformation(struct SysMonData *); struct TaskInfo; AROS_UFP3(struct TaskInfo *, TasksListConstructFunction, - AROS_UFHA(struct Hook *, h, A0), - AROS_UFHA(APTR, pool, A2), - AROS_UFHA(struct Task *, curTask, A1)); + AROS_UFPA(struct Hook *, h, A0), + AROS_UFPA(APTR, pool, A2), + AROS_UFPA(struct Task *, curTask, A1)); AROS_UFP3(VOID, TasksListDestructFunction, - AROS_UFHA(struct Hook *, h, A0), - AROS_UFHA(APTR, pool, A2), - AROS_UFHA(struct TaskInfo *, obj, A1)); + AROS_UFPA(struct Hook *, h, A0), + AROS_UFPA(APTR, pool, A2), + AROS_UFPA(struct TaskInfo *, obj, A1)); AROS_UFP3(APTR, TasksListDisplayFunction, - AROS_UFHA(struct Hook *, h, A0), - AROS_UFHA(STRPTR *, strings, A2), - AROS_UFHA(struct TaskInfo *, obj, A1)); + AROS_UFPA(struct Hook *, h, A0), + AROS_UFPA(STRPTR *, strings, A2), + AROS_UFPA(struct TaskInfo *, obj, A1)); AROS_UFP3(VOID, TaskSelectedFunction, - AROS_UFHA(struct Hook *, h, A0), - AROS_UFHA(Object *, object, A2), - AROS_UFHA(APTR, msg, A1)); + AROS_UFPA(struct Hook *, h, A0), + AROS_UFPA(Object *, object, A2), + AROS_UFPA(APTR, msg, A1)); AROS_UFP3(LONG, TaskCompareFunction, - AROS_UFHA(struct Hook *, h, A0), - AROS_UFHA(struct TaskInfo *, ti2, A2), - AROS_UFHA(struct TaskInfo *, ti1, A1)); + AROS_UFPA(struct Hook *, h, A0), + AROS_UFPA(struct TaskInfo *, ti2, A2), + AROS_UFPA(struct TaskInfo *, ti1, A1)); + +AROS_UFP3(VOID, processorgaugehookfunc, + AROS_UFPA(struct Hook *, h, A0), + AROS_UFPA(Object *, object, A2), + AROS_UFPA(APTR, msg, A1)); + +AROS_UFP3(VOID, processorgraphhookfunc, + AROS_UFPA(struct Hook *, h, A0), + AROS_UFPA(Object *, object, A2), + AROS_UFPA(APTR, msg, A1)); + +AROS_UFP3(VOID, processorgraphpercpuhookfunc, + AROS_UFPA(struct Hook *, h, A0), + AROS_UFPA(Object *, object, A2), + AROS_UFPA(APTR, msg, A1)); ULONG GetSIG_TIMER(); VOID SignalMeAfter(ULONG msecs); -- 2.11.4.GIT