/**
* Copyright 2007-2008 University Of Southern California
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package edu.isi.pegasus.planner.partitioner;
import edu.isi.pegasus.common.logging.LogManager;
import edu.isi.pegasus.planner.common.PegasusProperties;
import edu.isi.pegasus.planner.partitioner.graph.GraphNode;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
/**
* This partitioning technique considers each of the job in the dax as a
* separate partition. This is used for Euryale style mode of operation in
* Pegasus.
*
* @author Karan Vahi
* @version $Revision$
*/
public class One2One extends Partitioner {
/**
* A short description about the partitioner.
*/
public static final String DESCRIPTION = "One to One Partitioning";
/**
* The overloaded constructor.
*
* @param root the dummy root node of the graph.
* @param graph the map containing all the nodes of the graph keyed by
* the logical id of the nodes.
* @param properties the properties passed to the planner.
*/
public One2One( GraphNode root, Map graph, PegasusProperties properties ) {
super( root, graph, properties );
}
/**
* This ends up writing out a partition for each job in the dax. It is a
* one 2 one mapping from the jobs in the dax to the corresponding
* partitions in the pdax. The ids of the partitions in pdax is same
* as the ids of the corresponding jobs in the dax.
*
* @param c the callback object to callout to while partitioning.
*/
public void determinePartitions( Callback c ) {
//we just traverse the graph via an iterator, as we do not
//need to any particular graph traversal for this mode.
String key = null;
GraphNode node = null;
int currentIndex = 0;
for( Iterator it = mGraph.keySet().iterator(); it.hasNext(); ){
//the key is the logical id of the node specified in the dax
key = (String)it.next();
node = (GraphNode)mGraph.get(key);
//we have to ignore the dummy root node.
if( node.getID().equals( mRoot.getID() ) ){
//we go to next node
mLogger.log( "Ignoring node " + node.getID(),
LogManager.DEBUG_MESSAGE_LEVEL );
continue;
}
currentIndex++;
//construct the partition for this node
//the partition has just one node with id same as the id
//of the corresponding id of the job in the dax
List levelList = new ArrayList(1);
levelList.add( node );
Partition p = new Partition( levelList, node.getID() );
p.setIndex( currentIndex );
// p.setName(mDAXWriter.getPartitionName());
p.constructPartition();
mLogger.log( "Partition is " + p.getNodeIDs(),
LogManager.DEBUG_MESSAGE_LEVEL );
c.cbPartition( p );
}
//writing out the relations between the partitions in the file
mLogger.log( "Building Relations between partitions ",
LogManager.DEBUG_MESSAGE_LEVEL );
for(Iterator it = mGraph.keySet().iterator(); it.hasNext();){
//the key is the logical id of the node specified in the dax
key = (String)it.next();
node = (GraphNode)mGraph.get(key);
Collection<GraphNode> parents = node.getParents();
//we have to ignore the dummy root node.
//and the node with no parents
if( node.getID().equals(mRoot.getID()) || parents == null ){
//we go to next node
mLogger.log( "Ignoring node " + node.getID(),
LogManager.DEBUG_MESSAGE_LEVEL );
continue;
}
//get the parents of the node and write out to the pdax file.
List partitionIDs = new java.util.ArrayList( parents.size() );
for( Iterator it1 = parents.iterator(); it1.hasNext(); ) {
//the jobs in the dax have same id as corresponding paritions
partitionIDs.add( ( (GraphNode) it1.next()).getID());
}
//write out to the pdax file
c.cbParents( key, partitionIDs );
partitionIDs = null;
}
mLogger.log("Building Relations between partitions - DONE",
LogManager.DEBUG_MESSAGE_LEVEL);
//we are done with the partitioning
c.cbDone();
}
/**
* Returns a textual description of the transfer implementation.
*
* @return a short textual description
*/
public String description(){
return this.DESCRIPTION;
}
}