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