All Classes and Interfaces
Class
Description
Title: Abort Measure Interface
Factory creating the about dialog objects.
This panel draws the about window.
Base class of the JMT probability distributions, defining the common random drawing interface.
Defines the Abstract action of this application, it is connected to the
mediator which has the responsibility to react to it.
Base class of the actions of the JMT graphical editors.
Defines the Abstract action of this application, it is connected to the
WizardPanelMCH which has the responsibility to react to it.
TODO rivedere la descrizione
interface for all distributions parameters.
An abstract class grouping functionalities common to Undo and Redo action.
Provides the Action Bezier Edge Add Control Point functionality of the actions.
Provides the Action Bezier Edge Add Tangents functionality of the actions.
Provides the Action Bezier Edge Break Edge functionality of the actions.
Provides the Action Bezier Edge Remove Control Point functionality of the actions.
Provides the Action Bezier Edge Select Control Point functionality of the actions.
Provides the Action Bezier Edge Unlock Tangents functionality of the actions.
Provides the Action Cancel Edge Drawing functionality of the actions.
A class representing a "redo" action.
A class representing the "rotate" action.
A class representing the "set right" action.
A class representing an "undo" action.
Creates the names of the JMVA solution algorithms shown in the GUI.
Title: Algorithm Panel
Loads the input file formats of JWAT (standard and customized).
Exception thrown by the JABA convex hull algorithms when all the points are collinear.
Exception thrown by the JABA convex hull algorithms when all the points are coplanar.
This class implements the abstract superclass for approximate MVA algorithms
for solving multi-closed models
Panel representing the combo box on ExactWizard (GUI of JMVA)
Created by IntelliJ IDEA.
Interface that must be implemented by the class that represent the Animation
This class is a super class for all the animations.
Panel for JTeach models.
This is the superclass for solving the model using the Animation.
Created by IntelliJ IDEA.
Animator of JMCH: the thread that drives the animation of the scheduling and routing algorithms.
This class implements the AQL (Aggregate Queue Length) approximate MVA
algorithm [ZES88] for solving multiclass closed models, as described in the
AMVA section of the JMVA chapter of the JMT user manual.
Arithmetic functions.
Assorted array mangling stuff.
resize methods return a resized copy of an array, preserving data where possible and padding with a specified value
copy methods perform a deep copy of an array.Title: ArrivalRateParametricAnalysis
Title: ArrivalRatesPanel
Representing the arrival of the job.
Shows an engine warning from a separate thread after a short delay, so the GUI is up before the popup appears.
This class extends TopLevelBlock to also include a list of SecondaryMacroBlocks.
This interface should be implemented by all the classes which should
implement an auto-check method.
This class implements the B1 Block of the B matrix.
This class implements the Macro Blocks of the B1 Block of the B matrix.
This class implements the Micro Blocks of the B1 block of the B matrix.
This class implements the B2 Block of the B matrix.
This class implements the Macro Blocks of the B2 Block of the B matrix.
This class implements the Micro Blocks of the B2 block of the B matrix.
Balking impatience strategy: arriving jobs refuse to join the queue according to a given probability.
Parameters of the balking distribution.
Title: Load Dependent Service Time Strategy Editor
This class implements the Bard-Schweitzer approximate MVA algorithm [Sch79]
for solving multiclass closed models.
Base implementation of the priority MVA utilization calculators.
A class to encapsulate the basis of CoMoM (or MoM).
Title: Batched Distribution
This is the Batched distribution.
Title: Batch Circular List data structure
This is the parameter that should be passed to the Batched distribution.
Created by IntelliJ IDEA.
Created by IntelliJ IDEA.
Bernoulli distribution: returns 1 with probability p and 0 otherwise.
Bernoulli distribution: returns 1 with probability p and 0 otherwise.
Parameters of the Bernoulli distribution.
Vacation strategy in which the server takes a vacation after each service completion with a given (Bernoulli) probability.
Created by IntelliJ IDEA.
Created by IntelliJ IDEA.
(#)pf.js * * Copyright (c) 2000 by Sundar Dorai-Raj
* @author Sundar Dorai-Raj
* Email: sdoraira@vt.edu
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version,
* provided that any use properly credits the author.
A class defining a vertex.
Toolbar with the helpers to edit Bezier connections in JSIMgraph.
Title: Handles all the events when the user draws a Bezier connection
Title: Handles all the events when the user modifies a Bezier connection
Panel with the tools to modify Bezier connections in JSIMgraph.
This class is a representation of rational numbers.
Binomial distribution: number of successes in n independent trials, each with probability p.
Binomial distribution: number of successes in n independent trials, each with probability p.
Parameters of the binomial distribution.
Provides the BKT Prio MVA Util Calculator functionality of the utilisations.
This class implements the queue of a region input station, that is
the node which controls the access to a blocking region.
Title: Blocking Region Component
This class represents a blocking region, that is a region with a finite capacity.
Swing panel of the JMT wizard providing the blocking region class view.
Title: Blocking Region Definition Interface
Swing panel of the JMT wizard providing the blocking region group view.
Title: Blocking Region Parameter Panel
Title: Blocking Region Panel
This class implements a blocking router, i.e.
Title: Blocking Region Station Definition Panel
Cell renderer for the boolean cell values.
Impatience measurement storing a boolean impatience value.
Class for a single space inside the queue of the station
Provides the Browser Launcher functionality of the net.
A concrete implementation of the CoMoMBasis that orders the basis in the way required for the BTF linear systems
This class implements the BTF linear system, using the idea that the matrices only need to be generated once.
This class represents an exception that can be thrown if an internal error is
encountered where solving the BTF linear system
Title: Burst Distribution
This is the Burst distribution.
Title: BurstEngine
This is the parameter that should be passed to the Burst distribution.
Created by IntelliJ IDEA.
This class implements a class switch.
It represent a component that switches class of jobs coming into it.
Created by IntelliJ IDEA.
Item stored in the cache of a cache-equipped JSIM station, together with its access statistics.
Swing panel of the JMT wizard providing the cache section view.
Base class of the cache eviction strategies of the JSIM engine: it decides which cached item is removed when the cache is full.
Created by IntelliJ IDEA.
This class implements a calculator of the canonical order of
MultiplicitiesVector objects.
This class manages and draws points in a dimensional cartesian plane.
This class implements the Carry Forward Equations of the linear system
The Factory Methods newMacroBlock and subBlockCopy are implemented to return the correct
block type in the parallel hierarchy.
Title: Cell Component
A class grouping all cell creation suff
Listener notified when a JWAT variable changes.
Title: Chapter Identifier
Title: CheckBox Table CellViewer/CellEditor
Provides the Child Node functionality of the common.
This class implements the Chow approximate MVA algorithm [Cho83] for solving
multiclass closed models.
Class for the server in the station
This class implements an event queue used internally by the Sim_system to
manage the list of Sim_events.
Name: CircularList
Provides the CL_Y Prio MVA Util Calculator functionality of the utilisations.
Provides the CL_Z Prio MVA Util Calculator functionality of the utilisations.
Implements functionality related to class coverage.
Enum to represent the 3 types of class coverages: fully-covered, partially-covered and non-covered,
as defined in the LamLien83 paper.
Created by IntelliJ IDEA.
1st panel: classes number, names, types and data
1st panel: classes number, names, types and data
Created by IntelliJ IDEA.
This class implements a class switch.
It represent a component that switches class of jobs coming into it.
Class Switch Routing strategy of the JMT routing strategies.
Parameters of the class switch routing strategy.
Routing strategy used when a job changes its class: it selects the destination station of the switched job.
Provides the Class Switch Row functionality of the class switch utilities.
Swing panel of the JMT wizard providing the class switch section view.
a JTableHeader that can handle column selection
Wrapper class for single-class queueing models
Uses multi-class algorithm classes for solving the models
For iterative algorithms use IterativeClosedMultiToSingleSolverWrapper
Provides the CL Prio MVA Util Calculator functionality of the utilisations.
Information of a cluster produced by the JWAT fuzzy k-means algorithm.
Information of a cluster produced by the JWAT k-means algorithm.
Clustering algorithm of JWAT for identifying similarities in the workload data.
Panel showing the information of a JWAT clustering.
Information produced by a JWAT clustering algorithm (clusters and centroids).
Information produced by the JWAT fuzzy k-means clustering.
Information produced by the JWAT k-means clustering.
Panel showing the JWAT clustering results.
This class implements the Macro Blocks of the Carry Forward Equations
The Factory Methods newMicroBlock and subBlockCopy are implemented to return the correct
block type in the parallel hierarchy.
This class implements the Micro Blocks of the Carry Forward Equations componet of the Linear System.
Title: Color Cell Editor
Provides the Column Header Tool Tips functionality of the jwat.
Fork strategy that routes all the possible combinations of the tasks to the output stations of a fork.
Fork strategy that routes all the possible combinations of the tasks to the output stations of a fork.
Created by IntelliJ IDEA.
Title: ComboBox Table CellViewer/CellEditor
This class allows to solve a model contained in a ".xml" File from command line,
without using the graphic user interface of Java Modelling Tools.
The model is validated and solved.
The model is validated and solved.
Created by IntelliJ IDEA.
Created by IntelliJ IDEA.
This class implements the comparator for search keys.
A class to encapsulate the Basis of CoMoM
The basis is intialised according to the initial conditions of CoMoM.
A concrete implementation of the CoMoMBasis that orders the basis in the same way as the MatLab implementation, for comparison.
A concrete implementation of the CoMoMSolver class that choose to use the BTF
Linear System.
A concrete implementation of the CoMoMSolver class that choose to use the
Simple Linear System.
This class provides the high-level implementation of the CoMoM algorithm, it
is programmed to the interface provided by the LinearSystem class.
Abstract class representing complexity evaluator for calculating the complexity of a tree algorithm if
it were to be run on a given tree representing a network.
Title: Component Toolbar
This class defines fields that all component blocks of the linear system must have, and provides the interface
they must all implement.
Configuration values for tree algorithms.
Checks the validity of the connections of a JSIMgraph model.
Created by IntelliJ IDEA.
Converters of the constants used by the JMVA solvers.
Name: ConstantNode
Class that contains most of the descriptions and help labels of JMCH
Defines some useful constants.
Name: ConstMap
This class draws all the part of the graph
This is a panel which draws the Convex Hull diagram, given the pre-computed
set of faces.
Mouse action modes.
Keeps points coordinates both as world coords and as projected screen
coords.
A class representing the convex hull of a set of points.
This class constructs the convex hull for 3-classes model.
A class representing exceptions during construction of a convex hull.
Panel of the JABA tool showing the convex hull (characteristic polytope) of the model.
Implements the lowest level convolution operations, as outlined in the LamLien83 paper.
Layer in between the single and multi-threaded solvers and the convolution core.
This class implements the ConvolutionSolver object, which computes the
normalising constant for a network using the Convolution algorithm.
Title: Coxian Distribution
This is the Coxian distribution.
This is the parameter that should be passed to the Coxian
distribution.
Name: CSVLogger
This class implements a csv output for measure class.
Interface that simulates the beheviour of the Collection interface in Java.
This dialog factory is used to display all template relevant panels.
Title: Custom Toolbar Separator
Mapping of a JWAT variable onto the imported data.
Swing panel of the JMT wizard providing the deadline editor view.
Debug utilities of the JMVA solvers.
Debug Solver solution algorithm of JMVA.
Panel of the JSIMgraph debug solver.
Created by IntelliJ IDEA.
Created by IntelliJ IDEA.
Title: Simulation Defaults
Title: Defaults Editor
This class implements a multi-class delay service.
Represents a pure Delay service center
Swing panel of the JMT wizard providing the delay off section view.
description panel
description panel
Title: Deterministic Distribution
This is the Deterministic distribution, which returns always the same value
contained in the parameter.
This is the parameter that should be passed to the Deterministic
distribution.
Title: Parameter selection Dialog Factory
Title: Direct Circular List
A CellRenderer displaying null cells as disabled
Created by IntelliJ IDEA.
This class implements a disabled routing strategy.
This service strategy always raises a warning.
Name: DisabledStrategy
Base class of the discrete probability distributions of the JMT random package.
Provides the Discrete Uniform functionality of the discrete.
Name: DispatcherJMVAschema
Receives the absolute path of a xml file which describes the model using the
SIMmodeldefinition.xsd schema.
Title: Dispatcher Thread
Registers DispatcherThread as the SimulationRunner implementation.
Utilities of the JMVA solver dispatchers.
Swing panel of the JMT wizard providing the dispersion fuzzy view.
Swing panel of the JMT wizard providing the dispersionk mean view.
Swing component displaying the disp fuzzy matrix.
Swing component displaying the disp k mean matrix.
Swing component displaying the disp matrix.
Swing component displaying the disp qq plot matrix.
Title: Distribution
This is the Distribution abstract class, which is the interface of all distributions.
This interface is used to specify a custom check method on parameter's value (for example
value's range).
Title:Distribution Container
Manager of the service time and inter arrival time distributions for JMCH.
Title: Distributions' Editor
this class creates a dynamic list of double.
Impatience measurement storing a double impatience value.
Point with double coordinates used by the JABA convex hull algorithms and graphs.
This class implements a specific PS strategy: Discriminatory Processor-
Sharing.
Discriminatory Processor Sharing strategy with priorities: each class receives a distinct share of the station capacity.
MMQueues
--------------------------------------
23-mar-2004 - Graphics.constants/DrawSmall.java
Drawing constraints of the JMCH animation components.
MMQueues
--------------------------------------
23-mar-2004 - Graphics.constants/DrawSmall.java
MMQueues
--------------------------------------
23-mar-2004 - Graphics.constants/DrawSmall.java
A class representing a dynamic surface.
Title: DynamicDataAnalyzer Interface
Dynamic data analyzer of the JSIM engine.
Provides the Dynamic Format functionality of the jwat.
Earliest Due Date queue insertion strategy: the job with the earliest due date is placed ahead of the others.
Earliest Due Date queue insertion strategy with priorities.
Earliest Deadline First queue insertion strategy, preemptive variant of the earliest due date discipline.
Earliest Deadline First queue insertion strategy with priorities.
A class representing an edge.
Class for an edge in the animation.
Created by IntelliJ IDEA.
Title: EditDefaults Action
This is the Empirical distribution, which is constructed with
data provided by the user.
Class used for the empirical distribution, through which the user provides
the data needed to construct the empirical distribution: for each
empirical entry the requested data are a value and the probability of that value.
This is the parameter that should be passed to the empirical
distribution.
The node, into which job must be routed, is chosen using an empirical strategy.
Title:
Title: Enabling
Title: Enabling Packet
Title: Enabling Section Panel
Swing panel of the JMT wizard providing the enabling section panel for server view.
This class from the service demand and the saturation sectors
of the jaba engine create the list of Dominant, Dominate and Convex Hull
point.
String constants for node configuration used by engine classes (Server, PSServer, etc.).
Utility class used by the simulation engine
This class extends the ArrayList<Integer> object class by adding several useful
methods for operations encountered when dealing with the algorithms that
compute the normalising constants.
Swing component displaying the enlarge cdf.
Swing component displaying the enlarge pdf.
Custom file chooser class
Inner class used to create simple file filters with only extension check
Swing component displaying the enlarge qq plot.
Swing component displaying the enlarge qq plot.
Swing component displaying the enlarge qq plot var var.
Panel defining the observation epochs of the JWAT traffic analysis.
This class implements a specific PS strategy: Egalitarian Processor-
Sharing.
Egalitarian Processor Sharing strategy with priorities: all jobs share the station capacity equally.
An enhanced quick sort demonstration algorithm.
Title: Erlang distribution
Name: Erlang
This is the Erlang distribution.
This is the parameter that should be passed to the Erlang
distribution.
Sink for user-facing warnings and errors, so the engine need not depend on a GUI.
Global holder of the active
ErrorReporter; GUIs install their own at startup.Provides the ESA Util Sum Calculator functionality of the implementations.
Name: EvaluationException
A common interface for expression evaluators
Event signalling that a JWAT clustering has finished.
Event signalling that a JWAT operation has been aborted.
Event signalling that a JWAT load operation has finished.
Packet exchanged when a packet switching event finishes in the JSIM engine.
Name: EventQueue
Event signalling that a JWAT session has been loaded.
Status event of a time consuming JWAT operation.
a slightly more user-friendly JTextField-based DefaultCellEditor.
A CellRenderer displaying numbers and string with correct alignment and format
This class contains some constants for exact models.
Constants of the XML document format produced by the JMVA model solvers.
Creates the XML document representing a JMVA model for the exact solution algorithms.
Creates the station sections of the XML document of a JMVA model.
Model data structure of the exact JMVA algorithms: classes, stations, service demands and reference stations of a product form queueing network.
a table with some improvements:
has a click-aware header
has a click-aware row header
"more rows" and "more columns" warning icons
clipboard transfer of cell values (support depends on the underlying data model) - CTRL+C, CTRL+X, CTRL+V
can clear selected cells - DELETE
An utility abstract class implementing a framework for RowHeader-aware TableModels with identical column prototypes.
Implements Exhaustive Polling Get Strategy
Polling server that serves each queue until it is empty (exhaustive service).
Title: Exponential Distribution
This is the Exponential distribution (see the constructor description
for its pdf definition).
Exponential distribution fitting algorithm of JWAT.
This is the parameter that should be passed to the Exponential
distribution.
Name: ExpressionNode
Thrown if errors are found while parsing an expression
Created by IntelliJ IDEA.
Created by IntelliJ IDEA.
This strategy sends jobs to the resource with the fastest service.
Name: FastEvaluator
Title: FastGraph
A quick sort algorithm.
This class implements a specific preemptive strategy: all arriving jobs
are put to the queue in a First-Come-First-Served manner.
This class implements a specific preemptive strategy: all arriving jobs
are ordered according to their priorities.
This class implements a FCFS strategy (First Come First Served).
This class calculates the CDF and ICDF of the F(Fisher) distribution
Computes FFT's of complex, double precision data where n is an integer power of 2.
FIFO (First In First Out) cache eviction strategy: removes the item that first joined the cached item list.
ArrayList that implements the CustomCollection interface, to act as a FIFO Queue
JWAT filter on the date of the workload observations.
JWAT filter on numeric variables of the workload observations.
JWAT filter on string variables of the workload observations.
Filter on a variable of the JWAT workload data.
Created by IntelliJ IDEA.
Title: Firing
Title: Firing Packet
Title: Firing Section Panel
Distribution fitting algorithm of JWAT, applied to the workload data to parameterize the models.
Panel of the JWAT distribution fitting view.
Session of the JWAT distribution fitting view.
Degenerate discrete distribution that always returns the same value with probability one.
Created by IntelliJ IDEA.
Title: Fork
Generates new jobs in open systems, it generates jobs of 1 JobClass only
Editor for the fork parameters.
Title: Fork Job
Title: Fork Job Info
Title: ForkSection Panel
Base class of the JSIM fork strategies, which split a job into the tasks routed to the output stations of a fork.
Base class of the JSIM fork strategies, which split a job into the tasks routed to the output stations of a fork.
Reader of the JWAT input format description files (Perl5 format definitions).
Writer of the JWAT input format description files.
Formats the numbers shown in the JMCH graphical interface.
Interface for a function over a multidimensional domain to be integrated
Name: FunctionNode
Swing component displaying the fuzzy cluster details.
Swing component displaying the fuzzy info cluster.
Swing component displaying the fuzzy info clustering.
Fuzzy k-means clustering algorithm of JWAT: each observation belongs to the clusters with given membership degrees.
Engine running the JWAT fuzzy k-means clustering.
Swing component displaying the fuzzy k single cluster scatter.
Swing panel of the JMT wizard providing the fuzzy opt view.
Title: Gamma Distribution
Gamma and Beta functions.
This is the Gamma distribution (see the constructor description
for its pdf definition).
This is the parameter that should be passed to the Gamma
distribution.
This class is a conversion of the Fortran function to evaluate the Log of
the Gamma Function
Implements Gated Polling Get Strategy
Polling server that serves only the jobs present when the server arrives at the queue (gated service).
Solver for all the different animations (no PS)
Title: Global Job Info List
Global settings of JMT, read from the globalsettings configuration file.
This class implements a specific PS strategy: Generalised Processor-
Sharing.
Generalized Processor Sharing strategy with priorities: capacity is shared according to class weights.
Graham scan convex hull algorithm used by JABA to build the characteristic polytope of a two class model.
Title: Graph Panel
Minimal interface for GUI controllers that can change a graph cursor.
Title: GraphicalQueueState
Interface to wrap up all the methods for a graphic component
Title: Graph Panel
Title: Graph Panel
Interface for models that can refresh their graph representation
when station data changes.
Title: Graph StartScreen
Title: Gray Cell Renderer
Join strategy guarded by a condition on the tasks that have arrived at the join station.
Title: Gui Interface
Title: Gui XML Constants
Title: Gui XML Reader
Title: Gui XML Writer
This class implements a specific queue put strategy: all arriving jobs
are put at the head of the queue.
This class implements a specific queue put strategy: all arriving jobs
are ordered according to their priorities.
Sorting algorithm for vectors of data.
h-LRU cache eviction strategy, the hybrid variant of LRU used for cached items.
a very basic help system - you register (Component,String) couples and when the mouse enters the component the String is displayed in a JLabel.
Name: HtmlPanel
This class is an abstraction of an edge ( place where surfaces end )
This class is an abstraction of a vertex.
Name: HybridEventQueue
This is the Hyperexponential distribution (see the constructor
description for details).
Title: Hyperexponential Distribution
This is the parameter that should be passed to the Hyperexponential
distribution.
Created by IntelliJ IDEA.
This IllegalValueInInputFileException object is thrown when illegal values are
encountered while parsing an input file (e.g.
Title: Imaged ComboBox Table CellViewer/CellEditor Factory
Name: ImageLoader
Name: ImageLoaderImpl
Title: ImagePanel
Base class of the JSIM impatience strategies, which model customers leaving a queue before being served.
Factory creating the impatience editor objects.
Collects and stores impatience statistics (balking and reneging) gathered during a JSIM simulation run.
Parameters shared by the JSIM impatience (balking and reneging) strategies.
Types of impatience available in the JSIM simulation engine: none, balking and reneging.
This InconsistentLinearSystemException object is thrown when undeterminable
values that have been returned from a previous run of the linear system
solver need to be used for determining a subsequent run.
MMQueues
--------------------------------------
29-mar-2004 - Queues.Exceptions/InfiniteBufferException.java
MMQueues
--------------------------------------
31-mar-2004 - Queues.Exceptions/InfiniteException.java
Title: ForkSection Panel
Exception thrown when the model definition is not correct.
This class represents an exception that can be thrown if an error is
encountered while parsing the input file.
Loads the input data of a JWAT analysis.
Description: This class represents workload analysis tool input panel
Description: This class represents workload analysis tool input panel
Description: This class represents workload analysis tool input panel
Port to connect vertex through connections.
This abstract class implements a generic input section of a NetNode.
Created by IntelliJ IDEA.
Defines the behaviour of the mouse listener when the UI is in the insert mode
Interface to an integrator.
This class represents an exception that can be thrown if an internal error is
encountered somewhere in the program.
Priority MVA utilization calculator based on interpolation.
Interpolator used by the priority MVA calculators of JMVA.
Description:
It may be convenient to use an inverse measure to save computational time:
In fact, in some cases, it is easier to analyze a measure by passing samples which are
equals to 1/measure, instead of doing one division for each sample
(this would make simulation much slower).
Title: Iteration Selector Panel
Wrapper class for single-class queueing models
Uses multi-class algorithm to solve the single-class models
The solver interface for tree convolution solvers.
The solver interface for tree MVA solvers.
This class contains some constants for jaba models.
Interface for the JABA wizard controller, accessible from jmt-jaba-gui panels
without a compile-time dependency on jaba.JabaController (which lives in jmt-jsimg-gui).
An object grouping all the data describing a system.
Created by IntelliJ IDEA.
This is the object you use to define your system structure and parameters
Marker interface for JABA wizard panels that accept a JabaModel.
Colors of the JWAT charts.
Colors of the JWAT charts.
SuperClass of the MainWizard.
Abstract class to group all the new methods used in the panels of the wizard
Title: Jmodel Blocking Region Definition Interface
Title: Jmodel Class Definition Interface
Title: JModel User Classes Panel
Title:
Title: Jmodel Station Definition Interface
Entry point of the JMT application.
Title: JmtArc connection structure
Name: JMTButtonGroup
vertex cell for jmt
Title: Jmt Clipboard
Title: JmtDefaultCellViewFactory
Name: JMTDialog
Title: JmtEdge connection structure
Title: JmtEdgeBreakagesIterator
Title: JmtEdgeRenderer
Title: JmtEdgeView
Name: JMTFrame
An object that defines the view of a graphmodel.
Name: JMTImageLoader
Jmt version of JGraph.
Name: JMTMenuBar
Title: JmtOverlapping
Title: JMTPath
Name: JMTPoint
Name: JMTToolbar
Reads the
jmtVersion a file was saved with and compares versions, so the GUI can warn
before opening a file written by a newer JMT.Interface for the JMVA wizard controller, accessible from JMVA panels
without a compile-time dependency on JMVAController (which lives in jmt-jsimg-gui).
Factory for launching the JMVA wizard given an already-populated analytical.ExactModel.
Converts a JMVA model into the corresponding JSIM model.
This is the object you use to define your system structure and parameters
Job of the JMCH simulation: carries the arrival time, service time and due date of a job in the animated model.
Class for a job in the animation
This class implements a generic job of a queue network.
Created by IntelliJ IDEA.
This class implements the description of a job class.
This class implements a list of job classes.
Created by IntelliJ IDEA.
Interface for representing all the Components of an Animation.
This class is a generic job information storage class.
Name: JobInfoList
Swing panel of the JMT wizard providing the job parallelism editor view.
Created by IntelliJ IDEA.
Represent the queue (the queue of the system) and this queue contains
the jobs waiting for processing
MMQueues
--------------------------------------
3-apr-2004 - Graphics/JobsDrawer.java
This class implements a sink: every incoming job is destroyed.
Title: Join
Generates new jobs in open systems, it generates jobs of 1 JobClass only
Editor for the join parameters.
Swing panel of the JMT wizard providing the join section view.
Base class of the JSIM join strategies, which synchronize the tasks of a forked job at a join station.
Base class of the JSIM join strategies, which synchronize the tasks of a forked job at a join station.
Title: JMODEL Constants interface
JSIMGraphMain contains the main window of the jmodel project, it implements the
Singleton pattern.
Title: JMODEL-Model
Name: JSimLogger
Name: JSimLoggerFactory
Created by IntelliJ IDEA.
Title:
Converts a JSIM model into the corresponding JMVA model.
Interface for the JSIM Wizard controller, usable from jsimwiz panels
without depending on JSIMWizMain (which lives in jmt-jsimg-gui).
Created by IntelliJ IDEA.
Table showing the j wat bivariate stats.
Data model of the j wat bivariate stats table.
Constants of the JWAT tool (input formats, option names and defaults).
Model interface of the JWAT tool views.
Session of the JWAT tool: holds the model data of the workload analysis.
Table showing the j wat univariate stats.
Data model of the j wat univariate stats table.
Table showing the j wat variable input.
Data model of the j wat variable input table.
Base wizard of the JWAT tool.
Manager of the JWAT workload sessions and formats.
Name: KeyFocusAdapter
Swing component displaying the k fuzzy scatter.
K-means clustering algorithm of JWAT: partitions the observations into k clusters around their centroids.
Engine running the JWAT k-means clustering.
Swing component displaying the k mean scatter.
Pannello per la visualizzazione dello scatter plot risultato KMean
Swing component displaying the k means info cluster.
Swing component displaying the k mean single cluster scatter.
Swing panel of the JMT wizard providing the k means opt view.
Places the labels of the JABA graphs.
Name: LabelValue
This class implements a specific preemptive strategy: all arriving jobs
are put to the queue in a Last-Come-First-Served manner.
This class implements a specific preemptive strategy: all arriving jobs
are ordered according to their priorities.
This class implements a LCFS strategy (Last Come First Served).
the editor window itself.
An editor for LD service times.
the "help" dialog for the LD editor
Title: Load Dependent Service Time Strategy Parameter
Title: Load Dependent Station Service Strategy
Title: Load Dependent Service Time Strategy Editor
Created by IntelliJ IDEA.
This strategy sends jobs to the resource with the least utilization.
Rewrites a JMT XML file (any tool that stores
classPath attributes: .jsimg,
.jsimw, simulation input) between XmlFormats.This class implements a specific queue put strategy: all arriving jobs
are put to the queue in a Longest-Expected-Processing-Time manner.
This class implements a specific queue put strategy: all arriving jobs
are ordered according to their priorities.
LFU (Least Frequently Used) cache eviction strategy: removes the item with the smallest number of accesses.
LIFO (Last In First Out) cache eviction strategy: removes the item that last joined the cached item list.
ArrayDeque that implements the CustomCollection interface, to act as a LIFO Queue
Implements Limited Polling Get Strategy
Polling server that serves at most one job per visit (limited service).
Linear interpolator of the priority MVA utilization calculators.
This class implements the Linearizer [CN82] and De Souza-Muntz Linearizer
[dSeSM90] approximate MVA algorithms for solving multiclass closed models, as
described in the AMVA section of the JMVA chapter of the JMT user manual.
This abstract class provides the interface for the Linear System which is used by the CoMoM algorithm.
Title: Linkage
This class implements a linked job info list.
This class implements an event queue used internally by the Sim_system to
manage
the list of future and deferred Sim_events.
A class to keep track of row deletions/insertions in lists
This class implements a specific queue put strategy: all arriving jobs
are put to the queue in a Longest-Job-First manner.
This class implements a specific queue put strategy: all arriving jobs
are ordered according to their priorities.
Panel loading the demo data of the JWAT distribution fitting view.
Panel loading the JWAT demo files.
Created by IntelliJ IDEA.
Created by IntelliJ IDEA.
Created by IntelliJ IDEA.
Created by IntelliJ IDEA.
Title: Load Dependent Service Time Strategy
Loads data files of the JWAT tool.
Title: Model Loader
Custom file chooser class
Inner class used to create simple file filters with only extension check
Created by IntelliJ IDEA.
This class creates a file with a getLog of strings.
Log file of the JMCH simulation runs.
Title: Logger Cell
Parameters of a JMT logger: the path, name and options of the output file written during a simulation.
Title: LogTunnel Extension Panel
Manages the state of the JMT logger files during a simulation run.
Default
ErrorReporter: writes to the SLF4J log, safe in headless JVMs.Implements the core Logistic Sampling algorithm by calling the required
stationary point calculations, Hessian calculations, and the correct
integration scheme for solution of the model, to calculate the NC.
Additive logistic transformed version of the Logistic Core.
Multiplicative logistic transformed version of the Logistic Core.
Extends the SafeFunction abstract class.
Extension of the SafFunction base class.
Implementation of logistic function for single + delay servers under the additive transform
Implementation of the Multiserver Logistic Function, as given in Ong 2018:
Java Algorithms for Computer Performance Analysis.
Implementation of the Multiserver Logistic Function, as given in Ong 2018:
Java Algorithms for Computer Performance Analysis.
Implements the Logistic Function for single-server only networks, under the multiplicative transform
Implements the Logistic Function for delay + single server networks under the multiplicative transform
Title: Normal Distribution
This is the Lognormal distribution (see the constructor
description for its pdf definition).
This is the parameter that should be passed to the Normal
distribution.
Title: LogTunnel Extension
Visualizes the JWAT log files.
LRU (Least Recently Used) cache eviction strategy: removes the item with the smallest timestamp of last access.
LUP Decomposition algorithm based on pseudocode found in Cormen.
This class is a superclass for the Macro Blocks of the five main components of the BTF linear system: X, Y, B1, B2 and C.
A class to encapsulate the various policies for selecting Macro Blocks when constructing
the linear systems for lower classes.
Name: MacroReplacer
This is the main class of the program.
Background worker running the JWAT fuzzy k-means clustering.
Main window of the JWAT tool.
Background worker running the JWAT k-means clustering.
Main Panel of the MainWizard.
Main Wizard that contains all the panels for JTeach Models and Markov chains
Title: Manager
Title: MAP Distribution
This is the MAP distribution.
This is the parameter that should be passed to the MAP
distribution.
Mapping of the JWAT input formats (comparable by position).
Created by IntelliJ IDEA.
An abstract class that provides functionality required of the matrices of the simple linear system.
Column-major 4x4 matrix, used for 3D computations (homogeneous coordinates).
This class extends to MicroBlock class to provided extra functionality common to
the XMicroBlocks and YMicroBlocks that are both based on matrix data structrues.
This class stores all information about observations, variables and bivariate statistics
Monte Carlo Integrator object.
MD5 checksum computation used by the JMT file handling.
This class implements a measure object.
Title: Measure Definition Interface
Interface used to specify a listener on detected malformed replayer file.
Interface used to specify a listener on a measure.
Interface used to specify a listener on progress.
A measure output object is used to print a measure value(s).
Created by IntelliJ IDEA.
Name: MeasureValue
This class maintains a reference to all the main components of the Gui,
in this way it is possible to divide the responsibility of the actions &
every object know only about of himself & the mediator.
Utilities tracking the memory usage of the JMVA solvers.
Name: MenuAction
A merge sort demonstration algorithm.
This is a Java version of the Mersenne Twister.
Swing panel of the JMT wizard providing the metric configurations view.
This class is an abstract class that is extended by the Micro Blocks of the linear system.
A class to encapsulate the various policies for selecting Macro Blocks when considering lower classes
This class implements several basic math functions, low-level fast memory
copies, matrix type changes, memory usage calculations and printing operations.
MMQueues
--------------------------------------
25-mar-2004 - Queues/MM1dLogic.java
Contains the algorithm of the queue M/M/1 where lambda represent the arrival of the job
in second and s as service time of the job in the processor.
Title: MMPP2 Distribution
This is the MMPP2 distribution.
This is the parameter that should be passed to the MMPP2
distribution.
Dialog for the MMQueues
Panel of the main Wizard for the Markov chains.
Title: ModelChecker
Title: Model Converter
Name: ModelApproximator
Model of the JWAT distribution fitting view.
A tagging interface for TableModels.
Title: Model Loader
Custom file chooser class
Inner class used to create simple file filters with only extension check
Title: Model Snapshot
Checks whether the JMVA model is compatible with the selected solution algorithm.
Model of the JWAT traffic analysis view.
Model of the JWAT workload analysis view.
Clustering modified by the JWAT user after its execution.
Class which defines a ModularSolver object, which solves the
linear system using residual systems solved by Gaussian elimination.
The ModularSolverParallelTask performs the solution of a residual linear system
and part of the result recombination process.
The ModuloSelectionTask performs the selection of a prime modulo of a given
size.
Moment of a distribution used by the method of moments (MoM) exact algorithm of JMVA.
This class implements the MoMSolver object, which computes the normalising
constant for a network using the MoM algorithm.
This class implements the API to allow use by other applications.
Monte Carlo logistic regression solver of JMVA, used for large models where the exact algorithms become too expensive.
Monte Carlo solution algorithm of JMVA, used by the exact solvers to reduce the complexity of large models.
MRU (Most Recently Used) cache eviction strategy: discards the most recently used items first.
A custom BorderLayout manager that supports multiple items on the same position
User: Marco Bertoli
Date: 1-giu-2005
Time: 11.32.36
Class with all the JComponents for the Animation of a Routing Policy
This class implements the MultiplicitiesVector object, which is used to
store a multiplicities vector.
Tree Convolution solver that uses multiple threads.
Tree MVA solver that uses multiple threads.
Multivariate Gaussian distribution.
Interface for use in the MonteCarloLogistic Solver.
Multivariate student t.
Multivariate uniform distribution with specifiable lower and upper bounds per
dimension
Population vector used by the MVA algorithms of JMVA.
Utilities for the population vectors used by the MVA algorithms of JMVA.
Class for storing MVA performance measure results.
This class declares all the constants related to message event types.
This class implements a generic QueueNet exception.
This class implements a message which could be received for example by a
NetNode or by a NodeSection.
This class implements a generic QueueNetwork node.
This class controls the simulation running.
This class implements a network list.
Title: New Dynamic Data Analyzer Class
Created by IntelliJ IDEA.
Created by IntelliJ IDEA.
Title: What-If analysis Plot
Custom file chooser class
Inner class used to create simple file filters with only extension check
Interface used for rescaling callbacks
Point used by the JABA Graham scan convex hull algorithm.
Provides the NLI_LI Prio MVA Util Calculator functionality of the utilisations.
Provides the NLI_Y Prio MVA Util Calculator functionality of the utilisations.
Provides the NLI_Z Prio MVA Util Calculator functionality of the utilisations.
Class representing a tree node.
This class implements a list of nodes.
List of nodes together with the number of jobs of a given class present at each node.
This class implements a generic section of a NetNode.
MMQueues
--------------------------------------
20-mar-2004 - Queues.Exceptions/NoJobsException.java
MMQueues
--------------------------------------
22-mar-2004 - Queues.Exceptions/NonErgodicException.java
Non-linear interpolator of the priority MVA utilization calculators.
NonPreemptive Simulation class
It has a list with all its subclasses
Title: Normal Distribution
The normal (Gaussian) distribution, implemented with the polar method of Marsaglia.
This is the Normal distribution (see the constructor
description for its pdf definition).
Join strategy that releases the job when all its tasks have arrived at the join station.
Join strategy that releases the job when all its tasks have arrived at the join station.
This is the parameter that should be passed to the Normal
distribution.
MMQueues
--------------------------------------
16-mar-2004 - Graphics/Notifier.java
this is used for notifying graphical
panels.
Vacation strategy modelling a server that never takes vacations.
Title: NumberOfCustomerParametricAnalysis
Title: NumberOfCustomersPanel
Title: NumberOfServersPanel
Title: NumberOfServersParametricAnalysis
This class represents a single observation retrieved from a log file.
Created by IntelliJ IDEA.
Listener notified when the JWAT model is reset.
Listener notified when the JWAT parameters are set.
Name: OperatorNode
Created by IntelliJ IDEA.
Output path of a fork station: a task of a forked job together with its destination.
Output path of a fork station: a task of a forked job together with its destination.
This abstract class implements a generic output section of a NetNode.
Title: PADispatcherThread
This class draws all the part of the graph
Title: PAPlot
Title: Parametric Analysis Progress Window
This class extends the Solver one and adds to it all useful fields and
methods a parallel solver should support, such as thread management code,
shutdown routines, etc.
Parameter of the JWAT input formats.
interface for all distributions parameters.
Title: ParameterOptionPanel
Title:
Title: ValuesTable
Title: ParametricAnalysisChecker
Title: ParametricAnalysisDefinition
Title: ParametricAnalysisModelFactory
Title: ParametricAnalysisPanel
Title: ParametricAnalysisRunner
Notified as the run progresses.
Created by IntelliJ IDEA.
Title: PAResultsWindow
Specifies some basic functions performed by those components that contain
a Plot object
Custom file chooser class
Inner class used to create simple file filters with only extension check
Title: Pareto Distribution
This is the Pareto distribution (see the constructor description
for its pdf definition).
Pareto distribution fitting algorithm of JWAT, based on the Gulati-Shapiro test of hypothesis.
This is the parameter that should be passed to the Pareto
distribution.
Name: ParseError
Name: Parser
Join strategy that releases the job when a subset of its tasks has arrived at the join station.
Join strategy that releases the job when a subset of its tasks has arrived at the join station.
Title: PDF Viewer
Engine of the JABA asymptotic bound analysis: computes the saturation sectors and the convex hull of the model.
This graph shows the behaviour of the utilization of the resources.
A class to calculate a metric based off of the station type
Calculates the value for all classes at the same time
A class to calculate a metric based off of the station type
Calculates the value for one class at a time
Title: Phase-Type Distribution
This is the Phase-Type distribution.
This is the parameter that should be passed to the Phase-Type
distribution.
This abstract class implements a generic pipe section of a NetNode.
Place Cell, represents the place of SPN models.
PLRU (Pseudo Least Recently Used) cache eviction strategy: approximates LRU behaviour at a lower implementation cost.
Title: PNML Constants
Title: PNML Reader
Title: PNML Writer
Point in the three dimensional space used by the JABA convex hull algorithms.
Poisson distribution, typically used to model arrival processes in the JMT simulation engine.
Title: Poisson Distribution
Poisson distribution, typically used to model arrival processes in the JMT simulation engine.
This is the Poisson distribution.
Parameters of the Poisson distribution.
This is the parameter that should be passed to the Poisson
distribution.
Polling Get Strategies
This class implements a polling server.
Menu for editing polling server properties
This class performs polynomial fitting on given data: there are two
alghorithms.
A class representing a polygon
Polynomial functions.
This class implements the PopulationChangeVector object, which are used in
in the definition of the CoMoM basis.
Title: PopulationMixPanel
Title: PopulationMixParametricAnalysis
This class implements the PopulationVector object, which is used to
store a populations vector.
This simple class descirbe a position in the matrix (row, column)
Positional mapping of a JWAT input format.
Power of K Routing Strategy
This strategy picks, at random, k resources and sends jobs to the resource with the shortest queue.
Server supporting preemptive service disciplines of the JSIM engine.
Preemptive simulation of the JMCH scheduling algorithms (Processor Sharing).
To be implemented by preemptive strategies
print some finite precision numbers
Wrapper class for printing to console.
Prints the information of a JWAT k-means clustering.
Queue length calculator of the priority MVA algorithm for closed models.
Residence time calculator of the priority MVA algorithm for closed models.
Class to calculate the open queue lengths during PrioMVA
A class to initialise the different variations of PrioMVA
Throughput calculator of the priority MVA algorithms.
ArrayList that implements the CustomCollection interface, to act as a Priority Queue.
Helper computing residence times in the priority MVA calculators of JMVA.
Alot of this class isn't currently used, however, the functions implemented may be of use at some point
Fork strategy that selects the output tasks of a fork according to given probabilities.
Fork strategy that selects the output tasks of a fork according to given probabilities.
Custom tailored numerical integration of certain probability distributions.
Created by IntelliJ IDEA.
Checks whether the JMVA model has sufficient processing capacity for the given workload, as described in the user manual.
It represent the "Processor" (Server).
Menu for editing processor sharing server properties
ProcessorSharing Simulation class
Progress monitor of the JWAT time consuming operations.
Progress display interface of the JWAT time consuming operations.
Listener notified of the progress of a time consuming JWAT operation.
Listener notified of the progress of a time consuming JWAT operation.
Title: Progress Window
Routing strategy that selects the destination station based on a property of the stations.
This interface identifies TableModels that can supply maximum-length prototypes of
column data.
This class is a generic job information storage class used by processor-
sharing.
This class implements a linked job info list used by processor-sharing.
Name: PSServer
Name: PSServer
Solver for PS animations
Use this class to implement a specific PS strategy.
Queue based Processor Sharing strategy of the JSIM engine.
Queue based Processor Sharing strategy with priorities of the JSIM engine.
Created by IntelliJ IDEA.
This class contains an implementation of the input file reader and parser,
as well as a storage data structure for the model and performance evaluation
values.
The possible queue types.
Class which defines several methods every QNSolver object must support.
Interface which every solver must implement, as it defines a common way of
performing the same operations, such as initialisation, evaluation and
returning the results.
Swing panel of the JMT wizard providing the qq plot preview view.
Analyzes the data in order to calculate the requested quantiles.
Name: Queue
Draws a queue of the JMCH animation.
Use this class to implement a specific queue get strategy.
Acknowledgement body exchanged when a queue becomes idle in a vacation model.
Queue length calculator of the priority MVA algorithms of JMVA.
This interface represent the logic of the queue types: the arrival
and the execution of the process/job.
Created by IntelliJ IDEA.
This class implements a queue network.
Use this class to implement a specific queue put strategy.
Name: QuickHTMLViewer
Random cache eviction strategy: removes a uniformly chosen item from the cached item list.
Interface for all random numbers generators.
Random sample extraction filter of JWAT.
Class which can generate models for use when testing/evaluating the algorithms.
Created by IntelliJ IDEA.
Created by IntelliJ IDEA.
This class implements a job source (generator): a job is created every
t simulation time units using a statistical distribution according
to its class.
This class implements a random strategy: the output node
is chosen with a random number
This class implements a specific queue put strategy: all arriving jobs
are put at random positions of the queue.
This class implements a specific queue put strategy: all arriving jobs
are ordered according to their priorities.
This class implements the RECALSolver object, which computes the normalising
constant for a network using the RECAL algorithm.
This class implements the RECALSolver object, which computes the normalising
constant for a network using the RECAL algorithm.
This class implements the RecursiveSolver object, which contains common
methods for the Convolution and RECAL algorithms.
Reduced service time calculator used by the priority MVA algorithms.
Reflected non-linear interpolator of the priority MVA utilization calculators.
Created by IntelliJ IDEA.
Name: RemoveToken
Reneging impatience strategy: jobs abandon the queue after waiting for a given time.
Parameters of the reneging distribution.
Title: Replayer virtual distribution
Replays cyclically data, previously generated, reading them from a file.
Manages the file containing numbers (previously generated).
Request describing a job that must be placed into a queue.
Loads the results of a JWAT analysis.
Title: Results Constants
Title: Result's Model data structure
Panel for showing the results of the simulations.
Panel for showing the results of the Routing simulations
Panel for showing the results of the Scheduling simulations
A "reduced" ExactTable for showing unmodifiable results
Custom class for saving the results of previous simulations
Title: Results Window
Recursive Gaussian Filter (RGF) solution algorithm of JMVA.
Provides the RNLI_LI Prio MVA Util Calculator functionality of the utilisations.
Provides the RNLI_NC Prio MVA Util Calculator functionality of the utilisations.
Provides the RNLI_Y Prio MVA Util Calculator functionality of the utilisations.
Provides the RNLI_Z Prio MVA Util Calculator functionality of the utilisations.
Provides the Root Node functionality of the common.
Created by IntelliJ IDEA.
This class implements a round robin strategy: all the output nodes
are chosen in sequence, one at each time; when all the nodes have been chosen,
the sequence restarts.
Class for a router in the animation
This class implements a router, which routes the jobs according to the specified
routing strategies (one for each job class).
Title: Router Cell
Created by IntelliJ IDEA.
Created by IntelliJ IDEA.
Title: RoutingProbabilitiesPanel
Title: RoutingProbabilitiesParametricAnalysis
Created by IntelliJ IDEA.
Routing Simulation class
Created by IntelliJ IDEA.
Use this class to implement a specific routing strategy.
Interface defining the contract of the Row Delete Listener of the listeners.
A single-column JTable impersonating a table's row headers and listening to clicks for column selection
a default data model displaying row numbers
Cell renderer for the row header values.
Created by IntelliJ IDEA.
Abstract class that implements the Function interface.
Created by IntelliJ IDEA.
Collect statistics related to given simulation samples
Provides the SCA Service Time Calculator functionality of the implementations.
Swing component displaying the scatter.
Provides the SCA Util Sum Calculator functionality of the implementations.
This class transforms 3D coordinates into 2D screen coordinates.
Swing panel of the JMT wizard providing the scroll bivariate view.
This class is an abstract super class the implements the common featrues of the SecondaryMacroBlocks
that are found in the X and Y blocks of the A matrix.
Created by IntelliJ IDEA.
Created by IntelliJ IDEA.
Created by IntelliJ IDEA.
Title: Sectors 2D Panel
Title: Sectors 2D Panel
This class places orderly (hopefully) the labels on the saturation
sector graph
Title: Sectors 3D Panel
Title: Sectors 3D Panel
Panel of the JABA tool showing the saturation sectors of the model.
Title: Sectors Textual Panel
Title: SeedPanel
Title: SeedParametricAnalysis
Created by IntelliJ IDEA.
Name: SelectedActionChangeListener
Handles all the events when the user is in the select mode
Title: Semaphore
This class implements a specific queue put strategy: all arriving jobs
are put to the queue in a Shortest-Expected-Processing-Time manner.
This class implements a specific queue put strategy: all arriving jobs
are ordered according to their priorities.
This class implements a multi-class, single/multi server service.
Queue Cell, represents the default service center of the model.
Swing panel of the JMT wizard providing the server compatibility editor view.
Tabbed panel for editing advanced server features
Provides the Server Type functionality of the definitions.
Swing panel of the JMT wizard providing the server types editor view.
Swing panel of the JMT wizard providing the server vacation editor view.
4th panel: service times
4th panel: service times
This abstract class implements a generic service section of a NetNode.
Created by IntelliJ IDEA.
Title: Service Strategy Interface
Use this class to implement a specific service strategy.
Title: ServiceTimesPanel
4th panel: service times
4th panel: service times
Title: ServiceTimesParametricAnalysis
This strategy calculates the time of service of a job, using the specified
distribution and parameters.
This class implements a "tunnel" service section.
Loads a JWAT session from an XML file.
Provides the Set Bezier Connect State functionality of the actions.
Collection of special functions.
Shifted geometric distribution: number of trials before the first success, shifted by one.
Shifted geometric distribution: number of trials before the first success, shifted by one.
Parameters of the shifted geometric distribution.
Created by IntelliJ IDEA.
This strategy sends jobs to the resource with the shortest queue length.
Created by IntelliJ IDEA.
This strategy sends jobs to the resource with the shortest response time.
Title: ShowResults Action
A predicate which will match any event on the deferred event queue.
Constants used by QueueNet package.
This class represents entities, or processes, running in the system.
This class represents events which are passed between the entities
in the simulation.
This class contains the methods to load the DOM description of a
queueing network model from a XML file and then to create a Simulation object
from that description.
Implements a NodeList that lets also add Nodes, feel free to
add methods if u need.
A predicate which will not match any event on the
deferred event queue.
This class contains parameters that are shared by all DynamicDataAnalyzer objects.
This class extends the LinearSystem class to implement the linear system for
the simple CoMoMimplementation.
Class which defines a SimpleSolver object, which solves the
system using Gaussian elimination with partial pivoting.
Predicates are used to select events from the deferred queue.
This is the system class which manages the simulation.
A predicate to select events with specific tags from the deferred
event queue.
Common Interface to all the simulations.
This class creates a new Simulation.
Central repository for simulation engine default values that were previously
scattered as magic numbers across multiple classes.
Created by IntelliJ IDEA.
Class that resambles the Factory pattern.
A SimulationOutput object is used to print the results of all the measures.
Title: Simulation & Preloading Panel
Interface for objects that can run a JSIM simulation.
Factory interface for creating SimulationRunner instances.
Title: SimulationStateChecker
Marker interface for threads that run a simulation.
Enum with all the simulation types
Simulator of JMCH: drives the single step and continuous simulation of the scheduling and routing algorithms.
File system view restricted to a single directory, used by the JWAT format selection.
Swing component displaying the single k mean cluster info.
Created by IntelliJ IDEA.
Class with all the JComponents for the Animation of a Scheduling Policy
Tree Convolution solver that uses a single thread.
Single-threaded TMVA solver implementation.
Class for a sink in the animation.
Represents a Sink service center, it used to destroy jobs in open systems
This class implements a specific queue put strategy: all arriving jobs
are put to the queue in a Shortest-Job-First manner.
This class implements a specific queue put strategy: all arriving jobs
are ordered according to their priorities.
Swing component displaying the small cdf.
Swing component displaying the small pdf.
Swing component displaying the small plot dist graph.
Swing component displaying the small qq plot.
Swing component displaying the small qq plot.
generic solution panel
This class transforms the information of the Animation to match the structure of the CommonModel class.
Class which defines several methods every Solver object must
support.
Solver is an abstract class, which contains the methods to initialize and
solve models with a single class of jobs.
Solver is an abstract class, which contains the methods to
initialize and solve models with a single class of jobs.
Enum class for all implemented algorithm solvers
Counts the solutions performed by the JMVA solution algorithms.
Client side of the solver interface.
Server side of the solver interface.
This object takes a model, instantiates the correct solver, and solves it.
Should probably be rewritten using a different data structure to hold model information Debugged by Bertoli Marco: now uses visits correctly (31-jan-2006)
This object takes a model, instantiates the correct solver, and solves it.
Should probably be rewritten using a different data structure to hold model information Debugged by Bertoli Marco: now uses visits correctly (31-jan-2006)
Server side of the solver interface.
This object takes a model, instantiates the correct solver, and solves it.
Should probably be rewritten using a different data structure to hold model information
This object takes a model, instantiates the correct solver, and solves it.
Should probably be rewritten using a different data structure to hold model information
Listener used to notify when computation of a model is terminated.
Interface for classes which define several methods every LinearSystemSolver
object must support.
SolverMulti is an abstract class, which contains the methods initialize and
solve multiclass models.
SolverMulti is an abstract class, which contains the methods
initialize and solve multiclass models.
Selects the JMVA solution algorithm to be run for the model under study.
This class implements the abstract superclass of approximate MVA algorithms for solving multi-closed models
This class implements the AQL (Aggregated Queue Length) algorithm for solving multi-closed models
This class implements the Bard-Schweitzer algorithm for solving multi-closed models
This class implements the AQL (Aggregated Queue Length) algorithm for solving multi-closed models
Solves a multiclass closed model with the exact CoMoM (Class Oriented Method
of Moments) algorithm [Cas09], one of the exact solution techniques available
in JMVA for closed product form queueing networks.
This class implements the Linearizer and De Souza-Muntz Linearizer algorithms for solving multi-closed models
Solves a multiclass closed model with the exact MoM (Method of Moments)
algorithm [Cas06][Cas11], one of the exact solution techniques available in
JMVA for closed product form queueing networks.
Solves a multiclass closed model with the Monte Carlo algorithm, an exact
technique that estimates the normalizing constants of large models by
sampling, as described in the JMVA chapter of the JMT user manual.
Solves a multiclass closed model, using Monte Carlo Logistic algorithm.
Solves a multiclass closed model with the exact MVA (Mean Value Analysis)
algorithm [RL80].
Solves a multiclass closed model with the exact RECAL (Recursion by Chain
Algorithm) algorithm [CG86], one of the exact solution techniques available
in JMVA for closed product form queueing networks.
Solves a multiclass closed model with the RGF (Recursive Gaussian Filter)
algorithm, an exact solution technique available in JMVA for closed product
form queueing networks.
Solves a multiclass closed model with the exact TreeConvolution algorithm,
the tree based version of the convolution algorithm, which reduces the time
and space requirements of the exact solution for models with large
dimensions.
Solves a multiclass closed model with the exact TreeMVA algorithm [TS85], the
tree based version of the Mean Value Analysis, which reduces the time and
space requirements of the exact solution for models with large dimensions.
Dispatcher of the JMVA multiclass solvers: runs the selected exact or approximate algorithm and collects the results.
Iterative multiclass solution algorithm of JMVA, base of the approximate iterative solvers.
Solves a multiclass mixed model, with both open and closed customer classes,
combining the open model algorithms and the exact MVA algorithm as described
in the JMVA chapter of the JMT user manual.
Priority MVA solution algorithm of JMVA for mixed models with priority classes.
Reduced Work Rate Approximation
Solves a multiclass open model with the classical queueing network
algorithms, as described in the JMVA chapter of the JMT user manual
(load dependent stations are not allowed in open models).
Solves a single class closed model, using Monte Carlo Logistic algorithm.
Solves a single class closed model using the normalisation constant
algorithm, one of the exact solution techniques available in JMVA for closed
product form queueing networks.
Solves a single class closed model, using Normalisation Constant algorithm.
Solves a single class closed model, using Monte Carlo Logistic algorithm.
Solves a single class closed model with the exact MVA (Mean Value Analysis)
algorithm [RL80].
Solves a single class closed model, using Monte Carlo Logistic algorithm.
Solves a single class open model.
Interface which must be implemented by a sorting algorithm.
A comparator to sort an array of Enhanced Vectors, to be used by Basis objects.
A comparator to sort an array of Enhanced Vectors, to be used by Basis objects.
A comparator to sort an array of Enhanced Vectors, to be used by Basis objects.
A comparator to sort an array of Enhanced Vectors, to be used by Basis objects.
This class is responsible for creating the jobs and routing them to the first edge of the animation
Generates new jobs in open systems, it generates jobs of 1 JobClass only
This class implements the blocks that make up the SparseBlockMatrx objects.
This class implements the underlying data structure of the Secondary Macro Blocks.
This class perform spectral analysis and has also some useful functions for
DSP
Title: Spinner Table CellViewer/CellEditor
A 1.4 file that provides utility methods for
creating form- or grid-style layouts with SpringLayout.
This class implements a specific preemptive strategy: all arriving jobs
are put to the queue in a Shortest-Remaining-Processing-Time manner.
This class implements a specific preemptive strategy: all arriving jobs
are ordered according to their priorities.
This class provides a concrete implementation of the Matrix class that
is based in a two dimensional BigRational array.
Implementation of standard/sequential MVA algorithm.
Class representing bivariate statistics
Draws the statistics of the JMCH animation (queue length, utilization, response time).
Class for a station in the animation
Created by IntelliJ IDEA.
Created by IntelliJ IDEA.
Created by IntelliJ IDEA.
Created by IntelliJ IDEA.
Title: Station's Name Panel
Created by IntelliJ IDEA.
Created by IntelliJ IDEA.
2nd panel: stations number, names, types
2nd panel: stations number, names, types
Created by IntelliJ IDEA.
Title: StatisticalOutputsParameters
Title: StatisticalOutputsParameters
listener for ProgressBar in StatisticalOutputsEditor.
listener for ProgressBar in StatisticalOutputsEditor.
Title: StatisticalOutputsWindow Editor
Panel showing the descriptive statistics of the JWAT workload data.
Combo box of JWAT with a custom stepped user interface.
Stepped user interface of the JWAT combo box.
A marker interface for distributions to be stored in the DistributionContainer.
Title: Storage
Title: Storage Section Panel
Title: Result's Model data structure
String mapping of the JWAT input formats.
Title: Student's t-distribution
This is the StudentT distribution (see the constructor description
for its pdf definition).
This is the parameter that should be passed to the StudentT
distribution.
A class representing a surface.
Shows engine warnings and errors as Swing message dialogs.
This is the 3rd version of SwingWorker (also known as
SwingWorker 3), an abstract class that you subclass to
perform GUI-related work in a dedicated thread.
This is the 3rd version of SwingWorker (also known as
SwingWorker 3), an abstract class that you subclass to
perform GUI-related work in a dedicated thread.
Swing panel of the JMT wizard providing the switchover times editor view.
Created by IntelliJ IDEA.
an object that intercepts all selection events for a table
This class implements a specific queue put strategy: all arriving jobs
are put at the tail of the queue.
This class implements a specific queue put strategy: all arriving jobs
are ordered according to their priorities.
Title: Take Screen Shot Action
Table notifying the statistics of the JMCH animation.
This is an adaptation of the Total Bandwidth Server scheduling algorithm.
Class responsible for evaluating the complexity of the tree convolution algorithm if
it were to be run on a given tree representing a network.
File operations on the JSIMgraph model templates.
Provides the Template Node functionality of the common.
This class implements a terminal: each class has a finite number of customers in
the system.
Preloads new jobs in closed systems, it preloads jobs of 1 JobClass only
Title: Sectors Textual Panel
Custom file chooser class
Inner class used to create simple file filters with only extension check
Throughput calculator of the priority MVA algorithms of JMVA.
The Timer object can receive "start" and "pause" commands.
Title:
Title: Timing
Title: Timing Event Queue
Title: Timing Packet
Title: Timing Section Panel
Class responsible for evaluating the complexity of the tree MVA algorithm if
it were to be run on a given tree representing a network.
Core TMVA algorithm implementation, based on theory from Tucci's 1985 paper and Hoyme's 1986 paper.
This class is a superclass for the five main components of the BTF linear system: X, Y, B1, B2 and C.
Title: TotalStationCapacityPanel
Title: TotalStationCapacityParametricAnalysis
Provides the T Prio MVA Util Calculator functionality of the utilisations.
Session of the JWAT traffic analysis view.
Transition Cell, represents the transition of SPN models.
Title: Transition Matrix
Title: Transition Matrix
Title: Transition Vector
Title: Transition Vector
Created by IntelliJ IDEA.
Class that implements the Tree Convolution algorithm outlined in the paper
"A Tree Convolution Algorithm for the Solution of Queueing Networks" (Lam/Lien 1983).
Tree MVA implementation based on Hoyme and Tucci papers from 1985.
Class responsible for the tree planting phase of the Tree Convolution algorithm.
Enum for different tree planting approaches.
Class for printing trees to console.
Provides the Tree Table Node functionality of the common.
Tree traverser abstract class which implements generic single-threaded tree traversal, leaving the
actual node computations to the extending class.
Tree traverser abstract class which implements generic multi-threaded tree traversal, leaving the
actual node computations to the extending class.
A class defining a triangle
Trimming filter of JWAT: keeps only the observations between two given percentiles.
Trimming filter of JWAT: removes the outliers beyond a given percentile.
This Class computes Cumulative Distribution Function and ICDF for the
TStudent distribution
TTL (Time To Live) cache eviction strategy: removes items whose lifetime has expired.
The Tuple class provides objects which function just like a 2-tuple.
A policy that selects the type 1 Micro Blocks from the full block for use in lower class linear systesms
A policy to select the Type 1 Macro Blocks for lower class linear systems
A policy that selects the type 2(a) Micro Blocks from the full block for use in lower class linear systesms
A policy to select the Type 2(a) Macro Blocks for lower class linear systems
Default implementation of UIState interface all the methods are void to let
the user programmer implement only the necessary state methods
This class represents an exception that can be thrown if an undefined value is encountered when multiplying
This class relays messages to an actual
Please note that you should not add the
UndoManager; on success, it requests undo/redo
actions to update their status.Please note that you should not add the
UndoManager to the listener queue, but only the UndoManagerProxy.Title: Uniform Distribution
Discrete uniform distribution over an interval of integers.
This is the Uniform distribution.This object offers many
methods to obtain random value distributed like a uniform.
Parameters of the discrete uniform distribution.
This is the parameter that should be passed to the Uniform
distribution.
Description:
Exception thrown when the model is not supported by a solver.
Swing panel of the JMT wizard providing the update by instailer view.
Swing panel of the JMT wizard providing the update view.
Created by IntelliJ IDEA.
Used to get approximate values for a utilization in PrioMVA
Utilization sum calculator used by the priority MVA algorithms.
Point utilities of the JSIMgraph editor.
General utilities of the JMVA solvers.
A class containing the information about a server vacation job for performance indexing.
Provides the Vacation Parameters functionality of the definitions.
Base class of the JSIM vacation strategies, which model servers that suspend their service for a vacation period.
Vacation strategy in which the server starts a vacation when it becomes idle.
Date variable of a JWAT workload observation.
Mapping of a JWAT variable.
Name: VariableNode
Description: This class represents a single variable which contains numerical
values.
String variable of a JWAT workload observation.
Homogeneous 3D coordinates vector for 3D computations.
Vectors describing a request submitted to a server.
This class implements a csv output for measure class.
Reads a Verbose CSV measure output file, providing all the samples and weights.
A class defining a vertex.
3rd panel: visits
3rd panel: visits
This class implements a waiting request of a job to be processed by a
section: it contains information about the job and the node/the section which
sent the job.
Title: Warning ScrollPanel for Tables
Title: Warning Window
Title: Weibull distribution
This is the Weibull distribution.
This is the parameter that should be passed to the Weibull
distribution.
Weighted Round Robin Routing strategy of the JMT routing strategies.
Weighted round robin routing strategy: destinations are selected cyclically with given weights.
Weight entry of the weighted round robin routing strategy.
Dispatcher of the JMVA what-if analysis: solves the sequence of models obtained by varying the control parameters.
Title: What-If Analysis Panel
Title: What-If analysis Plot
Custom file chooser class
Inner class used to create simple file filters with only extension check
Interface used for rescaling callbacks
a generic Wizard framework
Some things all WizardPanels have in common.
Session of the JWAT workload analysis view.
Loads the results of the JWAT workload analysis.
This class places orderly (hopefully) the labels on the x-axis of a plane
This class implements the X Block of the A matrix.
This class implements the Macro Blocks of the X Block of the A matrix.
This class implements the Micro Blocks of the X block of the A matrix.
Title: XML Archiver
Created by IntelliJ IDEA.
XML dialects JMT has written.
Title: XML Reader
Title: XML Results Constants
Title: XML Results Reader
Title: XML Results Writer
Saves all the measure outputs in a xml file.
XML loading/saving of exact models
Title: XML Writer
This class provides a simple method to obtain XMLparameter representation
of a distribution object.
This class creates an xml parameter node given a
common.ForkStrategy object.
This class creates an xml parameter node given a
common.JoinStrategy object.
This class creates an xml parameter node given a
common.RoutingStrategy object.
This class creates an xml parameter node given a
common.SemaphoreStrategy object.
Loads the xsd schemas.
This class extends SecondaryMacroBlock to specify behavior specific to the Secondary Macro Blocks of the X Block.
This class places orderly (hopefully) the labels on the y-axis of a plane
This class implements the Y Block of the A matrix.
This class implements the Micro Blocks of the X block of the A matrix.
This class extends SecondaryMacroBlock to specify behavior specific to the Secondary Macro Blocks of the Y Block.
This service strategy always returns a service time equal to 0.0.
Name: ZeroStrategy
Zipf distribution, used to model popularity skews in the JMT simulation engine.
Zipf distribution, used to model popularity skews in the JMT simulation engine.
Parameters of the Zipf distribution.