High-level Language Research Articles

High-Level Programming of FPGA-Accelerated Systems with Parallel Patterns

As a result of frequency and power limitations, multi-core processors and accelerators are becoming more and more prevalent in today’s systems. To fully utilize such systems, heterogeneous parallel programming is needed, but this introduces new complexities to the development. High-level frameworks such as SkePU have been introduced to help alleviate these complexities. SkePU is a skeleton programming framework based on a set of programming constructs implementing computational parallel patterns, while presenting a sequential interface to the programmer. Using the various skeleton backends, SkePU programs can execute, without source code modification, on multiple types of hardware such as CPUs, GPUs, and clusters. This paper presents the design and implementation of a new backend for SkePU, adding support for FPGAs. We also evaluate the effect of FPGA-specific optimizations in the new backend and compare it with the existing GPU backend, where the actual devices used are of similar vintage and price point. For simple examples, we find that the FPGA-backend’s performance is similar to that of the existing backend for GPUs, while it falls behind in more complex tasks. Finally, some shortcomings in the backend are highlighted and discussed, along with potential solutions.

Predicting the next sentence (not word) in large language models: What model-brain alignment tells us about discourse comprehension.

Current large language models (LLMs) rely on word prediction as their backbone pretraining task. Although word prediction is an important mechanism underlying language processing, human language comprehension occurs at multiple levels, involving the integration of words and sentences to achieve a full understanding of discourse. This study models language comprehension by using the next sentence prediction (NSP) task to investigate mechanisms of discourse-level comprehension. We show that NSP pretraining enhanced a model's alignment with brain data especially in the right hemisphere and in the multiple demand network, highlighting the contributions of nonclassical language regions to high-level language understanding. Our results also suggest that NSP can enable the model to better capture human comprehension performance and to better encode contextual information. Our study demonstrates that the inclusion of diverse learning objectives in a model leads to more human-like representations, and investigating the neurocognitive plausibility of pretraining tasks in LLMs can shed light on outstanding questions in language neuroscience.

A programmable topological photonic chip

Controlling topological phases of light allows the observation of abundant topological phenomena and the development of robust photonic devices. The prospect of more sophisticated control with topological photonic devices for practical implementations requires high-level programmability. Here we demonstrate a fully programmable topological photonic chip with large-scale integration of silicon photonic nanocircuits and microresonators. Photonic artificial atoms and their interactions in our compound system can be individually addressed and controlled, allowing the arbitrary adjustment of structural parameters and geometrical configurations for the observation of dynamic topological phase transitions and diverse photonic topological insulators. Individual programming of artificial atoms on the generic chip enables the comprehensive statistical characterization of topological robustness against relatively weak disorders, and counterintuitive topological Anderson phase transitions induced by strong disorders. This generic topological photonic chip can be rapidly reprogrammed to implement multifunctionalities, providing a flexible and versatile platform for applications across fundamental science and topological technologies.

A Smart Interactive Programming Assistant for Error-Free Coding

This paper is aimed to make the programming easier and user friendly to the beginners. The programming tools use compilers which convert high level language to low level language. For efficiency the code should be error free and optimized code. Beginners find it very difficult to resolve the errors and to optimize their code. This project proposes an intelligent interactive programming tool which guides the programmers by correcting the basic errors they commit. The system provides a speech interface where the speech is converted into text with proper syntactic arrangements and resolves ambiguities. In addition to this, common syntactic errors made by the users can be identified interactively and are highlighted, thus helping the users to do programming in a user-friendly way. It uses Google API for speech recognition and its converted to the syntactic form of C++ programming language. Errors are highlighted by first splitting errors using java regular expressions and then highlighting to identify the common errors that occur during compilation. Therefore, this project will be very much helpful not only for novice programmers to correct the errors in the early stage with interactive comments.

Boundary SPH for Robust Particle–Mesh Interaction in Three Dimensions

This paper introduces an algorithm to tackle the boundary condition (BC) problem, which has long persisted in the numerical and computational treatment of smoothed particle hydrodynamics (SPH). Central to the BC problem is a need for an effective method to reconcile a numerical representation of particles with 2D or 3D geometry. We describe and evaluate an algorithmic solution—boundary SPH (BSPH)—drawn from a novel twist on the mesh-based boundary method, allowing SPH particles to interact (directly and implicitly) with either convex or concave 3D meshes. The method draws inspiration from existing works in graphics, particularly discrete signed distance fields, to determine whether particles are intersecting or submerged with mesh triangles. We evaluate the efficacy of BSPH through application to several simulation environments of varying mesh complexity, showing practical real-time implementation in Unity3D and its high-level shader language (HLSL), which we test in the parallelization of particle operations. To examine robustness, we portray slip and no-slip conditions in simulation, and we separately evaluate convex and concave meshes. To demonstrate empirical utility, we show pressure gradients as measured in simulated still water tank implementations of hydrodynamics. Our results identify that BSPH, despite producing irregular pressure values among particles close to the boundary manifolds of the meshes, successfully prevents particles from intersecting or submerging into the boundary manifold. Average FPS calculations for each simulation scenario show that the mesh boundary method can still be used effectively with simple simulation scenarios. We additionally point the reader to future works that could investigate the effect of simulation parameters and scene complexity on simulation performance, resolve abnormal pressure values along the mesh boundary, and test the method’s robustness on a wider variety of simulation environments.

High-Level Language Translation Controlled by Dataflow

The article is devoted to the description of the developed method and tools for translating high-level programming languages into an abstract syntactic tree. The peculiarity of the technique is that it is based on the object-attribute (OA) architecture of a computing system belonging to the dataflow class. The syntactic tree synthesized by the translator is a frame-like dynamic structure. The methodology includes the format and methodology of syntactic tree synthesis, the method for describing the translation algorithm, and the specialized programming language (OA-language) for describing a translation algorithm.

SMaLL: Software for Rapidly Instantiating Machine Learning Libraries

Interest in deploying deep neural network (DNN) inference on edge devices has resulted in an explosion of the number and types of hardware platforms that machine learning (ML) libraries must support. High-level programming interfaces, such as TensorFlow, can be readily ported across different devices; however, maintaining performance when porting the low-level implementation is more nuanced. High-performance inference implementations require an effective mapping of the high-level interface to the target hardware platform. Commonly, this mapping may use optimizing compilers to generate code at compile time or high-performance vendor libraries that have been specialized to the target platform. Both approaches rely on expert knowledge across levels to produce an efficient mapping. This makes supporting new architectures difficult and time-consuming. In this work, we present a DNN library framework, SMaLL, that is easily extensible to new architectures. The framework uses a unified loop structure and shared, cache-friendly data format across all intermediate layers, eliminating the time and memory overheads incurred by data transformation between layers. Each layer is implemented by specifying its dimensions and a kernel , the key computing operation of that layer. The unified loop structure and kernel abstraction allows the reuse of code across layers and computing platforms. New architectures only require a few hundred lines in the kernel to be redesigned. To show the benefits of our approach, we have developed software that supports a range of layer types and computing platforms; this software is easily extensible for rapidly instantiating high-performance DNN libraries. An evaluation of the portability of our framework is shown by instantiating end-to-end networks from the MLPerf:tiny benchmark suite on five ARM platforms and one x86 platform (an AMD Zen 2). We also show that the end-to-end performance is comparable to or better than ML frameworks such as TensorFlow, TVM, and LibTorch.

JAVA BASED FIRST-PERSON SHOOTER (FPS) GAME WITH REMASTERED GRAPHICS

Our project aims to accurately examine an old game's assembly source, comprehend its usefulness, and convert it into efficient Java code. Using Java's object-oriented characteristics, the emphasis is on restructuring and organizing code to make it more maintainable and comprehensible. The successful conversion of this game to Java demonstrates how knowledge of low-level assembly programming can supplement skill in high-level Java programming, resulting in a smooth integration of traditional gameplay with current technology. This integration not only heightens perceptions but also makes the game more accessible to modern audiences, providing an immersive gaming experience that combines the game's original character with contemporary software development standards. The enhanced graphics will also include upgrading game elements including textures, models, and special effects. The enhanced graphics will include improved game assets like textures, models, and special effects, as well as advanced lighting and shading effects. In addition, the game's user interface will be updated to increase use and appearance. The project's goal is to demonstrate the integration of classic FPS gameplay with contemporary graphics technology, providing players with an enhanced gaming experience that combines the recollections of old FPS games with the visual quality of modern gaming. Key Words: - Java programming, game development , FPS game, graphics.

Tools for studying of facial identification and authentication

One of the most common and popular among biometric techniques is biometry of face. Currently, a large number of information systems have been created using these techniques. Thus, there is a problem of studying the methods of machine face recognition during the training of relevant specialists. The aim of the work is to develop a software tools for studying the mechanism of biometric face authentication. Face is static biometry methodic. For implementation in the developed tools the method of comparison on key points was chosen. The main stages of comparing faces are: finding a face in a photo, formation of key points, normalization, formation of segments, formation of relations, comparison of ratios. A high-level cross-platform programming language C++ with the use of additional libraries was chosen to develop the software of the tools. An open face database was used to work with the tools. The tools have a demonstration nature. During its use, you can explore and study all the components of the process of biometric identifi-cation and authentication of the user by face: demonstration of the process of finding of key points on the face, forming of distances between points, calculating of their ratios and their comparison; comparison of etalon and candidate photos during the procedure of identification and authentication and response. Examples of the main processing stages of the complex and the corresponding screen forms (windows) are given. The com-position of the tools and software are developed in the work, the main examples and stages of its work are given. It is shown that the tools can be used in the educational process, for example in laboratory or practical classes.

Quantum Control Machine: The Limits of Control Flow in Quantum Programming

Quantum algorithms for tasks such as factorization, search, and simulation rely on control flow such as branching and iteration that depends on the value of data in superposition. High-level programming abstractions for control flow, such as switches, loops, higher-order functions, and continuations, are ubiquitous in classical languages. By contrast, many quantum languages do not provide high-level abstractions for control flow in superposition, and instead require the use of hardware-level logic gates to implement such control flow. The reason for this gap is that whereas a classical computer supports control flow abstractions using a program counter that can depend on data, the typical architecture of a quantum computer does not analogously provide a program counter that can depend on data in superposition. As a result, the complete set of control flow abstractions that can be correctly realized on a quantum computer has not yet been established. In this work, we provide a complete characterization of the properties of control flow abstractions that are correctly realizable on a quantum computer. First, we prove that even on a quantum computer whose program counter exists in superposition, one cannot correctly realize control flow in quantum algorithms by lifting the classical conditional jump instruction to work in superposition. This theorem denies the ability to directly lift general abstractions for control flow such as the λ-calculus from classical to quantum programming. In response, we present the necessary and sufficient conditions for control flow to be correctly realizable on a quantum computer. We introduce the quantum control machine, an instruction set architecture featuring a conditional jump that is restricted to satisfy these conditions. We show how this design enables a developer to correctly express control flow in quantum algorithms using a program counter in place of logic gates.

Hardware Acceleration of Digital Pulse Shape Analysis Using FPGAs.

The BC501A sensor is a liquid scintillator frequently used in nuclear physics for detecting fast neutrons. This paper describes a hardware implementation of digital pulse shape analysis (DPSA) for real-time analysis. DPSA is an algorithm that extracts the physically relevant parameters from the detected BC501A signals. The hardware solution is implemented in a MicroTCA system that provides the physical, mechanical, electrical, and cooling support for an AMC board (NAMC-ZYNQ-FMC) with a Xilinx ZYNQ Ultrascale-MP SoC. The Xilinx FPGA programmable logic implements a JESD204B interface to high-speed ADCs. The physical and datalink JESD204B layers are implemented using hardware description language (HDL), while the Xilinx high-level synthesis language (HLS) is used for the transport and application layers. The DPSA algorithm is a JESD204B application layer that includes a FIR filter and a constant fraction discriminator (CFD) function, a baseline calculation function, a peak detection function, and an energy calculation function. This architecture achieves an analysis mean time of less than 100 µs per signal with an FPGA resource utilization of about 50% of its most used resources. This paper presents a high-performance DPSA embedded system that interfaces with a 1 GS/s ADC and performs accurate calculations with relatively low latency.

WASMICO: Micro-containers in microcontrollers with WebAssembly

The Internet-of-Things (IoT) has created a complex environment where hardware and software interact in complex ways. Despite being a prime candidate for applying well-established software engineering practices, IoT has not seen the same level of adoption as other areas, such as cloud development. This discrepancy is even more evident in the case of edge devices, where programming and managing applications can be challenging due to their heterogeneous nature and dependence on specific toolchains and languages. However, the emergence of WebAssembly as a viable solution for running high-level languages on some devices presents an opportunity to streamline development practices, such as DevOps. In this paper, we present WASMICO — a firmware and command-line utility that allows for the execution and management of application lifecycles in microcontrollers. Our solution has been benchmarked against other state-of-the-art tools, demonstrating its feasibility, novel features, and empirical evidence that it outperforms some of the most widely used solutions for running high-level code on these devices. Overall, our work aims to promote the use of well-established software engineering practices in the IoT domain, helping to bridge the gap between cloud and edge development.

CuPBoP: Making CUDA a Portable Language

CUDA is designed specifically for NVIDIA GPUs and is not compatible with non-NVIDIA devices. Enabling CUDA execution on alternative backends could greatly benefit the hardware community by fostering a more diverse software ecosystem. To address the need for portability, our objective is to develop a framework that meets key requirements, such as extensive coverage, comprehensive end-to-end support, superior performance, and hardware scalability. Existing solutions that translate CUDA source code into other high-level languages, however, fall short of these goals. In contrast to these source-to-source approaches, we present a novel framework, CuPBoP, which treats CUDA as a portable language in its own right. Compared to two commercial source-to-source solutions, CuPBoP offers a broader coverage and superior performance for the CUDA-to-CPU migration. Additionally, we evaluate the performance of CuPBoP against manually optimized CPU programs, highlighting the differences between CPU programs derived from CUDA and those that are manually optimized. Furthermore, we demonstrate the hardware scalability of CuPBoP by showcasing its successful migration of CUDA to AMD GPUs. To promote further research in this field, we have released CuPBoP as an open-source resource.

PTVR - A software in Python to make virtual reality experiments easier to build and more reproducible.

Researchers increasingly use virtual reality (VR) to perform behavioral experiments, especially in vision science. These experiments are usually programmed directly in so-called game engines that are extremely powerful. However, this process is tricky and time-consuming as it requires solid knowledge of game engines. Consequently, the anticipated prohibitive effort discourages many researchers who want to engage in VR. This paper introduces the Perception Toolbox for Virtual Reality (PTVR) library, allowing visual perception studies in VR to be created using high-level Python script programming. A crucial consequence of using a script is that an experiment can be described by a single, easy-to-read piece of code, thus improving VR studies' transparency, reproducibility, and reusability. We built our library upon a seminal open-source library released in 2018 that we have considerably developed since then. This paper aims to provide a comprehensive overview of the PTVR software for the first time. We introduce the main objects and features of PTVR and some general concepts related to the three-dimensional (3D) world. This new library should dramatically reduce the difficulty of programming experiments in VR and elicit a whole new set of visual perception studies with high ecological validity.

Firmware development for the fibre-optic seismometer based on FOG

The main goal of the article is to present the concept of using a simulation environment when designing an advanced fibre-optic seismometer (FOS) using a field-programmable gate array (FPGA) computing system. The first part of the article presents the advanced requirements regarding the FOS principle of operation, as well as the measurement method using a closed-loop operation. The closed-loop control algorithm is developed using the high-level language C++ and then it is synthesised into an FPGA. The following part of the article describes the simulation environment developed to test the operation of the control algorithm. The environment includes a model of components of the measurement system, delays, and distortions in the signal processing path, and some of the measurement system surroundings. The article ends with a comparison of simulation data with measurements. The obtained results are consistent and prove correctness of the methodology adopted by the authors.

GethReplayer: a smart contract testing method based on transaction replay

PurposeSmart contracts are written in high-level programming languages, compiled into Ethereum Virtual Machine (EVM) bytecode, deployed onto blockchain systems and called with the corresponding address by transactions. The deployed smart contracts are immutable, even if there are bugs or vulnerabilities. Therefore, it is critical to verify smart contracts before deployment. This paper aims to help developers effectively and efficiently locate potential defects in smart contracts.Design/methodology/approachGethReplayer, a smart contract testing method based on transaction replay, is proposed. It constructs a parallel transaction execution environment with two virtual machines to compare the execution results. It uses the real existing transaction data on Ethereum and the source code of the tested smart contacts as inputs, conditionally substitutes the bytecode of the tested smart contract input into the testing EVM, and then monitors the environmental information to check the correctness of the contract.FindingsExperiments verified that the proposed method is effective in smart contract testing. Virtual environmental information has a significant effect on the success of transaction replay, which is the basis for the performance of the method. The efficiency of error locating was approximately 14 times faster with the proposed method than without. In addition, the proposed method supports gas consumption analysis.Originality/valueThis paper addresses the difficulty that developers encounter in testing smart contracts before deployment and focuses on helping develop smart contracts with as few defects as possible. GethReplayer is expected to be an alternative solution for smart contract testing and provide inspiration for further research.

BRAND: a platform for closed-loop experiments with deep network models.

Objective.Artificial neural networks (ANNs) are state-of-the-art tools for modeling and decoding neural activity, but deploying them in closed-loop experiments with tight timing constraints is challenging due to their limited support in existing real-time frameworks. Researchers need a platform that fully supports high-level languages for running ANNs (e.g. Python and Julia) while maintaining support for languages that are critical for low-latency data acquisition and processing (e.g. C and C++).Approach.To address these needs, we introduce the Backend for Realtime Asynchronous Neural Decoding (BRAND). BRAND comprises Linux processes, termednodes, which communicate with each other in agraphvia streams of data. Its asynchronous design allows for acquisition, control, and analysis to be executed in parallel on streams of data that may operate at different timescales. BRAND uses Redis, an in-memory database, to send data between nodes, which enables fast inter-process communication and supports 54 different programming languages. Thus, developers can easily deploy existing ANN models in BRAND with minimal implementation changes.Main results.In our tests, BRAND achieved <600 microsecond latency between processes when sending large quantities of data (1024 channels of 30 kHz neural data in 1 ms chunks). BRAND runs a brain-computer interface with a recurrent neural network (RNN) decoder with less than 8 ms of latency from neural data input to decoder prediction. In a real-world demonstration of the system, participant T11 in the BrainGate2 clinical trial (ClinicalTrials.gov Identifier: NCT00912041) performed a standard cursor control task, in which 30 kHz signal processing, RNN decoding, task control, and graphics were all executed in BRAND. This system also supports real-time inference with complex latent variable models like Latent Factor Analysis via Dynamical Systems.Significance.By providing a framework that is fast, modular, and language-agnostic, BRAND lowers the barriers to integrating the latest tools in neuroscience and machine learning into closed-loop experiments.

Parental Linguistic Input to Children Who are Deaf and Hard-of-Hearing during Parent-Child Interaction: A Systematic Review and Meta-Analysis

Objectives: Parental linguistic input has long been shown to predict children’s later language ability. This study aimed to characterize the quantity and quality of parental linguistic input of children who are deaf and hard-of-hearing (DHH) through systematic literature and meta-analysis.Methods: One thousand seven hundred sixty-one articles from 2001 to February 2022 investigating parental linguistic input in children with DHH were identified via database searches. Nine articles were identified that met the PICOS (Participants, Intervention, Comparison, Outcomes, and Study design) criteria. A systematic review and metaanalysis of the literature were conducted. We used mixed effects models to estimate the overall mean effect size metric to address each research question.Results: As a result of the systematic literature review, the selected articles had a low risk of bias. In a considerable number of the presented meta-analytic articles, mothers and children aged 24-36 months participated. We did detect significant differences in the number of total words, the number of different words, and the proportion of the high-level facilitative language techniques from the parents’ utterances between the DHH and the typical hearing (TH) groups. On the other hand, there was not a significant difference in the number of total utterances between the two groups.Conclusion: This meta-analysis reports on different patterns of parental linguistic input between children with DHH and children with TH. We conclude with a discussion of the findings and consideration of the implications for research.

Neural network analysis of safe life of the oil and gas industrial structures

Purpose is to study safe life of industrial (metal) structures under long-time operation in the corrosive-active media of oil and gas wells with the help of neural network analysis. Methods. The MATLAB system (MATrix LABoratory) was selected as the tool environment for interface modelling; the system is developed by Math Works Inc. and is a high-level programming language for technical computations. Of the three existing learning paradigms, we used the “with teacher” learning process, as we believed that a neural network had correct answers (network outputs) for each input example. The coefficients were adjusted so that the network gave answers being as close as possible to the known correct answers. Findings. An artificial neural network has helped obtain a generalized diagram of the expected areas of high viscoplastic characteristics of carbon steels used to manufacture metal structures in the oil and gas industry. While applying the trained neural networks, generalized dependences of the corrosion rates of structural steels on the parameters of media with different concentrations of chlorine ions, sulphate ions, hydrogen sulphide, carbon dioxide, carbon dioxide, and oxygen ions were obtained; they were the basis to predict corrosion behaviour of steels. Originality. For the first time, the possibility of applying neural network modelling to predict local corrosion damage of structural pipe steels has been shown in terms of the “steel 20 – oxygen and chloride-containing medium” system. For the first time, the technological possibility has been demonstrated to use neural network analysis for engineering predictive assessment of corrosion activity of binary systems of simulated solutions, which are most often found under industrial conditions of the oil and gas sector of the economy. Practical implications. The proposed technology of using the neural network analysis will make it possible to expand a range of predicted values beyond experimental data, i.e. to predict the value of Vcor in very dilute or concentrated salt solutions within the acidified and neutral pH ranges. It should be noted that the error of the prediction results shown by the neural network will increase along with distancing from the scope of experimental data.

Wind Mapping of Malaysia Using Ward’s Clustering Method

Malaysian wind maps used in wind analysis and engineering design are dated back to the last 50 years of wind data. Cotemporally, the mean wind speed was used as the basic wind design and due to changes in the weather condition worldwide, wind monitoring assumption and structure design are jeopardized. Therefore, this study aims to map the wind based on the trend of the highest wind speed recorded. The wind speed was analyzed based on a trend basis. The study included 42 Malaysian Metrological Department weather stations and the annual wind speed was acquired based on the monthly highest wind speed (1990–2019). The data were then processed using the 95% confidence interval method to determine the mean of the month, and the annual wind trendline was obtained. The trendline was then clustered using Ward’s method with the assistance of the high-level programming language, PYTHON v3.11.6. The clustering analysis produced two clusters for the Malaysian Peninsula and two for Sabah and Sarawak. The recommendation is to use the highest wind speed recorded on the map as the design wind speed. The recommendation is expected to help experts to compensate for the uncertainties in wind speed during the design stage and avoid incidents in the field.