Gian Carlo Bongiovanni

Parallel simulated annealing for shape detection

Abstract In this paper, we describe two parallel implementations of the simulated annealing method applied to the shape detection problem. The first is a massively parallel implementation on an SIMD mesh-connected architecture; the second uses an MIMD model of computation. The main focus of the paper is on restructuring the basic simulated annealing algorithm to execute on a multiprocessor. We show how to select appropriate sets of perturbations to be attempted at different temperatures to obtain good speed-ups. We give experimental results for the serial version of the algorithm applied to the detection of ellipses and parallelograms; we also present results obtained on an MIMD computer, the ENCORE MULTIMAX.

Parallel prefix computation on a pyramid computer

Abstract The initial prefix problem is to compute all n initial prefixes a1,a1°a2,…,a1°a2°…°an, given n elements a1, a2, …, an and a binary, associative operation denoted °. In this paper we present a parallel algorithm for the solution of such a problem on a pyramid computer. The algorithm is optimal, since for n elements it requires O(n/lg n) processors and O(lg n) time (excluding the time to load the image).

Computing the Hough transform on a pyramid architecture

An algorithm to implement the Hough transform for the detection of a straight line on a pyramidal architecture is presented. The algorithm consists of two phases. The first phase, called block-projection, takes constant time. The second phase, called block-combination, is repeated logn times and takes a total ofO(n1/2) time for the detection of all straight lines having a given slope on an n×n image; if there arep different slopes to be detected, then the total time becomesO(pn1/2).

Self-* through self-learning: Overload control for distributed web systems

Overload control is a challenging problem for web-based applications, which are often prone to unexpected surges of traffic. Existing solutions are still far from guaranteeing the necessary responsiveness under rapidly changing operative conditions. We contribute an original self-* overload control (SOC) algorithm that self-configures a dynamic constraint on the rate of incoming new sessions in order to guarantee the fulfillment of the quality requirements specified in a service level agreement (SLA). Our algorithm is based on a measurement activity that makes the system capable of self-learning and self-configuring even in the case of rapidly changing traffic scenarios, dynamic resource provisioning or server faults. Unlike other approaches, our proposal does not require any prior information about the incoming traffic, or any manual configuration of key parameters. We ran extensive simulations under a wide range of operating conditions. The experiments show how the proposed system self-protects from overload, meeting SLA requirements even under intense workload variations. Moreover, it rapidly adapts to unexpected changes in available capacity, as in the case of faults or voluntary architectural adjustments. Performance comparisons with other previously proposed approaches show that our algorithm has better performance and more stable behavior.

Self-* Overload Control for Distributed Web Systems

Unexpected increases in demand and most of all flash crowds are considered the bane of every Web application as they may cause intolerable delays or even service unavailability. Proper quality of service policies must guarantee rapid reactivity and responsiveness even in such critical situations. Previous solutions fail to meet common performance requirements when the system has to face sudden and unpredictable surges of traffic. Indeed they often rely on a proper setting of key parameters which requires laborious manual tuning, preventing a fast adaptation of the control policies. We contribute an original self-overload control (SOC) policy. This allows the system to self-configure a dynamic constraint on the rate of admitted sessions in order to respect service level agreements and maximize the resource utilization at the same time. Our policy does not require any prior information on the incoming traffic or manual configuration of key parameters. We ran extensive simulations under a wide range of operating conditions, showing that SOC rapidly adapts to time varying traffic and self-optimizes the resource utilization. It admits as many new sessions as possible in observance of the agreements, even under intense workload variations. We compared our algorithm to previously proposed approaches highlighting a more stable behavior and a better performance.

XOR-Based Schemes for Fast Parallel IP Lookups

Abstract An IP router must forward packets at gigabit speed in order to guarantee a good quality of service. Two important factors make this task a challenging problem: (i) for each packet, the longest matching prefix in the forwarding table must be quickly computed; (ii) the routing tables contain several thousands of entries and their size grows significantly every year. Because of this, parallel routers have been developed which use several processors to forward packets. In this work we present a novel algorithmic technique which, for the first time, exploits the parallelism of the router also to reduce the size of the routing table. Our method is scalable and requires only minimal additional hardware. Indeed, we prove that any IP routing table T can be split into two subtables T1 and T2 such that: (a) |T1| can be any positive integer k ≤ |T| and |T2| ≤ |T| - k + 1; (b) the two routing tables can be used separately by two processors so that the IP lookup on T is obtained by simply XOR-ing the IP lookup on the two tables. Our method is independent of the data structure used to implement the lookup search and it allows for a better use of the processors L2 cache. For real routers routing tables, we also show how to achieve simultaneously: (a) |T1| is roughly 7% of the original table T; (b) the lookup on table T2 does not require the bestmatching prefix computation.

An Autonomic Admission Control Policy for Distributed Web Systems

This paper tackles the problem of autonomic admission control for web clusters. The main contribution of this work is the proposal of a new session admission algorithm that self-configures a dynamic constraint on the rate of incoming new sessions to guarantee the respect of Service Level Agreements (SLA). Unlike other approaches, our policy does not need any prior information on the incoming traffic, nor any assumption on the probability distribution of request inter-arrival or service time. Furthermore, it does not require any manual configuration or parameter tuning. We performed extensive simulations under a range of operating conditions and compared our algorithm to other previously proposed approaches. The simulations show that our policy rapidly adapts to the given traffic profile and improves service throughput while respecting the response time constraints imposed by the SLAs. It also improves service quality by reducing the oscillations of response time and number of active clients common to other policies.

Minimal deadlock-free store-and-forward communication networks

Store-and-forward communication networks may be designed so as to be free from store-and-forward deadlock. This is accomplished by incorporating in the network an acyclic buffer graph on which messages are forwarded, from buffer to buffer, according to all the desired routes. A technique producing minimum buffer graphs for a rather large class of networks is illustrated. Successively, a comparison is made with other well-known deadlock avoidance techniques, showing that substantial savings can be achieved.

XOR-based schemes for fast parallel IP lookups

An IP router must forward packets at gigabit speed in order to guarantee a good QoS. Two important factors make this task a challenging problem: (i) for each packet, the longest matching prefix in the forwarding table must be computed; (ii) the routing tables contain several thousands of entries and their size grows significantly every year. Because of this, parallel routers have been developed which use several processors to forward packets. In this work, we present a novel algorithmic technique which, for the first time, exploits the parallelism of the router to also reduce the size of the routing table. Our method is scalable and requires only a minimal additional hardware. Indeed, we prove that any IP routing table T can be split into two subtables T1 and T2 such that: (a) |T1| can be any positive integer k ≤ |T| and |T2| ≤ |T|-k; (b) the two routing tables can be used separately by two processors so that the IP lookup on T is obtained by simply XOR-ing the IP lookup on the two tables. Our method is independent on the data structure used to implement the lookup search and it allows for a better use of the processors L2 cache. For real routers routing tables, we also show how to achieve simultaneously: (a) |T1| is roughly 7% of the original table T; (b) the lookup on table T2 does not require the best matching prefix computation.