Commit 7c59e709 authored by rosemaryng's avatar rosemaryng
Browse files

Removed unrelevant files in utils and changed path for 1067

parent cc653b86
No preview for this file type
Java Modelling Tools
====================
Introduction
------------
The Java Modelling Tools (JMT) is a free open source suite for performance evaluation,
capacity planning and modelling of computer and communication systems. The suite implements
numerous state-of-the-art algorithms for the exact, asymptotic and simulative analysis of
queueing network models, either with or without product-form solution. Models can be described
either through wizard dialogs or with a graphical user-friendly interface. The suite includes
also a workload analysis tool based on clustering techniques. The suite incorporates an XML
data layer that enables full reusability of the computational engines.
The JMT suite is composed of six tools that support different analyses frequently used in
capacity planning studies. The main features of each tool follows.
JSIMwiz: a discrete-event simulator for the analysis of queueing network models. An intuitive
sequence of wizard windows helps specifying network properties. The simulation engine supports
several probability distributions for characterizing service and inter-arrival times.
Load-dependent strategies using arbitrary functions of the current queue-length can be
specified. JSIM supports state-independent routing strategies, e.g., Markovian or round robin,
as well as state-dependent strategies, e.g., routing to the server with minimum utilization,
or with the shortest response time, or with minimum queue-length. The simulation engine
supports several extended features not allowed in product-form models, namely, finite capacity
regions (i.e., blocking), fork-join servers, and priority classes. The analysis of simulation
results employs on-line transient detection techniques based on spectral analysis.
What-if analyses, where a sequence of simulations is run for different values of parameters,
are also possible.
JSIMgraph: a graphical user-friendly interface for the simulator engine used by JSIMwiz. It
integrates the same functionalities of JSIMwiz with an intuitive graphical workspace. This
allows an easy description of network structure, as well as a simplified definition of
the execution features like blocking regions. Network topologies can be exported in vectorial
or raster image formats.
JMVA: meant for the exact analysis of single or multiclass product-form queueing
network models, either processing open, closed or mixed workloads. The classic MVA solution
algorithm is used. Network structure is specified by textual wizards, with conversion
functions from probabilities to average visit ratios (and viceversa). What-if analyses are
allowed.
JMCH: it applies a simulation technique to solve a single station model, with finite (M/M/1/k)
or infinite queue (M/M/1), and shows the underlying Markov Chain. It is also possible to
dynamically change the arrival rate and service time of the system.
JABA: a tool for the identification of bottlenecks in closed product-form networks using
efficient convex hull algorithms. The tool supports models with up to three job classes.
It is possible to identify potential bottlenecks corresponding to the different mixes of
customer classes. Models with thousands of queues can be analyzed efficiently. The saturation
sectors, i.e., the mixes of customer classes that saturate more than one resource
simultaneously, are identified.
JWAT: supports the workload characterization phase, with emphasis on Web log data.
Some standard formats for input file are provided (e.g., Apache HTTP log files), and
customized formats may also be specified. The imported data can initially be analyzed using
descriptive statistical techniques (e.g, means, correlations, pdf histograms, boxplots,
scatterplots), either for univariate or multivariate data. Algorithms for data scaling,
sample extraction, outlier filtering, k-means and fuzzy k-means clustering for identifying
similarities in the input data are provided. These techniques allow to determine cluster
centroids, and then estimate mean workload and service demands to be used for model
parametrization. The tool includes also an interface to the similarity clustering tool CLUTO.
Compiling instructions
----------------------
- To compile Java Modelling Tools you need Java J2SE SDK 1.5 (or later revision) that can be found at
http://java.com/ and Apache ANT that can be found at http://ant.apache.org/ .
- To create an installer you need IzPack that can be downloaded at http://www.izforge.com/izpack/ and
configure the appropriate path in "build.properties" file.
- Simply open "build.xml" with ANT and select desired target to build JMT from sources
License
-------
Copyright (C) 2006-Present, Laboratorio di Valutazione delle Prestazioni - Politecnico di Milano, Italy
Copyright (C) 2010-Present, Department of Computing - Imperial College London, UK
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.
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with this program;
if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
MA 02110-1301 USA
Java Modelling Tools includes the following third-party software that can be freely
distributed according to the licenses contained in the license folder:
- FreeHEP VectorGraphics package, released under GNU LGPL License.
- Apache Jakarta-ORO, released under Apache Software License.
- JFEP, released under the Apache License, Version 2.0
- JGoodies Looks, released under BSD open source License.
- JGraph, released under GNU LGPL License.
- Apache Log4j, released under Apache Software License.
- Apache Commons, released under Apache Software License.
- Ptolemy II Ptplot, released under BSD open source License.
- Apache Xerces Java Parser, released under Apache Software License.
- Pdf-renderer, released under GNU LGPL 2.1 License.
- Spearlib, released under BSD open source License.
Java Modelling Tools
====================
Introduction
------------
The Java Modelling Tools (JMT) is a free open source suite for performance evaluation,
capacity planning and modelling of computer and communication systems. The suite implements
numerous state-of-the-art algorithms for the exact, asymptotic and simulative analysis of
queueing network models, either with or without product-form solution. Models can be described
either through wizard dialogs or with a graphical user-friendly interface. The suite includes
also a workload analysis tool based on clustering techniques. The suite incorporates an XML
data layer that enables full reusability of the computational engines.
The JMT suite is composed of six tools that support different analyses frequently used in
capacity planning studies. The main features of each tool follows.
JSIMwiz: a discrete-event simulator for the analysis of queueing network models. An intuitive
sequence of wizard windows helps specifying network properties. The simulation engine supports
several probability distributions for characterizing service and inter-arrival times.
Load-dependent strategies using arbitrary functions of the current queue-length can be
specified. JSIM supports state-independent routing strategies, e.g., Markovian or round robin,
as well as state-dependent strategies, e.g., routing to the server with minimum utilization,
or with the shortest response time, or with minimum queue-length. The simulation engine
supports several extended features not allowed in product-form models, namely, finite capacity
regions (i.e., blocking), fork-join servers, and priority classes. The analysis of simulation
results employs on-line transient detection techniques based on spectral analysis.
What-if analyses, where a sequence of simulations is run for different values of parameters,
are also possible.
JSIMgraph: a graphical user-friendly interface for the simulator engine used by JSIMwiz. It
integrates the same functionalities of JSIMwiz with an intuitive graphical workspace. This
allows an easy description of network structure, as well as a simplified definition of
the execution features like blocking regions. Network topologies can be exported in vectorial
or raster image formats.
JMVA: meant for the exact analysis of single or multiclass product-form queueing
network models, either processing open, closed or mixed workloads. The classic MVA solution
algorithm is used. Network structure is specified by textual wizards, with conversion
functions from probabilities to average visit ratios (and viceversa). What-if analyses are
allowed.
JMCH: it applies a simulation technique to solve a single station model, with finite (M/M/1/k)
or infinite queue (M/M/1), and shows the underlying Markov Chain. It is also possible to
dynamically change the arrival rate and service time of the system.
JABA: a tool for the identification of bottlenecks in closed product-form networks using
efficient convex hull algorithms. The tool supports models with up to three job classes.
It is possible to identify potential bottlenecks corresponding to the different mixes of
customer classes. Models with thousands of queues can be analyzed efficiently. The saturation
sectors, i.e., the mixes of customer classes that saturate more than one resource
simultaneously, are identified.
JWAT: supports the workload characterization phase, with emphasis on Web log data.
Some standard formats for input file are provided (e.g., Apache HTTP log files), and
customized formats may also be specified. The imported data can initially be analyzed using
descriptive statistical techniques (e.g, means, correlations, pdf histograms, boxplots,
scatterplots), either for univariate or multivariate data. Algorithms for data scaling,
sample extraction, outlier filtering, k-means and fuzzy k-means clustering for identifying
similarities in the input data are provided. These techniques allow to determine cluster
centroids, and then estimate mean workload and service demands to be used for model
parametrization. The tool includes also an interface to the similarity clustering tool CLUTO.
Compiling instructions
----------------------
- To compile Java Modelling Tools you need Java J2SE SDK 1.5 (or later revision) that can be found at
http://java.com/ and Apache ANT that can be found at http://ant.apache.org/ .
- To create an installer you need IzPack that can be downloaded at http://www.izforge.com/izpack/ and
configure the appropriate path in "build.properties" file.
- Simply open "build.xml" with ANT and select desired target to build JMT from sources
License
-------
Copyright (C) 2006-Present, Laboratorio di Valutazione delle Prestazioni - Politecnico di Milano, Italy
Copyright (C) 2010-Present, Department of Computing - Imperial College London, UK
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.
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with this program;
if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
MA 02110-1301 USA
Java Modelling Tools includes the following third-party software that can be freely
distributed according to the licenses contained in the license folder:
- FreeHEP VectorGraphics package, released under GNU LGPL License.
- Apache Jakarta-ORO, released under Apache Software License.
- JFEP, released under the Apache License, Version 2.0
- JGoodies Looks, released under BSD open source License.
- JGraph, released under GNU LGPL License.
- Apache Log4j, released under Apache Software License.
- Apache Commons, released under Apache Software License.
- Ptolemy II Ptplot, released under BSD open source License.
- Apache Xerces Java Parser, released under Apache Software License.
- Pdf-renderer, released under GNU LGPL 2.1 License.
- Spearlib, released under BSD open source License.
#
# This file includes default build properties.
# Please do not change this file.
#
# To override default properties, create a file called 'build.custom.properties' and set them.
#
# General properties
singlejarName = JMT-singlejar-${jmt.version}.jar
installerName = JMT-installer-${jmt.version}.jar
srcName = JMT-src-and-libs-${jmt.version}.tar.gz
frameworkJarName = JMT_framework_${jmt.version}.jar
engineJarName = JMT_engine_${jmt.version}.jar
frameworkSrcJarName = JMT_framework_${jmt.version}_src.jar
startScreen = jmt.gui.common.startScreen.GraphStartScreen
# Custom folder default Locations. Do not change this, instead create
# a build.custom.properties file to override them
jmt_base = .
src = ${jmt_base}/src/main/java
re_src = ${jmt_base}/src/main/resources
util = ${jmt_base}/build_util
lib = ${jmt_base}/lib
izpack = e:/izPack
class = ${jmt_base}/class
dist = ${jmt_base}/JMT_dist
out = ${jmt_base}/JMT_output
#
# This file includes default build properties.
# Please do not change this file.
#
# To override default properties, create a file called 'build.custom.properties' and set them.
#
# General properties
singlejarName = JMT-singlejar-${jmt.version}.jar
installerName = JMT-installer-${jmt.version}.jar
srcName = JMT-src-and-libs-${jmt.version}.tar.gz
frameworkJarName = JMT_framework_${jmt.version}.jar
engineJarName = JMT_engine_${jmt.version}.jar
frameworkSrcJarName = JMT_framework_${jmt.version}_src.jar
startScreen = jmt.gui.common.startScreen.GraphStartScreen
# Custom folder default Locations. Do not change this, instead create
# a build.custom.properties file to override them
jmt_base = .
src = ${jmt_base}/src/main/java
re_src = ${jmt_base}/src/main/resources
util = ${jmt_base}/build_util
lib = ${jmt_base}/lib
izpack = e:/izPack
class = ${jmt_base}/class
dist = ${jmt_base}/JMT_dist
out = ${jmt_base}/JMT_output
<project name="JMT" default="create_jar" basedir=".">
<description>
build jmt project
</description>
<property file="global.properties" />
<property file="${globalsettings.path}" />
<property file="build.custom.properties" />
<property file="build.properties" />
<filter filtersfile="${globalsettings.path}" />
<target name="init" description="initialize build process">
<echo>Initialize build process for JMT v.${jmt.version}</echo>
<!-- Create the time stamp -->
<tstamp/>
<!-- Create the build directory structure used by compile -->
<mkdir dir="${jmt_base}" />
<mkdir dir="${class}" />
</target>
<target name="compile" depends="init" description="compile the source code">
<!-- Compile the java code from ${src} into ${build} -->
<javac srcdir="${src}" destdir="${class}" source="1.7" target="1.7" encoding="UTF-8" includeantruntime="false">
<classpath>
<fileset dir="${lib}">
<include name="*.jar" />
</fileset>
</classpath>
</javac>
</target>
<target name="copy_resources" depends="compile" description="copies resources into build dir">
<!-- Copy application resources -->
<copy todir="${class}">
<fileset dir="${re_src}" excludes="**/*.java,**/*.bak,**/*.log,**/*.dfPackage,**/.svn" />
</copy>
<!-- Copy License and Readme to class folder -->
<copy file="license/LICENSE_JMT.txt" tofile="${class}/License.txt" />
<copy file="README.txt" todir="${class}" />
</target>
<target name="prepare_dist" depends="compile,copy_resources" description="generate the distribution jar">
<!-- Create the output and the lib directory -->
<mkdir dir="${out}/lib" />
<!-- Copy libraries -->
<sync todir="${out}/lib">
<fileset dir="lib" includes="**/*.jar" />
</sync>
</target>
<!-- Bertoli Marco-->
<target name="create_jar" depends="prepare_dist" description="creates application jar">
<path id="jmt.class.path">
<fileset dir="${lib}">
<include name="*.jar" />
</fileset>
</path>
<manifestclasspath property="jmt.manifestcp" jarfile="JMT.jar">
<classpath refid="jmt.class.path" />
</manifestclasspath>
<!-- Jar application and resources into the JMT.jar file -->
<jar jarfile="${out}/JMT.jar">
<fileset dir="${class}">
<include name="**/*" />
<exclude name="jmt/test/**/*" />
</fileset>
<manifest>
<attribute name="Built-By" value="${user.name}" />
<attribute name="Class-Path" value="${jmt.manifestcp}" />
<attribute name="Main-Class" value="${startScreen}" />
</manifest>
</jar>
</target>
<!-- Bertoli Marco-->
<target name="create_single_jar" depends="create_jar" description="creates a single jar with every library">
<!-- Create the directory -->
<mkdir dir="${dist}/singlejar_JMT" />
<!-- Unjar all libs into singlejar_JMT dir -->
<unjar dest="${dist}/singlejar_JMT">
<fileset dir="${out}/lib" includes="*.jar" />
</unjar>
<!-- Copy JMT classes into singlejar_JMT dir -->
<copy todir="${dist}/singlejar_JMT">
<fileset dir="${class}">
<include name="**/*" />
<exclude name="jmt/test/**/*" />
</fileset>
</copy>
<!-- Add license to singlejar -->
<mkdir dir="${dist}/singlejar_JMT/license" />
<!-- Copy lib licenses dir -->
<sync todir="${dist}/singlejar_JMT/license">
<fileset dir="license" includes="*.txt" />
</sync>
<!-- Delete meta-inf dir (which contains the manifests of unpackaged libs) -->
<delete dir="${dist}/singlejar_JMT/META-INF" />
<!-- Create services for freehep (to save vectorial images) and copy service file -->
<mkdir dir="${dist}/singlejar_JMT/META-INF/services" />
<copy file="${util}/org.freehep.util.export.ExportFileType" todir="${dist}/singlejar_JMT/META-INF/services" />
<copy file="${util}/javax.imageio.spi.ImageWriterSpi" todir="${dist}/singlejar_JMT/META-INF/services" />
<!-- Jar all dir contents into a single jar file-->
<jar destfile="${dist}/${singlejarName}" basedir="${dist}/singlejar_JMT/" includes="**/*.*">
<manifest>
<attribute name="Built-By" value="${user.name}" />
<attribute name="Main-Class" value="${startScreen}" />
</manifest>
</jar>
<!-- Clean singleJAR directory -->
<delete dir="${dist}/singlejar_JMT" />
</target>
<target name="create_JMT_output_dir" depends="create_jar" description="create output package">
<!-- Create license directory -->
<mkdir dir="${out}/license" />
<!-- Copy lib licenses dir -->
<sync todir="${out}/license">
<fileset dir="license" includes="*.txt" />
</sync>
<!-- Copy jmt license file -->
<copy file="license/LICENSE_JMT.txt" todir="${out}" />
<!-- Create examples directory -->
<mkdir dir="${out}/examples" />
<!-- Copy examples dir -->
<sync todir="${out}/examples" >
<fileset dir="examples" includes="*.*" />
</sync>
<!-- Create jwatFormats directory -->
<mkdir dir="${out}/jwatFormats" />
<!-- Copy jwatFormats dir -->
<sync todir="${out}/jwatFormats">
<fileset dir="jwatFormats" includes="*.*" />
</sync>
<!-- Create manuals directory -->
<mkdir dir="${out}/manuals" />
<!-- Copy lib manuals dir -->
<sync todir="${out}/manuals">
<fileset dir="manuals" includes="*.*" />
</sync>
</target>
<!-- We call IzPack -->
<target name="create_installer" depends="create_JMT_output_dir"
description="Creates the jar with the installer, using IzPack">
<!-- Allow us to use the IzPack Ant task -->
<path id="izpack.classpath">
<fileset dir="${izpack}">
<include name="lib/*.jar" />
</fileset>
</path>
<taskdef name="iz_pack" classpathref="izpack.classpath" classname="com.izforge.izpack.ant.IzPackTask" />
<!-- Copy resources used by installer excluding shortcut specs -->
<copy todir="${out}" >
<fileset dir="${util}/" includes="*.*" excludes="*shortcutSpec.xml" />
</copy>
<copy todir="${out}" filtering="true" overwrite="true">
<fileset dir="${util}/" includes="*shortcutSpec.xml" />
</copy>
<!-- Create license directory -->
<echo message="Makes the installer using IzPack"/>
<mkdir dir="${dist}" />
<iz_pack input="${out}/jmt_install.xml" output="${dist}/${installerName}" installerType="standard" basedir="${out}"
izPackDir="${izpack}/" inheritall="true" />
</target>
<target name="clean_intermediate_dirs" description="clean up" >
<!-- Delete the ${out} directory tree -->
<delete dir="${out}" />
</target>
<target name="clean_all" depends="clean_intermediate_dirs" description="clean up" >
<!-- Delete the ${dist} directory -->
<delete dir="${dist}" />
<delete dir="${class}" />
</target>
<target name="create_framework" depends="copy_resources" description="builds the framework in a separate JAR">
<mkdir dir="${dist}" />
<jar destfile="${dist}/${frameworkJarName}">
<fileset dir="${class}">
<include name="**/framework/**/*" />
<include name="License.txt" />
</fileset>
<manifest>
<attribute name="Built-By" value="${user.name}" />
</manifest>
</jar>
<copy todir="${src}" file="License.txt" />
<jar destfile="${dist}/${frameworkSrcJarName}">
<fileset dir="${src}">
<include name="jmt/framework/**/*" />
<include name="License.txt" />
</fileset>
<manifest>
<attribute name="Built-By" value="${user.name}" />
</manifest>
</jar>
<delete file="${src}/License.txt" />
</target>
<target name="create_engine" depends="copy_resources" description="builds the engine in a separate JAR">
<mkdir dir="${dist}" />
<jar destfile="${dist}/${engineJarName}">
<fileset dir="${class}">
<include name="jmt/common/**/*" />
<include name="jmt/engine/**/*" />
<include name="jmt/analytical/**/*" />
<include name="License.txt" />
</fileset>
<manifest>
<attribute name="Built-By" value="${user.name}" />
</manifest>
</jar>
</target>
<target name="package_sources" description="package source files" >
<mkdir dir="${dist}" />
<tar destfile="${dist}/${srcName}" compression="gzip">
<fileset dir="${jmt_base}">
<include name="src/**" />
<include name="build_util/**" />
<include name="examples/**" />
<include name="jwatFormats/**" />
<include name="lib/**" />
<include name="license/**" />
<include name="manuals/**" />
<include name="*.properties" />
<include name="*.txt" />
<include name="*.xml" />
<exclude name="**/.svn" />
<exclude name="*custom*" />
</fileset>
</tar>
</target>
<target name="FULL_release" depends="clean_all,create_installer,create_single_jar,package_sources"
description="provide a full release">
<echo>Full release ${jmt.version} created</echo>
</target>
<project name="JMT" default="create_jar" basedir=".">
<description>
build jmt project
</description>
<property file="global.properties" />
<property file="${globalsettings.path}" />
<property file="build.custom.properties" />
<property file="build.properties" />
<filter filtersfile="${globalsettings.path}" />
<target name="init" description="initialize build process">
<echo>Initialize build process for JMT v.${jmt.version}</echo>
<!-- Create the time stamp -->
<tstamp/>
<!-- Create the build directory structure used by compile -->
<mkdir dir="${jmt_base}" />
<mkdir dir="${class}" />
</target>
<target name="compile" depends="init" description="compile the source code">
<!-- Compile the java code from ${src} into ${build} -->
<javac srcdir="${src}" destdir="${class}" source="1.7" target="1.7" encoding="UTF-8" includeantruntime="false">
<classpath>
<fileset dir="${lib}">
<include name="*.jar" />
</fileset>
</classpath>
</javac>
</target>
<target name="copy_resources" depends="compile" description="copies resources into build dir">
<!-- Copy application resources -->
<copy todir="${class}">
<fileset dir="${re_src}" excludes="**/*.java,**/*.bak,**/*.log,**/*.dfPackage,**/.svn" />
</copy>
<!-- Copy License and Readme to class folder -->
<copy file="license/LICENSE_JMT.txt" tofile="${class}/License.txt" />
<copy file="README.txt" todir="${class}" />
</target>
<target name="prepare_dist" depends="compile,copy_resources" description="generate the distribution jar">
<!-- Create the output and the lib directory -->
<mkdir dir="${out}/lib" />
<!-- Copy libraries -->
<sync todir="${out}/lib">
<fileset dir="lib" includes="**/*.jar" />
</sync>
</target>
<!-- Bertoli Marco-->
<target name="create_jar" depends="prepare_dist" description="creates application jar">
<path id="jmt.class.path">
<fileset dir="${lib}">
<include name="*.jar" />
</fileset>
</path>
<manifestclasspath property="jmt.manifestcp" jarfile="JMT.jar">
<classpath refid="jmt.class.path" />
</manifestclasspath>
<!-- Jar application and resources into the JMT.jar file -->
<jar jarfile="${out}/JMT.jar">
<fileset dir="${class}">
<include name="**/*" />
<exclude name="jmt/test/**/*" />
</fileset>
<manifest>
<attribute name="Built-By" value="${user.name}" />
<attribute name="Class-Path" value="${jmt.manifestcp}" />
<attribute name="Main-Class" value="${startScreen}" />
</manifest>
</jar>
</target>
<!-- Bertoli Marco-->
<target name="create_single_jar" depends="create_jar" description="creates a single jar with every library">
<!-- Create the directory -->
<mkdir dir="${dist}/singlejar_JMT" />
<!-- Unjar all libs into singlejar_JMT dir -->
<unjar dest="${dist}/singlejar_JMT">