removed all code associated with class visi_MRList
[dyninst.git] / visi / h / datagrid.h
1 #ifndef _datagrid_h
2 #define _datagrid_h
3 /*
4  * Copyright (c) 1993, 1994 Barton P. Miller, Jeff Hollingsworth,
5  *     Bruce Irvin, Jon Cargille, Krishna Kunchithapadam, Karen
6  *     Karavanic, Tia Newhall, Mark Callaghan.  All rights reserved.
7  * 
8  * This software is furnished under the condition that it may not be
9  * provided or otherwise made available to, or used by, any other
10  * person, except as provided for by the terms of applicable license
11  * agreements.  No title to or ownership of the software is hereby
12  * transferred.  The name of the principals may not be used in any
13  * advertising or publicity related to this software without specific,
14  * written prior authorization.  Any use of this software must include
15  * the above copyright notice.
16  *
17  */
18
19 /* $Log: datagrid.h,v $
20 /* Revision 1.12  1994/08/11 02:49:35  newhall
21 /* removed deleted member to gridcell
22 /*
23  * Revision 1.11  1994/07/30  03:25:25  newhall
24  * added enabled member to gridcell to indicate that the metric associated
25  * w/ this cell has been enabled and data will arrive for it eventually
26  * updated member functions affected by this addition
27  *
28  * Revision 1.10  1994/07/20  22:17:20  newhall
29  * added FirstValidBucket method function to visi_GridCellHisto class
30  *
31  * Revision 1.9  1994/06/16  18:21:46  newhall
32  * bug fix to AddNewValues
33  *
34  * Revision 1.8  1994/06/07  17:47:16  newhall
35  * added method functions to support adding metrics
36  * and resources to an existing data grid
37  *
38  * Revision 1.7  1994/05/23  20:55:16  newhall
39  * To visi_GridCellHisto class: added deleted flag, SumValue
40  * method function, and fixed AggregateValue method function
41  *
42  * Revision 1.6  1994/05/11  17:11:03  newhall
43  * changed data values from double to float
44  *
45  * Revision 1.5  1994/04/13  21:22:51  newhall
46  * *** empty log message ***
47  *
48  * Revision 1.4  1994/03/26  04:17:44  newhall
49  * change all floats to double
50  *
51  * Revision 1.3  1994/03/17  05:17:25  newhall
52  * added lastBucketFilled data member to class visi_GridCellHisto:  value of
53  * the largest bucket number for which new data values have been added
54  *
55  * Revision 1.2  1994/03/15  02:03:19  newhall
56  * added public member "userdata" to class visi_GridCellHisto
57  * to allow visi writer to add info to grid cells
58  *
59  * Revision 1.1  1994/03/14  20:27:26  newhall
60  * changed visi subdirectory structure
61  *  */ 
62 /////////////////////////////////
63 //  Data Grid Class definitions
64 /////////////////////////////////
65
66 #include <string.h>
67 #include  <math.h>
68 #include <values.h>
69 #include "visiTypes.h"
70
71 #define SUM     0
72 #define AVE     1
73
74 class Metric{
75      char       *units;    // how units are measured  i.e. "ms" 
76      char       *name;     // for y-axis labeling  
77      int         Id;       // unique metric Id
78      int         aggregate; //either SUM or AVE, for fold operation 
79   public:
80      Metric(){units = NULL; name = NULL; Id = NOVALUE; aggregate=SUM;}
81      Metric(char* ,char*,int,int); 
82      ~Metric(){delete[] units;delete[] name;} 
83      char       *Units(){return(units);}
84      char       *Name(){return(name);}
85      int         Identifier(){return(Id);}
86      int         Aggregate(){return(aggregate);}
87 };
88
89
90 class Resource{
91      char    *name;     // obj. name for graph labeling
92      int      Id;       // unique resource id
93    public:
94      Resource(){name = NULL; Id = -1;}
95      Resource(char*,int);
96      ~Resource(){ delete[] name;} 
97      char     *Name(){return(name);}
98      int       Identifier(){return(Id);}
99 };
100
101
102 ///////////////////////////////////////////////////////////////////
103 // visi_GridCellHisto: 
104 // size: number of buckets
105 // lastBucketFilled: number of full buckets 
106 // valid:   indicates that the cell contains histogram data  
107 // enabled: indicates that the cell can accept data values 
108 // if enabled == 0 then no values can be added to the data grid
109 // if enabled == 1 and valid == 1 then data values are present
110 // if enabled == 1 and valid == 0 then values are not present, 
111 //                                but instrumentation  has been
112 //                                enabled for this cell
113 ///////////////////////////////////////////////////////////////////
114
115 class visi_GridCellHisto {
116   private:
117      int   valid;    // set when data values are present for this cell
118      int   firstValidBucket;  // first index into "value" that is not NaN
119      int   size;              // size of array "value"
120      int   lastBucketFilled;  // bucket number of last data value added
121      int   enabled;   // set when data values can be added to this cell
122      sampleType *value;   // array of data values
123   public: 
124      void *userdata;  // to allow visi writer to add info to grid cells
125      visi_GridCellHisto(){value = NULL; valid = 0; size = 0; 
126                           userdata = NULL; lastBucketFilled = -1; 
127                           firstValidBucket = -1; enabled = 0;}
128      visi_GridCellHisto(int);
129      ~visi_GridCellHisto(){delete[] value; valid = 0; enabled = 0; size = 0;}
130      int    LastBucketFilled(){return(lastBucketFilled);}
131      sampleType  *Value(){ return(value);}
132
133      sampleType  Value(int i) { 
134             if((i < 0) || (i > size)){
135              return(ERROR);
136             }
137             return(value[i]);
138      }
139
140      int    Size(){return(size);}
141      int    Valid(){return(valid);}
142      int    Enabled(){return(enabled);}
143      void   SetEnabled(){enabled = 1;}
144      void   ClearEnabled(){enabled = 0;}
145      int    FirstValidBucket() { return(firstValidBucket); }
146      void   Invalidate(){delete[] value; value = NULL; size = 0; 
147                          valid = 0; lastBucketFilled = -1;}
148
149      int    AddNewValues(sampleType *temp,
150                          int arraySize,
151                          int lbf,
152                          void *ud,
153                          int v, 
154                          int e){
155         
156         if(temp == NULL){
157           value = NULL;
158           size = 0;
159         }
160         else{
161           // initialize cell to temp values
162           value = new sampleType[arraySize];
163           size = arraySize;
164           for(int i=0;i<size;i++){
165             if(!isnan(temp[i])){
166               value[i] = temp[i]; 
167               if(firstValidBucket == -1)
168                  firstValidBucket = i;
169             }
170             else
171               value[i] = ERROR; 
172           }
173         }
174         lastBucketFilled = lbf;
175         userdata = ud;
176         valid = v;
177         enabled = e;
178         return(OK);
179      }
180
181      void   Fold(int method){
182        int i,j;
183        if(valid){
184          firstValidBucket = -1;
185          for(i=0,j=0;(i< (lastBucketFilled+1)/2) // new bucket counter
186              && (j< (lastBucketFilled+1)); // old bucket counter
187              i++,j+=2){
188            if((!isnan(value[j])) && (!isnan(value[j+1]))){
189              value[i] = value[j] + value[j+1];
190              if(firstValidBucket == -1){
191                firstValidBucket = i;
192              }
193            }
194            else{
195              value[i] = ERROR;
196            }
197            if((value[i] != ERROR))
198              value[i] = value[i]/2; 
199          }
200          for(i=(lastBucketFilled+1)/2; i < size; i++){
201            value[i] = ERROR;
202          }
203          lastBucketFilled = ((lastBucketFilled+1)/2)-1;
204        }
205      }
206
207      sampleType  SumValue(timeType width){
208        int i;
209        sampleType sum;
210
211         if(value != NULL){
212            for(sum=0.0,i=0; i< size; i++){
213              if(!isnan(value[i])){
214                sum += value[i]; 
215              }
216            }
217            return(sum*width);
218         }
219         else{
220           return(ERROR);
221         }
222      }
223
224      sampleType  AggregateValue(int method){
225         int i,num;
226         sampleType sum;
227
228         if(value != NULL){
229            for(sum=0.0,num=i=0; i< size; i++){
230              if(!isnan(value[i])){
231                sum += value[i]; 
232                num++;
233              }
234            }
235
236            if(num != 0){
237              return(sum/(1.0*num));
238            }
239            else{
240              return(ERROR);
241            }
242         }
243         else{
244           visi_ErrorHandler(ERROR_AGGREGATE,"values == NULL");
245           return(ERROR_AGGREGATE);
246         }
247      }
248
249      int    AddValue(sampleType x,
250                      int i,
251                      int numElements){
252         
253        int j;
254
255        if (!enabled){ // if this cell has not been enabled don't add values
256          return(OK);
257        }
258        if (!valid){ // if this is the first value create a histo cell array 
259          if(value == NULL)
260            value = new sampleType[numElements];
261          size = numElements;
262          valid = 1;
263          enabled = 1;
264          for(j=0;j<size;j++){
265            value[j] = ERROR;
266          }
267        }
268        if((i < 0) || (i >= size))
269          return(ERROR_SUBSCRIPT);
270        value[i] = x;
271        if(i > lastBucketFilled)
272         lastBucketFilled = i;
273        if(firstValidBucket == -1)
274          firstValidBucket = i;
275        return(OK);
276      }
277
278      sampleType  operator[](int i){
279        if((i >= size) || (i < 0)){
280          visi_ErrorHandler(ERROR_SUBSCRIPT,
281                            "error in [] operator in histogridcell");
282          return(ERROR);
283        }
284        return(value[i]);
285      }
286 };
287
288
289 ////////////////////////////////////////
290 // visi_GridCellHisto: 
291 ////////////////////////////////////////
292 class  visi_GridHistoArray {
293    private:
294       visi_GridCellHisto *values;
295       int size;
296    public:
297       visi_GridHistoArray(){values = NULL; size = 0;}
298       visi_GridHistoArray(int);
299       ~visi_GridHistoArray();
300
301       int LastBucketFilled(int resource){
302          if((resource < 0) || (resource >= size))
303            return(ERROR_SUBSCRIPT);
304          else
305            return(values[resource].LastBucketFilled());
306       }
307
308       int AddValue(sampleType x,
309                    int resource,
310                    int bucketNum,
311                    int numBuckets){
312
313          if((resource < 0) || (resource >= size))
314            return(ERROR_SUBSCRIPT);
315          return(values[resource].AddValue(x,bucketNum,numBuckets));
316       }
317       int   Size(){ return(size);}
318       visi_GridCellHisto *Value(){return(values);}
319       int    Valid(int);
320       int    Invalidate(int);
321       int    AddNewResources(int);
322       int    AddNewValues(visi_GridCellHisto *,int);
323
324       void   Fold(int method){
325         int i;
326         for(i=0; i< size; i++)
327           values[i].Fold(method);
328       } 
329
330       sampleType  AggregateValue(int i,
331                              int method){
332         if((i>=0)&&(i<size))
333           return(values[i].AggregateValue(method));
334         else
335           return(ERROR);
336       }
337       sampleType  SumValue(int i,timeType width){
338         if((i>=0)&&(i<size))
339           return(values[i].SumValue(width));
340         else
341           return(ERROR);
342       }
343
344       visi_GridCellHisto&   operator[](int i){
345         if ((i>= 0) && (i < size)){
346           return(values[i]);
347         }
348         else{
349           visi_ErrorHandler(ERROR_SUBSCRIPT,
350                             "error in [] operator GridHistoArray");
351           return(values[0]);
352         }
353       }
354 };
355
356
357 ///////////////////////////////////////////////////////////////
358 // visi_DataGrid: 
359 // metrics:  list of metric info. for metrics in data grid 
360 // resources: list of resource info. for resources in data grid 
361 // numBins: number of bins in the histogram of each datagrid cell 
362 // binWidth: size of each bin in seconds
363 // data_values: array of size numMetrics each containing an array
364 //              of size numResources
365 ///////////////////////////////////////////////////////////////
366 class visi_DataGrid {
367  protected:
368      Metric     *metrics;
369      Resource   *resources;
370      int         numMetrics;
371      int         numResources;
372      int         numBins;
373      timeType    binWidth;
374      visi_GridHistoArray  *data_values;
375   public:
376      visi_DataGrid(){
377          metrics=NULL; 
378          resources=NULL; 
379          numMetrics=numResources=0;
380          data_values=NULL; 
381          numBins= 0; 
382          binWidth=0.0;
383      }
384
385      visi_DataGrid(int,int,Metric *,Resource *,int,timeType);
386      visi_DataGrid(int,int,visi_metricType *,visi_resourceType *,int,timeType);
387      virtual ~visi_DataGrid();
388      char      *MetricName(int i);
389      char      *MetricUnits(int i);
390      char      *ResourceName(int j);
391      int        NumMetrics(){return(numMetrics);}
392      int        FoldMethod(int);
393      int        NumResources(){return(numResources);}
394      int        MetricId(int); // returns metric Id
395      int        ResourceId(int); // returns Resource Id
396      int        NumBins(){return(numBins);}
397      timeType   BinWidth(){return(binWidth);}
398      int        Valid(int,int);  
399      int        Invalidate(int,int);
400      int        AddNewMetrics(int,visi_metricType *);
401      int        AddNewResource(int,visi_resourceType *);
402      int        ResourceInGrid(int);
403      int        MetricInGrid(int);
404
405      sampleType AggregateValue(int i,int j){
406        if((i>=0)&&(i<numMetrics))
407          return(data_values[i].AggregateValue(j,metrics[i].Aggregate())); 
408        else
409          return(ERROR);
410      }
411
412      sampleType  SumValue(int i,int j){
413        if((i>=0)&&(i<numMetrics))
414          return(data_values[i].SumValue(j,binWidth)); 
415        else
416          return(ERROR);
417      }
418
419      void  Fold(timeType width){
420        int i;
421        for(i=0; i < numMetrics; i++)
422          data_values[i].Fold(metrics[i].Aggregate());
423        binWidth = width;
424      }
425
426      int AddValue(int metric, 
427                   int resource, 
428                   int bucket,
429                   sampleType value){
430         if((metric < 0) || (metric >= numMetrics))
431            return(ERROR_SUBSCRIPT);
432         return(data_values[metric].AddValue(value,resource,bucket,numBins));
433      }
434
435      visi_GridHistoArray&  operator[](int i){
436         if((i < 0) || (i >= numMetrics)){
437            visi_ErrorHandler(ERROR_SUBSCRIPT,
438                            "error in [] operator DATAGRID");
439            return(data_values[0]);
440         }
441         return(data_values[i]);
442      }
443
444      int LastBucketFilled(int metric,int resource){
445         if((metric < 0) || (metric >= numMetrics))
446           return(ERROR_SUBSCRIPT);
447         return(data_values[metric].LastBucketFilled(resource));
448      }
449
450 };
451 #endif