3,361 research outputs found
Vienna FORTRAN: A FORTRAN language extension for distributed memory multiprocessors
Exploiting the performance potential of distributed memory machines requires a careful distribution of data across the processors. Vienna FORTRAN is a language extension of FORTRAN which provides the user with a wide range of facilities for such mapping of data structures. However, programs in Vienna FORTRAN are written using global data references. Thus, the user has the advantage of a shared memory programming paradigm while explicitly controlling the placement of data. The basic features of Vienna FORTRAN are presented along with a set of examples illustrating the use of these features
Extending HPF for advanced data parallel applications
The stated goal of High Performance Fortran (HPF) was to 'address the problems of writing data parallel programs where the distribution of data affects performance'. After examining the current version of the language we are led to the conclusion that HPF has not fully achieved this goal. While the basic distribution functions offered by the language - regular block, cyclic, and block cyclic distributions - can support regular numerical algorithms, advanced applications such as particle-in-cell codes or unstructured mesh solvers cannot be expressed adequately. We believe that this is a major weakness of HPF, significantly reducing its chances of becoming accepted in the numeric community. The paper discusses the data distribution and alignment issues in detail, points out some flaws in the basic language, and outlines possible future paths of development. Furthermore, we briefly deal with the issue of task parallelism and its integration with the data parallel paradigm of HPF
SVM Support in the Vienna Fortran Compilation System
Vienna Fortran, a machine-independent language extension to Fortran which allows the user to write programs for distributed-memory systems using global addresses, provides the forall-loop construct for specifying irregular computations that do not cause inter-iteration dependences. Compilers for distributed-memory systems generate code that is based on runtime analysis techniques and is only efficient if, in addition, aggressive compile-time optimizations are applied. Since these optimizations are difficult to perform we propose to generate shared virtual memory code instead that can benefit from appropriate operating system or hardware support. This paper presents the shared virtual memory code generation, compares both approaches and gives first performance results
A Survey on Parallel Architecture and Parallel Programming Languages and Tools
In this paper, we have presented a brief review on the evolution of parallel computing to multi - core architecture. The survey briefs more than 45 languages, libraries and tools used till date to increase performance through parallel programming. We ha ve given emphasis more on the architecture of parallel system in the survey
High Performance FORTRAN
High performance FORTRAN is a set of extensions for FORTRAN 90 designed to allow specification of data parallel algorithms. The programmer annotates the program with distribution directives to specify the desired layout of data. The underlying programming model provides a global name space and a single thread of control. Explicitly parallel constructs allow the expression of fairly controlled forms of parallelism in particular data parallelism. Thus the code is specified in a high level portable manner with no explicit tasking or communication statements. The goal is to allow architecture specific compilers to generate efficient code for a wide variety of architectures including SIMD, MIMD shared and distributed memory machines
HPF-2 Support for Dynamic Sparse Computations
This is a post-peer-review, pre-copyedit version of an article published in Lecture Notes in Computer Science. The final authenticated version is available online at: https://doi.org/10.1007/3-540-48319-5_15[Abstract] There is a class of sparse matrix computations, such as direct solvers of systems of linear equations, that change the fill-in (nonzero entries) of the coefficient matrix, and involve row and column operations (pivoting). This paper addresses the problem of the parallelization of these sparse computations from the point of view of the parallel language and the compiler. Dynamic data structures for sparse matrix storage are analyzed, permitting to efficiently deal with fill-in and pivoting issues. Any of the data representations considered enforces the handling of indirections for data accesses, pointer referencing and dynamic data creation. All of these elements go beyond current data-parallel compilation technology. We propose a small set of new extensions to HPF-2 to parallelize these codes, supporting part of the new capabilities on a runtime library. This approach has been evaluated on a Cray T3E, implementing, in particular, the sparse LU factorization.Ministerio de Educación y Ciencia; TIC96-1125-C03Xunta de Galicia; XUGA20605B96European Commision; BRITE-EURAM III BE95-1564European Commision; ERB4050P192166
User-Defined Data Distributions in High-Level Programming Languages
One of the characteristic features of today’s high performance
computing systems is a physically distributed
memory. Efficient management of locality is essential
for meeting key performance requirements for these architectures.
The standard technique for dealing with
this issue has involved the extension of traditional sequential
programming languages with explicit message passing,
in the context of a processor-centric view of
parallel computation. This has resulted in complex and
error-prone assembly-style codes in which algorithms
and communication are inextricably interwoven.
This paper presents a high-level approach to the design
and implementation of data distributions. Our
work is motivated by the need to improve the current
parallel programming methodology by introducing
a paradigm supporting the development of efficient and
reusable parallel code. This approach is currently being
implemented in the context of a new programming
language called Chapel, which is designed in the HPCS
project Cascade
dotCall64: An Efficient Interface to Compiled C/C++ and Fortran Code Supporting Long Vectors
The R functions .C() and .Fortran() can be used to call compiled C/C++ and
Fortran code from R. This so-called foreign function interface is convenient,
since it does not require any interactions with the C API of R. However, it
does not support long vectors (i.e., vectors of more than 2^31 elements). To
overcome this limitation, the R package dotCall64 provides .C64(), which can be
used to call compiled C/C++ and Fortran functions. It transparently supports
long vectors and does the necessary castings to pass numeric R vectors to
64-bit integer arguments of the compiled code. Moreover, .C64() features a
mechanism to avoid unnecessary copies of function arguments, making it
efficient in terms of speed and memory usage.Comment: 17 page
- …