AbstractTopology.h

Go to the documentation of this file.

 
/*
 *  @author János Végh (jvegh)
 *  @bug No known bugs.
*/
 
 
#ifndef ABSTRACTTOPOLOGY_H
#define ABSTRACTTOPOLOGY_H
 
//#include <iomanip>      // std::setfill, std::setw
//#include <vector>
//#include <iostream>     // std::cout, std::ios
//#include <sstream>      // std::ostringstream
//#include <bitset>         // std::bitset
//#include "GridPoint.h"
#include "MemoryClustering.h"
class GridPoint;
 
using namespace std;
 
const std::vector<char> GridXOffset {0,0,1, 1, 0,-1,-1};
const std::vector<char> GridYOffset {0,2,1,-1,-2,-1, 1};
 
// Here a  is assumed for the physical scGridPoints
// and the HThreads running on the , sharing its resources
// The core exists only in one instantiation, but data structures
// belonging to independent HThreads are partly stored in the scGridPoint, in arrays
 
extern int YFromPosition_Get(int x, int y);
class AbstractTopology
{
  public:
    AbstractTopology(void);
    virtual ~AbstractTopology(void); // Must be overridden
    int NumberOfGridPoints_Get(void) {return GRID_SIZE_X * GRID_SIZE_Y; }
    int NumberOfClusters_Get(void){return mClusters.size();}
    // Accessor functions: without thread, the physical access (0th HThread)
        GridPoint*
    ByID_Get(const int N); 
        GridPoint*
    ByIndex_Get(const int X, const int Y);  
        GridPoint*
    ByPosition_Get(int X, int Y);   
    // Helper functions for address calculation
        int
    LinearAddressFromCoordinates_Get( int X, int Y)
    {   assert(!(X<0 || X>=GRID_SIZE_X));   assert(!(Y<0 || Y>=GRID_SIZE_Y));
        return  X*GRID_SIZE_Y +  Y; }
        int
    LinearAddressFromPosition_Get(int X, int Y)
    {return LinearAddressFromCoordinates_Get(X,Y/2); }
        int
    LinearAddressFromPosition_Get(GridPoint* GP) ;
 //   {return LinearAddressFromCoordinates_Get(GP->X,GP->Y); }
        GridPoint*
    ByClusterAddress_Get(ClusterAddress_t C);
        GridPoint*
    ByClusterMember_Get(unsigned short int CN, ClusterNeighbor CM = cm_Head,  ClusterNeighbor CP = cm_Head);
        GridPoint*
    ByClusterPointer_Get(GridPoint* P, ClusterNeighbor CM = cm_Head);
        void
    Cluster_Create(GridPoint* P);
        void
    Cluster_Create(int X, int Y);
        GridPoint* 
    ClusterHeadOfMember_Get(GridPoint* GP); 
 //
        void
    ClusterStatus_Set(GridPoint* P, ClusterNeighbor N, ClusterStatus S); 
        ClusterStatus
    ClusterStatus_Get(GridPoint* P, ClusterNeighbor N); 
        ClusterAddress_t
    ClusterAddress_Get(GridPoint* P); 
        ClusterAddress_t
    ClusterAddressFromLinear_Get(int N); 
        int 
    NeighborIndexInCluster_Get(GridPoint* Head, GridPoint* Neighbor);
 
#ifdef DRAW
 Valuable and works, but needed only when changing the number of points or debugging
          void
    DrawPoint(int i,int j, ostringstream &oss);
        void
    Draw(void);
#endif // DRAW
 
        void
    CreateClusters(void);
 
        GridPoint*
    ClusterHead_Get(unsigned int N)
    {
        assert (!(N<0) || (N>=mClusters.size()));  // Illegal member
        return mClusters[N]; // We always have a 0-th thread
    }
        string 
    StringOfClusterAddress_Get(GridPoint* GP);
/*        string /// Return the proxy string, if any, of the proxy of GridPoint GP
    StringOfProxy_Get(GridPoint* GP);*/
        SC_ADDRESS_TYPE
    PC_Get() { return mProgramCounter;}
        void
    PC_Set(SC_ADDRESS_TYPE PC) { mProgramCounter = PC;}
 
  protected:
        // The SAME physical points are stored in different structures
        vector<vector<GridPoint*> >  
    mGrid; 
        vector<GridPoint*>  
    mClusters;  
        SC_ADDRESS_TYPE 
    mProgramCounter;
 };// of class AbstractTopology
#endif // ABSTRACTTOPOLOGY_H