Parallel job scheduling and allocation has long been an important research topic [1][2][3].
Users at traditional supercomputing centers usually need to specify the amount of processors to use when submitting a parallel job. The workload management system and job scheduler will allocate computing resources to each job according to the specified processor requirement. If the specified amount of processors is larger than current available resources, the job would have to wait while the available resources are kept idle, resulting in degraded resource utilization and job turnaround time.
The above situation might be unavoidable when running rigid jobs [4], which can only run with a specific amount of processors, or conducting performance benchmarking, e.g. drawing the speedup curve. However, most modern parallel applications, e.g. those written with MPI [5], usually have the moldable property [4], which allows them to exploit different parallelisms for execution at runtime. In such cases, system performance could be improved through adaptive processor allocation taking advantage of the moldable property [4]. Here, adaptive processor allocation means users and job schedulers have the flexibility to select a suitable amount of processors for job execution, considering both jobs’ parallelism characteristics and the amount of available resources at that moment. Some existing High-Performance Computing (HPC) workload management systems already support moldable job submission. For example, Load Sharing Facility(or simply LSF) [6],one of the most famous commercial HPC workload management system owned by IBM, allows users to specify a range of processor requirement, instead of a specific amount of processors, when submitting a moldable job. However, its scheduling mechanism for moldable jobs is quite primitive, simply adopting a greedy method
to allocate as many processors as possible within the range specified by a moldable job upon submission.
High performance computing (HPC) has long been a very important field for solving large-scale and complex scientific and engineering problems. However, accessing and running applications on HPC systems remains tedious, limiting wider adoption and user population [7]. As cloud computing emerges [8], which emphasizes easier and efficient access to IT infrastructure, recently the concept of HPC as a Service (HPCaaS) [7] was proposed to transform HPC facilities and applications into a more convenient and accessible service model. Unlike users at traditional supercomputing centers, who usually run parallel programs developed by themselves, most HPCaaS users run parallel applications developed by others and do not have a clear picture about the parallelism characteristics of the underlying applications. In such cases, users simply want to get their jobs done as soon as possible and don’t want or even have no idea on how to specify an appropriate amount of processors for the application’s execution.
Therefore, moldable job scheduling becomes a crucial research issue for HPCaaS in the following two aspects. Firstly, it relieves users’ burden of selecting an appropriate number of processors upon job submission, leading to a much easier and convenient user experience for HPCaaS. Secondly, moldable job scheduling has the potential to improve the average turnaround time of parallel applications and the overall resource utilization, benefiting both HPCaaS users and providers. On the other hand, moldable job scheduling is also more feasible in HPCaaS since the parallelism characteristics and speedup model of the parallel applications are more likely to be available than those of home-made parallel programs on traditional supercomputers.
Logically, moldable job scheduling approaches can be classified into four categories, as shown in Figure 1.1, according to two important aspects: submit-time or schedule-time decision and having job runtime information or not. Here, the job runtime information is the expected processor execution time required to process a job’s workload. Several moldable job scheduling approaches has been proposed in previous research [9][10][11], which fall into the categories in Figure 1.1 except the one without runtime information and making moldable decisions at submission time. In general, the approaches at schedule-time have potential to outperform the approaches at submit-time since job schedulers would have more accurate runtime information and greater flexibility in choosing an appropriate amount of processors for a specific job at schedule-time.
Therefore, in this thesis, we focus on the two schedule-time categories and propose three moldable job scheduling approaches which take advantage of the application speedup models to make appropriate processor allocation decisions at schedule time, falling into categories II and III in Figure 1.1.
Figure 1.1: Moldable job scheduling quadrants
Information about parallel program behavior is crucial for job schedulers to automatically choose effective amounts of processors for applications. In this thesis, we consider three commonly used parallel speedup models: linear speedup [12], Amdahl’s law [13] and Downey’s speedup model [14][15], which have been shown capable of representing the workload characteristics of both real parallel applications and entire system workload, such as NAS benchmarks [16], SDSC workload [17], and CTC workload [17].
The proposed moldable job scheduling approaches have been evaluated through a series of simulation experiments with different application speedup models and workload conditions.
The experimental results indicate that our approaches have potential to outperform existing moldable job scheduling approaches, achieving up to 83%, 78% and 89% performance improvement, respectively.
The remainder of this thesis is organized as follows. Chapter 2 discusses related works on moldable job scheduling. The moldable job scheduling approaches without runtime information is described in chapter 3. Chapter 4 presents the moldable job scheduling approaches taking advantage of job runtime information. Chapter 5 presents the experiments and the results of performance evaluation. Chapter 6 concludes this thesis.