---

InstArray.h

Go to the documentation of this file.

/*
    File:           InstArray.h

    Function:       Instrumented Array for tracking access patterns etc.
                    
    Author(s):      Andrew Willmott

    Copyright:      (c) 1998-2000, Andrew Willmott
*/

#ifndef __InstArray__
#define __InstArray__

#include <iostream.h>
#include "cl/NArray.h"
#include "cl/FileName.h"

class InstArrayStats
{
public:
    InstArrayStats();
    
    Void            Reset();
    Void            StartTrace(const FileName &fname);
    Void            StopTrace();
    Void            Dump();

    Void            Read(Int i);
    Void            Write(Int i);
    
    Int             reads;
    Int             writes;
    Int             *accesses;

    FILE            *trace;
};

#ifdef CL_INST_RW
// this will break on some accesses, because I don't have the patience
// to implement all the +=, *=, etc. operators. Also, it adds considerable
// overhead to reads & writes, so if you don't care about access type,
// you're better off without it.

template <class T> struct RWHelper
{
    RWHelper(InstArrayStats &s, Int i, T &e) : stats(s), idx(i), elem(e) {};

                    operator T()
                    { stats.Read(idx); return(elem); };
    T               &operator = (const T &rhs)
                    { stats.Write(idx); elem = rhs; return(elem); };
    T               &operator += (const T &rhs)
                    { stats.Write(idx); elem += rhs; return(elem); };

    InstArrayStats  &stats;
    Int             idx;
    T               &elem;
};
#endif

template <class T> class InstArray : public NArray<T>
{
public:
                    InstArray() : NArray<T>() {};
                    InstArray(Int size, Int alloc = kFirstNAllocation) :
                        NArray<T>(size, alloc) {};

#ifdef CL_INST_RW
    inline RWHelper<T> operator [] (Int i);     
#else
    inline T        &operator [] (Int i);       
#endif
    inline const T  &operator [] (Int i) const; 

    inline Void     Append(const T &t);         
    inline T        &Last();                    
    inline const T  &Last() const;              

    inline T        &Top();                     
    inline const T  &Top() const;               
    inline Void     Push(const T &t);           

    const T         &Item(Int i) const
                    { return(SELF[i]); };
    T               &Item(Int i)
                    { return(SELF[i]); };

    InstArrayStats  stats;
};


// --- Inlines ----------------------------------------------------------------


#ifdef CL_INST_RW
TMPLArray inline RWHelper<T> InstArray<T>::operator [] (Int i)
{
    CheckRange(i, 0, items, "(InstArray::[]) index out of range");

    return(RWHelper<T>(stats, i, *((T*) (item + i * eltSize))));
}
#else
TMPLArray inline T &InstArray<T>::operator [] (Int i)
{
    CheckRange(i, 0, items, "(InstArray::[]) index out of range");

    stats.Write(i);
    return(*((T*) (item + i * eltSize)));
}
#endif

TMPLArray inline const T &InstArray<T>::operator [] (Int i) const
{
    CheckRange(i, 0, items, "(InstArray::[]) index out of range");

    stats.Read(i);
    return(*((T*) (item + i * eltSize)));
}

TMPLArray inline T &InstArray<T>::Top()
{
    stats.Write(i);
    return(*((T*) (item + (items - 1) * eltSize)));
}

TMPLArray inline T &InstArray<T>::Last()
{
    stats.Write(i);
    return(*((T*) (item + (items - 1) * eltSize)));
}

TMPLArray inline const T &InstArray<T>::Top() const
{
    stats.Read(i);
    return(*((T*) (item + (items - 1) * eltSize)));
}

TMPLArray inline const T &InstArray<T>::Last() const
{
    stats.Read(i);
    return(*((T*) (item + (items - 1) * eltSize)));
}

TMPLArray inline Void InstArray<T>::Push(const T &t)
{
    if (items >= allocated)
        Grow();
    
    stats.Write(i);
    memcpy(item + eltSize * items++, &t, eltSize);
}

TMPLArray inline Void InstArray<T>::Append(const T &t)
{
    if (items >= allocated)
        Grow();
    
    stats.Write(i);
    memcpy(item + eltSize * items++, &t, eltSize);
}

#endif

---