Key Engineering Materials Submitted: 2015-06-29

ISSN: 1662-9795, Vol. 685, pp 943-947 Accepted: 2015-10-07

doi:10.4028/www.scientific.net/KEM.685.943 Online: 2016-02-18
© 2016 Trans Tech Publications, Switzerland

Using Parallel Computing in Queueing Network Simulation

Roman Mesheryakov1,a, Alexander Moiseev2,b, Anton Demin3,c,
Vadim Dorofeev4,d and Vasily Sorokin5,e
1
Tomsk State University of Control System and Radioelectronics, Lenin Avenue 40, Tomsk,
Russia, 634050
2
Tomsk State University, Lenin Avenue 36, Tomsk, Russia, 634050
3,4,5
Tomsk Polytechnic University, Lenin Avenue 30, Tomsk, Russia, 634050
a
[email protected], [email protected], [email protected], [email protected], [email protected]

Keywords: parallel computing, MPI, computer simulations, software design.

Abstract. The paper is devoted to the simulation of queueing networks on high performance
computer clusters. The objective is to develop a mathematical model of queueing network and
simulation approach to the modelling of the general network functionality, as well as to provide a
software implementation on a high-performance computer cluster. The simulation is based on a
discrete-event approach, object oriented programming, and MPI technology. The model of the
queueing networks simulation system was developed as an application that allows a user to simulate
networks of rather free configuration. The experiments on a high performance computer cluster
emphasize the high efficiency of parallel computing.

Introduction
In this article the usage of modelling simulation software is considered for general queueing
network simulation [1, 2, 3]. Object-oriented approach is used for application development. The
expected result is the probabilistic characteristics of the network functionality. Therefore, it is
necessary to make this simulation able to provide the sufficiently reliable empirical estimators of
these characteristics. It is obvious, that this would require large samples to obtain the network status
at the time of their operation. Moreover, these samples must enlarge in relation to the task
enlarging, which is the number of nodes in the network. Thus, it requires either a rather long
simulation of one process realization, or, which is more preferable, a simulation of realizations
plurality, even if the time intervals are shorter. Thus, there arises the task of parallelizing the
simulation of different implementations for one and the same network, its performing on separate
computing devices and further combining the obtained results with the purpose to compute
empirical estimators of functioning probability characteristics. To achieve this goal it is proposed to
use MPI technology to parallelize the simulation process inside the developed software [1].

Simulation software ODIS

On the basis of the principles involving the object-oriented approach [4] there has been developed
the software package ODIS [1], intended for queueing networks simulation. Let’s present a short
description of the system architecture with the account of all elements required for queueing
networks simulation.
The main algorithm of simulation modelling is implemented by a special object
SimulationModel, which uses a template method Run(). The algorithm of this method begins by
executing the operation OnInitialization(), intended for initializing. Then the method DoStep(),
responsible for one simulation step, is carried out in a cycle. The steps are executed by the moment
when function IsDone() retrieves the value “true”, which will indicate the completion of simulation.
Upon simulation completion the operation OnFinalization(), intended for the final actions
execution, is initiated.

All rights reserved. No part of contents of this paper may be reproduced or transmitted in any form or by any means without the written permission of Trans
Tech Publications, www.ttp.net. (ID: 165.215.209.15, ProQuest, USA-20/05/16,16:00:37)
944 High Technology: Research and Applications 2015

The class SimulationModel can serve as a basic one for any simulation modelling systems, which
use a step-by-step simulation. There is a special descendant of this class which is designed to
perform the simulation of queueing networks. This object called NetworkQueueSimulationModel
realizes interface of the model as follows:
• operation OnInitialization() used for the initial filling of an event logging with the incoming
requests events;
• operation IsDone() used for the indication of a particular condition of halting (due to the
simulation time or the number of incoming requests events);
• operation DoStep() used for the realization of the simulation step (servicing an event that is
the first in a queue).
To implement a discrete-event simulation procedure, there has been introduced a special object
Event, which encapsulates all the information necessary for the correct registration and processing
all events in the model. All events are registered in a special list, an event logging, which applies
sorting the events by time and provides a discrete-event control of the simulation time. Figure 1
shows the connection of the class Event with other objects of the program.

Fig.1 Event model

Abstraction Call is introduced in the system as an entity of transferring data, connected with a
special incoming request as well as for registering data about its processing. The object Element is
any system element (a requests source, a server block, a buffer, a router), able to accept requests
(operation Accept) and/or generate and process events connected with the requests (operation
ProcessEvent(…)).The object Event saves a pointer to the member, which has generated this event
and must process it, in the link invoker. The time moments, when an element will have to execute a
definite operation, will serve as Events for the model elements. For example, the entry of a request
to be processed will serve as an Event for the requests source; the processing termination will serve
as an Event for the server block, an effort of a request to apply for the repeated processing will serve
as an Event for the source of the repeated calls.
Such system organization enables the whole process happening at one simulation step (operation
DoStep() of the class NetworkQueueSimulationModel) to be presented as a simple algorithm
described here. The model retrieves the nearest event from the logging, initiates its processing
Process(), which simply forwards the call to the processing element. A finite element invoker
carries out all the necessary operations.
Various model elements are the ancestors of the basic class Element (Fig. 2). Each of them
processes the operations Accept() and ProcessEvent() depending on their missions. Specifically, the
requests source Source cannot receive any requests, its method Accept() generates the exception.
However, the operation ProcessEvent(), invoked in case of the event when a requests enters a
system, moves the request to the attached element (a pointer NextElement), whose role in queueing
network is played by the router Router. Moving the request implies calling the operation Accept(…)
of this element with the corresponding parameters.
The operation Accept(…) of the object ServerBlock (a block of servers, a node) verifies whether
the node is free (operation IsFree()) or occupied; if it is free the request goes into service, i.e. the
operation EnforceAccept(…) is enforced, in the other case a request is sent to the buffer (a pointer
buffer) if it is present in the system or is removed from the system. The operation ProcessEvent(…)
of the block (processing the event of service completion) simply deletes a request from the list of
 Key Engineering Materials Vol. 685 945

requests to be served by this block, sends the request to the next element (Router), and, in case a
passive buffer is available, a request next in a queue is compulsively taken away from it.

Fig.2 Model elements hierarchy

The objects PassiveBuffer and ActiveBuffer implement passive and active buffers respectively. A
distinguishing characteristic of an active buffers is their ability to send the request to the server on
their own by initiating the operation ProcessEvent(…), while the same operation in a passive buffer
does not initiate any actions.
A router Router cannot process requests on its own, therefore, its operation ProcessEvent(…)
generates an error. The operation Accept(…) of this element redirects the requests to the definite
network nodes depending on the parameter source of this operation (either the request has just
entered a network or it has already been processed at one of the nodes), as well as depending on the
input flow splitting vector v and the routing matrix r.
The result of simulation modelling is the implementation of a state change random process (the
number of requests in nodes) of the queueing networks service. Statistical indicators of network
functioning, such as an expectation empirical estimator and the covariance of the number of
requests in the network nodes, are of the major interest for the researchers. The profile of
accumulation and processing statistical information in the software package ODIS is implemented
via the hierarchy classes StatisticsAccumulator. The main point here is that the given classes enable
to gain the stated statistical values, and they involve the methods for merging with the similar
objects, which can be obtained as various simulations of one and the same network.

Parallel computing
The main peculiarity of using the described application for queueing network simulation service is
the possibility of multiple simulating of one and the same network. Thus, when simulating the use
of various computing devices it is possible to get and store much more statistic information than
during the simulation at one computer at the same interval of time. At the end of simulation all
stored files can be downloaded and united with a special utility (see above the operations Load ()
and Merge() of the class StatisticsAccumulator). It can be concluded that the large amount of
statistic material can be obtained during a short time span.
Parallel computing has been made on a high performance computer cluster of Tomsk
Polytechnic University (TPU). To run the application, the following tasks had to be solved:
1. the application decomposition (paralleling);
946 High Technology: Research and Applications 2015

2. selecting the technology able to provide parallel processing and synchronization

3. conducting simulation experiments and making analysis of temporary data;
4. detecting “bottlenecks”.
Whereas the characteristics of computing systems, the number of nodes, connections and other
parameters as well as the number of processed requests are an application input data, then,
according to the Flynn's classification, it is possible to use the computing systems with the
architectures SIMD and MIMD, enabling processing of several data flows in parallel.
In case of multiple data it is feasible to decompose data: portions of data of the similar size can
be assigned to computational flows before the parallel processing begins, which corresponds with
the static decomposition and makes paralleling and synchronization much simplified (Fig.3).

Fig.3 Architecture of parallelized application for simulation

MPI technology was chosen to be a parallelizing technology. As the application corresponds to

the architecture SIMD, graphics accelerators (such technologies as CUDA, AMD APP, OpenCL,
etc.) could have been used, but it would have required the application source code to be
considerably rewritten. It is connected with the fact that the application was developed on the basis
of C# language, while the graphics accelerators require the parallelized part of the algorism to be
written in C language. C# support is initially stated in a logging MPI.NET, which considerably
eases the task of selecting a technology [5].
Technology MPI implies the availability of one coordinator and several workflows. A
coordinator obtains the number 0, gives the tasks to workflows and processes the results of their
operation. Input data for each simulation task are recorded in files N.odis, where N is task
dimension. Each of these files obtains the parameters (of a system under simulation), such as the
number of requests, while the task dimension indicates the number of nodes in a system under
simulation. As a result of experiments there were gained data about the simulation productivity on
different amount of processor cores (Fig. 4a).
On the output of each process, a file, with the size from several kilobytes to several hundreds of
megabytes, containing the results of requests processing, was generated. Applying a general high-
speed storage for input data storing cause concern that simultaneous recording of such big amounts
of data can have a negative impact on the productivity measuring. Simulation experiments have
shown that the time of simulation with disk writing and without disk writing differs; but if a task
dimension is not large (up to 50), it has almost no effect on the general time of operation. If a task
dimension is larger, the impact of the stage of writing results on a disk is more significant, which
decreases the effectiveness of applying a large number of parallel flows (Fig.4b). The possible
solutions of this situation are using several data storages or separating writing operations of
different flows in time.
 Key Engineering Materials Vol. 685 947

Fig.4 Dependence of application a) execution time on task dimension and b) impact of the resulting
file writing on a disk on the time of application execution

During the simulation it has been stated that the requirements to the RAM volume at the increase
of the task dimension have grown. Thus, when simulating the system consisting of 500 nodes on 8
and 16 cores the application needs more than 32 gigabytes of memory. To solve this problem either
the number of parallel processes or the size of the task dimension needs to be decreased.

Conclusion
The main problem of using the application for simulating queueing networks with a large number of
nodes is the necessity to simulate a big number of profiles as well as obtaining statistic samples of
large volumes. It inevitably leads to the increase of processor time consumption and the volumes of
RAM used. To optimize the stated parameters during technical task implementation, the application
has been adapted to be launched at a high performance computer cluster. In consequence of test
launching it has been proved possible to use a high performance computer cluster for a system
simulation and there was obtained information on the impact of auxiliary operations (such as
writing the arrays of the obtained information on a disk) on the application efficiency.
The developed application can be used for scientific research in the application-oriented
probabilistic analysis area as well as for characteristics computing of actual computer systems of
queueing networks models.

References
[1] A.N. Moiseev, M.V. Sinyakov, Development of an object-oriented system model simulation
of queuing processes, Tomsk State University Journal of Control and Computer Science. 1
(2010) 89–93.
[2] J.R. Artalejo, A. Gomez-Corall, Retrial Queueing Systems. A Computational Approach,
Sprnger, Berlin, 2008.
[3] A.A. Nazarov, A.N. Moiseev, Analysis of an open non-Markovian GI–(GI|∞)K queueing
network with high-rate renewal arrival process, Problems of Information Transmission. 49
(2013) 167–178.
[4] A. Moiseev, S. Moiseeva, M. Sinyakov, Basic object model layer domain system simulation
of queuing processes, in Proc. of Int. Conf. on Application Of Information And
Communication Technology In Economy And Education (ICAICTEE-2011), University Of
National And World Economy, Sofia, 2011, pp. 230–236.
[5] A.Y. Demin, V.A. Dorofeev, Parallelization of the boundaries of objects extraction algorithm
based on structural and graphical representation, Bulletin of Tomsk Polytechnic University.
323 (2013) 159–164.
High Technology: Research and Applications 2015
10.4028/www.scientific.net/KEM.685

Using Parallel Computing in Queueing Network Simulation

10.4028/www.scientific.net/KEM.685.943

DOI References
[2] J.R. Artalejo, A. Gomez-Corall, Retrial Queueing Systems. A Computational Approach, Sprnger, Berlin,
(2008).
10.1007/978-3-540-78725-9
[3] A.A. Nazarov, A.N. Moiseev, Analysis of an open non-Markovian GI-(GI|∞)K queueing network with
high-rate renewal arrival process, Problems of Information Transmission. 49 (2013) 167-178.
10.1134/s0032946013020063
Reproduced with permission of the copyright owner. Further reproduction prohibited without
permission.