BigListElement.H

Go to the documentation of this file.

// BigListElement.H
//
// 2/11/98 WAH:  Broke away from Scheduler package; minor patching up.
// 3/23/98 WAH:  Added RemovePredecessor and RemoveSuccessor methods.
// 4/1/98 WAH:   Turned on assignment operator; added resetting of
//               array_size fields in Deallocate methods.

#ifndef _BIG_LIST_ELEMENT_H_
#define _BIG_LIST_ELEMENT_H_

#include <stl.h>
#include <iostream.h>
#include "legoOp.H"
#include "DagNode.H"
#include "SmallListElement.H"

/* This defines an element in the 'master list'. */
class BigListElement : public DagNode {

public:

   int ClusterId;               // Used for cluster scheduling
   double Value;                // Used for node-ordering

   vector < SmallListElement > *Predecessors, *Successors;

private:

   // Holds weight info for objects related to this object in the dag.
   // There is a weight for every cluster in the dag. The higher the
   // weight, the strong the 'affinity' for this object to that cluster.
   int *AncestorClusterInfo;
   int a_array_size;

   // Holds info telling if object OR data produced by the object has
   // been copied into other clusters in the machine
   int *CopiedResultInfo;
   int c_array_size;


   void BubbleSort( vector < SmallListElement > *, 
                    int (*Compare)( SmallListElement, SmallListElement ) );
   void SortList( vector < SmallListElement > *, 
                  int (*Compare)( SmallListElement, SmallListElement ) );

public:

   // Constructor, copy constructor, and destructor
   BigListElement();
   BigListElement( const BigListElement &src );
   ~BigListElement();

#if 1
   // Equality operator
   BigListElement & operator=(const BigListElement &src );
#endif

   // Equality test operator
   int operator==(const BigListElement &src )
   {
      if ( src.Op->GetOpId() == Op->GetOpId() ) return 1;
      else return 0;
   }

   // Allocate_AncestorClusterInfo - allocate an array of size n (> 0)
   void BigListElement::Allocate_AncestorClusterInfo( int n );

   // DeAllocate_AncestorClusterInfo - deallocate the array
   void DeAllocate_AncestorClusterInfo()
   {
     if ( a_array_size > 0 ) delete [] AncestorClusterInfo;
     a_array_size = 0;
   }

   // Get_a_array_size: returns the value of a_array_size
   int Get_a_array_size()                       { return a_array_size; }

   // GetAncestorClusterEntry - return entry [n] in AncestorClusterInfo
   int GetAncestorClusterEntry( int n )
   { if ( a_array_size > n ) return AncestorClusterInfo[ n ]; }

   // SetAncestorClusterEntry - entry [n] in AncestorClusterInfo to value
   void SetAncestorClusterEntry( int entry, int value )
   { if ( a_array_size > entry ) AncestorClusterInfo[ entry ] = value; }

   // InitAncestorClusterInfo - sets all entries to -1
   void InitAncestorClusterInfo();

   // Allocate_CopiedResultInfo
   void Allocate_CopiedResultInfo( int n );

   // Deallocate_CopiedResultInfo
   void Deallocate_CopiedResultInfo()
   {
     if ( c_array_size > 0 ) delete [] CopiedResultInfo;
     c_array_size = 0;
   }

   // AddCopiedResultInfo - notates that the *result* of this Op was scheduled
   //    to be copied to cluster in cycle
   void AddCopiedResultInfo( int cluster, int cycle )
   { if ( c_array_size > cluster ) CopiedResultInfo[ cluster ] = cycle; }

   // CheckCopyStatus - checks if this object copies its result data to
   //    cluster and if the data is present there by cycle. Returns 1 if
   //    yes, 0 otherwise.
   int CheckCopyStatus( int cluster, int cycle )
   {
      if ( c_array_size > 0 && CopiedResultInfo[ cluster ] != 0
           && CopiedResultInfo[ cluster ] <= cycle )
         return 1;
      else return 0;
   }

   void PrintElement();
   
   //HZ: 8/24/00 print to a stream
   void PrintElement(ofstream & os1);

   /* Add an Op as a data predecessor with an edge of type Dependency */
   int AddPredecessorBeginning( enum edgeTypes Dependency, legoOp *Op,
                       BigListElement *Iter );

   /* Add an Op as a data predecessor with an edge of type Dependency */
   int AddPredecessor( enum edgeTypes Dependency, legoOp *Op,
                       BigListElement *Iter );

   /* Add an Op as a data successor with an edge of type Dependency */
   int AddSuccessor( enum edgeTypes Dependency, legoOp *Op,
                     BigListElement *Iter );

   /* Remove an Op as a data predecessor with an edge of type Dependency */
   int RemovePredecessor( enum edgeTypes Dependency, legoOp *Op,
                          BigListElement *Iter );

   /* Remove an Op as a data successor with an edge of type Dependency */
   int RemoveSuccessor( enum edgeTypes Dependency, legoOp *Op,
                        BigListElement *Iter );

   /* Remove an Op as a data predecessor with an edge of type Dependency */
   vector < SmallListElement >::iterator 
   RemovePredecessor( enum edgeTypes Dependency, legoOp *Op );

   /* Remove an Op as a data successor with an edge of type Dependency */
   vector < SmallListElement >::iterator  
   RemoveSuccessor( enum edgeTypes Dependency, legoOp *Op );

   /* Returns size of predecessor list. A size of 0 indicates an entry node
      in a region. */
   int NumPredecessors()        { return Predecessors->size();  }

   /* Returns size of successor list. A size of 0 indicates an exit  node
      in a region. */
   int NumSuccessors()          { return Successors->size();    }


   /* Sort Successor Ops in a variety of ways. */
   void     SortSuccessorsByOpId();
   void     SortSuccessorsByHeight();
   void     SortSuccessorsByDepth();
   void     SortSuccessorsByWeight();
   void     SortSuccessorsByValue();

   /* Sort Predecessor Ops in a variety of ways. */
   void     SortPredecessorsByOpId();
   void     SortPredecessorsByHeight();
   void     SortPredecessorsByDepth();
   void     SortPredecessorsByWeight();
   void     SortPredecessorsByValue();
};


// DestructBigList:  destructs a list of of BigListElements
void DestructBigList( list < BigListElement > *List );

// DestructBigVector:  destructs a vector of of BigListElements
void DestructBigVector( vector < BigListElement > *Vector );
      
// CopyBigVector: copies data from Src to Target
int CopyBigVector( vector < BigListElement > *Src,
                   vector < BigListElement > *Target );

// FindOpInBigList: find Op w/'OpId' in the vector V, returns the index
//    where Op is located OR -1 if Op isn't found
int FindOpInList( vector < BigListElement > *V, int OpId );

// FindNode: find Op w/'OpId' in the vector V, returns an iterator to
//    the element. Returns V->end() if OPid isn't found.
vector < BigListElement >::iterator
    FindNode( int OpId, vector < BigListElement > *V );

#if 0
#if defined (_STL_LIST_USED_)
typedef list <BigListElement> MainList;
#else if defined (_STL_VECTOR_USED_)
typedef vector <BigListElement> MainList;
#endif
#endif

typedef vector <BigListElement> VectorList;
typedef list <BigListElement> ListList;

#if defined (_STL_LIST_USED_)
typedef ListList MainList;
#else if defined (_STL_VECTOR_USED_)
typedef VectorList MainList;
#endif

#endif

---