import java.util.PriorityQueue;
import java.util.concurrent.PriorityBlockingQueue;
import java.util.Iterator;
import java.util.ConcurrentModificationException;
import java.util.List;
import java.util.ArrayList;
import java.util.SortedSet;
import java.util.TreeSet;
import java.io.*;
import java.util.*;


/**This class provides the simulation engine logical process scheduling loop. This
 * loop runs in its own thread in parallel with the communication thread
 * of the PE. After instantiation, this class should have one or more
 * LogicalProcesses added (by {@link #createLP createLP}) before the thread is
 * started.
 * <p><em>Requires Java 5.0 due to use of the
 * <code>PriorityBlockingQueue</code> class and others.</em>
 * @author Yin Xiong
 * @author Glenn Matthews
 * @version 1.9 (09/2006)
 */

public class SchedulingLoop implements Runnable{
  
  /**The id of the parent PE of this scheduler.*/
  int id;

  /**The flag indicating the end of sim*/  
  Flag eosFlag;  
 
 /**Flag for computing GVT*/
  Flag gvtFlag;
  
  /**The most recent GVT*/
  int GVT;

  /**The frequency that GVT should be computed*/
  int gvtClock;

  /**The queue that store the saved LP state*/
  Vector<LogicalProcess> lpStates;

  /** Very primitive way of stopping the run loop: set this to true.
    * Run loop will terminate after current iteration and clean up after
    * itself.  
    */
  
  public boolean done = false;
 
 /** Shared priority queue containing incoming {@link Message}s from the
   * communication thread. 
   */

   public PriorityBlockingQueue<Message> incoming;

 /** Shared priority queue containing outgoing {@link Message}s to the 
   * communication thread. Note that the addressing of these Messages are
   * not likely to be fully specified, since this class does not have access
   * to a GlobalNameServer. In general, the communication thread should
   * expect to have to use {@link Message#senderAPPid} and
   * {@link Message#receiverAPPid} to look up the LPid and PE of the sender
   * and receiver. The communication thread is also expected to recognize
   * and handle the case where receiverAPPid ==
   * {@link LogicalProcess#ALL_LPS}.
   */       

    public PriorityBlockingQueue<Message> outgoing;


/** Local list storing all LogicalProcesses managed by this SchedulingLoop. */
    List<LogicalProcess> LPs;
   
/** Local priority queue storing simulation messages yet to be handled. */
   public PriorityQueue<Message> simMessages;

/** @since 1.7.
  * The queue that contains anti-messages. A anti-message is a copy of the
  * regular message with a negative sign.
  * When processing an event on LP i that schedules an event on
  * LP j, a message and a copy of the same message are created.
  * The copy is the 'anti-message'  sometimes called negative, or copy of the
  * positive message. The original (positive) message is transmitted to the  
  * destination LP j and the anti-message stays at the source LP i as a record
  * that the LP i transmitted a positive message to LP j
  */
    Vector<Message> antiMsgsOut=new Vector<Message>();
    
/**@since 1.7
  *The queue that contains unmatched anti-messages. Their positive counter-
  *parts haven't been received yet.
  */
  Vector<Message> antiMsgsIn=new Vector<Message>();
  
/**@since 1.7
  *The queue that stores the processed messages; used for rollback;
  *When an anti-message comes in, the scheduler first check if the
  *positive message has already been processed; if yes, rollback; if
  *not, cancel it; if the positive message is yet to receive, then store
  *the anti message in antiMsgsIn.
  */
Vector<Message> eventQueue=new Vector<Message>();

/** Local list storing sorted sets (one per LP) of current and future  
  * monitoring commands. 
  */
  
   private List<SortedSet<MonitorNode>> monitoring;
   
/** Local list storing sorted sets (one per LP) of current and future
  * steering commands. 
  */
  
  private List<SortedSet<SteerNode>> steering; 

  /**Constructs a new PE instance. Sets the id of the PE to peid.
    *@param pid int the id of the PE, i.e. the id of this process.
    */
  public SchedulingLoop(int pid)
  {
     id=pid;
     gvtClock=5;
     LPs=new Vector<LogicalProcess>();
     incoming=new PriorityBlockingQueue<Message>();
     outgoing=new PriorityBlockingQueue<Message>();
     LPs = new ArrayList<LogicalProcess>();
     simMessages = new PriorityQueue<Message>();
     monitoring = new ArrayList<SortedSet<MonitorNode>>();
     steering = new ArrayList<SortedSet<SteerNode>>();
     lpStates=new Vector<LogicalProcess>();
}//end constructor

/**Sets the GVT clock.
  *@param gc int the frequency that GVT will be computed.
  *@since 1.9
  */
void setGVTClock(int gc)
{
    gvtClock=gc;
}//end setGVTClock

/**Sets the flags.
  *@param ef Flag end-of-program flag
  *@param gf Flag flag indicating it's time to compute GVT
  *@since 1.9
  */
void setFlags(Flag ef, Flag gf)
{
    eosFlag=ef;
    gvtFlag=gf;
}//end setFlags

/**Computes the local minimum timestamp using Samadi's algorithm which dependes on
  *acknowledgement for each and every message sent
  *<p>local minimum timestamp = the minumum timestamp among
  *<ul>
  *<li>all unprocessed events
  *<li>all unacknowledged messages and anti-messages it has sent
  *<li>all marked acknowledgement messages it has received since it last received
  *a new GVT value
  *</ul>
  * the PE sets a flag indicating it's in find mode
  */

public int computeLocalMin()
{

  int localMin=-1;
  int temp;

  //check unprocessed event queue
  if(simMessages.size()>0){
    Message msg=(Message)simMessages.peek();
    temp=msg.timeStamp;
    if(temp>GVT){
       if(localMin<0 || (localMin>0 && temp<localMin))
         localMin=temp;
    }//end if
  }//end if
// System.out.println("PE " + id + " simMSG min: " + localMin);
    
  //check all marked acknowleged messages it has received since it last
  //received a new GVT
  for(int i=0;i<antiMsgsOut.size();i++){
   Message  msg=(Message)antiMsgsOut.get(i);
   temp=msg.timeStamp;
   //System.out.println("anti msg tag: " + msg.tag);
   if(msg.tag==1 && temp>GVT){
       if(localMin<0 || (localMin>0 && temp<localMin))
          localMin=temp;
    }//end if
 }//end for
    
 //System.out.println("PE " + id + " antiMsgsOut min: " + localMin);
         
 //check anti-messaes it has received but not matched with an unprocessed message
  for(int i=0;i<antiMsgsIn.size();i++){
   Message  msg=(Message)antiMsgsIn.get(i);
   temp=msg.timeStamp;
   if(temp>GVT){
       if(localMin<0 || (localMin>0 && temp<localMin))
         localMin=temp;
      }//end if
  }//end for
   
 //System.out.println("PE " + id + " antiMsgsIn min: " + localMin);
       
          
 //check LP's timestamp
  for(int i=0;i<LPs.size();i++){
     LogicalProcess lp=(LogicalProcess)LPs.get(i);
     if(localMin<0 || (localMin>0 && lp.currentTime<localMin))
        localMin=lp.currentTime;
  }//end for

 //System.out.println("PE " + id + " antiMsgsIn min: " + localMin);
   
  System.out.println("PE " + id + " localMin: " + localMin);
   
  return localMin;
}//end computeLocalMin 


/**Updates GVT and do fossil collection
  *@param newGVT int the new GVT broadcast by the controller
  */   
public void updateGVT(int newGVT)
{
  
   System.out.println("\nPE " + id + " update GVT: old GVT, new GVT: " + GVT + " " + newGVT);
   GVT=newGVT;
   int temp;
  
   //fossil collect all the space before the new GVT
 
  //fossil collection for unprocessed message
  if(simMessages.size()>0){
   for(int i=0;i<simMessages.size();i++){
      Message msg=(Message)simMessages.peek();
      temp=msg.timeStamp;
      if(temp<=GVT)
          simMessages.poll();
     }//end for
  }//end if

  //fossil collect the space from anti msges it sent
  for(int i=0;i<antiMsgsOut.size();i++){
   Message  msg=(Message)antiMsgsOut.get(i);
   temp=msg.timeStamp;
   if(temp<=GVT){
       antiMsgsOut.removeElementAt(i);
       //System.out.println("PE " + id + " remove antimsg out " + temp);
       i=i-1;
     }
  }//end for
   
      
  //fossil collect the space from anti msges it received
  for(int i=0;i<antiMsgsIn.size();i++){
   Message  msg=(Message)antiMsgsIn.get(i);
   temp=msg.timeStamp;
   if(temp<=GVT){
      antiMsgsIn.removeElementAt(i);
       //System.out.println("PE " + id + " remove antiMsgsIn " + temp);
       i=i-1;
     }
  }//end for


  //fossil collection for the LP states
  /*System.out.println("before update, PE " + id + " has " + schedulingLoop.lpStates.size() + " states");
  for(int i=0;i<lpStates.size();i++){
    LogicalProcess lp=(LogicalProcess)lpStates.get(i);
    //System.out.print (lp.currentTime + ", " );
   }//end for
   System.out.println();
*/
  
 for(int i=0;i<lpStates.size();i++){
    LogicalProcess lp=(LogicalProcess)lpStates.get(i);
    //System.out.println("PE " + id + "i, lpstate " + i + " " + lp.currentTime);
       
    if(lp.currentTime<=GVT){
      // System.out.println("PE " + id + " remove lpstate " + lp.currentTime);
       lpStates.removeElementAt(i);
       i=i-1;
      }//end if
  }//end for
       
 
 /* System.out.println("\nafter update, PE " + id + " has " + 
  lpStates.size() + " states");
  for(int i=0;i<lpStates.size();i++){
    LogicalProcess lp=(LogicalProcess)lpStates.get(i);
    System.out.print (lp.currentTime + ", " );
   }//end for
   System.out.println();
 */
    
}//end updateGVT



/**Places the specified (partly-formatted) Message into the outgoing message
 * queue for the communication thread to send out.
 * @param msg Message to send, assumed to have correctly filled senderAPPid,
 * senderLP, and receiverAPPid, but not necessarily senderPE, receiverLP,
 * or receiverPE (which are not likely to be known by this class or by any   
 * LogicalProcess, but should be known by the messaging thread). 
 */

public void sendMessage(Message msg) 
{
  //if it's a positive message, make a copy of the msg and store in antiMsgs queue as an anti-message
  if(msg.msgType==Message.MsgType.SIM_REGULAR){
        Message antimsg = msg.makeAntiMsg();
        antiMsgsOut.add(antimsg);
        //System.out.println("Scheduler " + id + " enqueued an anti msg, queue size: " + antiMsgsOut.size());   
   }
  //put the message in outgoing queue so the communication thread will send it out
  outgoing.offer(msg);
 
} //end sendMessage()

/**Sends out anti-messages.
  */
public Message sendAntiMsgs(int lp, int rbtime)
{
    int index=10000;
    Message m=null;

    //send anti messages, from rbtime on
     for(int i=0;i<antiMsgsOut.size();i++){
        m=(Message)antiMsgsOut.get(i);
        if(m.timeStamp>rbtime && m.senderLP==lp){
          if(index>i)
            index=i;
          System.out.println("scheduler " + id +  " sending anti msg for LP " + lp + " with timestamp " + m.timeStamp);
          //System.out.println("check msg type: " + m.msgType);

          sendMessage(m);
          m.tag=1; //change tag to 1 to indicate this amti msg has already been sent
          antiMsgsOut.setElementAt(m,i);
        }//end if
    }//end for

   System.out.println("scheduler " + id  + " finished sending anti msgs");
   
   //message at index is the new beginning, return this message for the LP to send out
   m=(Message)antiMsgsOut.get(index);
   m.setMsgType(Message.MsgType.SIM_REGULAR);
   System.out.println("after rollback, LP " + lp + " begins with resending " + m.timeStamp);   

return m;

}//end sendAntiMsgs

/** Method required by Runnable interface; called when the thread is first
 * created. Starts the scheduling loop and continues looping until {@link #done}
 * is set to <code>true</code>. 
 */
public void run() {
  int mostRecentLP = -1;
  done = false;

  //begin scheduling loop
  while (!done) {

    //deal with all incoming messages
    processIncoming();

    //apply the most recent simulation message to the LP it's aimed at
    mostRecentLP = runOneLP();

    //apply scheduled monitoring/steering to that LP
    if (mostRecentLP != -1) {
          applyMonitoring(mostRecentLP);
          applySteering(mostRecentLP);
    }//end apply monitoring/steering

       /*******************added by yin for stopping sim************/
   try{
      Thread thisThread=Thread.currentThread();
      thisThread.yield();

      if(eosFlag.get()<0){
        done=true;
        //System.out.println("scheduler " + id +  " gets flag  " + eosFlag.get() + " and is shutting down.");
       }

       /******************end added by yin for stopping sim********/
    }
  catch(Exception e){
     e.printStackTrace();
  }//end try-catch

     } //end while (!done)
  //TODO - cleanup and finish running
} // end run()

/** Calls {@link LogicalProcess#runLP} for the first {@link Message} in the
 * {@link #simMessages} queue. Messages directed to a LogicalProcess not
 * owned by this SchedulingLoop are assumed to have been misdelivered, and
 * are placed in <code>outgoing</code>.
 * @return The index of the given LogicalProcess in the local lists.
 */
public int runOneLP() 
{
  if (simMessages.size() == 0)
    return -1; //no messages to handle! 

  Message m = simMessages.poll();
  eventQueue.add(m);
  //System.out.println("scheduler " + id + " processed " + eventQueue.size() + " events");

  String target=m.getReceiverAPPid();
  int index=-1;
  if(target!=null)
     index = getLPIndexByAPPid(target);
  else
     index = getLPIndexByLPid(m.getReceiverLP());

  if (index <0) {
    System.out.println("Destination LP not found ");
    //put the message back into outgoing queue
    sendMessage(m);
    return -1; //Unknown LP!
    }

  //Pass the message into the LP in question
  LogicalProcess lp = LPs.get(index);

  //before run LP(and change LP state),save LP state
  LogicalProcess loglp=lp.appSavingLPState();
  loglp.savingLPState(lp);
  lpStates.add(loglp);
  //System.out.println("PE " + id + " saving lp state: " + loglp.toString());
  //System.out.println("lastTime,currentTime: " + loglp.lastTime + " " + loglp.currentTime);

  //if buffer is "full" (as spesified by gvtClock), set flag for computing GVT
  if(lpStates.size()>gvtClock){
     gvtFlag.set(id);
     System.out.println("buffer used: " + lpStates.size() + " set gvt flag");
  }

  //check local virtual time and receive time; if LVT > receive time, roll back
  if(lp.currentTime>m.timeStamp){
       System.out.println("\n" + lp.myname+ ": local virtual time: "
                +lp.currentTime+", receive time: "+m.timeStamp);
       System.out.println("***" + lp.myname +": got a message from the past, rollback to " + m.timeStamp + "\n");

      Message mm=rollBack(lp,m.timeStamp);
      //lp.runLP(mm);
   }
  else
     lp.runLP(m);
  return index;  
} // end runOneLP()


/**Rolls back to the time specified by rbtime and returns the first message
  *immediately after the rollback. e.g. if roll back from 4 to 2, then the
  *returned message should be 3.
  *@param theLP a LogicalProcess that needs to rollback
  *@param rbtime int the time the LP will rollback to
  */
Message rollBack(LogicalProcess theLP, int rbtime)
{
   //System.out.println("in rollBack, saved LP states: " + lpStates.size());
   for(int i=0;i<lpStates.size();i++){
      LogicalProcess lpstate=(LogicalProcess)lpStates.get(i);
        if(lpstate.currentTime<=rbtime){
            //System.out.println("PE " + id + " found the state to roll back to " + rbtime);
            theLP.rollback(lpstate,rbtime);
            break;
         }//end if
    }//end for

     Message m=sendAntiMsgs(theLP.LPid, rbtime);
     return m;
}//end rollBack

/**Annihilates the positive message who has received a matching anti-message.
  */
void annihilateMsg(Message m)
{
  System.out.println("LP " + m.receiverLP + " annihilating msg " + m.timeStamp);
  boolean done=false;

  //first check if the msg was processed; if yes, cancel it
  for(int i=0;i<eventQueue.size();i++){
    Message pm=(Message)eventQueue.get(i);
    if(pm.timeStamp==m.timeStamp && pm.receiverLP==m.receiverLP){
        System.out.println("matching positive msg has already been processed, annihilating " + pm.timeStamp);
        eventQueue.remove(pm);
        done=true;
        break;
    }//end if
  }//end for


  //if not found in event queue,then check simMessages
  if(!done){
      Iterator<Message> iterator = simMessages.iterator();
      try {
        while (iterator.hasNext()) {
           Message pm = iterator.next();
           if(pm.timeStamp==m.timeStamp && pm.receiverLP==m.receiverLP){
              System.out.println("found matching positive msg, annihilating " + pm.timeStamp);
              simMessages.remove(pm);
              done=true;
              break;
           }//end if 
        }//end while
       }//end try
      catch(Exception e){
           e.printStackTrace();      
      }
  }//end if

  //if the the positive msg hasn't received yet, store this anti message in the antiMsgsIn queue
  if(!done){
    System.out.println("scheduler " + id + " hasn't received the positive msg yet, store anti msg");
    antiMsgsIn.add(m);
   }

}//end annihilateMsg

/**@since 1.7
  *Returns true if the message has been canceled with an anti-message.
  *@param m Message to be checked
   */
boolean isMsgCanceled(Message m)
{
   boolean canceled=false;

   for(int i=0;i<antiMsgsIn.size();i++){
      Message am=(Message)antiMsgsIn.get(i);
      if(m.receiverLP==am.receiverLP && m.timeStamp==am.timeStamp){
         System.out.println("scheduler " + id + " canceled "+ am.getContent());   
         antiMsgsIn.remove(am);
         canceled=true; 
        break;
      }//end if
   }//end for

   return canceled;
         
}//end msgCanceled


/** Reads incoming messages from the communication thread and, based on their
 * {@link Message.MsgType} places them in the appropriate data structures for
 * later processing.
 * <ul>
 * <li>{@link Message.MsgType#SIM_REGULAR} - placed in {@link #simMessages}.
 * <li>{@link Message.MsgType#SYSTEM_MONITOR} - placed in {@link #monitoring}.
 * <li>{@link Message.MsgType#SYSTEM_STEER} - placed in {@link #steering}.
 * </ul>
 * Messages of unrecognized MsgType are discarded. Messages directed to
 * LogicalProcesses not owned by this SchedulingLoop are also discarded.
 */
public void processIncoming() {
  if (incoming.size() == 0)
    return;
  //System.out.println("Incoming message!");

  //NOTE - According to the Java 5.0 documentation, this Iterator
  //is *NOT* guaranteed to traverse the PriorityBlockingQueue in any
  //particular order. In this particular case, we want to get everything
  //out of it, so that's not a problem.
  Iterator<Message> iterator = incoming.iterator();
  try {
    while (iterator.hasNext()) {
      Message m = iterator.next();
      switch (m.getMsgType()) {
        case SIM_REGULAR:
          boolean canceled=isMsgCanceled(m);
           if(!canceled)
             simMessages.offer(m);
          break;
        case SIM_ANTI:
          System.out.println("PE " + id + " msg type ANTI");
          annihilateMsg(m);
          break;
        case SYSTEM_MONITOR:
          MonitorNode mn;
          try {
            mn = (MonitorNode)m.content;
            int i = getLPIndexByAPPid(m.receiverAPPid);
            if (i >= 0)
               monitoring.get(i).add(mn);
            else
              System.out.println("Monitoring message was"+
                "directed to LP \""+m.receiverAPPid+
                "\" - not present here!");
          } catch (ClassCastException cce) {
            System.out.println("Monitoring message does not"+
              "contain a MonitorNode object!");
          }
          break;
        case SYSTEM_STEER:
          SteerNode sn;
          try {
            sn = (SteerNode)m.content;
            int i = getLPIndexByAPPid(m.receiverAPPid);
            if (i >= 0)
               steering.get(i).add(sn);
            else
              System.out.println("Steering message was"+
                "directed to LP \""+m.receiverAPPid+
                "\" - not present here!");
          } catch (ClassCastException cce) {
            System.out.println("Steering message does not"+
              "contain a SteerNode object!");
          }
          break;
           //TODO - process other message types?
        default:
          System.out.print("Message type "+m.getMsgType()+
            " is not recognized by this SchedulingLoop! ");
          System.out.println("\""+m+"\" will be discarded.");
          break;
      }
      iterator.remove();
    }
  } catch (ConcurrentModificationException e) {
    //System.out.println("Error! Concurrent modification of \"incoming\""+
     // " PriorityBlockingQueue!");
    //e.printStackTrace();
  }
} // end processIncoming()




/** Applies any scheduled monitoring of a single LP.
 * @param index The storage index of the LP to monitor. */
public void applyMonitoring(int index) {
  //System.out.println("There's some monitoring to do!");
  
  LogicalProcess lp = LPs.get(index);
  SortedSet<MonitorNode> mon = monitoring.get(index);
  int lptime = lp.currentTime;
  if (mon.isEmpty()) {       
    //System.out.println("No assigned monitoring for LP "+lp.APPid);
    return;
  }
  Iterator<MonitorNode> it = mon.iterator();
  while (it.hasNext()) {
    MonitorNode m = it.next();
    if (m.startTime > lptime)
      break; //set is sorted, so all remaining elements aren't valid
    //Monitoring is applied BEFORE old commands are deleted
    //This way we can set startTime = stopTime for a one-shot command
    String s = lp.getState(m.targetVar);
    ReportNode rep = new ReportNode(s,lptime,m.targetVar,m.clientID);
    Message msg = new Message(lptime, Message.MsgType.SYSTEM_REPORT, rep,
        lp.APPid, null);
    msg.setSenderLP(lp.LPid);
    msg.setReceiverLP(m.clientID);
    sendMessage(msg);
    //NOW we can delete this command if it's obsolete.
    if (m.stopTime < lptime)
      it.remove();
  }
} //end applyMonitoring()

/** Applies any scheduled steering to the specified LP.
 * @param index The storage index of the LP to steer. */
public void applySteering(int index) {
  //System.out.println("There's some steering to do!");
  LogicalProcess lp = LPs.get(index);
  SortedSet<SteerNode> steer = steering.get(index);
  int lptime = lp.currentTime;
  if (steer.isEmpty()) {
    //System.out.println("No assigned monitoring for LP "+lp.APPid);
    return;
  }
  Iterator<SteerNode> it = steer.iterator();
  while (it.hasNext()) {
    SteerNode s = it.next();
    if (s.startTime > lptime)
      break; //set is sorted, so all remaining elements aren't valid
    //Steering is applied one last time BEFORE old commands are deleted
    //This way we can set startTime = stopTime for a one-shot command
    String str = lp.setState(s.targetVar, s.setPoint);
      if (str != null)
      System.out.println(str);
    AcknowledgeNode ack = new AcknowledgeNode(s.setPoint, lptime,
        str, s.targetVar, s.clientID);
    Message msg = new Message(lptime, Message.MsgType.SYSTEM_ACKNOWLEDGE,
        ack, lp.APPid, null);
    msg.setSenderLP(lp.LPid);
    msg.setReceiverLP(s.clientID);
    sendMessage(msg);
    //NOW we can delete obsolete commands
    if (s.stopTime < lptime)
      it.remove();
  }
} //end applySteering()



/** Finds the list index of a given LP (position associated with it in
 * {@link #LPs}, {@link #monitoring}, and {@link #steering}) based on its
 * LP.
 * @param lpid The LPid to look for
 * @return The index of the first occurrence of this LP, or -1 if none found.
 */
public int getLPIndexByLPid(int lpid) {
  if (lpid<0)
    return -1;
  for (int i=0; i<LPs.size(); i++) {
    LogicalProcess lp = LPs.get(i);
    if (lpid==lp.LPid)
      return i;
  }
  return -1;
} //end getLPIndexByLPid()


/** Finds the list index of a given LP (position associated with it in
 * {@link #LPs}, {@link #monitoring}, and {@link #steering}) based on its
 * APPid.
 * @param appid The APPid to look for (case insensitive)
 * @return The index of the first occurrence of this LP, or -1 if none found.
 */
public int getLPIndexByAPPid(String appid) {
  if (appid == null)
    return -1;
  for (int i=0; i<LPs.size(); i++) {
    LogicalProcess lp = LPs.get(i);
    if (appid.equalsIgnoreCase(lp.APPid))
      return i;
  }
  return -1;
} //end getLPIndexByAPPid()


/** Creates a new LogicalProcess of the specified type and adds it to the list
 * of LPs managed by this run loop.
 * @param pid The numerical ID of the PE where this LP resides
 * @param LPid The numerical ID of the LP
 * @param APPid The application-assigned ID of the LP
 * @param name The application-assigned full name of the LP
 * @param className Name of LogicalProcess subclass to create
 * @param data Configuration data to pass into the LP
 * @see LogicalProcess
 */
public void createLP(int pid, int LPid, String APPid, String name,
        String className, String data) {
  try {
    LogicalProcess LP =
      (LogicalProcess)(Class.forName(className).newInstance());
    LP.setPID(pid);
    LP.setLID(LPid);
    LP.setAppID(APPid);
    LP.setName(name); 
    LP.setConfigData(data);
    LP.setScheduler(this);
 
    LPs.add(LP);
    monitoring.add(new TreeSet<MonitorNode>());
    steering.add(new TreeSet<SteerNode>());
  } catch(Exception e) {
    e.printStackTrace();
  }
  //NOTE - Unlike PE, SchedulingLoop doesn't keep a LocalNameServer. That is
  //the responsibility of the communication thread. All messages generated
  //by LPs go into the outgoing list, even if the communication thread just
  //turns around and drops them right back into the incoming list.
}


/**Locates one of the LPs managed by this scheduling loop, based on its APPid.
 * @param appid The APPid to look for (case insensitive)
 * @return The first LP found with the given APPid, or null if none found.
 */
public LogicalProcess getLPByAPPid(String appid) {
  for (LogicalProcess lp : LPs) {
    if (appid.equalsIgnoreCase(lp.APPid))
      return lp;
  }
  return null;
} //end getLPByAPPid()
  
 
}//end class PE