Software standards for the multicore era

Recent advances in high-speed networks, rapid improvements in microprocessor design, and availability of highly performing clustering software implementations enables cost-effective high-performance parallel computing on clustered low cost workstations and PCs. Such clusters are very attractive because they rely on availability of the shelf hardware and software technologies. To simplify programming in network environments and to realise component-based software architectures, many models have emerged as possible standards, namely, RPC: Remote Procedure Call, DCE: Distributed Computing Environment, DCOM: Distributed Component Object Model, CORBA: Common Object Request Broker Architecture, PVM: Parallel Virtual Machine and MPI: Message Passing Interface. The MPI approach is considered one of the most mature methods currently used in parallel programming. MPI implementations an emerging cluster interconnects are an important requirement for useful parallel processing on cost-effective...

International Journal of Parallel Programming, 2016

The arrival of the multi-/many-core systems has produced a game-changing event for the computing industry, which today, much more than few years ago, is relying on parallel processing as a means of improving application performance. Although a wide gap still exists between parallel architectures and parallel programming maturity, the only way forward to keep increasing performance and reducing power consumption is through parallelism. Any program must become a parallel program in order to exploit the capabilities of modern computers at any scale. In the industrial practice, parallel programming is still dominated by low-level machine-centric unstructured approaches based on tools and specialized libraries that originate from high performance computing. Parallel programming at this level of abstraction is difficult, error-prone, time-consuming and, hence, economically infeasible in most application domains. Now, more than ever, it is crucial that the research community makes a significant progress toward making the development of parallel code accessible to all programmers, rather than allowing parallel programming to continue to be the domain of specialized expert programmers. Achieving a proper trade-off among performance, programmability and portability issues is becoming a must. Parallel and distributed programming methodologies are currently dominated by low-level techniques such as send/receive message passing or data sharing coordinated by locks. These abstractions are not a good fit for reasoning about parallelism. In this evolution/revolution phase, a fundamental role is played by high-level and portable programming tools as well as application development frameworks. They may offer

The development of multi-core technology has led to a great shift from sequential programming to parallel programming. This has made substantial challenges to software industries and government organizations to take full advantage of the performance intensification offered by the multi core systems. This paper aspires to compare and analyze the parallel computing ability offered by OpenMP(Open Multiprocessing), Intel Cilk Plus and MPI(Message passing Interface). Some proposals are also provided in parallel programming. The parallel programming features provided by these libraries are also studied and compared. The study is done by parallelizing problems related to Remote Sensing data processing which is large in volume and whose sequential processing is very much time consuming. This makes it pertinent to speed up the processing times by introducing parallelism in processing and for efficient utilization of multi processor multi core systems. The paper aims at exploring these libraries and studying the speed up achieved by using parallel processing and Data Parallelism paradigm.

2014

With the current trend towards the increased use of multicore processors, there is a growing need for simple, efficient parallel programming mechanisms. While Java has good support for multithreaded and distributed application development, our research into tuple-space systems for multicore processors highlighted a gap in the concurrency facilities available in Java. This arises in the context of independent applications (running in separate virtual machines) that need to synchronise their activities or communicate with each other. There are several possible solutions to this problem, ranging from extensions to the language and/or runtime environment through to the use of distributed programming methods. Using the latter introduces considerable performance overheads, and so we explored the use of the Java Native Interface in order to take advantage of the interprocess communication (IPC) facilities provided by the underlying operating system. The analysis and comparison of the perfo...

2010

In this paper we try to determine which the major problems a developer is confronted with, when building an automatic parallel compiler for legacy code. Most of the code for multicore systems is generated from old, legacy sequential code and the process should be optimized so the time and resources spent adapting it are reduced. The article studies the work done so far and the main solution found in order to automatically parallelize the code. Because the operation is complex and the results are hard to be predicted, the interaction with the user is a necessity. Most of the existing tools for automatic parallelization solved the problem only for particular cases and others are just semi-automatic.

Proceedings of the 7th …, 2008

Parallel programming is a challenging job in distributed community and depends upon the availability of suitable software tools and environment. And consequently, software developers have to face constraints such as nondeterminism, communication, synchronization, data partitioning ...

IEEE Micro, 2010

Parallel applications can benefit from the ability to explicitly control their thread scheduling policies in user-space. However, modern operating systems lack the interfaces necessary to make this type of "user-level" scheduling efficient. The key component missing is the ability for applications to gain direct access to cores and keep control of those cores even when making I/O operations that traditionally block in the kernel. A number of former systems provided limited support for these capabilities, but they have been abandoned in modern systems, where all efforts are now focused exclusively on kernel-based scheduling approaches similar to Linux’s. In many circles, the term "kernel" has actually become synonymous with Linux, and its Unix-based model of process and thread management is often assumed as the only possible choice. In this work, we explore the OS and runtime support required to resurrect user-level threading as a viable mechanism for exploiting parallelism on modern systems. The idea is that applications request cores, not threads, from the underlying system and employ user-level scheduling techniques to multiplex their own set of threads on top of those cores. So long as an application has control of a core, it will have uninterrupted, dedicated access to it. This gives developers more control over what runs where (and when), so they can design their algorithms to take full advantage of the parallelism available to them. They express their parallelism via core requests and their concurrency via user-level threads. We frame our work with a discussion of Akaros, a new, experimental operating system we developed, whose “Many-Core Process” (MCP) abstraction is built specifically with user-level scheduling in mind. The Akaros kernel provides low-level primitives for gaining direct access to cores, and a user-level library, called parlib, provides a framework for building custom threading packages that make use of those cores. From a parlib-based version of pthreads to a port of Lithe and the popular Go programming language, the combination of Akaros and parlib proves itself as a powerful medium to help bring user-level scheduling back from the dark ages.

Proceedings of the 42nd ACM technical symposium on Computer science education - SIGCSE '11, 2011

Multicore computers are now the norm. Taking advantage of these multiple cores entails parallel and concurrent programming. There is therefore a pressing need for courses that teach effective programming on multicore architectures.

IEEE Software, 2000

With the emergence of multicore and manycore processors, engineers must design and develop software in drastically new ways to bene t from the computational power of all cores. However, developing parallel software is much harder than sequential software because parallelism can't be easily abstracted away. Authors Hans Vandierendonck and Tom Mens provide an overview of technologies and tools to support developers in this complex and error-prone task. I look forward to hearing from both readers and prospective authors about this column and the technologies you want to know more about. -Christof Ebert SHARED-MEMORY ARCHITECTURES (such as multicore and manycore) have become commonplace, partly to continue to boost CPU performance. With single-core CPUs, this is no longer possible because CPU power dissipation limits further miniaturization. Multicore programming lets developers fully exploit the parallelization capabilities of software and hardware architecture to harness the computational power of all processors. However, it requires considerably more skills than sequential programming. This article discusses the state of the practice and current limitations of shared-memory parallel programming with modern programming languages as well as associated tools for multicore processors. To limit the scope of our discussion, we'll exclude heterogeneous solutions (for example, exploiting GPUs for parallel processing) and support for parallel programming in the supercom-puting and massively distributed computing domains (for example, grid computing).