Publications

We focus on agent-based simulations where a large number of agents move in the space, obeying to some simple rules. Since such kind of simulations are computational intensive, it is challenging, for such a contest, to let the number of agents to grow and to increase the quality of the simulation. A fascinating way to answer to this need is by exploiting parallel architectures. In this paper, we present a novel distributed load balancing schema for a parallel implementation of such simulations. The purpose of such schema is to achieve an high scalability. Our approach to load balancing is designed to be lightweight and totally distributed: the calculations for the balancing take place at each computational step, and influences the successive step. To the best of our knowledge, our approach is the first distributed load balancing schema in this context. We present both the design and the implementation that allowed us to perform a number of experiments, with up-to 1,000,000 agents. Tests show that, in spite of the fact that the load balancing algorithm is local, the workload distribution is balanced while the communication overhead is negligible.

We present a load-balancing technique that exploits the temporal coherence, among successive computation phases, in mesh-like computations to be mapped on a cluster of processors. Our method partitions the computation in balanced tasks and distributes them to independent processors through the Prediction Binary Tree (PBT). At each new phase, current PBT is updated by using previous phase computing time (for each task) as (next phase) cost estimate. The PBT is designed so that it balances the load across the tasks as well as reduce dependency among processors for higher performances. Reducing dependency is obtained by using rectangular tiles of the mesh, of almost-square shape (i.e. one dimension is at most twice the other). By reducing dependency, one can reduce inter-processors communication or exploit local dependencies among tasks (such as data locality). Our strategy has been assessed on a significant problem, Parallel Ray Tracing. Our implementation shows a good scalability, and improves over coherence-oblivious implementations. We report different measurements showing that granularity of tasks is a key point for the performances of our decomposition/mapping strategy.

Grid is one of the first data structure introduced at the very beginning of computer graphics. Grids are used in several applications of computer graphics, especially in rendering algorithms. Lately, in ray tracing dynamic scenes, grid has received attention for its appealing linear time building time. In this paper, we aim to survey several aspects behind the use of grids in ray tracing. In particular we investigate grid traversal algorithms, building techniques and several approaches for hierarchical grids.

In this paper we estimate the effectiveness of exploiting coherence in Parallel Ray Tracing. We present a load-balancing technique which divides the original rendering problem in balanced subtasks and distribute them to independent processors through a Prediction Binary Tree (PBT). Furthermore the PBT allows to exploit temporal coherence among successive image frames. At each new frame, it updates the current PBT using a cost function which uses the previous rendering time as cost estimate. We also provide two heuristics which take advantage of data-locality. We assess the effectiveness of the proposed solution by running two experiments. The first one aims to investigate the accurancy of predictions made using the PBT. Results show that such predictions are quite accurate even considering a heavily unbalanced scene and a fast moving camera. The second experiment evaluates the two locality-aware heuristics showing a modest improvement.

In this paper we aim at exploiting the temporal coherence among successive phases of a computation, in order to implement a load-balancing technique in mesh-like computations to be mapped on a cluster of processors. A key concept on which the load balancing schema is built on the use of a Predictor component that is in charge of providing an estimation of the unbalancing between successive phases. By using this information, our method partitions the computation in balanced tasks through the Prediction Binary Tree (PBT). At each new phase, current PBT is updated by using previous phase computing time (for each task) as (next phase) cost estimate. The PBT is designed so that it balances the load across the tasks as well as reduces {\em dependency} among processors for higher performances. Reducing dependency is obtained by using rectangular tiles of the mesh, of almost-square shape (i.e. one dimension is at most twice the other). By reducing dependency, one can reduce inter-processors communication or exploit local dependencies among tasks (such as data locality). Furthermore, we also provide two heuristics which take advantage of data-locality. Our strategy has been assessed on a significant problem, Parallel Ray Tracing. Our implementation shows a good scalability, and improves performance in both cheaper commodity cluster and high performance clusters with low latency networks. We report different measurements showing that tasks granularity is a key point for the performances of our decomposition/mapping strategy.

Ray tracing algorithms are widely used for rendering images aiming at an high realism. Speeding up ray tracing for interactive use with parallel architectures has received a big impulse during last years. Despite several techniques are employed in order to amortize communication costs and manage load balancing, they still represents a bottleneck to the scalability. We consider a new way of manage load balancing based on adaptive subdivision, assuring higher scalability and performance, compatible with commonly used balancing techniques such as work stealing and work sharing.