001: /*
002: * This file or a portion of this file is licensed under the terms of
003: * the Globus Toolkit Public License, found in file GTPL, or at
004: * http://www.globus.org/toolkit/download/license.html. This notice must
005: * appear in redistributions of this file, with or without modification.
006: *
007: * Redistributions of this Software, with or without modification, must
008: * reproduce the GTPL in: (1) the Software, or (2) the Documentation or
009: * some other similar material which is provided with the Software (if
010: * any).
011: *
012: * Copyright 1999-2004 University of Chicago and The University of
013: * Southern California. All rights reserved.
014: */
015: package org.griphyn.cPlanner.partitioner;
016:
017: import org.griphyn.cPlanner.common.LogManager;
018: import org.griphyn.cPlanner.common.PegasusProperties;
019:
020: import org.griphyn.cPlanner.partitioner.graph.GraphNode;
021:
022: import java.util.ArrayList;
023: import java.util.Iterator;
024: import java.util.List;
025: import java.util.Map;
026:
027: /**
028: * This partitioning technique considers each of the job in the dax as a
029: * separate partition. This is used for Euryale style mode of operation in
030: * Pegasus.
031: *
032: * @author Karan Vahi
033: * @version $Revision: 50 $
034: */
035:
036: public class One2One extends Partitioner {
037:
038: /**
039: * A short description about the partitioner.
040: */
041: public static final String DESCRIPTION = "One to One Partitioning";
042:
043: /**
044: * The overloaded constructor.
045: *
046: * @param root the dummy root node of the graph.
047: * @param graph the map containing all the nodes of the graph keyed by
048: * the logical id of the nodes.
049: * @param properties the properties passed to the planner.
050: */
051: public One2One(GraphNode root, Map graph,
052: PegasusProperties properties) {
053: super (root, graph, properties);
054: }
055:
056: /**
057: * This ends up writing out a partition for each job in the dax. It is a
058: * one 2 one mapping from the jobs in the dax to the corresponding
059: * partitions in the pdax. The ids of the partitions in pdax is same
060: * as the ids of the corresponding jobs in the dax.
061: *
062: * @param c the callback object to callout to while partitioning.
063: */
064: public void determinePartitions(Callback c) {
065: //we just traverse the graph via an iterator, as we do not
066: //need to any particular graph traversal for this mode.
067:
068: String key = null;
069: GraphNode node = null;
070: int currentIndex = 0;
071:
072: for (Iterator it = mGraph.keySet().iterator(); it.hasNext();) {
073: //the key is the logical id of the node specified in the dax
074: key = (String) it.next();
075: node = (GraphNode) mGraph.get(key);
076: //we have to ignore the dummy root node.
077: if (node.getID().equals(mRoot.getID())) {
078: //we go to next node
079: mLogger.log("Ignoring node " + node.getID(),
080: LogManager.DEBUG_MESSAGE_LEVEL);
081: continue;
082: }
083: currentIndex++;
084:
085: //construct the partition for this node
086: //the partition has just one node with id same as the id
087: //of the corresponding id of the job in the dax
088: List levelList = new ArrayList(1);
089: levelList.add(node);
090: Partition p = new Partition(levelList, node.getID());
091: p.setIndex(currentIndex);
092: // p.setName(mDAXWriter.getPartitionName());
093: p.constructPartition();
094:
095: mLogger.log("Partition is " + p.getNodeIDs(),
096: LogManager.DEBUG_MESSAGE_LEVEL);
097:
098: c.cbPartition(p);
099: }
100:
101: //writing out the relations between the partitions in the file
102: mLogger.log("Building Relations between partitions ",
103: LogManager.DEBUG_MESSAGE_LEVEL);
104: for (Iterator it = mGraph.keySet().iterator(); it.hasNext();) {
105: //the key is the logical id of the node specified in the dax
106: key = (String) it.next();
107: node = (GraphNode) mGraph.get(key);
108: List parents = node.getParents();
109:
110: //we have to ignore the dummy root node.
111: //and the node with no parents
112: if (node.getID().equals(mRoot.getID()) || parents == null) {
113: //we go to next node
114: mLogger.log("Ignoring node " + node.getID(),
115: LogManager.DEBUG_MESSAGE_LEVEL);
116: continue;
117: }
118:
119: //get the parents of the node and write out to the pdax file.
120: List partitionIDs = new java.util.ArrayList(parents.size());
121: for (Iterator it1 = parents.iterator(); it1.hasNext();) {
122: //the jobs in the dax have same id as corresponding paritions
123: partitionIDs.add(((GraphNode) it1.next()).getID());
124: }
125: //write out to the pdax file
126: c.cbParents(key, partitionIDs);
127: partitionIDs = null;
128: }
129: mLogger.logCompletion("Building Relations between partitions ",
130: LogManager.DEBUG_MESSAGE_LEVEL);
131:
132: //we are done with the partitioning
133: c.cbDone();
134: }
135:
136: /**
137: * Returns a textual description of the transfer implementation.
138: *
139: * @return a short textual description
140: */
141: public String description() {
142: return this.DESCRIPTION;
143: }
144:
145: }
|