pdutil/h/pdRate.h

   1 /*
   2  * Copyright (c) 1996-1999 Barton P. Miller
   3  *
   4  * We provide the Paradyn Parallel Performance Tools (below
   5  * described as Paradyn") on an AS IS basis, and do not warrant its
   6  * validity or performance.  We reserve the right to update, modify,
   7  * or discontinue this software at any time.  We shall have no
   8  * obligation to supply such updates or modifications or any other
   9  * form of support to you.
  10  *
  11  * This license is for research uses.  For such uses, there is no
  12  * charge. We define "research use" to mean you may freely use it
  13  * inside your organization for whatever purposes you see fit. But you
  14  * may not re-distribute Paradyn or parts of Paradyn, in any form
  15  * source or binary (including derivatives), electronic or otherwise,
  16  * to any other organization or entity without our permission.
  17  *
  18  * (for other uses, please contact us at paradyn@cs.wisc.edu)
  19  *
  20  * All warranties, including without limitation, any warranty of
  21  * merchantability or fitness for a particular purpose, are hereby
  22  * excluded.
  23  *
  24  * By your use of Paradyn, you understand and agree that we (or any
  25  * other person or entity with proprietary rights in Paradyn) are
  26  * under no obligation to provide either maintenance services,
  27  * update services, notices of latent defects, or correction of
  28  * defects for Paradyn.
  29  *
  30  * Even if advised of the possibility of such damages, under no
  31  * circumstances shall we (or any other person or entity with
  32  * proprietary rights in the software licensed hereunder) be liable
  33  * to you or any third party for direct, indirect, or consequential
  34  * damages of any character regardless of type of action, including,
  35  * without limitation, loss of profits, loss of use, loss of good
  36  * will, or computer failure or malfunction.  You agree to indemnify
  37  * us (and any other person or entity with proprietary rights in the
  38  * software licensed hereunder) for any and all liability it may
  39  * incur to third parties resulting from your use of Paradyn.
  40  */
  41
  42 #ifndef RATE_H
  43 #define RATE_H
  44
  45 #include <iostream.h>
  46 #include <assert.h>
  47 #include <math.h>
  48 #include "common/h/Time.h"
  49 #include "common/h/headers.h"   // for isnan on NT
  50 #include "pdutil/h/pdSample.h"
  51
  52
  53 // -----------------------------------------------------------------------
  54 // pdRate class definition ----------------------------------------
  55 class pdRate {
  56  private:
  57   double data;
  58
  59   static const pdRate *_zero;
  60   static const pdRate *_nan;
  61   static const pdRate *nanHelp();
  62  public:
  63   static const pdRate &Zero();
  64   static const pdRate &NaN();    // returns the not-a-number element of pdRate
  65
  66   // Constructors
  67   pdRate()  { setNaN(); }
  68   explicit pdRate(const double v) : data(v) { }
  69   explicit pdRate(const pdSample s, const timeLength t,
  70                   const timeUnit tu = timeUnit::ns()) {
  71     if(s.isNaN())  {  setNaN(); }
  72     else {
  73       data = static_cast<double>(s.getValue()) / t.getD(tu);
  74     }
  75   }
  76
  77   // General Assignment from like type
  78   /*
  79   pdRate& operator=(const pdRate &o) {
  80     if(this != &o) {
  81       this->assign(o);     }
  82     return *this;
  83   }
  84   */
  85
  86   bool isNaN() const {  return (isnan(getValue()) != 0); }
  87   void setNaN() {  *this = NaN(); }
  88
  89   // user-defined operator casts are very bad, More Effective C++ ch.5
  90   // so use non-operator cast function
  91   double getValue() const { return data; }
  92
  93   void assign(const double v)  {  data = v;  }
  94
  95   pdRate& operator+=(const pdRate &a) {
  96     assert(!a.isNaN());
  97     assign(data + a.getValue());
  98     return *this;
  99   }
 100   pdRate& operator-=(const pdRate &a) {
 101     assert(!a.isNaN());
 102     assign(data - a.getValue());
 103     return *this;
 104   }
 105 };
 106
 107 inline const pdRate &pdRate::Zero() {
 108   if(_zero == NULL) _zero = new pdRate(0);
 109   return *_zero;
 110 }
 111
 112 inline const pdRate &pdRate::NaN() {
 113   if(_nan == NULL) {  _nan = nanHelp(); }
 114   return *_nan;
 115 }
 116
 117 // pdRate @ pdRate operators ----------------------------------
 118 inline const pdRate operator+(const pdRate a, const pdRate b) {
 119   assert(!a.isNaN() && !b.isNaN());
 120   return pdRate(a.getValue() + b.getValue());
 121 }
 122 inline const pdRate operator-(const pdRate a, const pdRate b) {
 123   assert(!a.isNaN() && !b.isNaN());
 124   return pdRate(a.getValue() - b.getValue());
 125 }
 126 inline const pdRate operator*(const pdRate a, const pdRate b) {
 127   assert(!a.isNaN() && !b.isNaN());
 128   return pdRate(a.getValue() * b.getValue());
 129 }
 130 inline const pdRate operator/(const pdRate a, const pdRate b) {
 131   assert(!a.isNaN() && !b.isNaN());
 132   return pdRate(a.getValue() / b.getValue());
 133 }
 134
 135 // assumes that the pdRate was formed with pdSample / timeLength.getD(ns())
 136 // don't use if this isn't true
 137 inline const pdSample operator*(const pdRate a, const timeLength b) {
 138   assert(!a.isNaN() && b.isInitialized());
 139   return pdSample(static_cast<int64_t>(a.getValue() * b.getD(timeUnit::ns())));
 140 }
 141
 142 // pdRate * double
 143 inline const pdRate operator*(const pdRate a, const double b) {
 144   assert(!a.isNaN());
 145   return pdRate(a.getValue() * b);
 146 }
 147 // double * pdRate
 148 inline const pdRate operator*(const double a, const pdRate b) {
 149   assert(!b.isNaN());
 150   return pdRate(a * b.getValue());
 151 }
 152 // pdRate / double
 153 inline const pdRate operator/(const pdRate a, const double b) {
 154   assert(!a.isNaN());
 155   return pdRate(a.getValue() / b);
 156 }
 157 // double / pdRate
 158 inline const pdRate operator/(const double a, const pdRate b) {
 159   assert(!b.isNaN());
 160   return pdRate(a / b.getValue());
 161 }
 162
 163
 164 inline bool operator==(const pdRate a, const pdRate b) {
 165   assert(!a.isNaN() && !b.isNaN());
 166   return (a.getValue() == b.getValue());
 167 }
 168 inline bool operator!=(const pdRate a, const pdRate b) {
 169   assert(!a.isNaN() && !b.isNaN());
 170   return (a.getValue() != b.getValue());
 171 }
 172 inline bool operator>(const pdRate a, const pdRate b) {
 173   assert(!a.isNaN() && !b.isNaN());
 174   return (a.getValue() > b.getValue());
 175 }
 176 inline bool operator>=(const pdRate a, const pdRate b) {
 177   assert(!a.isNaN() && !b.isNaN());
 178   return (a.getValue() >= b.getValue());
 179 }
 180 inline bool operator<(const pdRate a, const pdRate b) {
 181   assert(!a.isNaN() && !b.isNaN());
 182   return (a.getValue() < b.getValue());
 183 }
 184 inline bool operator<=(const pdRate a, const pdRate b) {
 185   assert(!a.isNaN() && !b.isNaN());
 186   return (a.getValue() <= b.getValue());
 187 }
 188
 189 ostream& operator<<(ostream&s, const pdRate &sm);
 190
 191 #endif
 192
 193
 194
 195
 196
 197
 198
 199
 200
 201
 202