Skip to content
Free planNo credit card requiredStart writing
AI for Research home
AI for Research home
Dashboard
Sign inGet started

Search 250 million research papers

Read the abstract, see who wrote it and who cites it, and get the citation in APA, MLA, Chicago or Harvard.

About 1,392 papers for “Automatic parallelization”

Automatic parallelization of . . .

Vipin Chaudhary, Jialin Ju, Laiwu Luo et al. · 1996

This report summarizes our current experiences with Automatic Program Parallelization tools for converting sequential Fortran code for use on a multiprocessor computer. A number of such tools were evaluated, including Parafrase, Adaptor, PAT, Petit and the SUIF compiler package. We evaluated the suitability of such tools for parallelizing Computational Fluid Dynamics code supplied by the Army Research Laboratory, Aberdeen Proving Grounds. SUIF was found to be most suitable by carrying out extensive tests on a suite of test programs and a matrix multiplication program. As a result of these experiments we suggest some modifications to the existing SUIF toolkit for efficient parallelization of the CFD code. Although SUIF does efficient loop partitioning for uniform dependences, it cannot handle nested loops with irregular dependencies efficiently. Unlike the case of nested loops with uniform dependencies these will have a complicated dependence pattern which forms a non-uniform dependence vector set. We propose to incorporate additional passes in SUIF based on results from our previous research, to generate code which will handle applications with non-uniform dependences.

Cited by 0

Automatic Parallelization using

Korbinian Molitorisz, Jochen Schimmel, Frank Otto · 2013

Abstract. Practically all new computer systems are parallel. The minds of the majority of software engineers are not, and most of existing source code is still sequential. Within only a few years, multicore processors changed the system landscape, but the competence to reengineer for computer systems of today is shared among a small community of software engineers. In this paper we present AutoFuture, an approach that automatically identifies parallelizable locations in sequential source code and reengineers them for multicore. This approach demands minimal change to sequential source code. AutoFutures make parallel code easy to understand and increase the acceptance of parallel software. 1

Cited by 0

Scheduling and automatic parallelization

Steve Abbott · The Mathematical Gazette · 2001

An abstract is not available for this content so a preview has been provided. Please use the Get access link above for information on how to access this content.

Cited by 0

Automatic Parallelization with pMapper

Nadya Travinin, Henry Hoffmann, Robert Bond et al. · Proceedings · 2005

Algorithm implementation efficiency is key to delivering high-performance computing capabilities to demanding, high throughput signal and image processing applications and simulations. Significant progress has been made in optimization of serial programs, but many applications require parallel processing, which brings with it the difficult task of determining efficient mappings of algorithms. The pMapper infrastructure addresses the problem of performance optimization of multistage MATLABreg applications on parallel architectures. pMapper is an automatic performance tuning library written as a layer on top of pMatlab: Parallel Matlab Toolbox. While pMatlab abstracts the message-passing interface, the responsibility of mapping numerical arrays falls on the user. Choosing the best mapping for a set of numerical arrays is a nontrivial task that requires significant knowledge of programming languages, parallel computing, and processor architecture. pMapper automates the task of map generation. This abstract addresses the design details of pMapper and presents preliminary results

Cited by 0

Automatic and interactive parallelization

Kathryn S. McKinley · Rice Digital Scholarship Archive (Rice University) · 1992

The goal of this dissertation is to give programmers the ability to achieve high performance by focusing on developing parallel algorithms, rather than on architecture-specific details. The advantages of this approach also include program portability and legibility. To achieve high performance, we provide automatic compilation techniques that tailor parallel algorithms to shared-memory multiprocessors with local caches and a common bus. In particular, the compiler maps complete applications onto the specifics of a machine, exploiting both parallelism and memory.\nTo optimize complete applications, we develop novel, general algorithms to transform loops that contain arbitrary conditional control flow. In addition, we provide new interprocedural transformations which enable optimization across procedure boundaries. These techniques provide the basis for a robust automatic parallelizing algorithm that is applicable to complete programs.\nThe algorithm for automatic parallel code generation takes into consideration the interaction of parallelism and data locality, as well as the overhead of parallelism. The algorithm is based on a simple cost model that accurately predicts cache line reuse from multiple accesses to the same memory location and from consecutive accesses. The optimizer uses this model to improve data locality. It also uses the model to discover and introduce effective parallelism that complements the benefits of data locality. The optimizer further improves the effectiveness of parallelism by seeking to increase its granularity. Parallelism is introduced only when granularity is sufficient to overcome its associated costs.\nThe algorithm for parallel code generation is shown to be efficient and several of its component algorithms are proven optimal. The efficacy of the optimizer is illustrated with experimental results. In most cases, it is very effective and either achieves or improves the performance of hand-crafted parallel programs. When performance is not satisfactory, we provide an interactive parallel programming tool which combines compiler analysis and algorithms with human expertise.

Cited by 38Open access

Automatic Inter-procedural Parallelization

Hran K. M, Bhaskar P, Annamalai. S. P et al. · 2008

In this paper, we introduce a novel technique for automatic parallelization of independent procedures. Our proposed technique identifies the potentially independent procedure calls and generates code for executing them in parallel without the intervention of the programmer. Our major concern is to parallelize those function calls that consume a significant portion of the execution time like recursive function calls and functions calls inside a loop. The proposed technique uses a hybrid approach, which involves both static and dynamic (or runtime) analysis. To reduce the overhead of speculative runtime analysis we extend a technique called Sensitivity Analysis (originally developed for loops) to recursive procedures. If a procedure call is identified as a candidate for parallel execution then OpenMP constructs for executing the function call in parallel are generated. Generating OpenMP constructs has two major advantages, firstly it makes the program easy to understand and debug. Secondly it increases the portability of the program. I.

Cited by 0

Automatic Parallelization; Interprocedural Analysis

François Irigoin, Mines Paristech, Pierre Jouvelot et al. · 2015

The PIPS project was started in 1988 to investigate the automatic detection of medium- and large-grain parallelism in scientific programs thanks to summarization techniques based on convex array regions. By 1992 the PIPS system had reached its original goals, but it has morphed into a com-prehensive, open-source platform still in use today. What were the key scientific and engineering decisions that made this possible in spite of some inevitable shortcomings?

Cited by 0

Automatic Parallelization for GPUs

Thomas B. Jablin · 2013

GPUs are flexible parallel processors capable of accelerating real applications. To exploit them, programmers rewrite programs in new languages using intimate knowl-edge of the underlying hardware. This is a step backwards in abstraction and ease of use from sequential programming. When implementing sequential applications, pro-grammers focus on high-level algorithmic concerns, allowing the compiler to target the peculiarities of specific hardware. Automatic parallelization can return ease of use and hardware abstraction to programmers. This dissertation presents techniques for automatically parallelizing ordinary sequential C codes for GPUs using DOALL and pipelined parallelization techniques. The key contributions include: the first automatic data management and communication optimization framework for GPUs and the first automatic pipeline parallelization system for GPUs. Combining these two contributions with an automatic DOALL parallelization yields the first fully au-tomatic parallelizing compiler for GPUs. iii

Cited by 0

Automatic parallelization of programs

Mohammad Yazid M. Saman · Loughborough University Institutional Repository (Loughborough University) · 1993

A Doctoral Thesis. Submitted in partial fulfilment of the requirements for the award of Doctor of Philosophy at Loughborough University.

Cited by 2Open access

Scaling Astroinformatics: Python + Automatic Parallelization

Stefan Müller, Gustavo Alonso, A. Csillaghy · Computer · 2014

Pydron, a system that bridges the gap between interactive data analysis and scalable computing, enables astronomers to process large datasets with Python without the complexities of managing parallel processing code.

Cited by 12

Automatic Parallelization with Expression Templates

Christoph Paum, Robert D. Falgout · 2001

A new automatic parallelization technique is presented for numerical algorithms for solving partial dierential equations. This technique is based on expression templates and is applied to a nite element discretizations on semi-unstructured grids.

Cited by 0

Automatic parallelization with separation logic

Cristiano Calcagno, Mohammad Raza · 2009

Abstract. We present a separation logic framework which can express properties of memory separation between different points in a program. We describe an algorithm based on this framework for determining independences between statements in a program which can be used for parallelization. 1

Cited by 0

Parallelization of Automatic Speech Recognition

Yahya O. Mohamed Elhadj, Nathalie Revol · OpenGrey (Institut de l'Information Scientifique et Technique) · 2001

The automatic recognition of spoken words is increasingly common, for dictaphone applications, telephone services or the command of various devices by disabled persons. In the latter case, a high recognition rate is expected on a vocabulary of small to medium size. To achieve this goal, the model must be refined. Thus, both the training stage and the recognition stage for such applications can be very time consuming and occasional re-training may happen. Its parallelization is thus worth considering. In this paper we present firstly the models we use: the classical hidden Markov model and another model that takes into account the prosody of speech, namely the centisecond two-level hidden Markov model introduced by Meziane [10]. Then two parallelization strategies are detailed: the first one simply shares the vocabulary among the processors, the second one also distributes the model. Experimental results highlight the need for a finer load-balancing: an a priori load estimation is presented and is used to statically balance the computational load between the processors. Further experiments have been conducted and exhibit efficiencies higher than 65% on an architecture composed of 12 Pentium Pro interconnected via Myrinet. Directions for improving further the parallelization are given.

Cited by 1Open access

Parallelization of automatic speech recognition

Laboratoire de l'informatique du parallélisme, Yahya Ould Mohamed El Hadj, Revol, Nathalie · LARA - Libre Acces aux Rapports scientifiques et techniques · 2006

(eng) The automatic recognition of spoken words is increasingly common, for dictaphone applications, telephone services or the command of various devices by disabled persons. In the latter case, a high recognition rate is expected on a vocabulary of small to medium size. To achieve this goal, the model must be refined. Thus, both the training stage and the recognition stage for such applications can be very time consuming and occasional re-training may happen. Its parallelization is thus worth considering. In this paper we present firstly the models we use: the classical hidden Markov model and another model that takes into account the prosody of speech, namely the centisecond two-level hidden Markov model introduced by Meziane. Then two parallelization strategies are detailed: the first one simply shares the vocabulary among the processors, the second one also distributes the model. %which has to be slightly modified in order to allow this distribution. Experimental results highlight the need for a finer load-balancing: an

Cited by 0

Automatic parallelization of matricial algorithms

Daniel, H. A., Ruano, Antonio · Portuguese National Funding Agency for Science, Research and Technology (RCAAP Project by FCT) · 1999

The introduction of parallel processing architectures allowed the real time impelemtation of more sophisticated control algorithms with tighter specifications in terms of sampling time. However, to take advantage of the processing power of these architectures the control engeneer, due to the lack of appropriate tools, must spend a considerable amount of time in the parallelizaton of the control algorithm.

Cited by 1

Automatic parallelization via matrix multiplication

Shigeyuki Sato, Hideya Iwasaki · ACM SIGPLAN Notices · 2012

Existing work that deals with parallelization of complicated reductions and scans focuses only on formalism and hardly dealt with implementation. To bridge the gap between formalism and implementation, we have integrated parallelization via matrix multiplication into compiler construction. Our framework can deal with complicated loops that existing techniques in compilers cannot parallelize. Moreover, we have sophisticated our framework by developing two sets of techniques. One enhances its capability for parallelization by extracting max-operators automatically, and the other improves the performance of parallelized programs by eliminating redundancy. We have also implemented our framework and techniques as a parallelizer in a compiler. Experiments on examples that existing compilers cannot parallelize have demonstrated the scalability of programs parallelized by our implementation.

Cited by 1