Ismail Ababneh

An efficient free-list submesh allocation scheme for two-dimensional mesh-connected multicomputers

This paper presents an efficient free-list submesh allocation scheme for two-dimensional mesh-connected systems. The scheme maintains an unordered list of free submeshes. For allocation, it selects the first free submesh that has at least the same size as the request, and when the selected submesh is larger than the request the part actually allocated is one that has the largest number of busy neighbors and mesh boundary processors. Whereas the best previously proposed schemes have time complexities that are either quadratic or cubic in the number of free or allocated submeshes, the time complexity of the proposed scheme is linear in the number of free submeshes. To evaluate the effectiveness of the scheme, its system performance in terms of parameters such as the average job turnaround time was compared to that of promising previously proposed schemes. Simulation results show that the scheme performs at least as well as these schemes, yet it has the lowest time complexity.

Non-contiguous processor allocation strategy for 2D mesh connected multicomputers based on sub-meshes available for allocation

Contiguous allocation of parallel jobs usually suffers from the degrading effects of fragmentation as it requires that the allocated processors be contiguous and has the same topology as the network topology connecting these processors. In non-contiguous allocation, a job can execute on multiple disjoint smaller sub-meshes rather than always waiting until a single sub-mesh of the requested size is available. Lifting the contiguity condition in non-contiguous allocation is expected to reduce processor fragmentation and increase processor utilization. However, the communication overhead is increased because the distances traversed by messages can be longer. The extra communication overhead depends on how the allocation request is partitioned and allocated to free sub-meshes. In this paper, a new noncontiguous processor allocation strategy, referred to as greedy-available-busy-list, is suggested for the 2D mesh network, and is compared using simulation against the well-known non-contiguous and contiguous allocation strategies. To show the performance improved by proposed strategy, we conducted simulation runs under the assumption of wormhole routing and all-to-all communication pattern. The results show that the proposed strategy can reduce the communication overhead and improve performance substantially in terms of turnaround times of jobs and finish times

An efficient non-contiguous processor allocation strategy for 2D mesh connected multicomputers

In non-contiguous allocation, a job request can be split into smaller parts that are allocated possibly non-adjacent free sub-meshes rather than always waiting until a single sub-mesh of the requested size and shape is available. Lifting the contiguity condition is expected to reduce processor fragmentation and increase system utilization. However, the distances traversed by messages can be long, and as a result the communication overhead, especially contention, is increased. The extra communication overhead depends on how the allocation request is partitioned and assigned to free sub-meshes. In this paper, a new non-contiguous processor allocation strategy, referred to as Greedy-Available-Busy-List, is suggested for the 2D mesh network. Request partitioning in our suggested strategy is based on the sub-meshes available for allocation. To evaluate the performance improvement achieved by our strategy and compare it against well-known existing non-contiguous and contiguous strategies, we conduct extensive simulation runs under the assumption of wormhole routing and three communication patterns, notably one-to-all, all-to-all and random. The results show that the new strategy can reduce the communication overhead and substantially improve performance in terms of job turnaround time and system utilization.

A new window-based job scheduling scheme for 2D mesh multicomputers

Allocating submeshes to jobs in mesh-connected multicomputers in a FCFS fashion can lead to poor system performance (e.g., long job waiting delays) because the job at the head of the waiting queue can prevent the allocation of free submeshes to other waiting jobs with smaller submesh requirements. However, serving jobs aggressively out-of-order can lead to excessive waiting delays for jobs with large allocation requests. In this paper, we propose a scheduling scheme that uses a window of consecutive jobs from which it selects jobs for allocation and execution. This window starts with the current oldest waiting job and corresponds to the lookahead of the scheduler. The performance of the proposed window-based scheme has been compared to that of FCFS and other previous job scheduling schemes. Extensive simulation results based on synthetic workloads and real workload traces indicate that the new scheduling strategy exhibits good performance when the scheduling window size is large. In particular, it is substantially superior to FCFS in terms of system utilization, average job turnaround times, and maximum waiting delays under medium to heavy system loads. Also, it is superior to aggressive out-of-order scheduling in terms of maximum job waiting delays. Window-based job scheduling can improve both overall system performance and fairness (i.e., maximum job waiting delays) by adopting large lookahead job scheduling windows.

Comparative evaluation of contiguous allocation strategies on 3D mesh multicomputers

The performance of contiguous allocation strategies can be significantly affected by the type of the distribution adopted for job execution times. In this paper, the performance of the existing contiguous allocation strategies for 3D mesh multicomputers is re-visited in the context of heavy-tailed distributions (e.g., a Bounded Pareto distribution). The strategies are evaluated and compared using simulation experiments for both First-Come-First-Served (FCFS) and Shortest-Service-Demand (SSD) scheduling strategies under a variety of system loads and system sizes. The results show that the performance of the allocation strategies degrades considerably when job execution times follow a heavy-tailed distribution. Moreover, SSD copes much better than FCFS scheduling strategy in the presence of heavy-tailed job execution times. The results also reveal that allocation strategies that employ a list of allocated sub-meshes for both allocation and de-allocation exhibit low allocation overhead, and maintain good system performance in terms of average turnaround time and mean system utilization.

On submesh allocation for 2D mesh multicomputers using the free-list approach: Global placement schemes

Two global placement schemes for contiguous processor allocation in two-dimensional mesh-connected multicomputers are proposed in this paper. The first scheme gives preference to allocating a free peripheral submesh that has the largest number of mesh-boundary processors. This peripheral placement has for goal producing large leftover free submeshes, which can improve system performance. Another characteristic of this scheme is that it reduces the search space by halting the search process when a large-enough multicomputer corner submesh is found. The second proposed scheme considers allocation in the corners of all large-enough free submeshes and allocates a submesh that has the maximum number of allocated neighbors and multicomputer peripheral nodes. Using extensive simulations, we evaluated the proposed schemes and compared them with previous promising schemes. The simulation results show that the peripheral placement scheme produces the best average turnaround times, and its measured allocation and de-allocation times are smaller than those of the previous schemes. The second proposed scheme ranks overall second in terms of turnaround times, however it is last in terms of efficiency.

Availability-based noncontiguous processor allocation policies for 2D mesh-connected multicomputers

Various contiguous and noncontiguous processor allocation policies have been proposed for mesh-connected multicomputers. Contiguous allocation suffers from high external processor fragmentation because it requires that the processors allocated to a parallel job be contiguous and have the same topology as the multicomputer. The goal of lifting the contiguity condition in noncontiguous allocation is reducing processor fragmentation. However, this can increase the communication overhead because the distances traversed by messages can be longer, and messages from different jobs can interfere with each other by competing for communication resources. The extra communication overhead depends on how the allocation request is partitioned and mapped to free processors. In this paper, we investigate a new class of noncontiguous allocation schemes for two-dimensional mesh-connected multicomputers. These schemes are different from previous ones in that request partitioning is based on the submeshes available for allocation. The available submeshes selected for allocation to a job are such that a high degree of contiguity among their processors is achieved. The proposed policies are compared to previous noncontiguous policies using detailed simulations, where several common communication patterns are considered. The results show that the proposed policies can reduce the communication overhead and improve performance substantially.

An Efficient Processor Allocation Strategy that Maintains a High Degree of Contiguity among Processors in 2D Mesh Connected Multicomputers

Two strategies are used for the allocation of jobs to processors connected by mesh topologies: contiguous allocation and non-contiguous allocation. In noncontiguous allocation, a job request can be split into smaller parts that are allocated to non-adjacent free sub- meshes rather than always waiting until a single sub-mesh of the requested size and shape is available. Lifting the contiguity condition is expected to reduce processor fragmentation and increase system utilization. However, the distances traversed by messages can be long, and as a result the communication overhead, especially contention, is increased. The extra communication overhead depends on how the allocation request is partitioned and assigned to free sub-meshes. This paper presents a new noncontiguous allocation algorithm, referred to as greedy-available-busy-list (GABL for short), which can decrease the communication overhead among processors allocated to a given job. The simulation results show that the new strategy can reduce the communication overhead and substantially improve performance in terms of parameters such as job turnaround time and system utilization. Moreover, the results reveal that the shortest- service-demand-first (SSD) scheduling strategy is much better than the first-come-first-served (FCFS) scheduling strategy.

A new processor allocation strategy with a high degree of contiguity in mesh-connected multicomputers

Abstract Relaxing the contiguity condition in non-contiguous allocation can reduce processor fragmentation and increase processor utilization. However, communication overhead could increase due to the potential increase in message distances. The communication overhead depends on how the allocation request is partitioned and allocated to free sub-meshes. In this paper, a new non-contiguous processor allocation strategy, referred to as Greedy-Available-Busy-List (GABL for short), is suggested for the mesh network, and is compared against the existing non-contiguous and contiguous allocation strategies. To demonstrate the performance gains achieved by our proposed strategy, we have conducted simulation runs under the assumption of wormhole routing technique. The results have revealed that the new strategy can reduce communication overhead and considerably improve performance in terms of the job turnaround time, system utilization, and jobs finish time.

Towards scalable collective communication for multicomputer interconnection networks

A considerable number of broadcast algorithms have been proposed for the mesh over the past decade. Nonetheless, most of these algorithms do not exhibit good scalability properties as the network size increases. As a consequence, most existing broadcast algorithms cannot efficiently support real-world parallel applications that require large-scale system sizes due to their high Computational demands. Motivated by these observations, this paper proposes the Nearest Side First Algorithm (or NSF for short) as a new adaptive broadcast algorithm for the mesh. One of the key results is that the performance of the NSF algorithm scales up well with the increase of processing elements, a feature not demonstrated by any previous broadcast algorithms, which enables the proposed algorithm to utilise massive parallel architectures with maximum effectiveness.