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