Package graphs

Source Code of graphs.GraphPartitioner

package graphs;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.List;
import java.util.Vector;
import java.util.logging.Logger;

import system.DataLocator;
import system.JPregelConstants;
import system.MasterImpl;
import utility.JPregelLogger;
import api.Vertex;
import exceptions.DataNotFoundException;
import exceptions.IllegalInputException;

/**
* Partitions the graph into smaller chunks proportionate to the number of lines
* in the input. The input graph should be represented in adjacency list format
* with each line representing a vertex in the graph.
*
* @author Manasa Chandrasekhar
* @author Kowshik Prakasam
*
*/
public class GraphPartitioner {
  private String vertexClassName;
  private String graphFile;
  private MasterImpl master;
  private List<GraphPartition> listOfPartitions;
  private int numVertices;

  /**
   *
   * @return
   */
  public int getNumVertices() {
    return numVertices;
  }

  /**
   *
   * @param numVertices
   */
  public void setNumVertices(int numVertices) {
    this.numVertices = numVertices;
  }

  private Logger logger;
  private int partitionSize;

  /**
   * Returns the partition size of every graph partition created by this
   * partitioner
   *
   * @return
   */
  public int getPartitionSize() {
    return this.partitionSize;
  }

  private void setPartitionSize(int partitionSize) {
    this.partitionSize = partitionSize;
  }

  private static final String LOG_FILE_PREFIX = JPregelConstants.LOG_DIR
      + "graphpartitioner";
  private static final String LOG_FILE_SUFFIX = ".log";

  /**
   *
   * @param graphFile
   *            File containing graph in adjacency list format that needs to
   *            be partitioned
   * @param master
   *            Master class object that controls this partitioner
   * @param vertexClassName
   *            Name of the vertex class submitted by the application
   *            programmer
   * @throws IOException
   */
  public GraphPartitioner(String graphFile, final MasterImpl master,
      String vertexClassName) throws IOException {
    this();
    this.vertexClassName = vertexClassName;
    this.graphFile = graphFile;
    this.master = master;
    this.listOfPartitions = new Vector<GraphPartition>();
    // number of worker managers in the system
    int numWorkers = master.getWorkerMgrsCount();
    logger.info("num workers : " + numWorkers);
    // number of threads in each worker manager
    int numThreads = master.getWorkerMgrThreads();

    // Average no. of lines in a graph partition
    this.setPartitionSize(numThreads * numWorkers);

    // number of lines in the input graph
    setNumVertices(this.countLines());

    logger.info("Number of lines : " + getNumVertices());
    logger.info("Partition Size : " + getPartitionSize());

  }

  private void initLogger() throws IOException {
    this.logger = JPregelLogger.getLogger(getId(), LOG_FILE_PREFIX
        + LOG_FILE_SUFFIX);
  }

  /**
   * @return
   */
  private String getId() {
    // TODO Auto-generated method stub
    return "GraphPartitioner";
  }

  /**
   * Inits the logger
   *
   * @throws IOException
   *
   */
  public GraphPartitioner() throws IOException {
    this.initLogger();
  }

  /**
   * Partitions the input graphs based on the number of lines, number of
   * worker machines available at the disposal of the Master and the number of
   * threads designated to run on each worker machine.
   *
   * @return Number of partitions produced after partitioning
   * @throws IOException
   * @throws IllegalInputException
   * @throws DataNotFoundException
   * @throws InstantiationException
   * @throws IllegalAccessException
   * @throws ClassNotFoundException
   */
  public int partitionGraphs() throws IOException, IllegalInputException,
      DataNotFoundException, InstantiationException,
      IllegalAccessException, ClassNotFoundException {

    BufferedReader buffRdr = new BufferedReader(new FileReader(
        this.graphFile));
    String line = null;
    int thisPartitionSize = 0;
    while (true) {
      thisPartitionSize = 0;
      List<Vertex> listOfVertices = new Vector<Vertex>();
      while (thisPartitionSize < partitionSize
          && (line = buffRdr.readLine()) != null) {
        thisPartitionSize++;
        Vertex newVertex = (Vertex) (Class.forName(vertexClassName)
            .newInstance());
        newVertex.initialize(line);
        listOfVertices.add(newVertex);
      }

      if (listOfVertices.size() > 0) {
        int partitionID = listOfPartitions.size();
        String newPartitionFile = DataLocator.getDataLocator(
            partitionSize).getPartitionFile(partitionID);
        GraphPartition newPartition = new GraphPartition(partitionID,
            listOfVertices);
        logger.info("Dumped : " + listOfVertices.size() + " to file : "
            + newPartitionFile);
        newPartition.writeToFile(newPartitionFile);
        listOfPartitions.add(newPartition);
        newPartition.freePartition();
      }
      if (line == null) {
        logger.info("Breaking because no lines are left");
        break;
      }
    }
    buffRdr.close();
    return listOfPartitions.size();
  }

  /**
   * Returns the number of partitions generated by this partitioner
   * @return
   */
  public int getNumberOfPartitions() {
    return listOfPartitions.size();
  }

  // Counts the line in the input graph
  private int countLines() throws IOException {
    BufferedReader buffRdr = new BufferedReader(new FileReader(
        this.graphFile));

    int count = 0;
    while (buffRdr.readLine() != null) {
      count++;
    }
    buffRdr.close();
    return count;
  }

}
TOP

Related Classes of graphs.GraphPartitioner

TOP
Copyright © 2018 www.massapi.com. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.