Space-efficient scheduling of nested parallelism

In order to effectively utilize the broadcast bandwidth, it is necessary to have efficient on-line scheduling algorithms that can balance individual and overall performance and can scale in terms of database sizes and client populations. Moreover, the scheduling algorithm should be applicable to a heterogeneous environment where data items have different sizes. We address these issues in this paper. As stretch is widely adopted as a performance metric for variable-size data requests, we propose a broadcast scheduling algorithm to optimize the system performance in terms of stretch. We show by analysis that the proposed algorithm can indeed achieve the optimal performance in terms of stretch. Moreover, the proposed scheduling algorithm has very low decision overhead, which makes it a practical solution for on-demand broadcast scheduling. Simulation results demonstrate that our algorithm significantly outperforms existing scheduling algorithms under various scenarios.

Efficient scheduling algorithm is one of the key factors in determining the performance of distributed memory machines. This paper presents an enhanced Search and Du plication Based Scheduling (SDBS) algorithm which car schedule Directed Acyclic Graphs (DA Gs) with variable execution time tasks. Since the DAGs are based on data dependencies of the tasks, the control dependencies are clustered within each node. If the node encapsulates a loop or an if-then-else kind of statement, then assuming the execution times to be fixed would not be appropriate. It is assumed in this paper that the execution time varies between two time estimates. The complexity of this scheduling algorithm is in 0(V 4- E), where V is the number of node,- and E is the number of edges in the task graph. This algo rithm is based on some realistic assumptions and generates an optimal time schedule. If the assumptions cannot be completely satisfied then the algorithm provides a schedule which is close to optimal. The performance in these cases has been obtained using extensive simulation work which indicate the closeness of the results.

Efficient scheduling algorithms are key for attaining high performance in heterogeneous computing systems. In this article, we propose a new list scheduling algorithm for assigning task graphs to fully connected heterogeneous processors with an aim to minimize the scheduling length. The proposed algorithm, called Improved Predict Priority Task Scheduling (IPPTS) algorithm has two phases: task prioritization phase, which gives priority to tasks, and processor selection phase, which selects a processor for a task. The IPPTS algorithm has a quadratic time complexity as the related algorithms for the same goal, that is <inline-formula><tex-math notation="LaTeX">$O(t^{2} \times p)$</tex-math></inline-formula> , for <inline-formula><tex-math notation="LaTeX">$t$</tex-math></inline-formula> tasks and <inline-formula><tex-math notation="LaTeX">$p$</tex-math></inline-formula> processors. Our algorithm reduces the scheduling length significantly by looking ahead in both task prioritization phase and processor selection phase. In this way, the algorithm is looking ahead to schedule a task and its heaviest successor task to the optimistic processor, i.e., the processor that minimizes their computation and communication costs. The experiments based on both randomly generated graphs and graphs of real-world applications show that the IPPTS algorithm significantly outperforms previous list scheduling algorithms in terms of makespan, speedup, makespan standard deviation, efficiency, and frequency of best results.

Most static scheduling algorithms that schedule parallel programs represented by directed acyclic graphs (DAGs) are sequential. This paper discusses the essential issues on parallelization of static scheduling algorithms. An efficient parallel scheduling algorithm, the HPMCP algorithm, is proposed. It produces high-quality scheduling and is much faster than existing algorithms.

High efficient task scheduling algorithms can greatly influence the performance of reconfigurable systems. This paper analyzed the disadvantages of some current on-line reconfigurable system task scheduling algorithms, and proposed a new scheduling algorithm based on placement cost. This scheduling algorithm considered three types of cost, including hardware task execution time in FPGA, occupied FPGA area and fragmentation situation of FPGA, and also considered the unified scheduling of hardware and software tasks. When a hardware task was in scheduling, if the placement cost exceeded the setting threshold value, the task would be rejected to run in FPGA, but its software implementation could run in CPU. By reasonably rejecting some high cost tasks, this algorithm could achieve a higher overall successful scheduling rate. The simulation results show that this scheduling algorithm can achieve a higher deadline-guarantee ratio than others.

This paper presents a static scheduler which selects, from a set of scheduling algorithms, a subset of those which carry out the best assignment of a DAG representing an application program. To make that selection, some characteristics of the DAG, a decision model, and the evaluation parameters for choosing the best solution provided by the selected scheduling algorithms are defined. The selection of the scheduling algorithms is based on five decision levels. At each level, a subset of scheduling algorithms is selected. The final decision is made by carrying out an intersection operation between the subsets. When the scheduler was tested with a series of DAGs having different characteristics, the scheduler's decision was right 95% of the time in those cases in which the number of available processors is known, and 75% of the time when the number of processors is unbounded.

For better utilization of computing resources, it is important to consider parallel programming environments in which the number of available processors varies at runtime. In this paper, we discuss runtime support for data parallel programming in such an adaptive environment. Executing data parallel-programs in an adaptive environment requires redistributing data when the number of processors changes, and also requires determining new loop bounds and communication patterns for the new set of processors. We have developed a runtime library to provide this support. We also present performance results for a multiblock Navier-Stokes solver run on a network of workstations using PVM for message passing. Our experiments show that if the number of processors is not varied frequently, the cost of data redistribution is not significant compared to the time required for the actual computations. >

The performance of the multiprocessor system and time-sharing system rely upon CPU scheduling algorithm. Some of the well known efficient CPU scheduling algorithms are Round Robin scheduling (RR), Shortest job first(SJF), Preemptive version of SJF(SRTF), First Come First Serve (FCFS) etc. As of now, the Round Robin scheduling algorithm is considered as the efficient process scheduling algorithm among all the existing CPU scheduling algorithms. However, in RR the shortest one have to wait for a longer time and in SRTF longer process behaves as a suspended process as short tasks keep on executing. This paper proposes a new scheduling process algorithm ESRR (Efficient Shortest Remaining Time Round Robin) that consolidate two of the preemptive version of existing scheduling algorithms namely RR and SRTF. ESRR reduces total waiting time and turn around time in compare to RR and reduces the waiting time of the shorter process and it also provides a longer process to execute faster than SRTF.

Location-awareness plays a key role in various applications in future wireless networks. In GPS-challenged environments, location-awareness can be achieved via wireless navigation networks, which call for an efficient scheduling algorithm to optimize the navigation performance under communication constraints. In this paper, we develop a general framework for the design and analysis of scheduling algorithms for navigation networks with multiple measurement pairs per time slot. In particular, we provide sufficient and necessary conditions for the stability of the error evolution, and derive bounds on the time-averaged network localization errors (NLEs) for opportunistic and random scheduling. Furthermore, we show that the two scheduling algorithms are optimal in terms of the error scaling with respect to the number of agents, and we quantify the performance gain from measurement pair selections exploiting the network states. These results provide guidelines for designing efficient scheduling algorithms for network navigation.

Network services that dynamically allocate bandwidth resources, such as QoS and layer-1 bandwidth-on-demand(BoD), are increasingly required to advanced Internet backbones, such as science information networks (SINET) in Japan. In this paper, we propose scheduling algorithms for BoD service which allocate parts of full bandwidth dedicated to specific users according to their requests in advanced Internet backbones. The scheduling algorithms maximize the number of accepted requests, fairness, or the total bandwidth in BoD. Simulation results show that the proposed algorithms achieve high utilization of network resources and user’s fairness, compared with a simple random-based algorithm.

Job scheduling is an important issue in computational grid. In computational grid, computing resources are connected through networks and may locate at different network or regional areas. So, the computational capabilities or network status of computing resources may be different. If we want to take advantage of computational grid, an efficient scheduling algorithm is necessary to assign jobs to the appropriate computing nodes. In this paper, we propose a genetic algorithm based evolutional algorithm (G-EA) to solve the scheduling problems in computational grid. The proposed algorithm uses the optimal searching technique of genetic algorithm and takes different computing capabilities of computing nodes and dynamic network status into consideration. In order to verify the performance of G-EA, a simulation was performed, and it was then compared with four other scheduling algorithms. The results show that the proposed G-EA outperformed all other schedulers across a range of scenarios.

This paper presents a scheduling model for a class of interactive services in which requests are time bounded and lower result quality can be traded for shorter execution time. These applications include web search engines, finance servers, and other interactive, on-line services. We develop an efficient scheduling algorithm, Zeta, that allocates processor time among service requests to maximize the quality and minimize the variance of the response. Zeta exploits the concavity of the request quality profile to distribute processing time among outstanding requests. By executing some requests partially (and obtaining much or most benefit of a full execution), Zeta frees resources for other requests, which might have timed out and produced no results. Compared to scheduling algorithms that consider only deadline or quality profile information, Zeta improves overall response quality and reduces response quality variance, yielding significant improvement in the high-percentile response quality. We implemented and deployed Zeta in the Microsoft Bing web search engine and evaluated its performance in a production environment with realistic workloads. Measurements show that at the same response quality and latency as the production system, Zeta increases system capacity by 29% by improving both average and high percentile response quality. We also implemented Zeta in a finance server that computes option prices. In this application, Zeta improves average response quality by 28% and the 99-percentile quality by 80%. Using a simulation, we also compared Zeta to the offline optimal schedule and other scheduling algorithms. Although Zeta is only close to optimal, it provides better performance than prior algorithms under a wide variety of operating conditions.

Aim: Our research aims to explore a fast and efficient scheduling algorithm. The purpose is to schedule large-scale tasks on a limited number of processors reasonably while improving resource utilization. Methods: This paper proposes a clustering and duplication-based method for large-scale task scheduling on a limited amount of processors. We cluster large-scale task to reduce the scale of the task in our method at first. Second, duplication-based task scheduling is carried out. Third, we optimize the local effect more precisely by deduplication in the last stage. Results: We compare our algorithm with the state-of-the-art algorithms in the article. The results demonstrate that our scheduling scheme obtains about 30% optimization compared to existing large-scale scheduling methods and runs roughly ten times faster than existing duplication-based algorithms when scheduling large-scale tasks to a limited number of processors as compared to similar algorithms. Conclusion: In this paper, we propose a task scheduling algorithm that can decrease the scheduling time of large- scale tasks on a limited number of processors and speed up the global execution time of the task. Further, we will study large-scale task scheduling on heterogeneous processor clusters. Keywords

The running time and memory requirement of a parallel program with dynamic, lightweight threads depends heavily on the underlying thread scheduler. In this paper we present a new asynchronous, space-efficient scheduling algorithm for shared memory machines that combines the low scheduling overheads and good locality of work stealing with the low space requirements of depth-first schedulers. For a nested-parallel program with depth D and serial space requirement S 1 , we show that the expected space requirement is S 1 + O(K⋅ p⋅ D) on p processors. Here, K is a user-adjustable runtime parameter, which provides a tradeoff between running time and space requirement. Our algorithm achieves good locality and low scheduling overheads by automatically increasing the granularity of the work scheduled on each processor. We have implemented the new scheduling algorithm in the context of a native, user-level implementation of Posix standard threads or Pthreads, and evaluated its performance using a set of C-based benchmarks that have dynamic or irregular parallelism. We compare the performance of our scheduler with that of two previous schedulers: the thread library's original scheduler (which uses a FIFO queue), and a provably space-efficient depth-first scheduler. At a fine thread granularity, our scheduler outperforms both these previous schedulers, but requires marginally more memory than the depth-first scheduler. We also present simulation results on synthetic benchmarks to compare our scheduler with space-efficient versions of both a work-stealing scheduler and a depth-first scheduler. The results indicate that unlike these previous approaches, the new algorithm covers a range of scheduling granularities and space requirements, and allows the user to trade the space requirement of a program with the scheduling granularity.

In order to offload base station (BS) traffic and to enhance efficiency of spectrum, operators can activate many Device-to-Device (D2D) pairs or links in LTE networks. This increases the overall spectral efficiency because the same Resource Blocks (RBs) are used across cellular UEs (CUEs) (i.e., all UEs connected to BS for both C-Plane and D-plane communication) and D2D links (i.e., where the UEs are connected to BS only for C-plane communication). However, significant interference problems can be caused by D2D communications as the same RBs are being shared. In our work, we address this problem by proposing a novel scheduling algorithm, Efficient Scheduling and Power control Algorithm for D2Ds (ESPAD), which reuses the same RBs and tries to maximize the overall network throughput without affecting the CUEs throughput. ESPAD algorithm also ensures that Signal to Noise plus Interference Ratio (SINR) for each of the D2D links is maintained above a certain predefined threshold. The aforementioned properties of ESPAD algorithm makes sure that the CUEs do not experience very high interference from the D2Ds. It is observed that even when the SINR drop (i.e., maximum permissible drop in SINR of CUEs) is as high as 10 dB, there is no drastic decrease in CUEs throughput (only 3.78%). We also compare our algorithm against other algorithms and show that D2D throughput improves drastically without undermining CUEs throughput.