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