To see the other types of publications on this topic, follow the link: Grammatical automatic parallel programming.
Journal articles on the topic 'Grammatical automatic parallel programming'
Create a spot-on reference in APA, MLA, Chicago, Harvard, and other styles
Consult the top 50 journal articles for your research on the topic 'Grammatical automatic parallel programming.'
Next to every source in the list of references, there is an 'Add to bibliography' button. Press on it, and we will generate automatically the bibliographic reference to the chosen work in the citation style you need: APA, MLA, Harvard, Chicago, Vancouver, etc.
You can also download the full text of the academic publication as pdf and read online its abstract whenever available in the metadata.
Browse journal articles on a wide variety of disciplines and organise your bibliography correctly.
1
Alfonseca, Manuel, and Alfonso Ortega. "Book Review: Grammatical Evolution: Evolutionary Automatic Programming in an Arbitrary Language." Genetic Programming and Evolvable Machines 5, no. 4 (2004): 393. http://dx.doi.org/10.1023/b:genp.0000036057.27304.5b.
Full text
2
MORIARTY, K. J. M., and T. TRAPPENBERG. "PROGRAMMING TOOLS FOR PARALLEL COMPUTERS." International Journal of Modern Physics C 04, no. 06 (1993): 1285–94. http://dx.doi.org/10.1142/s0129183193001002.
Full textAbstract:
Although software tools already have a place on serial and vector computers they are becoming increasingly important for parallel computing. Message passing libraries, parallel operating systems and high level parallel languages are the basic software tools necessary to implement a parallel processing program. These tools up to now have been specific to each parallel computer system and a short survey will be given. The aim of another class of software tools for parallel computers is to help in writing or rewriting application programs. Because automatic parallelization tools are not very successful, an interactive component has to be incorporated. We will concentrate here on the discussion of SPEFY, a parallel program development facility.
3
Park, Ho-Hyun, Alexandre Grings, Marcus Vinicius dos Santos, and Alexsandro Santos Soares. "Parallel hybrid evolutionary computation: Automatic tuning of parameters for parallel gene expression programming." Applied Mathematics and Computation 201, no. 1-2 (2008): 108–20. http://dx.doi.org/10.1016/j.amc.2007.12.002.
Full text
4
García, Luis Germán, Emanuel Montoya, Sebastian Isaza, and Ricardo A. Velasquez. "An Open edX Extension for Parallel Programming Assignments with Automatic Configurable Grading." International Journal of Engineering Pedagogy (iJEP) 11, no. 4 (2021): 7. http://dx.doi.org/10.3991/ijep.v11i4.20097.
Full textAbstract:
Computing devices of all types have almost converged to using central processing units featuring multiple processing cores. In order to develop efficient software for such devices, programmers need to learn how to write parallel programs. We present an infrastructure to support parallel programming assignments for online courses. We developed an extension to the Open edX platform with a backend that handles the execution of student codes on a cluster lab. The web user interface offers instructors a wide range of configuration options for the programming assignments as well as a flexible definition of criteria for automatic grading. We have successfully integrated the software with Open edX and tested it with a real parallel programming cluster lab.
5
Magomedov, Sh G., and A. S. Lebedev. "A tool for automatic parallelization of affine programs for systems with shared and distributed memory." Russian Technological Journal 7, no. 5 (2019): 7–19. http://dx.doi.org/10.32362/2500-316x-2019-7-5-7-19.
Full textAbstract:
Effective programming of parallel architectures has always been a challenge, and it is especially complicated with their modern diversity. The task of automatic parallelization of program code was formulated from the moment of the appearance of the first parallel computers made in Russia (for example, PS2000). To date, programming languages and technologies have been developed that simplify the work of a programmer (T-System, MC#, Erlang, Go, OpenCL), but do not make parallelization automatic. The current situation requires the development of effective programming tools for parallel computing systems. Such tools should support the development of parallel programs for systems with shared and distributed memory. The paper deals with the problem of automatic parallelization of affine programs for such systems. Methods for calculating space-time mappings that optimize the locality of the program are discussed. The implementation of developed methods is done in Haskell within the source-to-source translator performing automatic parallelization. A comparison of the performance of parallel variants of lu, atax, syr2k programs obtained using the developed tool and the modern Pluto tool is made. The experiments were performed on two x86_64 machines connected by the InfiniBand network. OpenMP and MPI were used as parallelization technologies. The performance of the resulting parallel program indicates the practical applicability of the developed tool for affine programs parallelization.
6
Tsoulos, Ioannis G. "QFC: A Parallel Software Tool for Feature Construction, Based on Grammatical Evolution." Algorithms 15, no. 8 (2022): 295. http://dx.doi.org/10.3390/a15080295.
Full textAbstract:
This paper presents and analyzes a programming tool that implements a method for classification and function regression problems. This method builds new features from existing ones with the assistance of a hybrid algorithm that makes use of artificial neural networks and grammatical evolution. The implemented software exploits modern multi-core computing units for faster execution. The method has been applied to a variety of classification and function regression problems, and an extensive comparison with other methods of computational intelligence is made.
7
Szymczyk, M., and P. Szymczyk. "Automatic processing of Z-transform artificial neural networks using parallel programming." Neurocomputing 379 (February 2020): 74–88. http://dx.doi.org/10.1016/j.neucom.2019.10.078.
Full text
8
van Reeuwijk, Kees, Arjan J. C. van Gemund, and Henk J. Sips. "Spar: A programming language for semi-automatic compilation of parallel programs." Concurrency: Practice and Experience 9, no. 11 (1997): 1193–205. http://dx.doi.org/10.1002/(sici)1096-9128(199711)9:11<1193::aid-cpe334>3.0.co;2-b.
Full text
9
Xia, Tian, Peng Liu, Xiao Yang Jiang, and Ying Huang. "Parametric Design of Parallel Indexing CAM Based on VB." Advanced Materials Research 411 (November 2011): 50–53. http://dx.doi.org/10.4028/www.scientific.net/amr.411.50.
Full textAbstract:
Through the establishment of mathematical model of parallel indexing cam, a calculation method of the cam contour line is discovered. Then achieve automatic calculation about point in cam profile based on VB programming. Eventually output plots by SolidWorks.
10
Ierotheou, C. S., S. P. Johnson, P. F. Leggett, et al. "The Semi-Automatic Parallelisation of Scientific Application Codes Using a Computer Aided Parallelisation Toolkit." Scientific Programming 9, no. 2-3 (2001): 163–73. http://dx.doi.org/10.1155/2001/327048.
Full textAbstract:
The shared-memory programming model can be an effective way to achieve parallelism on shared memory parallel computers. Historically however, the lack of a programming standard using directives and the limited scalability have affected its take-up. Recent advances in hardware and software technologies have resulted in improvements to both the performance of parallel programs with compiler directives and the issue of portability with the introduction of OpenMP. In this study, the Computer Aided Parallelisation Toolkit has been extended to automatically generate OpenMP-based parallel programs with nominal user assistance. We categorize the different loop types and show how efficient directives can be placed using the toolkit's in-depth interprocedural analysis. Examples are taken from the NAS parallel benchmarks and a number of real-world application codes. This demonstrates the great potential of using the toolkit to quickly parallelise serial programs as well as the good performance achievable on up to 300 processors for hybrid message passing-directive parallelisations.
11
Hempel, Rolf, and Falk Zimmermann. "Automatic Migration from PARMACS to MPI in Parallel Fortran Applications." Scientific Programming 7, no. 1 (1999): 39–46. http://dx.doi.org/10.1155/1999/890514.
Full textAbstract:
The PARMACS message passing interface has been in widespread use by application projects, especially in Europe. With the new MPI standard for message passing, many projects face the problem of replacing PARMACS with MPI. An automatic translation tool has been developed which replaces all PARMACS 6.0 calls in an application program with their corresponding MPI calls. In this paper we describe the mapping of the PARMACS programming model onto MPI. We then present some implementation details of the converter tool.
12
Ramon-Cortes, Cristian, Ramon Amela, Jorge Ejarque, Philippe Clauss, and Rosa M. Badia. "AutoParallel: Automatic parallelisation and distributed execution of affine loop nests in Python." International Journal of High Performance Computing Applications 34, no. 6 (2020): 659–75. http://dx.doi.org/10.1177/1094342020937050.
Full textAbstract:
The last improvements in programming languages and models have focused on simplicity and abstraction; leading Python to the top of the list of the programming languages. However, there is still room for improvement when preventing users from dealing directly with distributed and parallel computing issues. This paper proposes and evaluates AutoParallel, a Python module to automatically find an appropriate task-based parallelisation of affine loop nests and execute them in parallel in a distributed computing infrastructure. It is based on sequential programming and contains one single annotation (in the form of a Python decorator) so that anyone with intermediate-level programming skills can scale up an application to hundreds of cores. The evaluation demonstrates that AutoParallel goes one step further in easing the development of distributed applications. On the one hand, the programmability evaluation highlights the benefits of using a single Python decorator instead of manually annotating each task and its parameters or, even worse, having to develop the parallel code explicitly (e.g., using OpenMP, MPI). On the other hand, the performance evaluation demonstrates that AutoParallel is capable of automatically generating task-based workflows from sequential Python code while achieving the same performances than manually taskified versions of established state-of-the-art algorithms (i.e., Cholesky, LU, and QR decompositions). Finally, AutoParallel is also capable of automatically building data blocks to increase the tasks’ granularity; freeing the user from creating the data chunks, and re-designing the algorithm. For advanced users, we believe that this feature can be useful as a baseline to design blocked algorithms.
13
Basto-Fernandes, Vitor, Iryna Yevseyeva, Rafael Z. Frantz, Carlos Grilo, Noemí Pérez Díaz, and Michael Emmerich. "An Automatic Generation of Textual Pattern Rules for Digital Content Filters Proposal, Using Grammatical Evolution Genetic Programming." Procedia Technology 16 (2014): 806–12. http://dx.doi.org/10.1016/j.protcy.2014.10.030.
Full text
14
CHANG, SHUCHIH ERNEST, and STEPHEN A. SZYGENDA. "AUTOMATIC FUNCTIONAL MODEL GENERATION FOR PARALLEL FAULT AND DESIGN ERROR SIMULATIONS." International Journal on Artificial Intelligence Tools 03, no. 02 (1994): 127–56. http://dx.doi.org/10.1142/s021821309400008x.
Full textAbstract:
The domain specific automatic programming technique was applied to the design and implementation of an automatic functional model generation system (AFMG) for effectively and efficiently creating simulation models of digital systems. The application domain knowledge, involved in a time-consuming and error-prone process for element modeling, was identified, organized, and incorporated into the AFMG as internal rules to guide several transformation processes for converting various forms of model specification, step by step, into desired functional models. Other design issues, such as incomplete specification handling, different signal representations, multiple-valued model generation, interaction of algorithm and data structure selection, …etc., were also carefully addressed and resolved during the design process of the AFMG system. Experimental results show that AFMG can significantly reduce the development time of creating functional models for digital logic simulation.
15
Kessler, Christoph W. "Pattern-Driven Automatic Parallelization." Scientific Programming 5, no. 3 (1996): 251–74. http://dx.doi.org/10.1155/1996/406379.
Full textAbstract:
This article describes a knowledge-based system for automatic parallelization of a wide class of sequential numerical codes operating on vectors and dense matrices, and for execution on distributed memory message-passing multiprocessors. Its main feature is a fast and powerful pattern recognition tool that locally identifies frequently occurring computations and programming concepts in the source code. This tool also works for dusty deck codes that have been "encrypted" by former machine-specific code transformations. Successful pattern recognition guides sophisticated code transformations including local algorithm replacement such that the parallelized code need not emerge from the sequential program structure by just parallelizing the loops. It allows access to an expert's knowledge on useful parallel algorithms, available machine-specific library routines, and powerful program transformations. The partially restored program semantics also supports local array alignment, distribution, and redistribution, and allows for faster and more exact prediction of the performance of the parallelized target code than is usually possible.
16
LEDERER, EDGAR F. A., and ROMEO A. DUMITRESCU. "AUTOMATIC RESULT VERIFICATION BY COMPLETE RUN-TIME CHECKING OF COMPUTATIONS." International Journal of Foundations of Computer Science 12, no. 01 (2001): 97–124. http://dx.doi.org/10.1142/s0129054101000424.
Full textAbstract:
Two-Stage Programming (2SP) is an experimental programming language, the first implementation of the Specification-Consistent Coordination Model (SCCM). The SCCM proposes a new, mixed-paradigm (functional/imperative) approach to developing reliable programs based on complete run-time checking of computations with respect to a given specification. A 2SP program consists of a functional specification and an imperative coordination tightly connected to the specification. The coordination maps the specification to an imperative and possibly parallel/distributed program. Normal termination of a 2SP program execution implies the correctness of the computed results with respect to the specification, for that execution. We present the basic feautures of the SCCM/2SP, a new message-spassing system of 2SP with integrated run-time checking, and a larger case study. We show that 2SP provides: functional specifications, specification-consistent imperative coordinations, automatic run-time result verification and error detection, enhanced debugging support, and good efficiency.
17
Váradi, Tamás. "Fishing for Translation Equivalents Using Grammatical Anchors." International Journal of Corpus Linguistics 5, no. 1 (2000): 1–16. http://dx.doi.org/10.1075/ijcl.5.1.02var.
Full textAbstract:
Bilingual parallel corpora offer a treasure house of human translator’s knowledge of the correspondences between the two languages. Extracting by automatic means the translation equivalents deemed accurate and contextually appropriate by a human translator is of great practical importance for various fields such as example-based machine translation, computational lexicography, information retrieval, etc. The task of word or phrase level identification is greatly reduced if suitable anchor points can be found in the stream of texts. It is suggested that grammatical morphemes provide very useful clues to finding translation equivalents. They typically form a closed set, occur frequently enough in sentences, have more or less fixed meanings, and, most important, will stand in a one-to-one or at most one-to-few relationship with corresponding elements in the other language. This paper will explore the viability of the idea with reference to the Hungarian and English versions of Plato’s Republic, which are available in sentence-aligned form. Hungarian has a rich set of suffixes which are typically deployed in a concatenated manner. Corresponding to them in English are prepositions, auxiliary words, and suffixes. The paper will show how, by starting from a well defined set of correspondences between Hungarian grammatical morphemes and their equivalents and using a combination of pattern matching and heuristics, one can arrive at a mapping of phrases between the two texts.
18
Li, Hua Zhong, Yong Sheng Liang, Tao He, and Yi Li. "AOI Multi-Core Parallel System for TFT-LCD Defect Detection." Advanced Materials Research 472-475 (February 2012): 2325–31. http://dx.doi.org/10.4028/www.scientific.net/amr.472-475.2325.
Full textAbstract:
The present Automatic Optical Inspection (AOI) technology can hardly satisfy online inspection requirements for large-scale high-speed, high-precision and high-sensitivity TFT-LCD. First, through studying the working principle of TFT-LCD Defect AOI System, the system architecture for mixed-parallel multi-core computer cluster is proposed to satisfy design requirements. Second, the study focuses on the software framework of AOI system and related key software technology. Finally, the fusion programming model for parallel image processing and its implementation strategy is proposed based on OpenMP, MPI, OpenCV, and Intel Integrated Performance Primitives (IPP).
19
Kallel, Emna, Yassine Aoudni, and Mohamed Abid. "OpenMP-Based Approach for High Level C Loops Synthesis." International Journal of Software Innovation 5, no. 1 (2017): 1–16. http://dx.doi.org/10.4018/ijsi.2017010101.
Full textAbstract:
The complexity of embedded systems design is continuously augmented, due to the increasing quantity of components and distinct functionalities incorporated into a single system. To deal with this situation, abstraction level of projects is incessantly raised. In addition, techniques to accelerate the code production process have appeared. In this context, the automatic code generation is an interesting technique for the embedded systems project. This work presents an automatic VHDL code generation method based on the OpenMP parallel programming specification. In order to synthesize C code for loops into hardware, the authors applied the directives of OpenMP, which specifies portable implementations of shared memory parallel programs. A case study focused on the use of embedded systems for the DCT algorithm is presented in this paper to demonstrate the feasibility of the proposed approach.
20
Kacmajor, Magdalena, and John Kelleher. "Automatic Acquisition of Annotated Training Corpora for Test-Code Generation." Information 10, no. 2 (2019): 66. http://dx.doi.org/10.3390/info10020066.
Full textAbstract:
Open software repositories make large amounts of source code publicly available. Potentially, this source code could be used as training data to develop new, machine learning-based programming tools. For many applications, however, raw code scraped from online repositories does not constitute an adequate training dataset. Building on the recent and rapid improvements in machine translation (MT), one possibly very interesting application is code generation from natural language descriptions. One of the bottlenecks in developing these MT-inspired systems is the acquisition of parallel text-code corpora required for training code-generative models. This paper addresses the problem of automatically synthetizing parallel text-code corpora in the software testing domain. Our approach is based on the observation that self-documentation through descriptive method names is widely adopted in test automation, in particular for unit testing. Therefore, we propose synthesizing parallel corpora comprised of parsed test function names serving as code descriptions, aligned with the corresponding function bodies. We present the results of applying one of the state-of-the-art MT methods on such a generated dataset. Our experiments show that a neural MT model trained on our dataset can generate syntactically correct and semantically relevant short Java functions from quasi-natural language descriptions of functionality.
21
Катаев, Н. А., and А. С. Колганов. "Additional parallelization of existing MPI programs using SAPFOR." Numerical Methods and Programming (Vychislitel'nye Metody i Programmirovanie), no. 4 (November 3, 2021): 239–51. http://dx.doi.org/10.26089/nummet.v22r415.
Full textAbstract:
Системы SAPFOR и DVM были спроектированы и предназначены для упрощения разработки параллельных программ научно-технических расчетов. Главной целью системы SAPFOR является автоматизация процесса отображения последовательных программ на параллельные архитектуры в модели DVMH. В некоторых случаях пользователь системы SAPFOR может рассчитывать на полностью автоматическое распараллеливание, если программа была написана или приведена к потенциально параллельному виду. DVMH модель представляет собой расширение стандартных языков C и Fortran спецификациями параллелизма, которые оформлены в виде директив и не видимы стандартным компиляторам. В статье будет рассмотрено автоматизированное дополнительное распараллеливание существующих MPI-программ с помощью системы SAPFOR, где, в свою очередь, будут использованы новые возможности DVMH модели по распараллеливанию циклов в MPI программе внутри узла. Данный подход позволяет существенно снизить трудоемкость распараллеливания MPI программ на графические ускорители и многоядерные процессоры, сохранив при этом удобство сопровождения уже написанной программы. Данная возможность в системе SAPFOR была реализована для языков Fortran и C. Эффективность данного подхода показана на примере некоторых приложений из пакета NAS Parallel Benchmarks. The SAPFOR and DVM systems are primarily designed to simplify the development of parallel programs of scientific-technical calculations. SAPFOR is a software development suite that aims to produce a parallel version of a sequential program in a semi-automatic way. The fully automatic parallelization is also possible if the program is well-formed and satisfies certain requirements. SAPFOR uses the DVMH directive-based programming model to expose parallelism in the code. The DVMH model introduces CDVMH and Fortran-DVMH (FDVMH) programming languages which extend the standard C and Fortran languages by parallelism specifications. We present MPI-aware extension of the SAPFOR system that exploits opportunities provided by the new features of the DVMH model to extend existing MPI programs with intra-node parallelism. In that way, our approach reduces the cost of parallel program maintainability and allows an MPI program to utilize accelerators and multicore processors. SAPFOR extension has been implemented for both Fortran and C programming languages. In this paper, we use the NAS Parallel Benchmarks to evaluate the performance of generated programs.
22
Steuwer, Michel, Michael Haidl, Stefan Breuer, and Sergei Gorlatch. "High-Level Programming of Stencil Computations on Multi-GPU Systems Using the SkelCL Library." Parallel Processing Letters 24, no. 03 (2014): 1441005. http://dx.doi.org/10.1142/s0129626414410059.
Full textAbstract:
The implementation of stencil computations on modern, massively parallel systems with GPUs and other accelerators currently relies on manually-tuned coding using low-level approaches like OpenCL and CUDA. This makes development of stencil applications a complex, time-consuming, and error-prone task. We describe how stencil computations can be programmed in our SkelCL approach that combines high-level programming abstractions with competitive performance on multi-GPU systems. SkelCL extends the OpenCL standard by three high-level features: 1) pre-implemented parallel patterns (a.k.a. skeletons); 2) container data types for vectors and matrices; 3) automatic data (re)distribution mechanism. We introduce two new SkelCL skeletons which specifically target stencil computations – MapOverlap and Stencil – and we describe their use for particular application examples, discuss their efficient parallel implementation, and report experimental results on systems with multiple GPUs. Our evaluation of three real-world applications shows that stencil code written with SkelCL is considerably shorter and offers competitive performance to hand-tuned OpenCL code.
23
Doroshenko, А. Yu, and O. S. Novak. "To the issue of optimizing cloud computing based on their cost." PROBLEMS IN PROGRAMMING, no. 4 (December 2020): 014–21. http://dx.doi.org/10.15407/pp2020.04.014.
Full textAbstract:
The paper offers an approach to the architectural settings of parallel computing on the cloud platform, which allows in semi-automatic mode to perform optimization of a parallel program with the goal function of minimum cost of computations. To solve the optimization problem, it is proposed to use linear programming and an available software solver, which with the help of the method of branches and boundaries in semi-automatic mode selects the value of the architecture parameters of the program configuration which significantly affect the cost of calculations. Therefore, the method of auto-tuning developed by the authors earlier is generalized and spread to the complex of services performed on the cloud platform. An analytical test was conducted on the model of cloud multiprocessor cluster, which presents the possibility of significantly reducing the cost of cloud computing due to the optimizations carried out.
24
Huang, Lan, Teng Gao, Dalin Li, Zihao Wang, and Kangping Wang. "A Highly Configurable High-Level Synthesis Functional Pattern Library." Electronics 10, no. 5 (2021): 532. http://dx.doi.org/10.3390/electronics10050532.
Full textAbstract:
FPGA has recently played an increasingly important role in heterogeneous computing, but Register Transfer Level design flows are not only inefficient in design, but also require designers to be familiar with the circuit architecture. High-level synthesis (HLS) allows developers to design FPGA circuits more efficiently with a more familiar programming language, a higher level of abstraction, and automatic adaptation of timing constraints. When using HLS tools, such as Xilinx Vivado HLS, specific design patterns and techniques are required in order to create high-performance circuits. Moreover, designing efficient concurrency and data flow structures requires a deep understanding of the hardware, imposing more learning costs on programmers. In this paper, we propose a set of functional patterns libraries based on the MapReduce model, implemented by C++ templates, which can quickly implement high-performance parallel pipelined computing models on FPGA with specified simple parameters. The usage of this pattern library allows flexible adaptation of parallel and flow structures in algorithms, which greatly improves the coding efficiency. The contributions of this paper are as follows. (1) Four standard functional operators suitable for hardware parallel computing are defined. (2) Functional concurrent programming patterns are described based on C++ templates and Xilinx HLS. (3) The efficiency of this programming paradigm is verified with two algorithms with different complexity.
25
Ishebabi, Harold, Philipp Mahr, Christophe Bobda, Martin Gebser, and Torsten Schaub. "Answer Set versus Integer Linear Programming for Automatic Synthesis of Multiprocessor Systems from Real-Time Parallel Programs." International Journal of Reconfigurable Computing 2009 (2009): 1–11. http://dx.doi.org/10.1155/2009/863630.
Full textAbstract:
An automated design approach for multiprocessor systems on FPGAs is presented which customizes architectures for parallel programs by simultaneously solving the problems of task mapping, resource allocation, and scheduling. The latter considers effects of fixed-priority preemptive scheduling in order to guarantee real-time requirements, hence covering a broad spectrum of embedded applications. Being inherently a combinatorial optimization problem, the design space is modeled using linear equations that capture high-level design parameters. A comparison of two methods for solving resulting problem instances is then given. The intent is to study how well recent advances in propositional satisfiability (SAT) and thus Answer Set Programming (ASP) can be exploited to automate the design of flexible multiprocessor systems. Integer Linear Programming (ILP) is taken as a baseline, where architectures for IEEE 802.11g and WCDMA baseband signal processing are synthesized. ASP-based synthesis used a few seconds in the solver, faster by three orders of magnitude compared to ILP-based synthesis, thereby showing a great potential for solving difficult instances of the automated synthesis problem.
26
Kolganov, Alexander Sergeevich, and Nikita Andreevich Kataev. "Data distribution and parallel code generation for heterogeneous computational clusters." Proceedings of the Institute for System Programming of the RAS 34, no. 4 (2022): 89–100. http://dx.doi.org/10.15514/ispras-2022-34(4)-7.
Full textAbstract:
We present new techniques for compilation of sequential programs for almost affine accesses in loop nests for distributed-memory parallel architectures. Our approach is implemented as a source-to-source automatic parallelizing compiler that expresses parallelism with the DVMH directive-based programming model. Compared to all previous approaches ours addresses all three main sub-problems of the problem of distributed memory parallelization: data and computation distribution and communication optimization. Parallelization of sequential programs with structured grid computations is considered. In this paper, we use the NAS Parallel Benchmarks to evaluate the performance of generated programs and provide experimental results on up to 9 nodes of a computational cluster with two 8-core processors in a node.
27
COLLINS, ALEXANDER, CHRISTIAN FENSCH, and HUGH LEATHER. "AUTO-TUNING PARALLEL SKELETONS." Parallel Processing Letters 22, no. 02 (2012): 1240005. http://dx.doi.org/10.1142/s0129626412400051.
Full textAbstract:
Parallel skeletons are a structured parallel programming abstraction that provide programmers with a predefined set of algorithmic templates that can be combined, nested and parameterized with sequential code to produce complex programs. The implementation of these skeletons is currently a manual process, requiring human expertise to choose suitable implementation parameters that provide good performance. This paper presents an empirical exploration of the optimization space of the FastFlow parallel skeleton framework. We performed this using a Monte Carlo search of a random subset of the space, for a representative set of platforms and programs. The results show that the space is program and platform dependent, non-linear, and that automatic search achieves a significant average speedup in program execution time of 1.6× over a human expert. An exploratory data analysis of the results shows a linear dependence between two of the parameters, and that another two parameters have little effect on performance. These properties are then used to reduce the size of the space by a factor of 6, reducing the cost of the search. This provides a starting point for automatically optimizing parallel skeleton programs without the need for human expertise, and with a large improvement in execution time compared to that achievable using human expert tuning.
28
Christou, Vasileios, Ioannis Tsoulos, Alexandros Arjmand, et al. "Grammatical Evolution-Based Feature Extraction for Hemiplegia Type Detection." Signals 3, no. 4 (2022): 737–51. http://dx.doi.org/10.3390/signals3040044.
Full textAbstract:
Hemiplegia is a condition caused by brain injury and affects a significant percentage of the population. The effect of patients suffering from this condition is a varying degree of weakness, spasticity, and motor impairment to the left or right side of the body. This paper proposes an automatic feature selection and construction method based on grammatical evolution (GE) for radial basis function (RBF) networks that can classify the hemiplegia type between patients and healthy individuals. The proposed algorithm is tested in a dataset containing entries from the accelerometer sensors of the RehaGait mobile gait analysis system, which are placed in various patients’ body parts. The collected data were split into 2-second windows and underwent a manual pre-processing and feature extraction stage. Then, the extracted data are presented as input to the proposed GE-based method to create new, more efficient features, which are then introduced as input to an RBF network. The paper’s experimental part involved testing the proposed method with four classification methods: RBF network, multi-layer perceptron (MLP) trained with the Broyden–Fletcher–Goldfarb–Shanno (BFGS) training algorithm, support vector machine (SVM), and a GE-based parallel tool for data classification (GenClass). The test results revealed that the proposed solution had the highest classification accuracy (90.07%) compared to the other four methods.
29
Wu, Shibin, Shaode Yu, Ling Zhuang, et al. "Automatic Segmentation of Ultrasound Tomography Image." BioMed Research International 2017 (2017): 1–8. http://dx.doi.org/10.1155/2017/2059036.
Full textAbstract:
Ultrasound tomography (UST) image segmentation is fundamental in breast density estimation, medicine response analysis, and anatomical change quantification. Existing methods are time consuming and require massive manual interaction. To address these issues, an automatic algorithm based on GrabCut (AUGC) is proposed in this paper. The presented method designs automated GrabCut initialization for incomplete labeling and is sped up with multicore parallel programming. To verify performance, AUGC is applied to segment thirty-two in vivo UST volumetric images. The performance of AUGC is validated with breast overlapping metrics (Dice coefficient (D), Jaccard (J), and False positive (FP)) and time cost (TC). Furthermore, AUGC is compared to other methods, including Confidence Connected Region Growing (CCRG), watershed, and Active Contour based Curve Delineation (ACCD). Experimental results indicate that AUGC achieves the highest accuracy (D=0.9275 and J=0.8660 and FP=0.0077) and takes on average about 4 seconds to process a volumetric image. It was said that AUGC benefits large-scale studies by using UST images for breast cancer screening and pathological quantification.
30
Alekseev, V. V., E. M. Antonyuk, and I. E. Varshavskiy. "Algorithmic Support of Adaptive Automatic Control Systems with Data Compression." Journal of the Russian Universities. Radioelectronics 23, no. 6 (2020): 84–99. http://dx.doi.org/10.32603/1993-8985-2020-23-6-84-99.
Full textAbstract:
Introduction. The exponential growth of measurement information caused by ongoing complication of technical and production facilities necessitates the development of improved or brand new information and measurement systems, including those performing adaptive automatic control functions. Automatic criteria-based selection and reduction of measurement information continuously supplied by multi-parameter sources characterizing the objects under study require algorithms ensuring reconfiguration of automatic control systems during operation. In comparison with automatic control systems based on time-division channelling, the considered adaptive systems provide timely information on the pre-emergency and emergency operation of a facility.Aim. To develop an algorithmic support for adaptive automatic control systems using asynchronous-cyclic and parallel-sequential operating algorithms, as well as to compare the proposed algorithms in terms of their, control reliability, compression ratio, operation speed and the error associated with multi-channelling.Materials and methods. The algorithms proposed for supporting the operation of adaptive systems were developed on the basis of queuing theory and simulation modelling using the MatLab/Simulink programming languages, C++.Results. The developed algorithmic support for automatic control systems based on asynchronous-cyclic analysis of deviations allows the amount of redundant information to be reduced by more than 4 times and the operation speed to be increased by 1.5 times. The developed algorithmic support for automatic control systems based on parallel-sequential analysis of deviations allows the error associated with multi-channelling to be reduced by 1.4 times, thereby bringing the control reliability of such systems closer to that of continuous-control systems. An analysis of the graphs of the error associated with multi-channelling showed that the automatic control systems based on parallel-sequential operational algorithms are invariant to the law of distribution of input quantities, compared to the systems based on asynchronous-cyclic operational algorithms.Conclusions. The proposed algorithmic support can significantly decrease the redundancy of information and improve the metrological characteristics of automatic control systems. The use of the developed algorithms in automatic control systems based on time-division channelling render their control reliability comparable with that of continuous-control systems.
31
Xu, Jingbo, Zhanning Bai, Wenfei Fan, et al. "GraphScope." Proceedings of the VLDB Endowment 14, no. 12 (2021): 2703–6. http://dx.doi.org/10.14778/3476311.3476324.
Full textAbstract:
Due to diverse graph data and algorithms, programming and orchestration of complex computation pipelines have become the major challenges to making use of graph applications for Web-scale data analysis. GraphScope aims to provide a one-stop and efficient solution for a wide range of graph computations at scale. It extends previous systems by offering a unified and high-level programming interface and allowing the seamless integration of specialized graph engines in a general data-parallel computing environment. As we will show in this demo, GraphScope enables developers to write sequential graph programs in Python and provides automatic parallel execution on a cluster. This further allows GraphScope to seamlessly integrate with existing data processing systems in PyData ecosystem. To validate GraphScope's efficiency, we will compare a complex, multi-staged processing pipeline for a real-life fraud detection task with a manually assembled implementation comprising multiple systems. GraphScope achieves a 2.86× speedup on a trillion-scale graph in real production at Alibaba.
32
O'keefe, Matthew, Terence Parr, B. Kevin Edgar, Steve Anderson, Paul Woodward, and Hank Dietz. "The Fortran-P Translator: Towards Automatic Translation of Fortran 77 Programs for Massively Parallel Processors." Scientific Programming 4, no. 1 (1995): 1–21. http://dx.doi.org/10.1155/1995/278064.
Full textAbstract:
Massively parallel processors (MPPs) hold the promise of extremely high performance that, if realized, could be used to study problems of unprecedented size and complexity. One of the primary stumbling blocks to this promise has been the lack of tools to translate application codes to MPP form. In this article we show how applications codes written in a subset of Fortran 77, called Fortran-P, can be translated to achieve good performance on several massively parallel machines. This subset can express codes that are self-similar, where the algorithm applied to the global data domain is also applied to each subdomain. We have found many codes that match the Fortran-P programming style and have converted them using our tools. We believe a self-similar coding style will accomplish what a vectorizable style has accomplished for vector machines by allowing the construction of robust, user-friendly, automatic translation systems that increase programmer productivity and generate fast, efficient code for MPPs.
33
Walsh, Stuart D. C., and Martin O. Saar. "Developing Extensible Lattice-Boltzmann Simulators for General-Purpose Graphics-Processing Units." Communications in Computational Physics 13, no. 3 (2013): 867–79. http://dx.doi.org/10.4208/cicp.351011.260112s.
Full textAbstract:
AbstractLattice-Boltzmann methods are versatile numerical modeling techniques capable of reproducing a wide variety of fluid-mechanical behavior. These methods are well suited to parallel implementation, particularly on the single-instruction multiple data (SIMD) parallel processing environments found in computer graphics processing units (GPUs).Although recent programming tools dramatically improve the ease with which GPUbased applications can be written, the programming environment still lacks the flexibility available to more traditional CPU programs. In particular, it may be difficult to develop modular and extensible programs that require variable on-device functionality with current GPU architectures.This paper describes a process of automatic code generation that overcomes these difficulties for lattice-Boltzmann simulations. It details the development of GPU-based modules for an extensible lattice-Boltzmann simulation package – LBHydra. The performance of the automatically generated code is compared to equivalent purposewritten codes for both single-phase,multiphase, andmulticomponent flows. The flexibility of the new method is demonstrated by simulating a rising, dissolving droplet moving through a porous medium with user generated lattice-Boltzmann models and subroutines.
34
Burton, F. Warren, and V. J. Rayward-Smith. "Worst case scheduling for parallel functional programs." Journal of Functional Programming 4, no. 1 (1994): 65–75. http://dx.doi.org/10.1017/s0956796800000940.
Full textAbstract:
AbstractMany of the details that a programmer must manage when programming in a procedural language are handled by the implementation in a functional language. In a parallel functional language, we would expect the assignment of processes to processors and the scheduling of processes to be handled by the implementation. The partitioning of a program into processes may be handled by the implementation as well.We will assume that a parallel functional program may create processes dynamically, and that processes may synchronize in an arbitrary manner. It does not matter whether processes are defined in the source program or generated by the implementation.On parallel systems where each processor has some local memory, it is common practice not to move processes once they have started to execute. We will show that if each process must be executed on a single processor, then no fully automatic scheduling strategy can ensure good performance.We also will show that if all processes are sequential processes (i.e. do not contain internal parallelism), and if a process may be moved whenever it resumes execution following synchronization with another process, then good performance can be assured, at least in theory.
35
Zima, Hans P. "From FORTRAN 77 to Locality-Aware High Productivity Languages for Peta-Scale Computing." Scientific Programming 15, no. 1 (2007): 45–65. http://dx.doi.org/10.1155/2007/219061.
Full textAbstract:
When the first specification of the FORTRAN language was released in 1956, the goal was to provide an "automatic programming system" that would enhance the economy of programming by replacing assembly language with a notation closer to the domain of scientific programming. A key issue in this context, explicitly recognized by the authors of the language, was the requirement to produce efficient object programs that could compete with their hand-coded counterparts. More than 50 years later, a similar situation exists with respect to finding the right programming paradigm for high performance computing systems. FORTRAN, as the traditional language for scientific programming, has played a major role in the quest for high-productivity programming languages that satisfy very strict performance constraints. This paper focuses on high-level support for locality awareness, one of the most important requirements in this context. The discussion centers on the High Performance Fortran (HPF) family of languages, and their influence on current language developments for peta-scale computing. HPF is a data-parallel language that was designed to provide the user with a high-level interface for programming scientific applications, while delegating to the compiler the task of generating an explicitly parallel message-passing program. We outline developments that led to HPF, explain its major features, identify a set of weaknesses, and discuss subsequent languages that address these problems. The final part of the paper deals with Chapel, a modern object-oriented language developed in the High Productivity Computing Systems (HPCS) program sponsored by DARPA. A salient property of Chapel is its general framework for the support of user-defined distributions, which is related in many ways to ideas first described in Vienna Fortran. This framework is general enough to allow a concise specification of sparse data distributions. The paper concludes with an outlook to future research in this area.
36
Alizadehashrafi, B., and A. Abdul-Rahman. "USING AFFORDABLE DATA CAPTURING DEVICES FOR AUTOMATIC 3D CITY MODELLING." ISPRS - International Archives of the Photogrammetry, Remote Sensing and Spatial Information Sciences XLII-4/W6 (November 13, 2017): 9–13. http://dx.doi.org/10.5194/isprs-archives-xlii-4-w6-9-2017.
Full textAbstract:
In this research project, many movies from UTM Kolej 9, Skudai, Johor Bahru (See Figure 1) were taken by AR. Drone 2. Since the AR drone 2.0 has liquid lens, while flying there were significant distortions and deformations on the converted pictures of the movies. Passive remote sensing (RS) applications based on image matching and Epipolar lines such as Agisoft PhotoScan have been tested to create the point clouds and mesh along with 3D models and textures. As the result was not acceptable (See Figure 2), the previous Dynamic Pulse Function based on Ruby programming language were enhanced and utilized to create the 3D models automatically in LoD3. The accuracy of the final 3D model is almost 10 to 20 cm. After rectification and parallel projection of the photos based on some tie points and targets, all the parameters were measured and utilized as an input to the system to create the 3D model automatically in LoD3 in a very high accuracy.
37
Sygal, Yael, and Shuly Wintner. "Towards Modular Development of Typed Unification Grammars." Computational Linguistics 37, no. 1 (2011): 29–74. http://dx.doi.org/10.1162/coli_a_00035.
Full textAbstract:
Development of large-scale grammars for natural languages is a complicated endeavor: Grammars are developed collaboratively by teams of linguists, computational linguists, and computer scientists, in a process very similar to the development of large-scale software. Grammars are written in grammatical formalisms that resemble very-high-level programming languages, and are thus very similar to computer programs. Yet grammar engineering is still in its infancy: Few grammar development environments support sophisticated modularized grammar development, in the form of distribution of the grammar development effort, combination of sub-grammars, separate compilation and automatic linkage, information encapsulation, and so forth. This work provides preliminary foundations for modular construction of (typed) unification grammars for natural languages. Much of the information in such formalisms is encoded by the type signature, and we subsequently address the problem through the distribution of the signature among the different modules. We define signature modules and provide operators of module combination. Modules may specify only partial information about the components of the signature and may communicate through parameters, similarly to function calls in programming languages. Our definitions are inspired by methods and techniques of programming language theory and software engineering and are motivated by the actual needs of grammar developers, obtained through a careful examination of existing grammars. We show that our definitions meet these needs by conforming to a detailed set of desiderata. We demonstrate the utility of our definitions by providing a modular design of the HPSG grammar of Pollard and Sag.
38
Szustak, Lukasz, and Pawel Bratek. "Performance portable parallel programming of heterogeneous stencils across shared-memory platforms with modern Intel processors." International Journal of High Performance Computing Applications 33, no. 3 (2019): 534–53. http://dx.doi.org/10.1177/1094342019828153.
Full textAbstract:
In this work, we take up the challenge of performance portable programming of heterogeneous stencil computations across a wide range of modern shared-memory systems. An important example of such computations is the Multidimensional Positive Definite Advection Transport Algorithm (MPDATA), the second major part of the dynamic core of the EULAG geophysical model. For this aim, we develop a set of parametric optimization techniques and four-step procedure for customization of the MPDATA code. Among these techniques are: islands-of-cores strategy, (3+1)D decomposition, exploiting data parallelism and simultaneous multithreading, data flow synchronization, and vectorization. The proposed adaptation methodology helps us to develop the automatic transformation of the MPDATA code to achieve high sustained scalable performance for all tested ccNUMA platforms with Intel processors of last generations. This means that for a given platform, the sustained performance of the new code is kept at a similar level, independently of the problem size. The highest performance utilization rate of about 41–46% of the theoretical peak, measured for all benchmarks, is provided for any of the two-socket servers based on Skylake-SP (SKL-SP), Broadwell, and Haswell CPU architectures. At the same time, the four-socket server with SKL-SP processors achieves the highest sustained performance of around 1.0–1.1 Tflop/s that corresponds to about 33% of the peak.
39
Roberge, Vincent, and Mohammed Tarbouchi. "Parallel Hybrid 2-Opt Flower Pollination Algorithm for Real-Time UAV Trajectory Planning on GPU." ITM Web of Conferences 48 (2022): 03007. http://dx.doi.org/10.1051/itmconf/20224803007.
Full textAbstract:
Abstract. The development of autonomous Unmanned Aerial Vehicles (UAVs) is a priority to many civilian and military organizations. An essential aspect of UAV autonomy is the ability for automatic trajectory planning. In this paper, we use a parallel Flower Pollination Algorithm (FPA) to deal with the problem's complexity and compute feasible and quasi-optimal trajectories for fixed-wing UAVs in complex 3D environments, taking into account the vehicle's flight properties. The global optimization algorithm is improved with the addition of 2-opt local search providing a significant improvement. The proposed trajectory planner in implemented and parallelized on a multicore processor (CPU) using OpenMP and a Graphics Processing Unit (GPU) using CUDA resulting in a 9.6x and a 68.5x speedup respectively compared to the sequential implementation on CPU. Index Terms—Flower Pollination Algorithm, Graphics Processing Unit, Parallel Programming, Trajectory Planning, Unmanned Aerial Vehicle.
40
Doroshenko, А. Yu, O. G. Beketov, M. M. Bondarenko, and О. А. Yatsenko. "Automated design and parallelization of programs for heterogeneous platforms using algebra-algorithmic tools." PROBLEMS IN PROGRAMMING, no. 2-3 (September 2020): 103–14. http://dx.doi.org/10.15407/pp2020.02-03.103.
Full textAbstract:
Methods and software tools for automated design and generation of OpenCL programs based on the algebra of algorithms are proposed. OpenCL is a framework for developing parallel software that executes across heterogeneous platforms consisting of general-purpose processors and/or hardware accelerators. The proposed approach consists in using high-level algebra-algorithmic specifications of programs represented in natural linguistic form and rewriting rules. The developed software tools provide the automated design of algorithm schemes based on a superposition of Glushkov algebra constructs that are considered as reusable components. The tools automatically generate code in a target programming language on the basis of the specifications. In most computing problems, a large part of hardware resources is utilized by computations inside loops, therefore the use of automatic parallelization of cyclic operators is most efficient for them. However, the existing automatic code parallelizing tools, such as Par4All, don’t account the limited amount of accelerator’s onboard memory space while real-life problems demand huge amounts of data to be processed. Thus, there is a need for the development of a parallelization technique embracing the cases of massive computational tasks involving big data. In the paper, a method and a software tool for semi-automatic parallelization of cyclic operators based on loop tiling and data serialization are developed. The parallelization technique uses rewriting rules system to transform programs. The framework for parallelization of loops for optimization of computations using graphics processing units allows semi-automatic parallelization of sequential programs. The approach is illustrated on an example of developing a parallel OpenCL image convolution program.
41
Bischof, Christian, Alan Carle, George Corliss, Andreas Griewank, and Paul Hovland. "ADIFOR–Generating Derivative Codes from Fortran Programs." Scientific Programming 1, no. 1 (1992): 11–29. http://dx.doi.org/10.1155/1992/717832.
Full textAbstract:
The numerical methods employed in the solution of many scientific computing problems require the computation of derivatives of a function f Rn→Rm. Both the accuracy and the computational requirements of the derivative computation are usually of critical importance for the robustness and speed of the numerical solution. Automatic Differentiation of FORtran (ADIFOR) is a source transformation tool that accepts Fortran 77 code for the computation of a function and writes portable Fortran 77 code for the computation of the derivatives. In contrast to previous approaches, ADIFOR views automatic differentiation as a source transformation problem. ADIFOR employs the data analysis capabilities of the ParaScope Parallel Programming Environment, which enable us to handle arbitrary Fortran 77 codes and to exploit the computational context in the computation of derivatives. Experimental results show that ADIFOR can handle real-life codes and that ADIFOR-generated codes are competitive with divided-difference approximations of derivatives. In addition, studies suggest that the source transformation approach to automatic differentiation may improve the time to compute derivatives by orders of magnitude.
42
Yuan, Yun Long, and Hong Cheng. "Screen Printing Equipment Control System Design Based on PLC." Applied Mechanics and Materials 415 (September 2013): 180–83. http://dx.doi.org/10.4028/www.scientific.net/amm.415.180.
Full textAbstract:
For the traditional operation mode of high strength, low efficiency in the process of the plastic ruler screen printing, the powerful PLC is used as the control core, the automatic PLC control system is developed, and the reasonable programming skills are applied so that the two institutions can work in parallel, which greatly improves the production efficiency. At the same time, sophisticated sensors are used to detect each action execution state so as to ensure that work is reliable with stable performance. Through actual production test, the printing speed has reached the capacity of 28 rulers on average per minute, and has achieved the good production benefit.
43
Jing, Yanhui, Nobuo Funabiki, Soe Thandar Aung, et al. "A Proposal of Mistake Correction Problem for Debugging Study in C Programming Learning Assistant System." International Journal of Information and Education Technology 12, no. 11 (2022): 1158–63. http://dx.doi.org/10.18178/ijiet.2022.12.11.1733.
Full textAbstract:
Currently, C programming is taught as the first programming language in many universities around the world due to the easy-to-learn and middle-level nature. However, the confusing concepts of keywords and unfamiliar formality make it difficult for students to study. Therefore, we have previously developed C programming learning assistance system (CPLAS) for self-studies of novice students. CPLAS offers several types of exercise problems with the automatic answer marking by string matching. In this paper, we propose a mistake correction problem (MCP) for code debugging study as a new problem type in CPLAS. MCP requests to answer every mistaken element and its correction in a given corrupt source code. We list up reserved words and common library functions in C programming for candidates of mistaken elements, and implement the MCP instance generation algorithm. To help solving MCP instances by a student, we implement the answer interface that shows the line number of each mistake, the corrupt code and answer forms in parallel, and the hint of suggesting the first character of each answer. For evaluations of the proposal, we generate 20 instances with 91 mistakes for basic grammars, and assign them to 18 university students in Japan, China, and Indonesia. Their answer results confirm the effectiveness of MCP.
44
Findlay, John M., and Robin Walker. "A model of saccade generation based on parallel processing and competitive inhibition." Behavioral and Brain Sciences 22, no. 4 (1999): 661–74. http://dx.doi.org/10.1017/s0140525x99002150.
Full textAbstract:
During active vision, the eyes continually scan the visual environment using saccadic scanning movements. This target article presents an information processing model for the control of these movements, with some close parallels to established physiological processes in the oculomotor system. Two separate pathways are concerned with the spatial and the temporal programming of the movement. In the temporal pathway there is spatially distributed coding and the saccade target is selected from a “salience map.” Both pathways descend through a hierarchy of levels, the lower ones operating automatically. Visual onsets have automatic access to the eye control system via the lower levels. Various centres in each pathway are interconnected via reciprocal inhibition. The model accounts for a number of well-established phenomena in target-elicited saccades: the gap effect, express saccades, the remote distractor effect, and the global effect. High-level control of the pathways in tasks such as visual search and reading is discussed; it operates through spatial selection and search selection, which generally combine in an automated way. The model is examined in relation to data from patients with unilateral neglect.
45
Катаев, Н. А., and А. С. Колганов. "Automated parallelization of programs for heterogeneous clusters using the SAPFOR system." Numerical Methods and Programming (Vychislitel'nye Metody i Programmirovanie), no. 4 (October 15, 2022): 379–94. http://dx.doi.org/10.26089/nummet.v23r424.
Full textAbstract:
В статье рассмотрен подход к автоматизированному распараллеливанию программ для кластеров с помощью системы SAPFOR (System FOR Automated Parallelization). Главной целью системы SAPFOR является автоматизация процесса отображения последовательных программ на параллельные архитектуры в модели DVMH, которая является моделью программирования, основанной на директивах. Помимо этого, система SAPFOR позволяет выполнять автоматически некоторый класс преобразований над исходным кодом программы по запросу пользователя через графический интерфейс. На определенных классах задач пользователь системы SAPFOR может рассчитывать на полностью автоматическое распараллеливание, если программа была написана или приведена к потенциально параллельному виду. Также в статье описаны подходы к построению схем распределения данных и вычислений на распределенную память в модели DVMH. Эффективность полученных алгоритмов построения схем аспределения данных и вычислений продемонстрирована на примере некоторых приложений из пакета NAS Parallel Benchmarks. This paper has proposed an approach to the automated parallelization of programs for heterogeneous computational clusters. This approach is implemented in SAPFOR (System FOR Automated Parallelization). SAPFOR is a software development suite that aims to produce a parallel version of a sequential program in a semi-automatic way. SAPFOR uses the DVMH directivebased programming model to expose parallelism in the code. SAPFOR also implements different source-to-source transformations and gives the user opportunity to control the parallelization process through the graphical user interface. Fully automatic parallelization is also possible if the program is well-formed and satisfies certain requirements. This paper has described an approach which allows SAPFOR to automate selection of data and computation distribution. We use the NAS Parallel Benchmarks to evaluate the performance of generated programs.
46
Santos, Francisco Alan De Oliveira. "A Tool for Assisted Correction of Programming Exercises in Java Based in Computational Reflection." Journal on Computational Thinking (JCThink) 2, no. 1 (2018): 51. http://dx.doi.org/10.14210/jcthink.v2.n1.p51.
Full textAbstract:
INTRODUCTION: This work reports on the creation and use of a tool to verify compliance in java programming exercises. The solution is based on the hypothesis that computational reflection can provide a way to automatically assess the programing competences of students. The work reflects the concern to make students learning a programming language have practical activities in parallel to what they learn in theoretical classes. OBJECTIVE: Attesting the effectiveness of using computational reflection to automatically correct programming exercises. Provide the teacher with a tool to support the follow-up of practical activities. Provide students with immediate feedback on their learning, so as to encourage them to behave more autonomously. METHOD: A case study was carried out with two classes of a computer sciencecourse. They answered five practical programming exercices and their responses for each activity were collected in source code format, which were used as the basis of solutions, totaling 100 responses.A comparative analysis was made between the notes obtained through CodeTeacher and the notes assigned by a group of teachers. RESULTS: Comparing the expected notes and the actual notes, the automatic correction obtained an accuracy of 90.17%. CONCLUSION: The use of computational reflection techniques for assisted correction in programming classes can bring beneficial result. Teachers can optimize their work and have performance reports of their students. Students can also be benefited by having an immediate feedback, so they can perceive themselves capable of achieving the learning objectives defined by the teacher.
47
Sah, Sudhakar, and Vinay G. Vaidya. "New Approach to Speedup Dynamic Program Parallelization Analysis." International Journal of Software Innovation 2, no. 4 (2014): 28–47. http://dx.doi.org/10.4018/ijsi.2014100103.
Full textAbstract:
Development of parallel programming tools has become a mainstream research topic and it has produced many useful tools that reduce the burden of parallel programming. The most important aspect of any such tool is the data dependency analysis, which is very complex and computationally intensive. Fully automatic tools have many demerits such as low efficiency and lack of interaction with the user. In this paper, the authors present our tool called EasyPar having unique features to assist the user at the time of program development as opposed most of the other tools that work on completed programs. Performing parallelization analysis at the time of program development has a potential to exploit more parallelization opportunity by interaction with the programmer. Two most important requirements of such a tool are the accuracy and the performance of the analysis. The authors propose the method that uses database to enable quick and efficient dependency analysis. The proposed method utilizes a database to save program information in structured from and using a query based method for data dependency analysis. The database approach has three benefits. First, it makes the incremental parsing easier and faster; second, query-based approach makes the dependency analysis efficient and third it allows the demand driven program analysis possible. The authors have tested their tool on popular benchmark codes, presented the performance results, and compared it with relevant work.
48
Levin, I. I., V. A. Gudkov, G. A. Еvstafiev, A. I. Dordopulo, A. A. Gulenok, and A. V. Bovkun. "TECHNIQUE OF C PROGRAM TRANSLATION FOR RECONFIGURABLE AND HYBRID COMPUTER SYSTEMS BASED ON FIELD-PROGRAMMABLE GATE ARRAYS." Vestnik komp'iuternykh i informatsionnykh tekhnologii, no. 186 (December 2019): 54–60. http://dx.doi.org/10.14489/vkit.2019.12.pp.054-060.
Full textAbstract:
In this paper, we thoroughly consider the technique of conversion of procedural programs in C to configuration files for field-programmable gate arrays used in the toolkit for programming of reconfigurable and hybrid computer systems. The creation of parallel program in the COLAMO (Common Oriented Language for Architecture of Multi Objects) language using the analysis results of information dependences in the initial procedural program and its further conversion to a parallel and pipeline form are the distinctive characteristics of the technique. We addressed the methods of scalar splitting and array extension by iterations, which are applied for the fulfillment of the single assignment and unique substitution rules in parallel program and the saving of information communications of the initial procedural program. The technique of conversion of automatically created parallel program to the scalable parallel and pipeline form is presented. The “Procrustes” preprocessor adapts the form for different architectures and configurations of reconfigurable and hybrid computer systems. Owing to the described methodology, it is possible to synthesize a resource-independent scalable COLAMO-application, which can adapt to available computational resource by changing of several constants in automatic mode without any considerable modification of the program source code. Then, the scalable COLAMO-applicationis translated by the COLAMO-translator into field-programmable gate arrays configuration files for the specified reconfigurable computer resource.
49
Abramov, Sergey, Vladimir Roganov, Valeriy Osipov, and German Matveev. "Implementation of the LAMMPS package using T-system with an Open Architecture." Informatics and Automation 20, no. 4 (2021): 971–99. http://dx.doi.org/10.15622/ia.20.4.8.
Full textAbstract:
Supercomputer applications are usually implemented in the C, C++, and Fortran programming languages using different versions of the Message Passing Interface library. The "T-system" project (OpenTS) studies the issues of automatic dynamic parallelization of programs. In practical terms, the implementation of applications in a mixed (hybrid) style is relevant, when one part of the application is written in the paradigm of automatic dynamic parallelization of programs and does not use any primitives of the MPI library, and the other part of it is written using the Message Passing Interface library. In this case, the library is used, which is a part of the T-system and is called DMPI (Dynamic Message Passing Interface). In this way, it is necessary to evaluate the effectiveness of the MPI implementation available in the T-system. The purpose of this work is to examine the effectiveness of DMPI implementation in the T-system. In a classic MPI application, 0% of the code is implemented using automatic dynamic parallelization of programs and 100% of the code is implemented in the form of a regular Message Passing Interface program. For comparative analysis, at the beginning the code is executed on the standard Message Passing Interface, for which it was originally written, and then it is executed using the DMPI library taken from the developed T-system. Сomparing the effectiveness of the approaches, the performance losses and the prospects for using a hybrid programming style are evaluated. As a result of the conducted experimental studies for different types of computational problems, it was possible to make sure that the efficiency losses are negligible. This allowed to formulate the direction of further work on the T-system and the most promising options for building hybrid applications. Thus, this article presents the results of the comparative tests of LAMMPS application using OpenMPI and using OpenTS DMPI. The test results confirm the effectiveness of the DMPI implementation in the OpenTS parallel programming environment
50
Guzmán, Eduardo, Mario Vázquez, David Del Valle, and Paulino Pérez-Rodríguez. "Artificial Neuronal Networks: A Bayesian Approach Using Parallel Computing." Revista Colombiana de Estadística 41, no. 2 (2018): 173–89. http://dx.doi.org/10.15446/rce.v41n2.55250.
Full textAbstract:
An Artificial Neural Network (ANN) is a learning paradigm and automatic processing inspired in the biological behavior of neurons and the brain structure. The brain is a complex system; its basic processing unit are the neurons, which are distributed massively in the brain sharing multiple connections between them. The ANNs try to emulate some characteristics of humans, and can be thought as intelligent systems that perform some tasks in a different way that actual computer does. The ANNs can be used to perform complex activities, for example: pattern recognition and classification, weather prediction, genetic values prediction, etc. The algorithms used to train the ANN, are in general complex, so therefore there is a need to have alternatives which lead to a significant reduction of times employed to train an ANN. In this work, we present an algorithm based in the strategy ``divide and conquer'' which allows to train an ANN with a single hidden layer. Part of the sub problems of the general algorithm used for training are solved by using parallel computing techniques, which allows to improve the performance of the resulting application. The proposed algorithm was implemented using the C++ programming language, and the libraries Open MPI and ScaLAPACK. We present some application examples and we asses the application performance. The results shown that it is possible to reduce significantly the time necessary to execute the program that implements the algorithm to train the ANN.