Multiprogramming Level Research Articles

Analysis of balanced fork-join queueing networks

This paper presents an analysis of closed, balanced, fork-join queueing networks with exponential service time distributions. The fork-join queue is mapped onto two non-parallel networks, namely, a serial-join model and a state-dependent model. Using these models, it is proven that the proportion of the number of jobs in the different subsystems of the fork-join queueing network remains constant, irrespective of the multiprogramming level. This property of balanced fork-join networks is used to compute quick, inexpensive bounds for arbitrary fork-join networks.

Performance of recovery algorithms for centralized database management systems

Database recovery is responsible for preserving the database consistency after a failure of any kind (transaction, system or media). Relevant information solely for recovery is saved in a log during normal transaction processing. To recover from a failure, basically two operations: undo and redo are applied with the help of the log on the last consistent state of the database. These two operations can be combined in four different ways to define four different types of recovery algorithms: “undo-redo,” “no undo-redo,” “undo-no redo” and “no undo-no redo.” Each of these algorithms manages log and updates to the database differently, which affect the overall performance and the availability of the database. To our knowledge, not much work has been done on the performance of recovery algorithms. There are only six reports available and these works have concentrated their studies on only a few algorithms. They have mainly used a queuing approach, which we believe is not adequate for a detailed performance study. In this paper we investigate the relative performance of these four algorithms through simulation. The purpose of conducting this study is first, to verify the findings of earlier works, and second, to obtain a detailed comparison of the behavior of all recovery algorithms. Our simulation studies show that in most cases, undo-redo and no undo-redo deliver similar but better recovery performance than undo-no redo and no undo-no redo. We observe that the recovery times increase with multiprogramming level, but generally decrease as the number of checkpoints increases. The undo-no redo algorithm results in a greater number of transaction rollbacks, which creates a larger transaction log, and thus longer recovery times. Its performance increases against undo-redo and no undo-redo as input/output performance improves. Slow input/output performance is also attributed to be the cause of the no undo-no redo algorithm's poor recovery performance.

Inverted file partitioning schemes in multiple disk systems

Multiple-disk I/O systems (disk arrays) have been an attractive approach to meet high performance I/O demands in data intensive applications such as information retrieval systems. When we partition and distribute files across multiple disks to exploit the potential for I/O parallelism, a balanced I/O workload distribution becomes important for good performance. Naturally, the performance of a parallel information retrieval system using an inverted file structure is affected by the partitioning scheme of the inverted file. In this paper, we propose two different partitioning schemes for an inverted file system for a shared-everything multiprocessor machine with multiple disks. We study the performance of these schemes by simulation under a number of workloads where the term frequencies in the documents are varied, the term frequencies in the queries are varied, the number of disks are varied and the multiprogramming level is varied. >

Managing memory for real-time queries

The demanding performance objectives that real-time database systems (RTDBS) face necessitate the use of priority resource scheduling. This paper introduces a Priority Memory Management (PMM) algorithm that is designed to schedule queries in RTDBS. PMM attempts to minimize the number of missed deadlines by adapting both its multiprogramming level and its memory allocation strategy to the characteristics of the offered workload. A series of simulation experiments confirms that PMM's admission control and memory allocation mechanisms are very effective for real-time query scheduling.

Performance analysis of a concurrent file reorganization algorithm for record clustering

Presents a simulation-based performance analysis of a concurrent file reorganization algorithm. We examine the effect on throughput of (a) buffer size, (b) degree of reorganization, (c) write probability of transactions, (d) multiprogramming level, and (e) degree of clustered transactions. The problem of file reorganization that we consider involves altering the placement of records on pages of a secondary storage device. In addition, we want this reorganization to be done in place, i.e. using the file's original storage space for the newly reorganized file. Our approach is appropriate for a non-in-place reorganization as well. The motivation for such a physical change, i.e. record clustering, is to improve the database system's performance, i.e. minimizing the number of page accesses made in answering a set of queries. There are numerous record clustering algorithms, but they usually do not solve the entire problem, i.e., they do not specify how to efficiently reorganize the file to reflect the clustering assignment that they determine. In previous work, we have presented an algorithm that is a companion to general record clustering algorithms, i.e. it actually transforms the file. In this work we show through simulation that our algorithm, when run concurrently with user transactions, provides an acceptable level of overall database system performance.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Queueing models of concurrency control in database with Poisson arrivals

We study the mean performance of concurrency control in database with Poisson arrival. The computer system is formulated as open queueing systems with two cases, no waiting room case and unlimited waiting room case. To avoid the complexity of the state space, we propose two aggregate models, birth-death process and quasi-birth-death process, to predict system performance. The death rates of two models are defined by the throughput of closed systems. Instead of DC-trashing appeared in closed system, we obtain the monotonicity of response time and loss probability in birth-death models. From these properties we can obtain the optimal of multiprogramming level. In quasi-birth-death models we give the algorithms to calculate the equilibrium probability. We obtain numerical results from both analytic model and computer simulation. Comparisons show that the results of birth-death models and quasi-birth-death models are very similar, and the predictions of our models fit well with the simulation results.

Performance optimization of distributed-system models with unreliable servers

Models of distributed systems with servers subject to breakdown and repair are investigated for optimization of performance measures. The optimization problems are the cost minimization, response time minimization, and throughput maximization. The system is modeled by a preemptive-resume priority queuing network. The mean-value analysis algorithm is applied to derive a relationship between the multiprogramming level and performance measure formulas. Based on this relationship the Lagrange multiplier technique is applied to carry out the optimization of performance measures. Optimal service rates are obtained that reach a target throughput while minimizing the total cost. Servers are also treated individually in order to minimize the mean response time of a particular server in the system in order to find the optimal service rates which minimize the response time of a particular server while reaching a target throughput. Formulas are derived for determining the maximum throughput of the system; unfortunately, it has no closed-form solution. However, it can be solved using the binary search and insert value method. Numerical examples illustrate the solutions.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Factors affecting the performance of multiuser database management systems

While in the past 20 years database management systems (DBMS) have become a critical component of almost all organizations, their behavior in a multiuser environment has surprisingly not been studi...

The performance of flow graph locking

The performance of flow graph locking (FGL) is compared with that of two-phase locking (2PL). As the data sharing level increases, FGL has a better response time than 2PL. Regardless of the data sharing or multiprogramming levels, FGL usually facilitates a better throughput rate than 2PL. >

An analytical cache model

Trace-driven simulation and hardware measurement are the techniques most often used to obtain accurate performance figures for caches. The former requires a large amount of simulation time to evaluate each cache configuration while the latter is restricted to measurements of existing caches. An analytical cache model that uses parameters extracted from address traces of programs can efficiently provide estimates of cache performance and show the effects of varying cache parameters. By representing the factors that affect cache performance, we develop an analytical model that gives miss rates for a given trace as a function of cache size, degree of associativity, block size, subblock size, multiprogramming level, task switch interval, and observation interval. The predicted values closely approximate the results of trace-driven simulations, while requiring only a small fraction of the computation cost.

Analysis of catastrophic phenomena in a multiprogramming system

AbstractThis paper presents a state analysis of multiprogramming, using the concept of cusp catastrophe in the theory of catastrophe. Based on the result, the catastrophic phenomena in the multiprogramming system are analyzed. It is shown first that the multiprogramming system exhibits two stable states, i.e., monostable and bistable states, for the change of job generation rate and the change of the maximum multiprogramming level. Then it is shown that a rapid change (catastrophe) of the performance of the multiprogramming system, such as the mean number of jobs in the system, throughput and response time, may occur with the change of the stable state of the system. Furthermore, it is shown that for any given job generation rate, there exists a maximum multiprogramming level which maximizes the throughput and minimizes the response time.

The effects of two-phase locking on the performance of a distributed database management system

In this paper, the effects of two-phase locking on the performance of a distributed database management system are evaluated. In particular, the relationship between the average transaction response time for four concurrency control algorithms based on two-phase locking has been established with respect to the static degree of interference for a given multiprogramming level, database size, and transaction size. The increase in average probability of one lock request conflicting with another has been measured with respect to the static degree of interference and the percentage of aborted transactions has been measured for each algorithm. In addition, the impact of a number of parameters (e.g. data replication, lock predeclaration, time-out, local processing time, degree of locality of references, interarrival time, number of nodes and transmission time) on the performance of a distributed database management system in the presence of a concurrency control mechanism has also been measured. The study has been made using simulation and the SIMULA programming language.

Modeling the software architecture of a prototype parallel machine

A high-level Petri net model of the software architecture of an experimental MIMD multiprocessor system for Artificial Intelligence applications is derived by direct translation of the code corresponding to the assumed workload. Hardware architectural constraints are then easily added, and formal reduction rules are used to simplify the model, which is then further approximated to obtain a performance model of the system based on generalized stochastic Petri nets. From the latter model it is possible to estimate the optimal multiprogramming level of each processor so as to achieve the maximum performance in terms of overall throughput (number of tasks completed per unit time).

Locking performance in centralized databases

An analytic model is used to study the performance of dynamic locking. The analysis uses only the steady-state average values of the variables. The solution to the model is given by a cubic, which has exactly one valid root for the range of parametric values that is of interest. The model's predictions agree well with simulation results for transactions that require up to twenty locks. The model separates data contention from resource contention, thus facilitating an analysis of their separate effects and their interaction. It shows that systems with a particular form of nonuniform access, or with shared locks, are equivalent to systems with uniform access and only exclusive locks. Blocking due to conflicts is found to impose an upper bound on transaction throughput; this fact leads to a rule of thumb on how much data contention should be permitted in a system. Throughput can exceed this bound if a transaction is restarted whenever it encounters a conflict, provided restart costs and resource contention are low. It can also be exceeded by making transactions predeclare their locks. Raising the multiprogramming level to increase throughput also raises the number of restarts per completion. Transactions should minimize their lock requests, because data contention is proportional to the square of the number of requests. The choice of how much data to lock at a time depends on which part of a general granularity curve the system sees.

Integrated Performance Models for Distributed Processing in Computer Communication Networks

This paper deals with the analysis of large-scale closed queueing network (QN) models which are used for the performance analysis of computer communication networks (CCN's). The computer systems are interconnected by a wide-area network. Users accessing local/remote computers are affected by the contention (queueing delays) at the computer systems and the communication subnet. The computational cost of analyzing such models increases exponentially with the number of user classes (chains), even when the QN is tractable (product-form). In fact, the submodels of the integrated model are generally not product-form, e.g., due to blocking at computer systems (multiprogramming level constraints) and in the communication subnet (window flow control constraints). Two approximate solution methods are proposed in this paper to analyze the integrated QN model. Both methods use decomposition and iterative techniques to exploit the structure of the QN model such that computational cost is proportional to the number of chains. The accuracy of the solution methods is validated against each other and simulation. The model is used to study the effect that channel capacity assignments, window sizes for congestion control, and routing have on system performance.

On the applicability of using multiprogramming level distributions

A computer system's workload is represented by its multiprogramming level, which is defined as the number of tasks (jobs, customers) which actively compete for resources within the system. In a product-form queuing network model of the system, the workload is modeled by assuming that the multiprogramming level is either fixed (i.e., closed model) or that the multiprogramming level depends upon an outside arrival process (i.e., open model). However, in many actual systems, closed and open models are both inappropriate since the multiprogramming level is neither fixed nor governed by an outside arrival process. In an actual system., the multiprogramming level varies due to features such as task spawning, killing, blocking, parallel processing, and/or simultaneous resource possession. The multiprogramming level is a random variable with an associated distribution. This paper demonstrates that improved models can result from using this multiprogramming level distribution information. Several examples relative to open versus closed models, subsystem models, actual system models, and blocking models are given which demonstrate the applicability of using multiprogramming level distributions. This applicability, shown via the examples, is the main contribution of the paper. The examples also motivate interesting theoretical results relating to open models, closed models, and subsystem models.

Multiclass queueing networks with population constrainted subnetworks

A Multiclass Queueing Network model (MQN) is partitioned into a set of disjoint subnetworks. Population constraints are applied to each subnetwork such that within each subnetwork each population chain is either subject to an individual population constraint, or a group of chains may be subject to a common (shared) population constraint. Such population constraints are necessary in order to model multiprogramming level constraints in mainframe computer systems and window flow control mechanisms in computer communication networks. A computationally efficient approximate solution method is developed for solving MQN's with population constraints. Each subnetwork is reduced to a single approximately flow equivalent composite centre by assuming that the effect of other chains on a given chain can be adequately represented by their average customer populations. The accuracy of the population constraint approximation is compared against previous techniques by applying it to a set of test cases for which simulation solutions have previously been reported. The accuracy of the approximation technique is found to be good and in general is an improvement over previously published concurrency constraint approximations.

Sojourn Time Distribution in a Multiprogrammed Computer System

We present a method for calculating the moments and the distribution of sojourn time in a multiprogrammed computer system. We assume that the CPU and I/O subsystem can be represented by a general state-dependent server who works according to the processor sharing discipline. Further, at most m jobs may be simultaneously receiving service. Thus, m is the multiprogramming level of the system. The arrival of jobs occurs according to a Poisson process, and the arrivals must wait in a waiting area if m jobs are already receiving service. The method presented may be useful in designing the multiprogramming level needed to meet certain objectives on the characteristics of the sojourn time.

A methodology for database system performance evaluation

This paper presents a methodology for evaluating the performance of database management systems and database machines in a multiuser environment. Three main factors that affect transaction throughput in a multiuser environment are identified: multiprogramming level, degree of data sharing among simultaneously executing transactions, and transaction mix. We demonstrate that only four basic query types are needed to construct a benchmark that will evaluate the performance of a system under a wide variety of workloads. Finally, we present the results of applying our techniques to the Britton-Lee IDM 500 database machine

Parameter interdependencies of file placement models in a Unix system

A file assignment case study of a computer system running Unix is presented. A queueing network model of the system is constructed and validated. A modeling technique for the movement of files between and within disks is proposed. A detailed queueing network model is constructed for several file distributions in secondary storage. The interdependencies between the speed of the CPU , the swapping activity, the visit ratios and the multiprogramming level are examined and included in the modeling technique. The models predict the performance of several possible file assignments. The various file assignments are implemented and comparisons between the predicted and actual performance are made. The models are shown to accurately predict user response time.