A Python-based programming language for high-performance computational genomics

ScalaLab and GroovyLab are both MATLAB-like environments for the Java Virtual Machine. ScalaLab is based on the Scala programming language and GroovyLab is based on the Groovy programming language. They present similar user interfaces and functionality to the user. They also share the same set of Java scientific libraries and of native code libraries. From the programmer's point of view though, they have significant differences. This paper compares some aspects of the two environments and highlights some of the strengths and weaknesses of Scala versus Groovy for scientific computing. The discussion also examines some aspects of the dilemma of using dynamic typing versus static typing for scientific programming. The performance of the Java platform is continuously improved at a fast pace. Today Java can effectively support demanding high-performance computing and scales well on multicore platforms. Thus, both systems can challenge the performance of the traditional C/C++/Fortran scientific code with an easier to use and more productive programming environment.

Download Full-text

USING METAPROGRAMMING TO PARALLELIZE FUNCTIONAL SPECIFICATIONS

Parallel Processing Letters ◽

10.1142/s0129626402000926 ◽

2002 ◽

Vol 12 (02) ◽

pp. 193-210 ◽

Cited By ~ 3

Author(s):

CHRISTOPH A. HERRMANN ◽

CHRISTIAN LENGAUER

Keyword(s):

Parallel Computing ◽

Programming Language ◽

High Performance ◽

Parallel Implementation ◽

General Purpose ◽

Functional Language ◽

Application Domain ◽

Domain Specific ◽

Domain Independent

Metaprogramming is a paradigm for enhancing a general-purpose programming language with features catering for a special-purpose application domain, without a need for a reimplementation of the language. In a staged compilation, the special-purpose features are translated and optimised by a domain-specific preprocessor, which hands over to the general-purpose compiler for translation of the domain-independent part of the program. The domain we work in is high-performance parallel computing. We use metaprogramming to enhance the functional language Haskell with features for the efficient, parallel implementation of certain computational patterns, called skeletons.

Download Full-text

A Pattern Recognition Model of Python Programming using Artificial Neural Network via NeMo

International Journal of Recent Technology and Engineering - 2 ◽

10.35940/ijrte.e6960.018520 ◽

2020 ◽

Vol 8 (5) ◽

pp. 109-113

Keyword(s):

Neural Network ◽

Pattern Recognition ◽

Programming Languages ◽

Programming Language ◽

High Performance ◽

Back Propagation ◽

Back Propagation Neural Network ◽

Network Simulator ◽

Source Codes ◽

Python Programming

Background/Objectives: In the field of software development, the diversity of programming languages increases dramatically with the increase in their complexity. This leads both programmers and researchers to develop and investigate automated tools to distinguish these programming languages. Different efforts were conducted to achieve this task using keywords of source codes of these programming languages. Therefore, instead of using keywords classification for recognition, this work is conducted to investigate the ability to detect the pattern of a programming language characteristic by using NeMo(High-performance spiking neural network simulator) of neural network and testing the ability of this toolkit to provide detailed analyzable results. Methods/Statistical analysis: the method of achieving these objectives is by using a back propagation neural network via NeMo based on pattern recognition methodology. Findings: The results show that the NeMo neural network of pattern recognition can identify and recognize the pattern of python programming language with high accuracy. It also shows the ability of the NeMo toolkit to represent the analyzable results through a percentage of certainty. Improvements/Applications: it can be noticed from the results the ability of NeMo simulator to provide beneficial platform for studying and analyzing the complexity of the backpropagation neural network model.

Download Full-text

High-performance Python for crystallographic computing

Journal of Applied Crystallography ◽

10.1107/s1600576719008471 ◽

2019 ◽

Vol 52 (4) ◽

pp. 882-897 ◽

Cited By ~ 1

Author(s):

A. Boulle ◽

J. Kieffer

Keyword(s):

Programming Language ◽

High Performance ◽

Scientific Computing ◽

State Of The Art ◽

Third Party ◽

Improve Performance ◽

Python Language ◽

Python Programming Language ◽

Numerical Computing ◽

Python Programming

The Python programming language, combined with the numerical computing library NumPy and the scientific computing library SciPy, has become the de facto standard for scientific computing in a variety of fields. This popularity is mainly due to the ease with which a Python program can be written and executed (easy syntax, dynamical typing, no compilation etc.), coupled with the existence of a large number of specialized third-party libraries that aim to lift all the limitations of the raw Python language. NumPy introduces vector programming, improving execution speeds, whereas SciPy brings a wealth of highly optimized and reliable scientific functions. There are cases, however, where vector programming alone is not sufficient to reach optimal performance. This issue is addressed with dedicated compilers that aim to translate Python code into native and statically typed code with support for the multi-core architectures of modern processors. In the present article it is shown how these approaches can be efficiently used to tackle different problems, with increasing complexity, that are relevant to crystallography: the 2D Laue function, scattering from a strained 2D crystal, scattering from 3D nanocrystals and, finally, diffraction from films and multilayers. For each case, detailed implementations and explanations of the functioning of the algorithms are provided. Different Python compilers (namely NumExpr, Numba, Pythran and Cython) are used to improve performance and are benchmarked against state-of-the-art NumPy implementations. All examples are also provided as commented and didactic Python (Jupyter) notebooks that can be used as starting points for crystallographers curious to enter the Python ecosystem or wishing to accelerate their existing codes.

Download Full-text

Evaluation of XcalableACC with tightly coupled accelerators/InfiniBand hybrid communication on accelerated cluster

The International Journal of High Performance Computing Applications ◽

10.1177/1094342018821163 ◽

2019 ◽

Vol 33 (5) ◽

pp. 869-884 ◽

Cited By ~ 1

Author(s):

Masahiro Nakao ◽

Tetsuya Odajima ◽

Hitoshi Murai ◽

Akihiro Tabuchi ◽

Norihisa Fujita ◽

...

Keyword(s):

Programming Language ◽

High Performance ◽

Lattice Quantum Chromodynamics ◽

Cluster Systems ◽

Communication Latency ◽

Lattice Quantum ◽

Tightly Coupled ◽

High Bandwidth ◽

Sequential Code ◽

Better Than

Accelerated clusters, which are cluster systems equipped with accelerators, are one of the most common systems in parallel computing. In order to exploit the performance of such systems, it is important to reduce communication latency between accelerator memories. In addition, there is also a need for a programming language that facilitates the maintenance of high performance by such systems. The goal of the present article is to evaluate XcalableACC (XACC), a parallel programming language, with tightly coupled accelerators/InfiniBand (TCAs/IB) hybrid communication on an accelerated cluster. TCA/IB hybrid communication is a combination of low-latency communication with TCA and high bandwidth with IB. The XACC language, which is a directive-based language for accelerated clusters, enables programmers to use TCA/IB hybrid communication with ease. In order to evaluate the performance of XACC with TCA/IB hybrid communication, we implemented the lattice quantum chromodynamics (LQCD) mini-application and evaluated the application on our accelerated cluster using up to 64 compute nodes. We also implemented the LQCD mini-application using a combination of CUDA and MPI (CUDA + MPI) and that of OpenACC and MPI (OpenACC + MPI) for comparison with XACC. Performance evaluation revealed that the performance of XACC with TCA/IB hybrid communication is 9% better than that of CUDA + MPI and 18% better than that of OpenACC + MPI. Furthermore, the performance of XACC was found to further increase by 7% by new expansion to XACC. Productivity evaluation revealed that XACC requires much less change from the serial LQCD code to implement the parallel LQCD code than CUDA + MPI and OpenACC + MPI. Moreover, since XACC can perform parallelization while maintaining the sequential code image, XACC is highly readable and shows excellent portability due to its directive-based approach.

Download Full-text

Developing a high-performance web server in Concurrent Haskell

Journal of Functional Programming ◽

10.1017/s095679680200432x ◽

2002 ◽

Vol 12 (4-5) ◽

pp. 359-374 ◽

Cited By ~ 5

Author(s):

SIMON MARLOW

Keyword(s):

Fault Tolerance ◽

Programming Language ◽

High Performance ◽

Web Server ◽

Unique Combination ◽

Web Servers ◽

Improved Performance ◽

Critical Components ◽

Time Critical ◽

Minimal Effort

Server applications, and in particular network-based server applications, place a unique combination of demands on a programming language: lightweight concurrency, high I/O throughput, and fault tolerance are all important. This paper describes a prototype web server written in Concurrent Haskell (with extensions), and presents two useful results: firstly, a conforming server could be written with minimal effort, leading to an implementation in less than 1500 lines of code, and secondly the naive implementation produced reasonable performance. Furthermore, making minor modifications to a few time-critical components improved performance to a level acceptable for anything but the most heavily loaded web servers.

Download Full-text

hts-nim: scripting high-performance genomic analyses

Bioinformatics ◽

10.1093/bioinformatics/bty358 ◽

2018 ◽

Vol 34 (19) ◽

pp. 3387-3389 ◽

Cited By ~ 4

Author(s):

Brent S Pedersen ◽

Aaron R Quinlan

Keyword(s):

Programming Language ◽

High Performance ◽

Genomic Data ◽

Scripting Languages ◽

Custom Software ◽

Genomic Analyses ◽

Biological Insight

Abstract Motivation Extracting biological insight from genomic data inevitably requires custom software. In many cases, this is accomplished with scripting languages, owing to their accessibility and brevity. Unfortunately, the ease of scripting languages typically comes at a substantial performance cost that is especially acute with the scale of modern genomics datasets. Results We present hts-nim, a high-performance library written in the Nim programming language that provides a simple, scripting-like syntax without sacrificing performance. Availability and implementation hts-nim is available at https://github.com/brentp/hts-nim and the example tools are at https://github.com/brentp/hts-nim-tools both under the MIT license.

Download Full-text