1,721,022 research outputs found
The octave queueing package, version 1.2.1
No full textThe octave queueing package is a collection of functions written in GNU Octave for analyzing queueing Network models. In particular, qnetworks contains functions for analyzing Jackson networks, open, closed or mixed product-form BCMP networks, and for computing performance bounds. The queueing package has been described in the following paper:
M. Marzolla, "The qnetworks Toolbox: A Software Package for Queueing
Networks Analysis". Khalid Al-Begain, Dieter Fiems and William J. Knottenbelt, Editors, Proceedings 17th International Conference on Analytical and Stochastic Modeling Techniques and Applications (ASMTA 2010) Cardiff, UK, June 14–16, 2010, volume 6148 of Lecture Notes in Computer Science, Springer, pp. 102–116, ISBN 978-3-642-13567-
Efficient Performance models in Component-Based Software Engineering
No full textPerformance evaluation of Component-Based software systems should be performed as early as possible during the software development life cycle. Unfortunately, a detailed quantitative analysis is often not possible during such stages, as only the system outline is available, with very little quantitative knowledge. In this paper we propose an approach based on Queueing Network analysis for performance evaluation of component-based software systems at the software architectural level. Our approach provides performance bounds which can be efficiently computed. Starting from annotated UML diagrams we compute bounds on the system throughput and response time without explicitly deriving or solving the underlying multichain and multiclass Queueing Network model. We illustrate with an example how the technique can be applied to answer many performance-related questions which may arise during the software design phase
Towards Performance Evaluation of Mobile Systems in UML
No full textThe current generation of network-centric applications ex- hibits an increasingly higher degree of mobility. Wireless networks allow devices to move from one location to another without loosing connectivity. Also, new software technolo- gies allow code fragments or entire running applications to migrate from one host to another. Performance modeling of such complex systems is a difficult task, which should be carried out during the early design stages of system devel- opment. However, the integration of performance modeling analysis with software system specification for mobile sys- tems is still an open problem, since there is no unique widely accepted notation for describing mobile systems. Moreover performance modeling is usually developed separately from high-level system description. This is not only time con- suming, but the separation of performance model and system specification makes more difficult the feedback process of re- porting the performance analysis results at the system design level, and modifying system model to analyze design alter- natives. In this paper we address the problem of integrating system performance modeling and analysis with a specifica- tion of mobile software system based on UML. In particular we introduce a unified UML notation for high-level descrip- tion and performance modeling of mobile systems. The no- tation allows inclusion of quantitative information, which are used to build a process-oriented simulation model of the sys- tem. The simulation model is executed, and the results are reported back in the UML notation. We describe a prototype tool for translating annotated UML models into simulation programs and we present a simple case study
A P2P Resource Discovery System Based on a Forest of Trees
No full textThe convergence of the Grid and Peer-to-Peer (P2P) worlds has led to many solutions that try to efficiently solve the problem of resource discovery on Grids. Some of these solutions are extensions of P2P DHT-based networks. We believe that these systems are not flexible enough in the case the data present in the network is very dynamic, i.e. the data values change very frequently over time. This a very common case for some kind of data in typical Grid systems, like CPU loads, queue occupation, etc. In this paper we present a variation of a previous work based on a tree-shaped P2P overlay network. The system uses Routing Indexes to efficiently route queries and update messages in the presence of highly variable data. The new system is based on a twolevel hierarchical network topology, where tree topologies must be only maintained at the lower level of the hierarchy. The main aim of this new organization is to achieve a simpler maintenance of the overall P2P graph topology. This is reached at the cost of some imprecision in the routing indexes built at the upper level of the graph hierarchy
Peer-to-peer Systems for Resource Discovery in a Dynamic Grid
No full textThe convergence of the Grid and Peer-to-Peer (P2P) worlds has led to many solutions that try to efficiently solve the problem of resource discovery on Grids. Some of these solutions are extensions of P2P DHT-based networks. We believe that these systems are not flexible enough when the indexed data are very dynamic, i.e., the values of the resource attributes change very frequently over time. This is a common case for Grid metadata, like CPU loads, queue occupation, etc. Moreover, since common requests for Grid resources may be expressed as multi-attribute range queries, we think that the DHT-based P2P solutions are poorly flexible and efficient in handling them.
In this paper we present two P2P systems. Both are based on Routing Indexes, which are used to efficiently route queries and update messages in the presence of highly variable data. The first system uses a tree-shaped overlay network. The second one is an evolution of the first, and is based on a two-level hierarchical network topology, where tree topologies must only be maintained at the lower level of the hierarchy, i.e., within the various node groups making up the network. The main goal of the second organization is to achieve a simpler maintenance of the overall P2P graph topology, by preserving the good properties of the tree-shaped topology.
We discuss the results of extensive simulation studies aimed at assessing the performance and scalability of the proposed approaches. We also analyze how the network topologies affect the propagation of query and update messages
A Framework for QoS-aware Execution of Workflows over the Cloud
No full textThe Cloud Computing paradigm is providing system architects with a new powerful tool for building scalable applications. Clouds allow allocation of resources on a ”pay-as-you-go” model, so that additional resources can be requested during peak loads and released after that. In this paper we describe SAVER (qoS-Aware workflows oVER the Cloud), a QoS-aware algorithm for executing workflows involving Web Services hosted in a Cloud environment. SAVER allows execution of arbitrary workflows subject to response time constraints. SAVER uses a simple Queueing Network (QN) model to identify the optimal resource allocation; specifically, the QN model is used to identify bottlenecks, and predict the system performance as Cloud resources are allocated or released. Our approach has been validated through numerical simulations, whose results are reported in this paper
Efficient Performance models in Component-Based Software Engineering
No full textPerformance evaluation of Component-Based software systems should be performed as early as possible during the software development life cycle. Unfortunately, a de- tailed quantitative analysis is often not possible during such stages, as only the system outline is available, with very little quantitative knowledge. In this paper we propose an approach based on Queueing Network analysis for performance evaluation of component-based software systems at the software architectural level. Our approach provides performance bounds which can be efficiently computed. Starting from annotated UML diagrams we compute bounds on the system throughput and response time without explicitly deriving or solving the underlying multichain and multiclass Queueing Network model. We illustrate with an ex- ample how the technique can be applied to answer many performance-related questions which may arise during the software design phase
UML-PSI: the UML Performance SImulator
No full textIn this paper we describe UML-Ψ, a software performance evaluation tool based on process-oriented simulation. The tool can be used to evaluate performances of software systems described as annotated UML diagrams. UML-Ψ transforms the software model into a performance model based on process-oriented simulation, executes the performance model and collects results. Performance results are inserted into the software model as tagged values associated to the relevant UML elements
Performance Prediction of Web Service Workflows
No full textWeb Services play an important role in the Service-oriented
Architecture paradigm, as they allow services to be selected on-the-fly to
build applications out of existing components. In this scenario, the Business
Process Execution Language notation can be used as an orchestration
language which allows the user to describe interactions with Web
Services in a standard way. The performance of a BPEL workflow is a
very important factor for deciding which components must be selected,
or to choose whether a given sequence of interactions can provide the requested
quality of service. Due to its very dynamic nature, workflow performance
evaluation can not be accomplished using traditional, heavyweight
techniques. In this paper we present a multi-view approach for the
performance prediction of service-based applications encompassing both
users and service provider(s) perspectives. As a first step towards the
realization of this integrated framework we present an efficient approach
for performance assessment of Web Service workflows described using
the BPEL notation. Starting from annotated BPEL and WSDL specifications,
we derive performance bounds on response time and throughput.
In such a way users are able to assess the efficiency of a BPEL workflow,
while service provider(s) can perform sizing studies or estimate performance
gains of alternative upgrades to existing systems. To bring this
approach to fruition we developed a prototype tool called bpel2qnbound,
using which we analyze a simple case study
- …
