distributed computer systems

v2.0.0 Development

DISCO Lab is proud to present the DISCO Deterministic Network Calculator, a network calculus library. This library contains a number of classes written in Java(tm) which may be useful for analyzing communication networks using the Network Calculus. This calculus allows to determine such characteristics of data flows as the maximum latency or the minimum bandwidth, as long as bounds can be specified for these flows in the form of so-called arrival curves.

For feedback, questions, etc., please contact Steffen Bondorf.

If you use the Disco Deterministic Network Calculator for research, please include one of the following entries in any resulting publication. 

System Requirements

Known Issues

  • none

Known Limitations

  • The double based number representation will round (intermediate) results. No mechanism to ensure rounding into the right direction is implemented. Thus it is not guaranteed that the resulting bounds are valid.
  • Using the rational number representation, analyses may fail due to integer overflows.
  • There is no PMOO analysis for FIFO multiplexing nodes.


We offer an archive with the complete source code. For development, you need to get the dependencies listed in the System Requirements section, and set up your environment so that all external libraries are in the classpath.

Although this is a release candidate, unknown issues might occur.

DISCO Deterministic Network Calculator 2.0rc9 (source)


Previous Versions

  • Version 1.1, the previous major release, can still be found here. An archive containing some of the functional tests of version 2.0rc9 backported to v1.1 can now also be found there.
  • Version 1.0.1 is also available as all in one and plain version.
  • The code of the original version 1.0 developed by Frank Zdarsky is available as an all in one archive including all libraries necessary to run the calculator (download) or a plain version without the dependencies (download).


Development towards version 2.0 focusses on eliminating external dependencies, improving precision by using rational numbers, reducing structural complexity by modularization and simplifying the usage of the Network Calculator.

RC 9

Besides the usual code, performance and stability improvements, this release candidate has the following noteworthy changes to offer:

  • Critical bug fixes in Flow.java: Calling getPrecedingServer( Server s ) or getSucceedingServer( Server s ) won't crash the calculator anymore.
  • New feature: Arrival Bound Caching. The calculator can now optionally cache arrival bounds for later reuse. The recursive per-hop arrival bound calculation can cache all intermediate results whereas the other bounding methods only store the final one. Caching can be enabled by setting the use_cache configuration option to true. The included functional tests pass.

RC 8

  • ServiceCurve: Rate latency components for the zero delay burst curve were added.
  • Deconvolution: Improved handling of zero delay burst and null service curves.
  • PmooAnalysis: Added recognition of resulting delay burst and null service curves.
  • Num (double based): Improved +/- infinity representation.
  • Path: Added methods for getting the length in either servers or links.

RC 7

  • The Rational class was renamed to Num.
  • A new Num class wrapping doubles was implemented. It yields faster runtimes by sacrificing the precision of the fraction based one. Thus the tests fail when using it. External libraries are not necessary with this number representation. The BigFraction based wrapper is still around but can be considered obsolete from now on.
  • The bounding methods were moved into separate classes and fixed in order to properly work with zero delay burst service curves.
  • Convolution and deconvolution were split into two separate classes and moved into the new package unikl.disco.minplus.
  • Performance improvements by reducing the amount of created Num instances of common values like zero, NaN, and positive/negative Infinity.
  • JavaDoc improvements.

RC 6

  • Fixed the copying of arrival and service curves.
  • Performance improvement in the network class.

RC 5

  • Performance improvement in the Rational classes.
  • JavaDoc cleanups and some additions.
  • SFA and PMOO: getEnd2EndServiceCurve() was renamed to getLeftOverServiceCurve().
  • A new class called Path was created in order to allow storing servers as well as links of a flow’s path.
  • More modularization:
    • The calculation of cross-traffic arrivals bounding was separated from the analysis classes and moved into according {PerHop,Pmoo}ArrivalBound classes. They can now be used independent of the analysis on the flow of interest’s path. Tests are displaying the results using PerHopArrivalBound as it was the default case for non-PMOO analyses before. Test documentation was updated accordingly.
    • Service and arrival curve classes were split out of the generic curve class.
    • The left over service curve calculation was moved in an own class, too.

RC 4

  • The explicit sink should not be visible to the user anymore.
  • PMOO's recursive output bound calculation now posesses the same improvement as SFA's gained in RC3, i.e., the flow of interest is assigned the lowest priority throughout the whole analysis.

up to RC 3

  • Output bound calculations during an SFA consider the given flow of interest having the lowest priority during analysis, i.e., the flow of interest will not interfere with any other flow and thus not be considered during the calculation of left-over service curves. (according previous know limitation was: "SFA is only aware of the flow of interest on its path, i.e., when calculating the arrival curve of a rejoining cross flow, the flow of interest will be considered cross-traffic to it at the previous server/s these two flows met. See FeedForward_1SC_2Flows_1AC_2Paths in src/unikl/disco/tests/FeedForward.pdf for an example.").
  • Network.java's API was extended to cover parameters of server, link and flow during their creation. Therefore the amount of constructors of the network elements were reduced to the one demanding to set all parameters.
  • Flow.java: It was ensured that getSink() will not return the explicit sink needed for internal calculations.
  • Flow.java: The method setPath( List<Link> path ) was added.
  • Curve.java: makeArrivalCurve( Curve curve ) now modifies the given Curve instead of creating a new one. The old behavior was moved to getAsArrivalCurve( Curve curve ).
  • Network.java: getExplicitSink() was added.

Beta 4

Beta 4 breaks compatibility with previous beta versions due to the following changes:

  • Curve.java: createRateLatency( latency, rate ) -> createRateLatency( rate, latency )
  • Curve.java: createTokenBucket( burstiness, rate ) -> createTokenBucket( rate, burstiness )
  • Name change: Edge -> Link
  • Name change: Vertex -> Server
  • Name change in analyses: performAnalysis( flow_of_interest ) -> performEnd2EndAnalysis( flow_of_interest )
  • Name change in analyses: getEndToEndServiceCurve -> getEnd2EndServiceCurve
  • Exception handling: performEnd2EndAnalysis( flow_of_interest ) throws exceptions that need to be caught by the user (see Demo4.java).

up to Beta 3

  • Major code modularization and cleanups were done in order to improve extensibility and ease maintenance.
  • Removal of analysis methods unrelated to network calculus (Charny bound, fair queueing).
  • The dependency on the deprecated JUNG 1.7.6 library was removed in favor of a minimalistic internal representation of the necessary network elements.
  • Explicit input and output nodes of flows were removed from the user facing interface. Whereas the former could be removed completely, the latter ones are handled internally by the new network class.
  • Removal of the distinction between network graph and server graph. The turn prohibition algorithm also vanished. From v2.0b1 on it is the users responsibility to prevent cyclic dependencies between flows.
  • To prevent rounding errors, the Network Calculator now uses a rational class derived from Apache Commons Math3's Fraction class instead doubles. In case Integer Overflows occur, there is an alternative rational class implementation based on BigFraction, however, tests will fail due to rounding errors again.
  • Multiplexing behavior can now be set on a per node basis.
  • TFA provides both FIFO and arbitrary multiplexing.
  • TFA per node delay and backlog bounds are stored and made accessible.
  • SFA bounds for arbitrary multiplexing nodes were improved.
  • SFA per node residual service curves are stored and made accessible.
  • Resolved long standing issue with vertical deviation between token bucket arrival curve and rate service curve leading to wrong backlog bounds of 0.
  • Functional tests were added (incl. pdf documents containing the according calculations).
  • There's a central configuration class containing all user modifiable flags.
  • Four simple demos are included.
  • Rudimentary visualization of results was removed.
  • Logger was removed.

University of Kaiserslautern

Write your thesis with a disco advisor

We offer a variety of bachelor and master theses at any point in the academic year. Also check out some of our completed theses. Read more...

Go to top