portusagesplitter.java

一种将c高级语言转化给VHDL的编译器

      return 9999;
    //bestDataPort.getPortUseCnter().addUse(time);
    //bestAddyPort.getPortUseCnter().addUse(time);
    int cost = Math.max(bestDataPort.getPortUseCnter().testPortUse(bNode, time),
                        bestAddyPort.getPortUseCnter().testPortUse(bNode, time));
  	  /*System.out.println("+++++++++++++++++++++++++++++++");
  	  System.out.println("anfang");
  	  System.out.println("cost " + cost);
  	  System.out.println("bestDataPort.getPortUseCnter().testPortUse(bNode, time) " + bestDataPort.getPortUseCnter().testPortUse(bNode, time));
  	  System.out.println("bestAddyPort.getPortUseCnter().testPortUse(bNode, time) " + bestAddyPort.getPortUseCnter().testPortUse(bNode, time));
  	  System.out.println("+++++++++++++++++++++++++++++++");*/
    if(trueCost)
      cost += (bestDataPort.read_latency - 1);
    return cost;
    
  }
  public int addStoreTest(BlockNode bNode, int time, boolean trueCost) {
    Port bestDataPort = findPort(bNode, time, DATA_WRITE, BEST);
    Port bestAddyPort = findPort(bNode, time, ADDRESS_WRITE, BEST);
    
    if((bestDataPort == null)||(bestAddyPort == null)) 
      return 9999;
    //bestDataPort.getPortUseCnter().addUse(time);
    //bestAddyPort.getPortUseCnter().addUse(time);
    int cost = Math.max(bestDataPort.getPortUseCnter().testPortUse(bNode, time),
                        bestAddyPort.getPortUseCnter().testPortUse(bNode, time));
    if(trueCost)
      cost += (bestDataPort.write_latency - 1);
    return cost;
    
  }
  
  /*public int addLoadTest(int time) {
  
    Port bestAddyPort = findBestAddyLoadPort(time);
    Port bestDataPort = findBestDataLoadPort(time);
    if((bestAddyPort == null)||(bestDataPort == null)) {
      return 9999;
    }
    else {
      return (bestDataPort.getPortUseCnter().testPortUse(time)-1) + bestDataPort.read_latency;
    }
    
  }

  public int addLoadTestCnt(int time) {
  
    Port bestAddyPort = findBestAddyLoadPort(time);
    Port bestDataPort = findBestDataLoadPort(time);
    if((bestAddyPort == null)||(bestDataPort == null)) {
      return 9999;
    }
    else {
      return bestDataPort.getPortUseCnter().testPortUse(time);
    }
    
  }*/

  public int getDataPortUseCnt(BlockNode bNode, int time, boolean load) {
  
    HashSet dataPorts = null;
    if(load)
      dataPorts = DATA_READ;
    else 
      dataPorts = DATA_WRITE;
    Port bestDataPort = findPort(bNode, time, dataPorts, BEST);
  	  /*System.out.println("_______________________________");
  	  System.out.println("anfang");
  	  System.out.println("time " + time);
  	  System.out.println("bestDataPort.getPortUseCnter().getLoad(bNode, time) " + bestDataPort.getPortUseCnter().getLoad(bNode, time));
  	  System.out.println("_______________________________");*/
    if(bestDataPort == null) {
      return 9999;
    }
    else {
      return bestDataPort.getPortUseCnter().getLoad(bNode, time);
    }
    
  }

  /*public int getLoadDataPortUseCnt(int time) {
  
    Port bestDataPort = findBestDataLoadPort(time);
    if(bestDataPort == null) {
      return 9999;
    }
    else {
      return bestDataPort.getPortUseCnter().getLoad(time);
    }
    
  }*/

  public int addLoads(BlockNode bNode, int time, int cnt, boolean trueCost) {
    Port bestDataPort = null;
    if(trueCost)
      bestDataPort = findPort(bNode, time, DATA_READ, BEST);
    int totalCost = 0;
    for(int i=0; i<cnt; i++) {
      totalCost += addLoad(bNode, time, trueCost);
    }
    if(trueCost)
      totalCost -= (cnt-1)*bestDataPort.read_latency;
    return totalCost;
    
  }
  
  public int addStores(BlockNode bNode, int time, int cnt, boolean trueCost) {
    Port bestDataPort = null;
    if(trueCost)
      bestDataPort = findPort(bNode, time, DATA_WRITE, BEST);
    int totalCost = 0;
    for(int i=0; i<cnt; i++) {
      totalCost += addStore(bNode, time, trueCost);
    }
    //System.out.println("totalCost " + totalCost);
    if(trueCost)
      totalCost -= (cnt-1)*bestDataPort.write_latency;
    return totalCost;
    
  }
  
  /*public int addLoads(int time, int cnt) {
  
    Port bestDataPort = findBestDataLoadPort(time);
    int totalCost = 0;
      System.out.println("time " + time);
    for(int i=0; i<cnt; i++) {
      totalCost += addLoad(time);
    }
    //we need only add the read_latency once:
    if(bestDataPort == null) {
      return 9999;
    }
    else {
      return totalCost - (cnt-1)*bestDataPort.read_latency;
    }
  }

  public int addLoadsCnt(int time, int cnt) {
  
    int totalCost = 0;
    for(int i=0; i<cnt; i++) {
      totalCost += addLoadCnt(time);
    }
    //we need only add the read_latency once:
    return totalCost;
  }*/

  /*public Port findBestAddyStorePort(int time) {
    return findStoreAddyPort(time, true);
  }
  
  public Port findBestDataStorePort(int time) {
    return findStoreDataPort(time, true);
  }
  
  public Port findWorstAddyStorePort(int time) {
    return findStoreAddyPort(time, false);
  }
  
  public Port findWorstDataStorePort(int time) {
    return findStoreDataPort(time, false);
  }
  
  public Port findStoreAddyPort(int time, boolean findBest) {
    Port bestPort = null;
    Port port = null;
    int cost = 0;
    for (Iterator portIt = _port.iterator(); 
         portIt.hasNext(); ) {
      port = (Port)portIt.next();
      if(bestPort == null) bestPort = port;
      //int cost = port.getPortUseCnter().getLoad(time);
      if((port.typeCode == Port.ADDRESS_WRITE_TYPE)||
    	 (port.typeCode == Port.ADDRESS_RW_TYPE)) { 
        int portCost = port.getPortUseCnter().testPortUse(time);
        if((((cost==0)||(cost > portCost) || 
    	    ((cost == portCost)&&(port.typeCode == Port.ADDRESS_WRITE_TYPE)))
	           && findBest) ||  //find best port
	   (((cost==0)||(cost < portCost) || 
    	    ((cost == portCost)&&(port.typeCode == Port.ADDRESS_RW_TYPE)))
	           && !findBest)){   //find worst port

    	  cost = portCost;
          bestPort = port;

        }
      }
    }
    return bestPort;
  }
  
  public Port findStoreDataPort(int time, boolean findBest) {
    Port bestPort = null;
    Port port = null;
    int cost = 0;
    for (Iterator portIt = _port.iterator(); 
         portIt.hasNext(); ) {
      port = (Port)portIt.next();
      if(bestPort == null) bestPort = port;
      //int cost = port.getPortUseCnter().getLoad(time);
      if((port.typeCode == Port.DATA_WRITE_TYPE)||
    	 (port.typeCode == Port.DATA_RW_TYPE)) { 
        int portCost = port.getPortUseCnter().testPortUse(time);
        if((((cost==0)||(cost > portCost) || 
    	    ((cost == portCost)&&(port.typeCode == Port.DATA_WRITE_TYPE)))
	           && findBest) ||  //find best port
	   (((cost==0)||(cost < portCost) || 
    	    ((cost == portCost)&&(port.typeCode == Port.DATA_RW_TYPE)))
	           && !findBest)){   //find worst port

    	  cost = portCost;
          bestPort = port;

        }
      }
    }
    return bestPort;
  }*/
  
  /*public int addStore(int time) {
    Port bestAddyPort = findBestAddyStorePort(time);
    Port bestDataPort = findBestDataStorePort(time);
    if((bestAddyPort == null)||(bestDataPort == null)) {
      return 9999;
    }
    else {
      bestAddyPort.getPortUseCnter().addUse(time);
      bestDataPort.getPortUseCnter().addUse(time);
      return (bestDataPort.getPortUseCnter().getLoad(time)-1) + bestDataPort.write_latency;
    }
  }
  
  public int addStoreCnt(int time) {
    Port bestAddyPort = findBestAddyStorePort(time);
    Port bestDataPort = findBestDataStorePort(time);
    if((bestAddyPort == null)||(bestDataPort == null)) {
      return 9999;
    }
    else {
      bestAddyPort.getPortUseCnter().addUse(time);
      bestDataPort.getPortUseCnter().addUse(time);
      return bestDataPort.getPortUseCnter().getLoad(time);
    }
  }
  
  public int subStore(int time) {
    Port worstAddyPort = findWorstAddyStorePort(time);
    Port worstDataPort = findWorstDataStorePort(time);
    if((worstAddyPort == null)||(worstDataPort == null)) {
      return 0;
    }
    else {
      worstAddyPort.getPortUseCnter().subUse(time);
      worstDataPort.getPortUseCnter().subUse(time);
      return (worstDataPort.getPortUseCnter().getLoad(time)-1) + worstDataPort.write_latency;
    }
  }
  
  public int subStoreCnt(int time) {
    Port worstAddyPort = findWorstAddyStorePort(time);
    Port worstDataPort = findWorstDataStorePort(time);
    if((worstAddyPort == null)||(worstDataPort == null)) {
      return 0;
    }
    else {
      worstAddyPort.getPortUseCnter().subUse(time);
      worstDataPort.getPortUseCnter().subUse(time);
      return worstDataPort.getPortUseCnter().getLoad(time);
    }
  }*/
  
  /*public int addStoreTest(int time) {
    Port bestAddyPort = findBestAddyStorePort(time);
    Port bestDataPort = findBestDataStorePort(time);
    if((bestAddyPort == null)||(bestDataPort == null)) {
      return 9999;
    }
    else {
      return (bestDataPort.getPortUseCnter().testPortUse(time)-1) + bestDataPort.write_latency;
    }
  }
  
  public int addStoreTestCnt(int time) {
    Port bestAddyPort = findBestAddyStorePort(time);
    Port bestDataPort = findBestDataStorePort(time);
    if((bestAddyPort == null)||(bestDataPort == null)) {
      return 9999;
    }
    else {
      return bestDataPort.getPortUseCnter().testPortUse(time);
    }
  }*/
  
  /*public int addStores(int time, int cnt) {
  
    Port bestDataPort = findBestDataStorePort(time);
    int totalCost = 0;
    for(int i=0; i<cnt; i++) {
      totalCost += addStore(time);
    }
    if(bestDataPort == null) {
      return 9999;
    }
    else {
      return totalCost - (cnt-1)*bestDataPort.write_latency;
    }
  }
  
  public int addStoresCnt(int time, int cnt) {
  
    int totalCost = 0;
    for(int i=0; i<cnt; i++) {
      totalCost += addStoreCnt(time);
    }
    return totalCost;
  }
  
  public int getStoreDataPortUseCnt(int time) {
  
    Port bestDataPort = findBestDataStorePort(time);
    if(bestDataPort == null) {
      return 9999;
    }
    else {
      return bestDataPort.getPortUseCnter().getLoad(time);
    }
    
  }*/
  

}