2 research outputs found
Pure functions in C: A small keyword for automatic parallelization
© 2017 IEEE. The need for parallel task execution has been steadily growing in recent years since manufacturers mainly improve processor performance by scaling the number of installed cores instead of the frequency of processors. To make use of this potential, an essential technique to increase the parallelism of a program is to parallelize loops. However, a main restriction of available tools for automatic loop parallelization is that the loops often have to be 'polyhedral' and that it is, e.g., not allowed to call functions from within the loops.In this paper, we present a seemingly simple extension to the C programming language which marks functions without side-effects. These functions can then basically be ignored when checking the parallelization opportunities for polyhedral loops. We extended the GCC compiler toolchain accordingly and evaluated several real-world applications showing that our extension helps to identify additional parallelization chances and, thus, to significantly enhance the performance of applications
Impact of the scheduling strategy in heterogeneous systems that provide co-scheduling [extended version]
In recent years, the number of processing units per compute node has
been increasing. In order to utilize all or most of the available resources of a highperformance computing cluster, at least some of its nodes will have to be shared by
several applications at the same time. Yet, even if jobs are co-scheduled on a node,
it can happen that high performance resources remain idle, although there are jobs
that could make use of them (e. g., if the resource was temporarily blocked when
the job was started). Heterogeneous schedulers, which schedule tasks for different
devices, can bind jobs to resources in a way that can significantly reduce the idle
time. Typically, such schedulers make their decisions based on a static strategy.
We investigate the impact of allowing a heterogeneous scheduler to modify its
strategy at runtime. For a set of applications, we determine the makespan and show
how it is influenced by four different scheduling strategies. A strategy tailored to
one use case can be disastrous in another one and can consequently even result in a
slowdown - in our experiments of up to factor 2.5