dispatcher_jmvaschema.java

一个用于排队系统仿真的开源软件,有非常形象的图象仿真过程!

            }
        }

        return true;
    }
    
    /**
     * Transforms model using new Java class to perform transformation instead of old bugged XSLT transformer.
     * Avoid to measure elements with null service demand.
     * @param inputModel input model in exact solver format
     * @param outputModel output model in simulator format
     * @return open ExactModel or null if an error occurred
     */
    public ExactModel getTransformedModel(String inputModel, String outputModel) {
        /*********************DEFINITION MODEL*********************/
        File input = new File(inputModel);
        if (!input.exists()) {
            //the passed file does not exist
            logger.error("The model file " + inputModel + " does not exist...");
            return null;
        } else {
            logger.debug("Model definition path: " + input.getAbsolutePath());
        }


        /*********************SIM DEFINITION MODEL*********************/

        //Loads ExactModel and transforms it to CommonModel
        ExactModel exact = new ExactModel();
        XMLUtils xmlUtils = new XMLUtils();
        Document inputDoc;
        try {
            inputDoc = xmlUtils.loadXML(input);
            exact.loadDocument(inputDoc);
        } catch (SAXException e1) {
            logger.error("Cannot parse correctly input JMVA model: " + e1.getMessage());
            return null;
        } catch (IOException e1) {
            logger.error("I/O error opening input JMVA model: " + e1.getMessage());
            return null;
        }
        logger.debug("Input model opened correctly...");
        CommonModel simModel = new CommonModel();
        Vector warnings = ModelConverter.convertJMVAtoJSIM(exact, simModel, true);
        // Last element of warning is transform matrix
        for (int i=0; i<warnings.size() - 1; i++)
            logger.warn("Warning during conversion: "+warnings.get(i));
        transform = (double[][]) warnings.lastElement();
        
        // Removes all measures from classes with null service demands
        removeNullMeasures(exact, simModel);
        logger.debug("Removed null measures from simulator model");

        Document modelDocument = XMLWriter.getDocument(simModel, outputModel);
        logger.debug("Converted JMVA xml to JSIM one");
        // Adds blocking region informations to model document
        NodeList blockingList = inputDoc.getElementsByTagName("blockingRegion");
        // If model has one blocking region only, adds router to it.
        if (blockingList.getLength() == 1) {
            Element region = (Element) blockingList.item(0);
            Element router = inputDoc.createElement("regionNode");
            router.setAttribute("nodeName","Router");
            region.insertBefore(router, region.getFirstChild());
        }
        
        for (int i=0; i<blockingList.getLength(); i++)
            modelDocument.getDocumentElement().appendChild(modelDocument.importNode(blockingList.item(i), true));
        logger.debug("Added finite capacity regions");
        
        XMLWriter.writeXML(outputModel, modelDocument);
        
        logger.debug("JSIM model definition wrote to disk");

        return exact;
    }
    
    
    /**
     * Solves model using new Java class to perform transformation instead of old bugged XSLT transformer.
     * Avoid to measure elements with null service demand.
     * @return true if model was solved correctly, false otherwise.
     */
    public boolean solveModelNewTransform() {
        boolean transfSuccess = false;
        //get file name: same directory of model file, with the same name preceeded by "sim_"
        String modelDefinitionParent = modelDefinition.getParent();
        
        if (modelDefinitionParent.endsWith(SEPARATOR)) {
            simModelDefinitionPath = modelDefinitionParent + "sim_" +
                modelDefinition.getName();
        } else {
            simModelDefinitionPath = modelDefinitionParent + SEPARATOR + "sim_" +
                modelDefinition.getName();
        }
        
        ExactModel inputModel = getTransformedModel(modelDefinitionPath, simModelDefinitionPath);
        if (inputModel == null)
            return false;

        /*********************SIMULATION LOADING AND RUNNING*********************/

        //sim model successfully created
        //now prepare simulation
        try {
            SimLoader simLoader = new SimLoader(simModelDefinitionPath);
            Simulation sim = simLoader.getSim();
            //sim.MONITOR_BLOCKING_REGION = true;            
            //sets in the Simulation object the path of the original (i.e. MVA)
            //xml model definition
            sim.setXmlModelDefPath(modelDefinitionPath);

            if (!automaticSeed) {
                //if automaticSeed == false, then a user defined seed is present
                sim.setRandomEngineSeed(simulationSeed);
                sim.initialize();

                logger.debug("jSIM correctly initialized with simulation seed = " + simulationSeed);
            } else {
                sim.initialize();
                logger.debug("jSIM correctly initialized");
            }

            //Avoid saturation
            if (sim.getAllRegions() == null) {
            	//if there are no regions...
            	boolean sufficientProcessingCapacity = checkProcessingCapacity();

                if (!sufficientProcessingCapacity) {
                    logger.warn("Current workload causes system saturation. Simulation will not be started.");
                    return false;
                }
            }
            


            simStarted = true;
            net = sim.getNetwork();


            long start, stop;
            double elapsed;

            //Start time
            start = System.currentTimeMillis();

            sim.run();

            //stop time
            stop = System.currentTimeMillis();
            elapsed = ((double) (stop - start) ) / 1000.0;

            simFinished = true;

            logger.info("Model " + modelDefinitionPath + " solved by jSIM in " + Double.toString(elapsed) + " seconds");

        } catch (IOException e) {
            e.printStackTrace();
            logger.error(e.getMessage());
            return false;
        } catch (LoadException e) {
            e.printStackTrace();
            logger.error(e.getMessage());
            return false;
        } catch (Exception e) {
            e.printStackTrace();
            logger.error(e.getMessage());
            return false;
        }

        simModelDefinition = new File(simModelDefinitionPath);


        /*********************COPYING SIMULATION RESULTS*********************/

        //the results file has been obtained
        //the file has been saved in the same directory of model file, with the same name preceeded by "res_sim_"



        if (modelDefinitionParent.endsWith(SEPARATOR)) {
            simResultsPath = modelDefinition.getParent() + "res_" +
            simModelDefinition.getName();
        } else {
            simResultsPath = modelDefinition.getParent() + SEPARATOR + "res_" +
            simModelDefinition.getName();
        }

        simResults = new File(simResultsPath);

        logger.debug("jSIM results path: " + simResultsPath);


        //transforms the SIMmodeloutput into JMTmodel
       
        //setup transformer
        ModelTransformer md = new ModelTransformer();
        md.setValidate(validate);
        //create temp file to contain model definition and results
        File temp = null;
        String tempPath = null;

        try {
            temp = File.createTempFile("~jmt_model", ".xml", modelDefinition.getParentFile());
            tempPath = temp.getAbsolutePath();
        } catch (IOException e) {
            e.printStackTrace();
            logger.error(e.getMessage());
            logger.error("Error in creating temp file for model " + modelDefinitionPath);

            return false;
        }

        transfSuccess = md.OUTtoMVA(simResultsPath, tempPath);

        if (!transfSuccess) {
            logger.error("OUT to MVA transformation failed model " + modelDefinitionPath);
            return false;
        } else {
            //if successful, rename to model definition file, after deleting the old version
            if (modelDefinition.exists()) {
                modelDefinition.delete();
            }
            
            // Put in place all measures from classes with null service demands and adjusts throughputs
            Document outDocument;
            XMLUtils xmlUtils = new XMLUtils();
            try {
                outDocument = xmlUtils.loadXML(temp);
                addNullMeasuresCorrectThroughputs(inputModel, outDocument);
            } catch (SAXException e2) {
                logger.error("Cannot parse correctly output JMVA model: " + e2.getMessage());
                return false;
            } catch (IOException e1) {
                logger.error("I/O error opening output JMVA model: " + e1.getMessage());
                return false;
            }
            logger.debug("Added null measures to final results");
            
            try {
                xmlUtils.saveXML(outDocument, modelDefinition);
            } catch (Exception e3) {
                logger.error("could not copy results into model " + modelDefinitionPath);
                return false;
            }
            
            resultsObtained = true;
            logger.debug("jSIM results copied into model " + modelDefinitionPath);

            //delete temp file
            if (!temp.delete()){
                temp.deleteOnExit();
                logger.warn("Could not delete a temp file. Deletion will be retried on JVM exit.");
            }

        }


        /*********************DELETE INTERMEDIATE FILES*********************/

        //if true delete intermediate files
        if (deleteIntermediateFiles) {

            //false if one or more files cannot be deleted
            boolean successfulDelete = true;

            if (simModelDefinition.exists()) {
                if (!simModelDefinition.delete()) {
                    successfulDelete = false;
                    //try in another way
                    simModelDefinition.deleteOnExit();
                }
            }
            if (simResults.exists()) {
                if (!simResults.delete()) {
                    successfulDelete = false;
                    //try in another way
                    simResults.deleteOnExit();
                }
            }

            if (successfulDelete) {
                logger.debug("Intermediate files deleted for model " + modelDefinitionPath);
            } else {
                logger.warn("Could not delete some intermediate files. They will be deleted on JVM exit.");
            }
        }

        return true;
    }



    /**
     * allows to know the state of simulation
     * @return the percentage of progress (= number of computed confidence intervals /
     * total number of required confidence intervals)
     */
    public double checkSimProgress() {
        if (!simStarted) {
            //not started yet
            return 0.0;
        }
        if (simFinished) {
            //already finished
            return 1.0;
        }
        try {
            //compute progress

            if (pauseSim()) {
                double progr = NetSystem.checkProgress(net);
                restartSim();
                return progr;
            } else {
                return 0;
            }

        } catch (NetException e) {
            return 0.0;
        }

    }



    /**
     * Pauses the simulation, refreshes temp measures and then restarts simulation
     */
    public void refreshTempMeasures() {

        //simulation not started yet
        if (!simStarted)
            return;

        //pauses the computation
        if (pauseSim()) {

            //at the first execution, measures must be retrieved
            if (tempMeasures == null) {
                if (net == null) {
                    return;
                } else {
                    //gets the measures defined for this queue network
                    LinkedList measures = net.getMeasures();

                    //creates the array of temp measures
                    tempMeasures = new TempMeasure[measures.size()];

                    for (int m = 0; m < measures.size(); m++) {
                        tempMeasures[m] = new TempMeasure((Measure) measures.get(m));
                        tempMeasures[m].refreshMeasure();
                    }
                }
            } else {
                //temp measures have already been retrieved
                //only refresh temp values
                for (int m = 0; m < tempMeasures.length; m++) {
                    tempMeasures[m].refreshMeasure();
                }
            }

            //restart computation
            restartSim();

        }
        return;
    }


    /**
     * gets the temp measures
     * @return the temp measure