Code Refinement of Stencil Codes

2014 ◽  
Vol 24 (03) ◽  
pp. 1441003 ◽  
Author(s):  
Marcel Köster ◽  
Roland Leißa ◽  
Sebastian Hack ◽  
Richard Membarth ◽  
Philipp Slusallek
Keyword(s):  
Programming Language ◽  
General Purpose ◽  
Peak Performance ◽  
Domain Specific Language ◽  
Competitive Performance ◽  
Specific Language ◽  
Popular Method ◽  
Domain Specific ◽  
Stencil Codes ◽  
Target Platform

A straightforward implementation of an algorithm in a general-purpose programming language does usually not deliver peak performance: Compilers often fail to automatically tune the code for certain hardware peculiarities like memory hierarchy or vector execution units. Manually tuning the code is firstly error-prone as well as time-consuming and secondly taints the code by exposing those peculiarities to the implementation. A popular method to avoid these problems is to implement the algorithm in a Domain-Specific Language (DSL). A DSL compiler can then automatically tune the code for the target platform. In this article we show how to embed a DSL for stencil codes in another language. In contrast to prior approaches we only use a single language for this task which offers explicit control over code refinement. This is used to specialize stencils for particular scenarios. Our results show that our specialized programs achieve competitive performance compared to hand-tuned CUDA programs while maintaining a convenient coding experience.

Combinators for program generation

1999 ◽  
Vol 9 (5) ◽  
pp. 483-525 ◽  
Author(s):  
PETER THIEMANN
Keyword(s):  
Programming Language ◽  
Functional Programming ◽  
Domain Specific Language ◽  
Functional Language ◽  
Abstract Syntax ◽  
Specific Language ◽  
Program Generation ◽  
Domain Specific ◽  
Meta Programming ◽  
General Method

We present a general method to transform a compositional specification of a specializer for a functional programming language into a set of combinators that can be used to perform the same specialization more efficiently. The main transformation steps are the transition to higher-order abstract syntax and untagging. All transformation steps are proved correct. The resulting combinators can be implemented in any functional language, typed or untyped, pure or impure. They may also be considered as forming a domain-specific language for meta-programming. We demonstrate the generality of the method by applying it to several specializers of increasing strength. We demonstrate its efficiency by comparing it with a traditional specialization system based on self-application.

scholarly journals Combining Effects in a Music Programming Language based on Patterns

2019 ◽  
Author(s):  
Andre Du Bois ◽  
Rodrigo Ribeiro
Keyword(s):  
Programming Language ◽  
Functional Programming ◽  
Domain Specific Language ◽  
Original Design ◽  
Specific Language ◽  
Domain Specific ◽  
Functional Programming Language ◽  
Current Implementation ◽  
Music Programming ◽  
Music Patterns

HMusic is a domain specific language based on music patterns that can be used to write music and live coding. The main abstractions provided by the language are patterns and tracks. Code written in HMusic looks like patterns and multi-tracks available in music sequencers, drum machines and DAWs. HMusic provides primitives to design and combine patterns generating new patterns. The objective of this paper is to extend the original design of HMusic to allow effects on tracks. We describe new abstractions to add effects on individual tracks and in groups of tracks, and how they influence the combinators for track composition and multiplication. HMusic allows the live coding of music and, as it is embedded in the Haskell functional programming language, programmers can write functions to manipulate effects on the fly. The current implementation of the language is compiled into Sonic Pi [1], and we describe how the compiler’s back-end was modified to support the new abstractions for effects. HMusic can be and can be downloaded from [2].

scholarly journals Swiftlink: a distributed, parallelised and scriptable linkage engine architecture for the 21st century

2018 ◽  
Vol 3 (4) ◽  
Author(s):  
James Farrow
Keyword(s):  
Programming Language ◽  
21St Century ◽  
Domain Specific Language ◽  
Specific Language ◽  
Computing Resource ◽  
Domain Specific ◽  
Distributed Solutions ◽  
And Performance ◽  
Data Elements ◽  
Glue Code

IntroductionMany currently extant generic tools for performing bulk linkage were developed last century and while they have accreted features to improve their utility they have failed to fully exploit modern computing architectures. Custom highly-parallelised and distributed solutions exist but there is a need for a modern generalised linkage toolkit. Objectives and ApproachThe aim of this project has been to design, from the ground up, a modern flexible, i.e. scriptable, linkage suite which also takes advantage of contemporary computing architectures to address issues such as distribution of computation, parallelisation of computation and cloud-based computation. Rather than being a monolithic linkage tool or a programming suite, a domain specific language has been developed to specifically describe linkage tasks. Linkage tasks written in this language are then 'executed' or 'compiled and run' to perform pair-wise calculations on data elements. Since linkage tasks are generally bespoke, scriptability has been an important consideration. ResultsDeveloping a domain specific linkage language has enabled problem specification to be more descriptive and flexible than a monolithic linkage application. The shift in focus from a programming language to a linkage language has enabled a corresponding shift in focus to linkage-related effort (such as blocking and comparison strategies) away from distracting 'glue' code which relates not to linkage tasks under consideration but rather to the distracting bookkeeping aspects of programme execution. The same linkage task may be compiled against different back ends and languages, e.g. FEBRL (python), swift, Amazon lambda (go). The architecture has enabled otherwise idle computing resource to be utilised as well as cloud-based computing facilities for increased throughput and performance. The architecture of the linkage system will be shown with examples. Conclusion/ImplicationsContemporary advances in computing sciences can and must be leveraged in modern linkage tools. By providing a custom scriptable linkage language, tasks may be more clearly specified in a manner more flexible than monolithic linkage applications and by uncoupling linkage specification from execution, linkage may be performed optimally across multiple machines and resources.

scholarly journals Application of the CHARM++ software model as a target platform for a domain-specific language compiler for the analysis of static graphs

2017 ◽  
pp. 103-114
Author(s):  
А.С. Фролов
Keyword(s):  
Code Generation ◽  
Programming Model ◽  
Graph Representation ◽  
Connected Components ◽  
Domain Specific Language ◽  
Specific Language ◽  
Domain Specific ◽  
Software Model ◽  
Execution Model ◽  
Target Platform

Представлена реализация модуля генерации параллельного программного кода на Charm++ в компиляторе проблемно-ориентированного языка программирования Green-Marl, предназначенного для разработки параллельных алгоритмов анализа статических графов. Приводится описание представления графа в генерируемом коде и способов отображения основных конструкций языка Green-Marl в параллельный код на Charm++. Проведенное оценочное тестирование с использованием типовых графовых задач (поиск кратчайших путей от заданной вершины до остальных вершин графа (SSSP), поиск связных компонент (CC) и вычисление рангов вершин с использованием алгоритма PageRank) показало, что производительность программ на Green-Marl, странслированных в Charm++, находится на одном уровне с реализациями на Charm++, разработанными вручную. The implementation of a code generation mechanism in the domain-specific language (DSL) Green-Marl compiler targeted in the Charm++ framework is presented. Green-Marl is used for the parallel static graph analysis and adopts an imperative shared memory programming model, whereas Charm++ implements a message-driven execution model. The graph representation in the generated Charm++ code and the translation of the basic Green-Marl constructs to Charm++ are described. The evaluation of the typical graph algorithms: Single-Source Shortest Path (SSSP), Connected Components (CC), and PageRank shows that the performance of Green-Marl programs translated to Charm++ is the same as for native Charm++ implementations.

scholarly journals Comparing general-purpose and domain-specific languages: An empirical study

2010 ◽  
Vol 7 (2) ◽  
pp. 247-264 ◽  
Author(s):  
Tomaz Kosar ◽  
Nuno Oliveira ◽  
Marjan Mernik ◽  
Varanda Pereira ◽  
Matej Crepinsek ◽  
...  
Keyword(s):  
User Interfaces ◽  
General Purpose ◽  
Domain Specific Language ◽  
Problem Domain ◽  
Domain Specific Languages ◽  
Cognitive Dimension ◽  
Specific Language ◽  
Domain Specific ◽  
Implementation Approach ◽  
Open Issue

Many domain-specific languages, that try to bring feasible alternatives for existing solutions while simplifying programming work, have come up in recent years. Although, these little languages seem to be easy to use, there is an open issue whether they bring advantages in comparison to the application libraries, which are the most commonly used implementation approach. In this work, we present an experiment, which was carried out to compare such a domain-specific language with a comparable application library. The experiment was conducted with 36 programmers, who have answered a questionnaire on both implementation approaches. The questionnaire is more than 100 pages long. For a domain-specific language and the application library, the same problem domain has been used - construction of graphical user interfaces. In terms of a domain-specific language, XAML has been used and C# Forms for the application library. A cognitive dimension framework has been used for a comparison between XAML and C# Forms.

scholarly journals The Kansas University rewrite engine

2014 ◽  
Vol 24 (4) ◽  
pp. 434-473 ◽  
Author(s):  
NEIL SCULTHORPE ◽  
NICOLAS FRISBY ◽  
ANDY GILL
Keyword(s):  
Programming Languages ◽  
General Purpose ◽  
Generic Programming ◽  
Domain Specific Language ◽  
Transformation System ◽  
Specific Language ◽  
Domain Specific ◽  
Main Challenge ◽  
Engineering Effort ◽  
Transformation Systems

AbstractWhen writing transformation systems, a significant amount of engineering effort goes into setting up the infrastructure needed to direct individual transformations to specific targets in the data being transformed. Strategic programming languages provide general-purpose infrastructure for this task, which the author of a transformation system can use for any algebraic data structure. The Kansas University Rewrite Engine (KURE) is a typed strategic programming language, implemented as a Haskell-embedded domain-specific language. KURE is designed to support typed transformations over typed data, and the main challenge is how to make such transformations compatible with generic traversal strategies that should operate over any type. Strategic programming in a typed setting has much in common with datatype-generic programming. Compared to other approaches to datatype-generic programming, the distinguishing feature of KURE's solution is that the user can configure the behaviour of traversals based on the location of each datum in the tree, beyond their behaviour being determined by the type of each datum. This article describes KURE's approach to assigning types to generic traversals, and the implementation of that approach. We also compare KURE, its design choices, and their consequences, with other approaches to strategic and datatype-generic programming.

scholarly journals PyFlies: A Domain-Specific Language for Designing Experiments in Psychology

2021 ◽  
Vol 11 (17) ◽  
pp. 7823
Author(s):  
Igor Dejanović ◽  
Mirjana Dejanović ◽  
Jovana Vidaković ◽  
Siniša Nikolić
Keyword(s):  
Programming Languages ◽  
Flanker Task ◽  
General Purpose ◽  
Domain Specific Language ◽  
Code Generator ◽  
Specific Language ◽  
Domain Specific ◽  
Programming Skills ◽  
Textual Form

The majority of studies in psychology are nowadays performed using computers. In the past, access to good quality software was limited, but in the last two decades things have changed and today we have an array of good and easily accessible open-source software to choose from. However, experiment builders are either GUI-centric or based on general-purpose programming languages which require programming skills. In this paper, we investigate an approach based on domain-specific languages which enables a text-based experiment development using domain-specific concepts, enabling practitioners with limited or no programming skills to develop psychology tests. To investigate our approach, we created PyFlies, a domain-specific language for designing experiments in psychology, which we present in this paper. The language is tailored for the domain of psychological studies. The aim is to capture the essence of the experiment design in a concise and highly readable textual form. The editor for the language is built as an extension for Visual Studio Code, one of the most popular programming editors today. From the experiment description, various targets can be automatically produced. In this version, we provide a code generator for the PsychoPy library while generators for other target platforms are planned. We discuss the language, its concepts, syntax, some current limitations, and development directions. We investigate the language using a case study of the implementation of the Eriksen flanker task.

scholarly journals Design, Implementation and Evaluation of IPv4/IPv6 Longest Prefix Match support in P4 Dataplanes

2018 ◽  
Author(s):  
Fabricio E. Rodriguez Cesen ◽  
P Gyanesh Kumar Patra ◽  
Christian Esteve Rothenberg ◽  
Gergely Pongracz
Keyword(s):  
Software Defined Networking ◽  
Domain Specific Language ◽  
Multiple Targets ◽  
Specific Language ◽  
Domain Specific ◽  
Definition Of ◽  
High Level ◽  
Compiler System ◽  
Target Platform

New trends in dataplane programmability inside Software Defined Networking (SDN) paradigm are in an effort to bring multi-platform support with a high-level definition of the dataplane pipeline functions. The MultiArchitecture Compiler System for Abstract Dataplanes (MACSAD) can integrate the Protocol-Independent Packet Processors (P4) domain-specific language and the OpenDataPlane Project (ODP) APIs, to define a programmable dataplane across multiple targets in a unified compiler system. In this paper, we present and evaluate the IPv4/IPv6 Longest Prefix Match (LPM) support in MACSAD. We develop a new ODP Helper library implementing the IPv6 lookup mechanism based on the current IPv4 solution and evaluate its performance and scalability for diverse workloads and target platform configurations.

An Evaluation of a Pure Embedded Domain-Specific Language for Strategic Term Rewriting

2012 ◽  
pp. 81-108
Author(s):  
Shirren Premaratne ◽  
Anthony M. Sloane ◽  
Leonard G. C. Hamey
Keyword(s):  
Programming Languages ◽  
Term Rewriting ◽  
General Purpose ◽  
Domain Specific Language ◽  
Specific Language ◽  
Domain Specific ◽  
Trade Offs ◽  
Implementation Approach ◽  
Performance Penalty ◽  
Embedded Implementation

Domain-specific languages are often implemented by embedding them in general-purpose programming languages. The Kiama library used in this chapter for the Scala programming language contains a rewriting component that is an embedded implementation of the Stratego term rewriting language. The authors evaluate the trade-offs inherent in this approach and its practicality via a non-trivial case study. An existing Stratego implementation of a compiler for the Apply image processing language was translated into a Kiama implementation. The chapter examines the linguistic differences between the two versions of the Stratego domain-specific language, and compares the size, speed, and memory usage of the two Apply compiler implementations. The authors’ experience shows that the embedded language implementation inflicts constraints that mean a precise duplication of Stratego is impossible, but the main flavor of the language is preserved. The implementation approach allows for writing code of similar size, but imposes a performance penalty. Nevertheless, the performance is still at a practically useful level and scales for large inputs in the same way as the Stratego implementation.

Sign in / Sign up

Export Citation Format

Share Document