DLParProcs(int pNum, MultiTarget* t);The arguments are the number of processors and the pointer to the multiprocessor target. This method creates
pNumUniProcessors for processing elements. These UniProcessors are deallocated in the destructor
Based on the type of node described in
scheduleItmethod of the DLScheduler class, we call one of the following methods to schedule the node.
virtual void scheduleSmall(DLNode* n);This method is a public method to schedule an atomic node that will be scheduled on one processor. This is virtual since the HuParProcs class redefines this method. The scheduling procedure is as follows:
(1) Obtain the list of processors that can schedule this node. Refer to
candidateProcsmethod of the CGMultiTarget class . Here, we examine the resource restriction of the processor, as well as the types of stars that a processor supports, in case of a heterogeneous target. If all invocations of a star should be scheduled to the same processor and another invocation of the star is already scheduled, we put only that processor only into the list of candidate processors that can schedule this node.
(2) Among all candidate processors, we select the processor that can schedule this node the earliest. In this stage, we consider all communication overhead if ancestors would be assigned to the different processors.
(3) Assign the node to that processor:
void assignNode(DLNode* n, int destP, int time);Is a protected method to assign an atomic node (
n)to the processor of index
time.This method also schedules the communication requirements in the communication resources.
(4) Indicate that the node was fired:
virtual void fireNode(DLNode* node);It is a virtual and protected method. It fires the argument node and insert its descendants into the list of runnable nodes if they become runnable after this node is fired.
(5) Finally, we decrease the number of unscheduled nodes and the total remaining work of the DLGraph class.
The DLNode class has the pointer to the Profile class that determines the inside schedule of the node. We insert idle time slots to the processors to match the pattern of processor availability with the starting pattern of the profile and append the node at the end of the processors. We record the assignment of the profile to the processors in
assignedIdarray of the Profile class . We also save the scheduling information in the DLNode: when the node is scheduled and completed, and on which processor it is scheduled. To determine the latter, we select the processor that the inside scheduler assumes the first processor it is assigned.
After appending the profile at the end of the available processors, we fire the node and update the variables of the DLGraph.
void initialize(DLGraph* graph);This method calls
ParProcessors:: initialize and resets the
candidatemember to the index of the first UniProcessor, and
DLGraph* myGraph;A protected members to store the pointer to the input APEG.
int costAssignedTo(DLNode* node, int destP, int start);This method is a protected method to compute the earliest time when the processor of index
destPcould schedule the node
nodethat is runnable at time