usermode/library/malloc-hoard-old/src/heapstats.h

//
// Hoard: A Fast, Scalable, and Memory-Efficient Allocator
//        for Shared-Memory Multiprocessors
// Contact author: Emery Berger, http://www.cs.utexas.edu/users/emery
//
// Copyright (c) 1998-2000, The University of Texas at Austin.
//
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Library General Public License as
// published by the Free Software Foundation, http://www.fsf.org.
//
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Library General Public License for more details.
//
#ifndef _HEAPSTATS_H_
#define _HEAPSTATS_H_

#include "config.h"

#include <stdio.h>
#include <assert.h>


class heapStats {
public:

  heapStats (void)
    : 
    U (0),
    A (0)
#if HEAP_STATS
    ,Umax (0),
    Amax (0)
#endif
  {}

  inline const heapStats& operator= (const heapStats& p);

  inline void incStats (int updateU, int updateA);
  inline void incUStats (void);

  inline void decStats (int updateU, int updateA);
  inline void decUStats (void);
  inline void decUStats (int& Uout, int& Aout);

  inline void getStats (int& Uout, int& Aout);


#if HEAP_STATS
  
  inline int getUmax (void);
  inline int getAmax (void);

#endif


private:

  // U and A *must* be the first items in this class --
  // we will depend on this to atomically update them.

  int U;        // Memory in use.
  int A;        // Memory allocated.

#if HEAP_STATS
  int Umax;
  int Amax;
#endif
};


inline void heapStats::incStats (int updateU, int updateA) 
{
  assert (updateU >= 0);
  assert (updateA >= 0);
  assert (U <= A);
  assert (U >= 0);
  assert (A >= 0);
  U += updateU;
  A += updateA;
#if HEAP_STATS
  Amax = MAX (Amax, A);
  Umax = MAX (Umax, U);
#endif
  assert (U <= A);
  assert (U >= 0);
  assert (A >= 0);
}


inline void heapStats::incUStats (void)
{
  assert (U < A);
  assert (U >= 0);
  assert (A >= 0);
  U++;
#if HEAP_STATS
  Umax = MAX (Umax, U);
#endif
  assert (U >= 0);
  assert (A >= 0);
}


inline void heapStats::decStats (int updateU, int updateA)
{
  assert (updateU >= 0);
  assert (updateA >= 0);
  assert (U <= A);
  assert (U >= updateU);
  assert (A >= updateA);
  U -= updateU;
  A -= updateA;
  assert (U <= A);
  assert (U >= 0);
  assert (A >= 0);
}


inline void heapStats::decUStats (int& Uout, int& Aout) 
{
  assert (U <= A);
  assert (U > 0);
  assert (A >= 0);
  U--;
  Uout = U;
  Aout = A;
  assert (U >= 0);
  assert (A >= 0);
}


inline void heapStats::decUStats (void) 
{
  assert (U <= A);
  assert (U > 0);
  assert (A >= 0);
  U--;
}


inline void heapStats::getStats (int& Uout, int& Aout) 
{
  assert (U >= 0);
  assert (A >= 0);
  Uout = U;
  Aout = A;
  assert (U <= A);
  assert (U >= 0);
  assert (A >= 0);
}


#if HEAP_STATS
inline int heapStats::getUmax (void) 
{
  return Umax;
}


inline int heapStats::getAmax (void) 
{
  return Amax;
}
#endif // HEAP_STATS



#endif // _HEAPSTATS_H_

---