Bertels, Peter

English

Ghent University Academic Bibliography

Java and the Power of Multi-Core ProcessingPeter BertelsSupervisor: Dirk StroobandtAbstract—The new era of multi-core processing challenges software de-signers to efficiently exploit the parallelism that is now massively available.Programmers have to exchange the conventional sequential programmingparadigm for parallel programming: single-threaded designs must be de-composed into dependent, interacting tasks.The Java programming language has built-in thread support and istherefore suitable for the development of parallel software. We are workingon a framework and tool support to assist the programmer with the tedioustask of parallel programming.Keywords—Java; multi-core; parallel programmingI. INTRODUCTIONAC cording to Moore’s law the number of transistors on asingle die is doubling every two years. During the lastdecades this evolution has lead to an exponential performanceincrease because processor clock speeds also doubled at thesame rate. Due to power limitations this clock speed doublingcame to an end. Computer architects came up with the ideaof multi-core computing: large and complex processors are re-placed by simpler and slimmer cores working together.In this new era of multi-core computing, Moore’s law can beapplied to the number of cores. Current multi-core architec-tures consist of only a few cores, but this number is expectedto increase as exemplified by the announcement of an 80 corearchitecture by Intel.Software designers are challenged to efficiently exploit themassive parallelism available on these future multi-core archi-tectures. In Section II we discuss parallelisation of sequentialcode as a first attempt to meet the multi-core challenge and weexplain why this cannot completely solve the problems we arefaced with. We feel that software designers have to exchangethe conventional sequential programming paradigm for parallelprogramming. This transition requires a fundamentally differ-ent way of thinking about algorithms and programming prob-lems. We elaborate on the challenges imposed by this transitionin Section III.Parallel programming languages and programming modelsare needed to help programmers with this ‘parallel thinking’.Multi-threaded programming languages can be used to describeparallel behaviour, e.g. Java. We feel that Java alone is not suffi-cient, because multi-threaded programming is cumbersome. InSection IV we explain how Java can be extended to make it bet-ter suited for multi-core programming and we discuss relatedwork and similar approaches.II. WHY PARALLELISATION CANNOT SOLVE THE PROBLEMAfter more than 40 years of research in the field of parallelis-ing compilers, the results are still limited. For fairly simple andPeter Bertels is with the Department of Electronics and Information Systems(ELIS), Ghent University, Sint-Pietersnieuwstraat 41, B-9000 Gent, Belgium.E-mail: peter.bertels@ugent.be.regular code, loop nests in particular, parallelising is straight for-ward. But automatic parallelisation of irregular code with lotsof data dependencies is still not completely solved.Control dependencies severely limit the available parallelisa-tion. The control flow in useful and real-world applications isoften complex and highly data dependent. Lam et al. propose torelax the constraints imposed by control flow and they suggestseveral techniques: speculative execution, control dependenceanalysis and following multiple flows of control [1].Although these techniques for automatic parallelisation in-crease the possible parallelism in applications, these efforts arestill too limited to effectively use 80 cores on a multi-core ar-chitectures for general purpose applications. We can concludethat automatic parallelisation is useful for very regular applica-tions but that other applications require a more specific, manualapproach. Software designers have to adopt to the parallel pro-gramming paradigm and have to come up with new, inherentlyparallel, software solutions.III. CHALLENGES OF PARALLEL PROGRAMMINGThe most important challenge for parallel programmers is thedecomposition of a single application into several, dependentand interacting tasks. The efficiency of the parallel program ishighly dependent on this decomposition step: it determines thesynchronisation and communication overhead.Other challenges are synchronisation and communication be-tween parallel threads. Synchronising parallel threads is a te-dious task: synchronising too often leads to inefficient programexecution but not enough synchronisation can lead to incorrectresults due to data races or conditional hazards. Faulty synchro-nisation can lead to deadlocks.We identify load balancing as our fourth important challenge.If we can achieve an appropriate decomposition of the problemin several tasks that can be run on multiple cores, we have tothink about executing these tasks efficiently in parallel. Howcan we divide the work load equally among all these cores? Canwe avoid that some cores remain idle? A related challenge isscheduling of all these parallel threads and tasks.Finally we want to add scalability to our list of challenges. Ifwe want to execute the same application as well as on a multi-core architecture with 4 cores as on an architecture with 80cores, we have to think about scalability. Can we describe ourparallel algorithms in such a way that we can exploit the avail-able parallelism on an 80 core machine and nevertheless executethe same parallel program efficiently on a quad core?IV. CAN JAVA BE THE SOLUTION?The Java programming language has built-in thread support.Therefore, it seems a good candidate to become the ultimatelanguage for parallel programming. However, as Edward Leepointed out, there are some problems with threads. Threads arefundamentally flawed as a computation model because they arewildly nondeterministic [2]. Executing the same program twicecan lead to different results. Programmer’s are expected to prunethis determinism by adding synchronisation, semaphores, moni-tors etc. This is a tedious task and synchronisation errors are al-most impossible to avoid. Moreover synchronisation problemsoften remain undetected: the nondeterminism makes it difficult,if not impossible, to write test cases that cover all these possiblefaults.In this section we elaborate on several approaches to over-come the problem with Java threads: the zJava project devel-oped at the University of Toronto [3] and the DataRush frame-work developed by Pervasive Software [4].A. The zJava projectThe zJava project investigates automatic parallelisation ofJava programs [3]. The basic idea of this project is to combinea compile-time and a run-time method to exploit parallelismamong methods in Java applications. The zJava run-time sys-tems starts a new independent thread for each method invoca-tion. This thread executes asynchronously with the main threadwhich consists of the main method of the application. The run-time systems uses compile-time information about memory ac-cesses to determine when a thread may execute and which de-pendencies need to be enforced.Chan and Abdelrahman have evaluated their approach on aSun quad core multiprocessor. They report a scalable speedupwhen using 1, 2, 3 or 4 cores. For some benchmarks the idealspeedup, equal to the number of processors, was achieved.This approach overcomes the nondeterminism problem in thesense that the original program is fully sequential and that therun-time systems which creates the threads is supposed to dothis in a correct-by-construction manner. The zJava project isessentially an automatic parallelisation tool as explained in Sec-tion II: it helps the programmer to make use of the parallelismavailable in the sequential program, but it does not increase theparallelism. This seems to be a viable approach for speedingup applications on multi-core architectures with a few cores, de-pending on the inherent parallelism in the sequential program.B. Pervasive DataRushThe DataRush framework [4] developed by Pervasive Soft-ware enables the programmer to describe parallel programs asa directed dataflow graph in an XML based DataRush processcomposition language, DFXML. The basic operators in thisdataflow graph are written in standard Java. DFXML also al-lows to specify hierarchical dataflow graphs. A run-time systemcan execute these applications efficiently on a multi-core plat-form.DataRush provides special operators which can be used towrap collections of processes and other operators together.These operators can be used to express several forms of par-allel decomposition: horizontal decomposition, i.e. one processcan be duplicated on several cores to process multiple data ob-jects in parallel, vertical decomposition, i.e. several processescan process the same data object in parallel and pipelining. Therun-time systems uses this information to efficiently map theapplication on the given platform. The number of available pro-cessor cores determines the amount of parallel decomposition.The nondeterminism problem with threads is solved becausethe programmer has to specify interactions and dependenciesbetween threads explicitly. This framework is also scalable frommulti-core platforms with only a few cores to much larger multi-processors. The only drawback is that the DataRush frameworksomewhat limits the possibilities, e.g. cyclic dataflow graphscannot be represented — this is an easy way to guarantee dead-lock freedom — and processes can only communicate via inputand output streams whereas shared variables would be an inter-esting feature, especially if we want to transform legacy codefor single processing into code for multi-core platforms.C. The best of both worldsWe propose something which could be described as a com-bination of the aforementioned techniques. Currently we areworking on a theoretical basis for a new framework which will,as the DataRush framework, enable programmers to explic-itly describe interaction between processes described in Java,but which on the other hand would support communication viashared memory. Our research is currently focussed on the defi-nition of a subset of the shared memory paradigm which is lim-ited enough to guarantee that it would fit in such a frameworkbut which is nevertheless practically useful.V. CONCLUSIONS AND FUTURE WORKMulti-core architecture have recently become the name ofthe game in computer industry. These platforms provide mas-sive parallelism to software designer who are trained to writeinherently sequential code. In this article we summarised thechallenges these programmers are facing when they make thetransition from the conventional programming paradigm intothe new era of parallel programming. New programming mod-els and tools can support this transition. We described recentapproaches to extending the Java language to make it moresuitable for programming multi-core architectures and proposesome new ideas and extensions to alleviate the burden of parallelprogramming.In order for our new programming model to be useful we planto implement a run-time environment — built on top of the Javavirtual machine — to execute our parallel programs.ACKNOWLEDGMENTSPeter Bertels is supported by a PhD grant of the Institute forthe Promotion of Innovation through Science and Technologyin Flanders (IWT-Vlaanderen). His research is also partiallyfunded by the IWT grant 060086.REFERENCES[1] Monica S. Lam and Robert P. Wilson, “Limits of control flow on paral-lelism,” in ISCA 1992: Proceedings of the 19th annual international sym-posium on Computer architecture. 1992, pp. 46–57, ACM Press.[2] Edward A. Lee, “The problem with threads,” Computer, vol. 39, no. 5, pp.33–42, 2006.[3] Bryan Chan and Tarek S. Abdelrahman, “Run-time support for the auto-matic parallelization of Java programs,” Journal of Supercomputing, vol.28, pp. 91–117, 2004.[4] Pervasive DataRush, “A java framework for dataflow applications: unleashthe power of multi-core,” http://www.pervasivedatarush.com/.

Java and the power of multi-core processing

https://biblio.ugent.be/publication/417035/file/751354

Java and the power of multi-core processing

Abstract

Similar works

Full text

Available Versions

Ghent University Academic Bibliography