changed parameters to DM_sequential_init
[dyninst.git] / paradyn / src / DMthread / DMmetric.h
1 /*
2  * Copyright (c) 1993, 1994 Barton P. Miller, Jeff Hollingsworth,
3  *     Bruce Irvin, Jon Cargille, Krishna Kunchithapadam, Karen
4  *     Karavanic, Tia Newhall, Mark Callaghan.  All rights reserved.
5  *
6  * This software is furnished under the condition that it may not be
7  * provided or otherwise made available to, or used by, any other
8  * person, except as provided for by the terms of applicable license
9  * agreements.  No title to or ownership of the software is hereby
10  * transferred.  The name of the principals may not be used in any
11  * advertising or publicity related to this software without specific,
12  * written prior authorization.  Any use of this software must include
13  * the above copyright notice.
14  *
15  */
16 #ifndef dmmetric_H
17 #define dmmetric_H
18 #include "util/h/sys.h"
19 #include "util/h/hist.h"
20 #include "dataManager.thread.h"
21 #include "dataManager.thread.SRVR.h"
22 #include <string.h>
23 #include "paradyn/src/UIthread/Status.h"
24 #include <stdlib.h>
25 #include "util/h/Vector.h"
26 #include "util/h/Dictionary.h"
27 #include "util/h/String.h"
28 #include "DMinclude.h"
29 #include "DMdaemon.h"
30
31
32 class metricInstance;
33
34 // a part of an mi.
35 //
36 class component {
37     friend class metricInstance;
38     friend class paradynDaemon;
39     public:
40         component(paradynDaemon *d, int i, metricInstance *mi) {
41             daemon = d;
42             id = i;
43             // Is this add unique?
44             assert(i >= 0);
45             d->activeMids[(unsigned)id] = mi;
46         }
47         ~component() {
48             daemon->disableDataCollection(id);
49             assert(id>=0);
50             daemon->disabledMids += (unsigned) id;
51             daemon->activeMids.undef((unsigned)id);
52         }
53         int getId(){return(id);}
54     private:
55         sampleInfo sample;
56         paradynDaemon *daemon;
57         int id;
58 };
59
60
61 //
62 //  info about a metric in the system
63 //
64 class metric {
65     friend class dataManager;
66     friend class metricInstance;
67     friend class paradynDaemon;
68     friend void addMetric(T_dyninstRPC::metricInfo &info);
69     friend void histDataCallBack(sampleValue *, timeStamp , 
70                                  int , int , void *);
71     // TODO: remove these when PC is re-written ***************
72     friend void PCmetricFunc(perfStreamHandle, const char *name,
73                              int style, int aggregate,
74                              const char *units, metricHandle m_handle);
75     friend void PCmain(void* varg);
76     friend class PCmetric;
77     friend void PCnewData(perfStreamHandle,metricInstanceHandle,
78                           int,sampleValue);
79     // ********************************************************
80     public:
81         metric(T_dyninstRPC::metricInfo i); 
82         const T_dyninstRPC::metricInfo  *getInfo() { return(&info); }
83         const char *getName() { return((info.name.string_of()));}
84         const char *getUnits() { return((info.units.string_of()));}
85         metricHandle getHandle() { return(info.handle);}
86         metricStyle  getStyle() { return((metricStyle) info.style); }
87         int   getAggregate() { return info.aggregate;}
88
89         static unsigned  size(){return(metrics.size());}
90         static const T_dyninstRPC::metricInfo  *getInfo(metricHandle handle);
91         static const char *getName(metricHandle handle);
92         static const metricHandle  *find(const string name); 
93         static vector<string> *allMetricNames();
94         static vector<met_name_id> *allMetricNamesIds();
95
96     private:
97         static dictionary_hash<string, metric*> allMetrics;
98         static vector<metric*> metrics;  // indexed by metric id
99         T_dyninstRPC::metricInfo info;
100
101         static metric  *getMetric(metricHandle iName); 
102 };
103
104 struct archive_type {
105     Histogram *data;
106     phaseHandle phaseId;
107 };
108
109 typedef struct archive_type ArchiveType;
110
111 class metricInstance {
112     friend class dataManager;
113     friend class metric;
114     friend class paradynDaemon;
115     friend void histDataCallBack(sampleValue *buckets, timeStamp, int count, 
116                                  int first, void *arg);
117     // TODO: remove these when PC is re-written ***************
118     friend void PCnewData(perfStreamHandle,metricInstanceHandle,
119                           int,sampleValue);
120     friend class datum;
121     friend class PCmetric;
122     // ********************************************************
123     public:
124         metricInstance(resourceListHandle rl, metricHandle m,phaseHandle ph);
125         ~metricInstance(); 
126         float getValue() {
127             float ret;
128             if (!data) abort();
129             ret = data->getValue();
130             ret /= enabledTime;
131             return(ret);
132         }
133         float getTotValue() {
134             float ret;
135
136             if (!data) abort();
137             ret = data->getValue();
138             return(ret);
139         }
140         int currUsersCount(){return(users.size());}
141         int globalUsersCount(){return(global_users.size());}
142         int getSampleValues(sampleValue*, int, int, phaseType);
143         int getArchiveValues(sampleValue*, int, int, phaseHandle);
144
145         static unsigned  mhash(const metricInstanceHandle &val){
146             return((unsigned)val);
147         }
148         metricInstanceHandle getHandle(){ return(id); }
149         metricHandle getMetricHandle(){ return(met); }
150         resourceListHandle getFocusHandle(){ return(focus); }
151         void addInterval(timeStamp s,timeStamp e,sampleValue v,bool b){
152              if(data) 
153                  data->addInterval(s,e,v,b);
154              if(global_data)
155                  global_data->addInterval(s,e,v,b);
156         }
157         // void disableDataCollection(perfStreamHandle ps);
158
159         bool isEnabled(){return(enabled);}
160         void setEnabled(){ enabled = true;}
161         void clearEnabled(){ enabled = false;}
162         void setPersistentData(){ persistent_data = true; } 
163         void setPersistentCollection(){ persistent_collection = true; } 
164         void clearPersistentData(){ persistent_data = false; } 
165         void clearPersistentCollection(){ persistent_collection = false; } 
166         bool isDataPersistent(){ return persistent_data;}
167         bool isCollectionPersistent(){ return persistent_collection;}
168         // returns false if componet was already on list (not added)
169         bool addComponent(component *new_comp);
170         bool addPart(sampleInfo *new_part);
171
172         static timeStamp GetGlobalWidth(){return(global_bucket_width);}
173         static timeStamp GetCurrWidth(){return(curr_bucket_width);}
174         static void SetGlobalWidth(timeStamp nw){global_bucket_width = nw;}
175         static void SetCurrWidth(timeStamp nw){curr_bucket_width = nw;}
176         static phaseHandle GetCurrPhaseId(){return(curr_phase_id);}
177         static void setPhaseId(phaseHandle ph){curr_phase_id = ph;}
178         static void stopAllCurrentDataCollection(phaseHandle);
179
180     private:
181         metricHandle met;
182         resourceListHandle focus;
183         float enabledTime;
184         bool enabled;    // set if data for mi is currently enabled
185         vector<sampleInfo *> parts;
186         vector<component *> components;
187
188         vector<perfStreamHandle> users;  // subscribers to curr. phase data
189         Histogram *data;                 // data corr. to curr. phase
190         vector<perfStreamHandle> global_users;  // subscribers to global data
191         Histogram *global_data;     // data corr. to global phase
192         vector<ArchiveType *> old_data;  // histograms of data from old phases 
193         
194         // if set, archive old data on disable and on new phase definition
195         bool persistent_data;  
196         // if set, don't disable on new phase definition
197         bool persistent_collection; 
198
199         unsigned id;
200         sampleInfo sample;
201         static dictionary_hash<metricInstanceHandle,metricInstance *> 
202             allMetricInstances;
203
204         // vector of ids...reuse ids of deleted metricInstances
205         static vector<bool> nextId;
206
207         // info. about phase data
208         static phaseHandle curr_phase_id;  // TODO: set this on Startphase
209         static timeStamp global_bucket_width;  // updated on fold
210         static timeStamp curr_bucket_width;    // updated on fold
211
212         static metricInstance *getMI(metricInstanceHandle);
213         static metricInstance *find(metricHandle, resourceListHandle);
214         void newCurrDataCollection(metricStyle, dataCallBack, foldCallBack);
215         void newGlobalDataCollection(metricStyle, dataCallBack, foldCallBack);
216         void addCurrentUser(perfStreamHandle p); 
217         void addGlobalUser(perfStreamHandle p); 
218         // clear enabled flag and remove comps and parts
219         void dataDisable();  
220         void removeGlobalUser(perfStreamHandle);
221         void removeCurrUser(perfStreamHandle);
222         void deleteCurrHistogram();
223 };
224 #endif