Loop Programs Research Articles

Efficiency of Various Tiling Strategies for the Zuker Algorithm Optimization

This paper focuses on optimizing the Zuker RNA folding algorithm, a bioinformatics task with non-serial polyadic dynamic programming and non-uniform loop dependencies. The intricate dependence pattern is represented using affine formulas, enabling the automatic application of tiling strategies via the polyhedral method. Three source-to-source compilers—PLUTO, TRACO, and DAPT—are employed, utilizing techniques such as affine transformations, the transitive closure of dependence relation graphs, and space–time tiling to generate cache-efficient codes, respectively. A dedicated transpose code technique for non-serial polyadic dynamic programming codes is also examined. The study evaluates the performance of these optimized codes for speed-up and scalability on multi-core machines and explores energy efficiency using RAPL. The paper provides insights into related approaches and outlines future research directions within the context of bioinformatics algorithm optimization.

Implement Speech Recognition and Synthesis System Using Python

Python script implements a speech recognition and synthesis system using the Speech Recognition and pyttsx3 libraries. The system allows users to speak into their microphone, recognizes the speech using Google's Web Speech API, and then speaks out the recognized text. The main program loop continuously listens for speech input, recognizes it, and then synthesizes the recognized text into speech. The loop terminates when the recognized speech is "exit". This implementation demonstrates the integration of speech recognition and synthesis capabilities in Python, showcasing their potential applications in various domains such as human-computer interaction, accessibility, and automation.

Time and Energy Benefits of Using Automatic Optimization Compilers for NPDP Tasks

In this article, we analyze the program codes generated automatically using three advanced optimizers: Pluto, Traco, and Dapt, which are specifically tailored for the NPDP benchmark set. This benchmark set comprises ten program loops, predominantly from the field of bioinformatics. The codes exemplify dynamic programming, a challenging task for well-known tools used in program loop optimization. Given the intricacy involved, we opted for three automatic compilers based on the polyhedral model and various loop-tiling strategies. During our evaluation of the code’s performance, we meticulously considered locality and concurrency to accurately estimate time and energy efficiency. Notably, we dedicated significant attention to the latest Dapt compiler, which applies space–time loop tiling to generate highly efficient code for the NPDP benchmark suite loops. By employing the aforementioned optimizers and conducting an in-depth analysis, we aim to demonstrate the effectiveness and potential of automatic transformation techniques in enhancing the performance and energy efficiency of dynamic programming codes.

LCVD: Loop-oriented code vulnerability detection via graph neural network

Due to the unique mechanism and complex structure, loops in programs can easily lead to various vulnerabilities such as dead loops, memory leaks, resource depletion, etc. Traditional approaches to loop-oriented program analysis (e.g. loop summarization) are costly with a high rate of false positives in complex software systems. To address the issues above, recent works have applied deep learning (DL) techniques to vulnerability detection. However, existing DL-based approaches mainly focused on the general characteristics of most vulnerabilities without considering the semantic information of specific vulnerabilities. As a typical structure in programs, loops are highly iterative with multi-paths. Currently, there is a lack of available approaches to represent loops, as well as useful methods to extract the implicit vulnerability patterns. Therefore, this paper introduces LCVD, an automated loop-oriented code vulnerability detection approach. LCVD represents the source code as the Loop-flow Abstract Syntax Tree (LFAST), which focuses on interleaving multi-paths around loop structures. Then a novel Loop-flow Graph Neural Network (LFGNN) is proposed to learn both the local and overall structure of loop-oriented vulnerabilities. The experimental results demonstrate that LCVD outperforms the three static analysis-based and four state-of-the-art DL-based vulnerability detection approaches across evaluation settings.

Software Pipelining for Quantum Loop Programs

We propose a method for performing software pipelining on quantum for-loop programs, exploiting parallelism in and across iterations. We redefine concepts that are useful in program optimization, including array aliasing, instruction dependency and resource conflict, this time in optimization of quantum programs. Using the redefined concepts, we present a software pipelining algorithm exploiting instruction-level parallelism in quantum loop programs. The optimization method is then evaluated on some test cases, including popular applications like QAOA, and compared with several baseline results. The evaluation results show that our approach outperforms loop optimizers exploiting only in-loop optimization chances by reducing total depth of the loop program to close to the optimal program depth obtained by full loop unrolling, while generating much smaller code in size. This is the first step towards optimization of a quantum program with such loop control flow as far as we know.

Synthesis of nested loop exercises for practice in introductory programming

Novice programmers struggle to comprehend specific programming constructs such as arrays, recursion, and loops. One way to address this challenge is to provide practice problems for students in these topics that are considered difficult to comprehend — such as nested loops. It is proven that practice aids program comprehension, hence, since it is time consuming to manually create many practice problems; synthesising these problems is an Expert Artificial Intelligence Task that is worth investigating. In this paper we present the synthesis of nested loop exercises in Python for practice using a context-free grammar. We defined the grammar rules for modeling program templates. Algorithms were designed and implemented for the generation of structurally different nested loop exercises based on the defined production rules of the context-free grammar. Each program generated consists of two or more looping statements, with a nesting, and the context-free grammar rules also allow for the spawning of infinitely many sub-loops for every loop. We checked for the correctness of the synthesised nested loop programs with an experimental procedure of iteratively supplying these programs to the Python interpreter. The first 120,000 iterations returned no syntactic bugs, hence, showing that these programs do compile and have outputs. Furthermore, an evaluation of the programs was carried out in a survey with 210 participants (novice and expert programmers). The results of the evaluation show that over 82% of the participants agreed that the synthesised exercises were correctly generated, solvable and can be used as practice exercises for novice programmers in introductory programming modules. 120,000 iterations of synthesised loop programs can be found at: https://tinyurl.com/nestedloops2021.

Synthesizing ranking functions for loop programs via SVM

Termination of programs is probably the most famous undecidable problem in computer science. Despite this undecidability result, a lot of effort has been spent on improving algorithms that prove termination of loops, which is one of the fundamental aspects of software reliability analysis. These algorithms usually focus on finding an appropriate ranking function for the loop, which proves its termination. In this paper, we focus on handling the synthesis problem of nested ranking functions and multi-phase ranking functions for loop programs. We first reduce the problem of a nested ranking function synthesis to the existence problem of a hyperplane separating classes of data. This allows us to leverage Support-Vector Machines (SVM) techniques for the synthesis of nested ranking functions. SVM are supervised learning algorithms that are used to classify data; they work by finding a hyperplane separating data points parted into two classes. We show how to carefully define the data points so that the separating hyperplane gives rise to a nested ranking function for the loop. Then we use this algorithm for nested ranking functions synthesis as a subprocedure to devise a sound algorithm which incrementally synthesizes multi-phase ranking functions. Experimental results confirm the effectiveness of our SVM-based synthesis of nested and multi-phase ranking functions.

Test Case Generation using Symbolic Execution

Testing is a well-known technique for identifying errors in software programs. Testing can be done in two ways: Static analysis and Dynamic analysis. Symbolic execution plays a vital role in static analysis for test case generation and to find the unreachable path with minimum test cases. Unreachable path is a part of a program which can never be executed i.e., the symbolic execution doesn’t continue for that path and the current execution stops there. It generates a test suite for loop-free programs that is achieved by path coverage. In the best case program loops implies increase in the number of paths exponentially and in the worst case the program will not terminate. The functions of symbolic execution are test input generation, unreachable path detection, finding bugs in software programs, debugging. In this paper, we focus on dead code detection and test input generation using symbolic execution. Our execution for Java programs uses Java Path Finder (JPF) model tester. Our analysis shows that the symbolic execution method can be used to reduce symbolic execution time and to find out the unreachable path with less number of test cases.

Pelacakan Perahu Masyarakat Yang Mengalami Kondisi Darurat Di Perairan Sipora Utara Kab. Kepulauan Mentawai Berbasis Internet Of Things

Technology in search and rescue has been growing at this time, especially in early detection systems. Basarnas as the leading sector in search and rescue, has used an early detection communication tool called Radio Beacon to quick response search and rescue for aircraft and ship accidents, and conditions that endanger humans. However, in its application in the field, this early detection system has not been touched by the local community, especially because the price is still relatively expensive and the socialization of the importance of safety itself has not been maximized in the community. From these problems, this paper designs a tracking device that works like a Radio Beacon where the switch will activate the Arduino device, GPS module and SIM800l module. The GPS module receives the location coordinates to be further processed by Arduino and sent using the SIM800l module to Firebase and notifications is received by the smartphone and the location can be monitored through an android application created using the MIT App Inventor platform. From the test results, it is found that the initial data transmission process starts from the switch is activated until the notification is received by the smartphone, a delay of 70 seconds occurs while in the process of repeating sending data there is a delay between 10-35 seconds from what has been set in the program looping every 50 seconds.

A Direct Modulation for Matrix Converters Based on the One-Cycle Atomic Operation Developed in Verilog HDL

This article presents a fast direct pulsewidth modulation (PWM) algorithm for the conventional matrix converters developed in Verilog hardware description language. All PWM duty cycle calculations are performed in one cycle by an atomic operation designed as a digital module using field-programmable gate array basic blocks. The algorithm can be extended to any number of output phases. The improved version of the discontinuous direct analytic voltage PWM (DAV-PWM) method is proposed, in which the use of trigonometry, angles, and program loops has been eliminated. The proposed DAV-PWM is equivalent to the space vector modulation; it can be applied during input asymmetry and also allows for the control of the displacement input angle. The proposal has been verified using the circuit simulation in PSIM, digital structure modeling in ModelSim, and finally through an experiment.

Algebra-Based Reasoning for Loop Synthesis

Provably correct software is one of the key challenges of our software-driven society. Program synthesis—the task of constructing a program satisfying a given specification—is one strategy for achieving this. The result of this task is then a program that is correct by design. As in the domain of program verification, handling loops is one of the main ingredients to a successful synthesis procedure. We present an algorithm for synthesizing loops satisfying a given polynomial loop invariant. The class of loops we are considering can be modeled by a system of algebraic recurrence equations with constant coefficients, thus encoding program loops with affine operations among program variables. We turn the task of loop synthesis into a polynomial constraint problem by precisely characterizing the set of all loops satisfying the given invariant. We prove soundness of our approach, as well as its completeness with respect to an a priori fixed upper bound on the number of program variables. Our work has applications toward synthesizing loops satisfying a given polynomial loop invariant—program verification—as well as generating number sequences from algebraic relations. To understand viability of the methodology and heuristics for synthesizing loops, we implement and evaluate the method using the Absynth tool.

Optimization of Indoor Luminaire Layout for General Lighting Scheme Using Improved Particle Swarm Optimization

An improved mathematical model and an improved particle swarm optimization (IPSO) are proposed for the complex design parameters and conflicting design goals of the indoor luminaire layout (ILL) problem. The ILL problem is formulated as a nonlinear constrained mixed-variable optimization problem that has four decision variables. For a general lighting scheme (GLS), the number and location of luminaires can be uniquely determined by optimizing four decision variables, which avoid using program loops to determine the number of luminaires. We improve the particle swarm optimization (PSO) in three aspects: (1) up-down probabilistic rounding (UDPR) method proposed to solve mixed integer, (2) improving the velocity of the best global particle, and (3) using nonlinear inertia weights with random items. The IPSO has better optimization results in an office study compared with the PSO and genetic algorithm (GA). The results are validated by DIALux simulation software, and a maximum deviation of 2.2% is found. The validated results show that the method using four decision variables increased the speed by 10.6% and the success rate by 23.33%. Furthermore, Indoor Luminaire Layout System APP is designed to provide guidelines visually for lighting designers and related researchers.

Moment-based analysis of Bayesian network properties

We use algebraic reasoning to translate Bayesian network (BN) properties into linear recurrence equations over statistical moments of BN variables. We show that this translation can always be done for various BNs, such as discrete, Gaussian, conditional linear Gaussian, and dynamic BNs. An important part of our work comes with representing BNs as while loops in probabilistic programs with polynomial assignments over random variables and parametrised distributions. We prove that closed-form summaries of probabilistic loops precisely characterize higher-order moments of BN variables. As such, we automatically solve several BN-related problems, including exact inference, sensitivity analysis, filtering, and computing the expected number of rejecting samples in sampling-based procedures. We evaluate our work on a number of BN benchmarks, using automated invariant generation within Prob-solvable loop analysis.This paper is an extended version of the “Analysis of Bayesian Networks via Prob-Solvable Loops” manuscript published at ICTAC 2020[1].

Practical Closed-Loop Strategies for Deep Brain Stimulation: Lessons From Chronic Pain.

Deep brain stimulation (DBS) is a plausible therapy for various neuropsychiatric disorders, though continuous tonic stimulation without regard to underlying physiology (open-loop) has had variable success. Recently available DBS devices can sense neural signals which, in turn, can be used to control stimulation in a closed-loop mode. Closed-loop DBS strategies may mitigate many drawbacks of open-loop stimulation and provide more personalized therapy. These devices contain many adjustable parameters that control how the closed-loop system operates, which need to be optimized using a combination of empirically and clinically informed decision making. We offer a practical guide for the implementation of a closed-loop DBS system, using examples from patients with chronic pain. Focusing on two research devices from Medtronic, the Activa PC+S and Summit RC+S, we provide pragmatic details on implementing closed- loop programming from a clinician’s perspective. Specifically, by combining our understanding of chronic pain with data-driven heuristics, we describe how to tune key parameters to handle feature selection, state thresholding, and stimulation artifacts. Finally, we discuss logistical and practical considerations that clinicians must be aware of when programming closed-loop devices.

Tight Polynomial Bounds for Loop Programs in Polynomial Space

We consider the following problem: given a program, find tight asymptotic bounds on the values of some variables at the end of the computation (or at any given program point) in terms of its input values. We focus on the case of polynomially-bounded variables, and on a weak programming language for which we have recently shown that tight bounds for polynomially-bounded variables are computable. These bounds are sets of multivariate polynomials. While their computability has been settled, the complexity of this program-analysis problem remained open. In this paper, we show the problem to be PSPACE-complete. The main contribution is a new, space-efficient analysis algorithm. This algorithm is obtained in a few steps. First, we develop an algorithm for univariate bounds, a sub-problem which is already PSPACE-hard. Then, a decision procedure for multivariate bounds is achieved by reducing this problem to the univariate case; this reduction is orthogonal to the solution of the univariate problem and uses observations on the geometry of a set of vectors that represent multivariate bounds. Finally, we transform the univariate-bound algorithm to produce multivariate bounds.

Predicting unstable software benchmarks using static source code features

Software benchmarks are only as good as the performance measurements they yield. Unstable benchmarks show high variability among repeated measurements, which causes uncertainty about the actual performance and complicates reliable change assessment. However, if a benchmark is stable or unstable only becomes evident after it has been executed and its results are available. In this paper, we introduce a machine-learning-based approach to predict a benchmark’s stability without having to execute it. Our approach relies on 58 statically-computed source code features, extracted for benchmark code and code called by a benchmark, related to (1) meta information, e.g., lines of code (LOC), (2) programming language elements, e.g., conditionals or loops, and (3) potentially performance-impacting standard library calls, e.g., file and network input/output (I/O). To assess our approach’s effectiveness, we perform a large-scale experiment on 4,461 Go benchmarks coming from 230 open-source software (OSS) projects. First, we assess the prediction performance of our machine learning models using 11 binary classification algorithms. We find that Random Forest performs best with good prediction performance from 0.79 to 0.90, and 0.43 to 0.68, in terms of AUC and MCC, respectively. Second, we perform feature importance analyses for individual features and feature categories. We find that 7 features related to meta-information, slice usage, nested loops, and synchronization application programming interfaces (APIs) are individually important for good predictions; and that the combination of all features of the called source code is paramount for our model, while the combination of features of the benchmark itself is less important. Our results show that although benchmark stability is affected by more than just the source code, we can effectively utilize machine learning models to predict whether a benchmark will be stable or not ahead of execution. This enables spending precious testing time on reliable benchmarks, supporting developers to identify unstable benchmarks during development, allowing unstable benchmarks to be repeated more often, estimating stability in scenarios where repeated benchmark execution is infeasible or impossible, and warning developers if new benchmarks or existing benchmarks executed in new environments will be unstable.

Symbolic Loop Compilation for Tightly Coupled Processor Arrays

Tightly Coupled Processor Arrays (TCPAs), a class of massively parallel loop accelerators, allow applications to offload computationally expensive loops for improved performance and energy efficiency. To achieve these two goals, executing a loop on a TCPA requires an efficient generation of specific programs as well as other configuration data for each distinct combination of loop bounds and number of available processing elements (PEs). Since both these parameters are generally unknown at compile time—the number of available PEs due to dynamic resource management, and the loop bounds, because they depend on the problem size—both the programs and configuration data must be generated at runtime. However, pure just-in-time compilation is impractical, because mapping a loop program onto a TCPA entails solving multiple NP-complete problems. As a solution, this article proposes a unique mixed static/dynamic approach called symbolic loop compilation. It is shown that at compile time, the NP-complete problems (modulo scheduling, register allocation, and routing) can still be solved to optimality in a symbolic way resulting in a so-called symbolic configuration , a space-efficient intermediate representation parameterized in the loop bounds and number of PEs. This phase is called symbolic mapping . At runtime, for each requested accelerated execution of a loop program with given loop bounds and known number of available PEs, a concrete configuration , including PE programs and configuration data for all other components, is generated from the symbolic configuration according to these parameter values. This phase is called instantiation . We describe both phases in detail and show that instantiation runs in polynomial time with its most complex step, program instantiation, not directly depending on the number of PEs and thus scaling to arbitrary sizes of TCPAs. To validate the efficiency of this mixed static/dynamic compilation approach, we apply symbolic loop compilation to a set of real-world loop programs from several domains, measuring both compilation time and space requirements. Our experiments confirm that a symbolic configuration is a space-efficient representation suited for systems with little memory—in many cases, a symbolic configuration is smaller than even a single concrete configuration instantiated from it—and that the times for the runtime phase of program instantiation and configuration loading are negligible and moreover independent of the size of the available processor array. To give an example, instantiating a configuration for a matrix-matrix multiplication benchmark takes equally long for 4× 4 and 32× 32 PEs.

Intellectual method of the iterative space partitioning for program loop operators

Intellectual method of the iterative space partitioning for program loop operators

Characterization and simulation of the nonlinear thermal field of the aramid/bismaleimide composites caused by the dielectric heating effects of the microwave radiations

AbstractThe aramid/bismaleimide composites are severely affected by the dielectric heating effects of the microwave radiations during use as the microwave functional materials. This study aims to characterize and predict the nonlinear thermal fields and thermal damages of the aramid/bismaleimide composites caused by the microwave radiations. The microwave radiation experiments were performed using a tailor‐made system, and the equilibrium temperature and thermal damage threshold of the aramid/bismaleimide composites were experimentally determined. The temperature variation, thermal damage mechanism, and effect of the composite thickness associated with the dielectric heating were analyzed. Further, a simulation approach was developed to predict the nonlinear thermal fields of the composites caused by the microwave radiations. The dielectric heating process was considered an internal heat source, and a loop program was subsequently designed to implement the nonlinear thermal load. The developed simulation method efficiently predicted the equilibrium temperature and thermal damage of the composite materials due to the dielectric heating effect. The microwave radiation power was suggested to remain below 550 W for 3 mm thick aramid composites during service as a wave‐transmitting material.

Investigation of the parameters of discrete particle swarm optimization method for problem of finding of optimal tile sizes in program loops

Investigation of the parameters of discrete particle swarm optimization method for problem of finding of optimal tile sizes in program loops