Towards the Reproduction of Selected Dynamic Loop Scheduling Experiments Using SimGrid-SimDag

Abstract

Modern computing architectures exhibit increasing parallelism. Therefore, dynamic loop scheduling (DLS) plays an increasing role in the performance optimization of parallel applications executing on the modern computing architectures. In the previous decades, there was a large body of research concerning DLS techniques. Reproduction of the DLS experiments is significant for ensuring the trustworthiness of the DLS techniques implementation in modern scheduling tools or within new scientific applications. The results of executing the implemented DLS techniques are expected to be in agreement with the results reported in earlier work. The present work is a step towards the reproduction of the experiments that introduced the well-known DLS technique named factoring (FAC). Studying scheduling techniques via simulation is favorable compared to native execution to have control over all the factors that may affect the performance. The use of simulation in this work is essential for the reproduction of the scheduling experiments performed on computing systems that no longer exist. This work shows that the self scheduling technique with matrix multiplication kernel has a significantly poorer performance on the modern system considered in this study than on the past system.

Performance Reproduction and Prediction of Selected Dynamic Loop Scheduling Experiments

“…The average of the absolute %E is 10.89% in all the scheduling experiments on the RP3 system and the SG-SD simulation results shown in the present work. For the results centralized process coordination [13], the minimum and the maximum absolute %E are 0.49%, and 30.94%, respectively, in the case of GSS -AC-d and 24 threads (see Figure 2(g)) and SS -AC-d and 56 threads (see Figure 2(f)). The average of the absolute %E is 7.44% between the simulative results [13] (SG-SD-C) and the native execution results [3].…”

“…For the results centralized process coordination [13], the minimum and the maximum absolute %E are 0.49%, and 30.94%, respectively, in the case of GSS -AC-d and 24 threads (see Figure 2(g)) and SS -AC-d and 56 threads (see Figure 2(f)). The average of the absolute %E is 7.44% between the simulative results [13] (SG-SD-C) and the native execution results [3]. The simulative results follow a similar trend to the original native experiments, which is of high relevance for the comparison of different scheduling techniques.…”

“…These results show that the simulation performance is close to the native performance in the original publication. The simulative performance of the same experiments using a centralized process coordination [13] (SG-SD-C) is also compared against the original native performance results [3] in Figure 2 Figure 2(b). The average of the absolute %E is 10.89% in all the scheduling experiments on the RP3 system and the SG-SD simulation results shown in the present work.…”

“…The performance results in terms of parallel cost of the native execution of the DLS techniques implemented using decentralized process coordination are compared to the performance results of the native execution using the centralized approach [13] in Figure 3. As can be observed from Figure 3, the parallel cost of the centralized process coordination increases as the number of threads increases.…”

“…Algorithm 3: SG-SD pseudocode -decentralized process coordination Input: platf ormF ile, numT hreads, kT ype, pSize, method Output: simulatedTime Data: schedulingStep, scheduledT asks, chunkSize, hosts, tasks, numT asks, dummyT ask, dummyComm, changedT asks 1 numT asks ← pSize × pSize 2 tasks ← CreateT asks(kT ype, pSize) 3 foreach i ∈ numT asks do 4 SD task watch(tasks[i], SD DONE) 5 end /* Create a computational task to represent create threads overhead */ 6 dummyT ask ← SD task create comp seq("createThreads", thread creation overhead according to numT hreads in FLOPs) 7 SD task schedule(dummyT ask, hosts[0]) Algorithm 3: SG-SD pseudocode -decentralized process coordination -continued /* Run the simulation until a task is completed */ 8 while ! (is empty(changedT asks=SD simulate(-1))) do 9 for i = 0 : numT hreads do 10 if (scheduledT asks < numT asks) and is free(hosts[i]) then 11 chunkSize ← calculate chunk size(numT asks, numT hreads, schedulingStep, method) /* Create a scheduling overhead task according to the scheduling method */ 12 dummyT ask ← SD task create comp seq("scheduling overhead", scheduling overhead in FLOPs correponding to method) 13 dummyComm ← SD task create end end comm("assigning chunk", chunkSize × pSize × 8) /* Add dependencies between calculating chunk overhead, assigning overhead and the start of the execution of the chunk of tasks */ Terminate the program A SG-SD sequential computation task is created to represent the scheduling overhead of each DLS technique. This task is scheduled on the available thread in each simulated scheduling round.…”