Main Page   Class Hierarchy   Compound List   File List   Compound Members   File Members  

InstArray.h

Go to the documentation of this file.
00001 /*
00002     File:           InstArray.h
00003 
00004     Function:       Instrumented Array for tracking access patterns etc.
00005                     
00006     Author(s):      Andrew Willmott
00007 
00008     Copyright:      (c) 1998-2000, Andrew Willmott
00009 */
00010 
00011 #ifndef __InstArray__
00012 #define __InstArray__
00013 
00014 #include <iostream.h>
00015 #include "cl/NArray.h"
00016 #include "cl/FileName.h"
00017 
00018 class InstArrayStats
00019 {
00020 public:
00021     InstArrayStats();
00022     
00023     Void            Reset();
00024     Void            StartTrace(const FileName &fname);
00025     Void            StopTrace();
00026     Void            Dump();
00027 
00028     Void            Read(Int i);
00029     Void            Write(Int i);
00030     
00031     Int             reads;
00032     Int             writes;
00033     Int             *accesses;
00034 
00035     FILE            *trace;
00036 };
00037 
00038 #ifdef CL_INST_RW
00039 // this will break on some accesses, because I don't have the patience
00040 // to implement all the +=, *=, etc. operators. Also, it adds considerable
00041 // overhead to reads & writes, so if you don't care about access type,
00042 // you're better off without it.
00043 
00044 template <class T> struct RWHelper
00045 {
00046     RWHelper(InstArrayStats &s, Int i, T &e) : stats(s), idx(i), elem(e) {};
00047 
00048                     operator T()
00049                     { stats.Read(idx); return(elem); };
00050     T               &operator = (const T &rhs)
00051                     { stats.Write(idx); elem = rhs; return(elem); };
00052     T               &operator += (const T &rhs)
00053                     { stats.Write(idx); elem += rhs; return(elem); };
00054 
00055     InstArrayStats  &stats;
00056     Int             idx;
00057     T               &elem;
00058 };
00059 #endif
00060 
00061 template <class T> class InstArray : public NArray<T>
00062 {
00063 public:
00064                     InstArray() : NArray<T>() {};
00065                     InstArray(Int size, Int alloc = kFirstNAllocation) :
00066                         NArray<T>(size, alloc) {};
00067 
00068 #ifdef CL_INST_RW
00069     inline RWHelper<T> operator [] (Int i);     
00070 #else
00071     inline T        &operator [] (Int i);       
00072 #endif
00073     inline const T  &operator [] (Int i) const; 
00074 
00075     inline Void     Append(const T &t);         
00076     inline T        &Last();                    
00077     inline const T  &Last() const;              
00078 
00079     inline T        &Top();                     
00080     inline const T  &Top() const;               
00081     inline Void     Push(const T &t);           
00082 
00083     const T         &Item(Int i) const
00084                     { return(SELF[i]); };
00085     T               &Item(Int i)
00086                     { return(SELF[i]); };
00087 
00088     InstArrayStats  stats;
00089 };
00090 
00091 
00092 // --- Inlines ----------------------------------------------------------------
00093 
00094 
00095 #ifdef CL_INST_RW
00096 TMPLArray inline RWHelper<T> InstArray<T>::operator [] (Int i)
00097 {
00098     CheckRange(i, 0, items, "(InstArray::[]) index out of range");
00099 
00100     return(RWHelper<T>(stats, i, *((T*) (item + i * eltSize))));
00101 }
00102 #else
00103 TMPLArray inline T &InstArray<T>::operator [] (Int i)
00104 {
00105     CheckRange(i, 0, items, "(InstArray::[]) index out of range");
00106 
00107     stats.Write(i);
00108     return(*((T*) (item + i * eltSize)));
00109 }
00110 #endif
00111 
00112 TMPLArray inline const T &InstArray<T>::operator [] (Int i) const
00113 {
00114     CheckRange(i, 0, items, "(InstArray::[]) index out of range");
00115 
00116     stats.Read(i);
00117     return(*((T*) (item + i * eltSize)));
00118 }
00119 
00120 TMPLArray inline T &InstArray<T>::Top()
00121 {
00122     stats.Write(i);
00123     return(*((T*) (item + (items - 1) * eltSize)));
00124 }
00125 
00126 TMPLArray inline T &InstArray<T>::Last()
00127 {
00128     stats.Write(i);
00129     return(*((T*) (item + (items - 1) * eltSize)));
00130 }
00131 
00132 TMPLArray inline const T &InstArray<T>::Top() const
00133 {
00134     stats.Read(i);
00135     return(*((T*) (item + (items - 1) * eltSize)));
00136 }
00137 
00138 TMPLArray inline const T &InstArray<T>::Last() const
00139 {
00140     stats.Read(i);
00141     return(*((T*) (item + (items - 1) * eltSize)));
00142 }
00143 
00144 TMPLArray inline Void InstArray<T>::Push(const T &t)
00145 {
00146     if (items >= allocated)
00147         Grow();
00148     
00149     stats.Write(i);
00150     memcpy(item + eltSize * items++, &t, eltSize);
00151 }
00152 
00153 TMPLArray inline Void InstArray<T>::Append(const T &t)
00154 {
00155     if (items >= allocated)
00156         Grow();
00157     
00158     stats.Write(i);
00159     memcpy(item + eltSize * items++, &t, eltSize);
00160 }
00161 
00162 #endif

Generated at Sat Aug 5 00:16:32 2000 for Class Library by doxygen 1.1.0 written by Dimitri van Heesch, © 1997-2000