clientjobmanager.java

The ElectricTM VLSI Design System is an open-source Electronic Design Automation (EDA) system that c

            if (ejob.jobType == Job.Type.CHANGE) return true;
        }
        for (EJob ejob: waitingJobs) {
            if (ejob.jobType == Job.Type.CHANGE) return true;
        }
        return false;
    }
    
    /** get all jobs iterator */
    Iterator<Job> getAllJobs() { // synchronization !!!
        ArrayList<Job> jobsList = new ArrayList<Job>();
        for (EJob ejob: startedJobs) {
            Job job = ejob.getJob();
            if (job != null)
                jobsList.add(job);
        }
        for (EJob ejob: waitingJobs) {
            Job job = ejob.getJob();
            if (job != null)
                jobsList.add(job);
        }
        return jobsList.iterator();
    }
    
    private class FIFO {
        private final String CLASS_NAME = ClientJobManager.CLASS_NAME + ".FIFO";
        private final ArrayList<Client.ServerEvent> queueF = new ArrayList<Client.ServerEvent>();
        private final ArrayList<Client.ServerEvent> queueT = new ArrayList<Client.ServerEvent>();
        private boolean getC = false;
        private int getIndex = 0;
        private int numGet;
        private int numPut;
        
        private synchronized void put(Client.ServerEvent o) {
            logger.logp(Level.FINEST, CLASS_NAME, "put", "ENTRY");
//            ArrayList<Client.ServerEvent> thisQ;
            ArrayList<Client.ServerEvent> thatQ;
            if (getC) {
//                thisQ = queueT;
                thatQ = queueF;
            } else {
//                thisQ = queueF;
                thatQ = queueT;
            }
            boolean empty = numGet == numPut;
            thatQ.add(o);
            numPut++;
            if (empty) {
                logger.logp(Level.FINEST, CLASS_NAME, "put", "invokeLater(clientInvoke)");
                SwingUtilities.invokeLater(clientInvoke);
            }
            logger.logp(Level.FINEST, CLASS_NAME, "put", "RETURN");
        }
        
        private synchronized Client.ServerEvent get() {
            logger.logp(Level.FINEST, CLASS_NAME, "get", "ENTRY");
            if (numGet == numPut) return null;
            ArrayList<Client.ServerEvent> thisQ;
            ArrayList<Client.ServerEvent> thatQ;
            if (getC) {
                thisQ = queueT;
                thatQ = queueF;
            } else {
                thisQ = queueF;
                thatQ = queueT;
            }
            Client.ServerEvent o = null;
            if (getIndex < thisQ.size()) {
                o = thisQ.set(getIndex++, null);
            } else {
                o = thatQ.set(0, null);
                getIndex = 1;
                getC = !getC;
                thisQ.clear();
            }
            numGet++;
            logger.logp(Level.FINEST, CLASS_NAME, "get", "RETURN");
            return o;
        }
    }
    
    private final FIFO clientFifo = new FIFO();
    
//    private static volatile int clientNumExamine = 0;
    private static Snapshot clientSnapshot = EDatabase.clientDatabase().getInitialSnapshot();
    
    private final ClientInvoke clientInvoke = new ClientInvoke();
    private class ClientInvoke implements Runnable {
        private final String CLASS_NAME = getClass().getName();
        public void run() {
            logger.entering(CLASS_NAME, "run");
            assert SwingUtilities.isEventDispatchThread();
            for (;;) {
                logger.logp(Level.FINEST, CLASS_NAME, "run", "before get");
                if (jobTreeChanged) {
                    jobTreeChanged = false;
                    ArrayList<Job> jobs = new ArrayList<Job>();
                    for (Iterator<Job> it = Job.getAllJobs(); it.hasNext();) {
                        Job j = it.next();
                        if (j.getDisplay()) {
                            jobs.add(j);
                        }
                    }
                    JobTree.update(jobs);
              }
                int numGet = clientFifo.numGet;
                Client.ServerEvent o = clientFifo.get();
                if (o == null) break;
                if (o instanceof Client.EJobEvent) {
                    Client.EJobEvent ejobEvent = (Client.EJobEvent)o;
                    EJob ejob_ = ejobEvent.ejob;
                    if (false) {
                        System.out.print("Job " + ejob_.jobId + " " + ejob_.jobName + " " + ejob_.jobType + " " + ejob_.state +
                                " old=" + ejob_.oldSnapshot.snapshotId + " new=" + ejob_.newSnapshot.snapshotId +
                                " t=" + ejobEvent.timeStamp + "(" + (System.currentTimeMillis() - ejobEvent.timeStamp) + ")");
                        if (ejob_.serializedJob != null)
                            System.out.print(" ser=" + ejob_.serializedJob.length);
                        if (ejob_.serializedResult != null)
                            System.out.print(" res=" + ejob_.serializedResult.length);
                        System.out.println();
                    }
                    int jobId = ejob_.jobId;
                    logger.logp(Level.FINER, CLASS_NAME, "run", "result begin {0}", Integer.valueOf(numGet));
                    if (ejob_.newSnapshot != clientSnapshot) {
                        (new SnapshotDatabaseChangeRun(clientSnapshot, ejob_.newSnapshot)).run();
                        clientSnapshot = ejob_.newSnapshot;
                    }
                    if (Job.currentUI != null) {
                        Job.getExtendedUserInterface().showSnapshot(ejobEvent.ejob.newSnapshot, ejobEvent.ejob.jobType == Job.Type.UNDO);
//                        Job.currentUI.addEvent(o);
                        continue;
                    }
                    if (ejob_.state != EJob.State.SERVER_DONE) continue;
                    EJob ejob = null;
                    for (EJob ej: startedJobs) {
                        if (ej.jobId == jobId) {
                            ejob = ej;
                            break;
                        }
                    }
                    if (ejob == null) {
                        System.out.println("Can't find EJob " + jobId);
                        continue;
                    }
                    ejob.serializedResult = ejob.serializedResult;
                    Job job = ejob.getJob();
                    if (job != null) {
                        Job.runTerminate(ejob);
                        // delete
                        if (job.deleteWhenDone) {
                            startedJobs.remove(job);
                            TopLevel.setBusyCursor(isChangeJobQueuedOrRunning());
                        }
                        logger.logp(Level.FINER, CLASS_NAME, "run", "result end {0}", ejob.jobName);
                    } else {
                        logger.logp(Level.WARNING, CLASS_NAME, "run", "result of unknown job {0}", o);
                        System.out.println("Job " + jobId + " was not found in startedJobs");
                    }
                } else if (o instanceof Client.PrintEvent) {
                    logger.logp(Level.FINEST, CLASS_NAME, "run", "string begin");
                    if (Job.currentUI != null)
                        Job.currentUI.addEvent(o);
                    logger.logp(Level.FINEST, CLASS_NAME, "run", "string end {0}", o);
                }
            }
            if (waitingJobs.isEmpty()) {
                logger.exiting(CLASS_NAME, "run");
                return;
            }
            EJob ejob = waitingJobs.remove(0);
            Job job = ejob.clientJob;
            if (ejob.jobType == Job.Type.EXAMINE) {
                logger.logp(Level.FINER, CLASS_NAME, "run", "Schedule EXAMINE {0}", job);
                try {
                    job.doIt();
                } catch (JobException e) {
                    e.printStackTrace();
                }
            } else {
                logger.logp(Level.FINER, CLASS_NAME, "run", "Schedule {0}", job);
                ejob.jobId = ++numStarted;
                Throwable e = ejob.serialize(EDatabase.clientDatabase());
                if (e != null) {
                    System.out.println("Job " + this + " was not launched in CLIENT mode");
                    e.printStackTrace(System.out);
                } else {
                    try {
                        writeEJob(ejob);
                        
                        ejob.getJob().started = true;
                        startedJobs.add(ejob);
//                        clientJob = job;
                    } catch (IOException ee) {
                        System.out.println("Job " + this + " was not launched in CLIENT mode");
                        ee.printStackTrace(System.out);
                    }
                }
            }
            logger.exiting(CLASS_NAME, "run");
       }
    };
    
    
    private static class SnapshotDatabaseChangeRun implements Runnable 
	{
		private Snapshot oldSnapshot;
        private Snapshot newSnapshot;
		private SnapshotDatabaseChangeRun(Snapshot oldSnapshot, Snapshot newSnapshot) {
            this.oldSnapshot = oldSnapshot;
            this.newSnapshot = newSnapshot;
        }
        public void run() {
            EDatabase database = EDatabase.clientDatabase();
            database.lock(true);
            try {
                database.checkFresh(oldSnapshot);
                database.lowLevelSetCanUndoing(true);
                database.getNetworkManager().startBatch();
                database.undo(newSnapshot);
                database.getNetworkManager().endBatch();
                database.lowLevelSetCanUndoing(false);
//            EDatabase.clientDatabase().undo(newSnapshot);
//            NetworkTool.updateAll(oldSnapshot, newSnapshot);
//            DatabaseChangeEvent event = new DatabaseChangeEvent(oldSnapshot, newSnapshot);
//            UserInterfaceMain.fireDatabaseChangeEvent(event);
            } finally {
                database.unlock();
            }
        }
	}
}