Native Code Research Articles

Programming Real-Time Sound in Python

For its versatility, Python has become one of the most popular programming languages. In spite of its possibility to straightforwardly link native code with powerful libraries for scientific computing, the use of Python for real-time sound applications development is often neglected in favor of alternative programming languages, which are tailored to the digital music domain. This article introduces Python as a real-time software programming tool to interested readers, including Python developers who are new to the real time or, conversely, sound programmers who have not yet taken this language into consideration. Cython and Numba are proposed as libraries supporting agile development of efficient software running at machine level. Moreover, it is shown that refactoring few critical parts of the program under these libraries can dramatically improve the performances of a sound algorithm. Such improvements can be directly benchmarked within Python, thanks to the existence of appropriate code parsing resources. After introducing a simple sound processing example, two algorithms that are known from the literature are coded to show how Python can be effectively employed to program sound software. Finally, issues of efficiency are mainly discussed in terms of latency of the resulting applications. Overall, such issues suggest that the use of real-time Python should be limited to the prototyping phase, where the benefits of language flexibility prevail on low latency requirements, for instance, needed during computer music live performances.

Reminder and Online Booking Features at Android-Based Motorcycle Repair Shop Marketplace

Generally, vehicle service is a must for the vehicle owner. However, due to tight work routines, people often forget to service their vehicles. In addition, the service process is still using a manual system, such as taking a queue number which leads to the long queue of the service time. An Android-based Motorcycle Repair Shop Information System provides a solution to remind people to do a regular service on their vehicles with a reminder feature and make online bookings. The system development uses the SDLC (System Development Life Cycle) method. The implementation process requires an Android smartphone and a computer device by using MySQL as data storage, Firebase as a notification sender, React native and Visual Studio Code are used for developing the system. The results of the UAT test (user acceptance testing) from 20 users show 55,8% answered agree to the display, features and flow of the system, 39,5% answered strongly agree to the three question parameters, and 4,7% answered disagree with the flow and display of the system.

Two decades of live coding and debugging of virtual machines through simulation

SummaryOpenSmalltalk‐VM is a virtual machine (VM) for languages in the Smalltalk family (eg, Squeak and Pharo), which is itself written in a subset of Smalltalk that can easily be translated to C. VM development is done in Smalltalk, an activity we call “simulation.” The production VM is then derived by translating the core VM code to C. As a result, two execution models coexist: simulation, where the Smalltalk code is executed on top of a Smalltalk VM, and production, where the same code is compiled to an executable through a C compiler. The whole VM execution can be simulated: the heap is represented as a huge byte array, the VM code is executed as Smalltalk, and the native code generated by the just‐in‐time (JIT) compiler is executed by a processor simulator. All the Smalltalk development tools, such as the debugger, are then available while simulating. In addition, in simulation, it is also possible to use debugging features such as single stepping in the machine code generated by the JIT compiler. The Smalltalk development tools combined with the simulation debugging features provide developers with a productive environment in which to extend and debug the VM. In this article, we detail the VM simulation infrastructure and report our experiences developing and debugging VM features within it such as the garbage collector and the JIT compiler.

An open-source solution to performance portability for Summit and Sierra supercomputers

Programming models that use a higher level of abstraction to express parallelism can target both CPUs and any attached devices, alleviating the maintainability and portability concerns facing today's heterogenous systems. This article describes the design, implementation, and delivery of a compliant OpenMP device offloading implementation for IBM-NVIDIA heterogeneous servers composing the Summit and Sierra supercomputers in the mainline open-source Clang/LLVM compiler and OpenMP runtime projects. From a performance perspective, reconciling the GPU programming model, best suited for massively parallel workloads, with the generality of the OpenMP model was a significant challenge. To achieve both high performance and full portability, we map high-level programming patterns to fine-tuned code generation schemes and customized runtimes that preserve the OpenMP semantics. In the compiler, we implement a low-overhead single-program multiple-data scheme that leverages the GPU native execution model and a fallback scheme to support the generality of OpenMP. Modular design enables the implementation to be extended with new schemes for frequently occurring patterns. Our implementation relies on key optimizations: sharing data among threads, leveraging unified memory, aggressive inlining of runtime calls, memory coalescing, and runtime simplification. We show that for commonly used patterns, performance on the Summit and Sierra GPUs matches that of hand-written native CUDA code.

Identifying Java Calls in Native Code via Binary Scanning (artifact)

Identifying Java Calls in Native Code via Binary Scanning (artifact)

Identifying Java Calls in Native Code via Binary Scanning (artifact)

Identifying Java Calls in Native Code via Binary Scanning (artifact)

TEMPORALLY ADAPTIVE-DYNAMIC SPARSE NETWORK FOR MODELING DISEASE PROGRESSION.

Alzheimer's disease (AD) is a neurodegenerative disorder with progressive impairment of memory and cognitive functions. Sparse coding (SC) has been demonstrated to be an efficient and effective method for AD diagnosis and prognosis. However, previous SC methods usually focus on the baseline data while ignoring the consistent longitudinal features with strong sparsity pattern along the disease progression. Additionally, SC methods extract sparse features from image patches separately rather than learn with the dictionary atoms across the entire subject. To address these two concerns and comprehensively capture temporal-subject sparse features towards earlier and better discriminability of AD, we propose a novel supervised SC network termed Temporally Adaptive-Dynamic Sparse Network (TADsNet) to uncover the sequential correlation and native subject-level codes from the longitudinal brain images. Our work adaptively updates the sparse codes to impose the temporal regularized correlation and dynamically mine the dictionary atoms to make use of entire subject-level features. Experimental results on ADNI-I cohort validate the superiority of our approach.

ПРАГМАТИЧНИЙ ПОТЕНЦІАЛ НАТИВНОЇ РЕКЛАМИ: ФОРМИ, ТРЕНДИ (НА ПРИКЛАДІ НАТИВНОГО КОНТЕНТУ В СОЦІАЛЬНІЙ МЕРЕЖІ FACEBOOK ЩОДО БРЕНДА ФАКУЛЬТЕТУ ЖУРНАЛІСТИКИ ЗНУ)

<div><p><em>The article analyzes the peculiarities of the format of native advertising in the media space, its pragmatic potential (in particular, on the example of native content in the social network Facebook by the brand of the journalism department of ZNU), highlights the types and trends of native advertising. The following research methods were used to achieve the purpose of intelligence: descriptive (content content, including various examples), comparative (content presentation options) and typological (types, trends of native advertising, in particular, cross-media as an opportunity to submit content in different formats (video, audio, photos, text, infographics, etc.)), content analysis method using Internet services (using Popsters service). And the native code for analytics was the page of the journalism department of Zaporizhzhya National University on the social network Facebook. After all, the brand of the journalism department of Zaporozhye National University in 2019 celebrates its 15th anniversary. The brand vector is its value component and professional training with balanced distribution of theoretical and practical blocks (seven practices), student-centered (democratic interaction and high-level teacher-student dialogue) and integration into Ukrainian and world educational process (participation in grant programs).</em></p></div><p><em>And advertising on social networks is also a kind of native content, which does not appear in special blocks, and is organically inscribed on one page or another and unobtrusively offers, just remembering the product as if «to the word». Popsters service functionality, which evaluates an account (or linked accounts of one person) for 35 parameters, but the main three areas: reach or influence, or how many users evaluate, comment on the recording; true reach – the number of people affected; network score – an assessment of the audience’s response to the impact, or how far the network information diverges (how many share information on this page).</em></p><p><strong><em>Key words:</em></strong><em> nativeness, native advertising, branded content, special project, communication strategy.</em></p>

Physical IC Design Layout of Memory-Based Real Fast Fourier Transform Architecture using 90nm Technology

In this paper we present a low complexity physical IC layout for memory based Real Fast Fourier Transform (RFFT) architecture using 90nm technology. FFT architectures are the most important algorithms in the modern communication systems like and very high bit rate digital subscriber line (VDSL) asymmetric digital subscriber line (ADSL). In this FFT algorithm is based on radix-2 decimation-in-frequency. In order to meet the real time requirements of very large scale integration (VLSI), we designed a low complexity and high speed FFT architecture. The RFFT architecture was realised using Verilog hardware description language (HDL). This architecture is simulated using Native code launch of cadence and synthesized using RTL code complier of cadence tool. Each step of application specific integrated circuit (ASIC) physical IC design flow was synthesized using cadence Innovus 90nm technology and we optimize the design to reduce the area, power and timing requirements.

Early childhood identity: ethnicity and acculturation

How are concepts such as ethnic identity, acculturation and cultural orientation being perceived by a child? What is the process of identity construction in early preschool age? How is children’s wellbeing affected by parents’ desire to expose them to a certain culture, other than the one the children were born into? How natural is learning a foreign language for children, given a multiethnic space characterized by adversity and disparities such as “them”- -“us”? And what are the potential outcomes of the phenomena in question? These are a few questions that the current study refl ectively followed up upon by using a qualitative research design and data triangulation in order to increase its validity. The SDQ Questionnaire used to study the children’s wellbeing, the semi-structured “in-depth” interviews conducted on the main early preschool identity builders in the Cristian community and the participative observation indicated the children were proud to be part of the German department group. They did not undergo a brutal process of affi liation to the Saxon ethnicity due to the educators’ various compromises, and their wellbeing didn’t seem to be affected at the SDQ administration stage. However, learning German proved to be a diffi cult process and the two potential outcomes included hitting the language barrier or resuming adaptation to the native ethnic code. This study highlights the impact of the cultural code on the early identity foundation.

O-glasses: Visualizing X86 Code From Binary Using a 1D-CNN

Malicious document files used in targeted attacks often contain a small program called shellcode. It is often hard to prepare a runnable environment for dynamic analysis of these document files because they exploit specific vulnerabilities. In these cases, it is necessary to identify the position of the shellcode in each document file to analyze it. If the exploit code uses executable scripts such as JavaScript and Flash, it is not so hard to locate the shellcode. On the other hand, it is sometimes almost impossible to locate the shellcode when it does not contain any JavaScript or Flash but consists of native x86 code only. Binary fragment classification is often applied to visualize the location of regions of interest, and shellcode must contain at least a small fragment of x86 native code even if most of it is obfuscated, such as a decoder for the obfuscated body of the shellcode. In this paper, we propose a novel method, o-glasses, to visualize the shellcode by recognizing the x86 native code using a specially designed one-dimensional convolutional neural network (1d-CNN). The fragment size needs to be as small as the minimum size of the x86 native code in the whole shellcode. Our results show that a 16-instruction-sequence (approximately 48 bytes on average) is sufficient for the code fragment visualization. Our method, o-glasses (1d-CNN), outperforms other methods in that it recognizes x86 native code with a surprisingly high F-measure rate (about 99.95%).

Real‐time performance assessment using fast interrupt request on a standard Linux kernel

SummaryThis article presents the use of ARM's fast interrupt request (FIQ) to accomplish better jitter performance on real‐time drivers without using patches for real‐time extensions on the native Linux kernel code. Writing an FIQ interrupt handler is challenging due to the lack of Linux kernel support and the need to avoid page faults exception during its execution. We investigate and evaluate a mechanism that employs static mapping for peripherals and changes on the Linux kernel code to allow the FIQ interrupt handler to be written in the C language. Furthermore, the FIQ performance was evaluated by comparing it with a timer Interrupt Request on Linux PREEMPT‐RT in full CONFIG_PREEMPT_RT mode. Both were applied on a Linux driver for data acquisition of a pipeline inspection gauge system. Results show that the FIQ approach was able to reduce in 97.49% the interrupt jitter and, as a result, allowed an increase in the data acquisition frequency from 1024 Hz to 2048 Hz, showing that the FIQ approach can be considered for real‐time applications without resorting to real‐time extensions.

An approach for realistically simulating the performance of scientific applications on high performance computing systems

Scientific applications often contain large, computationally-intensive, and irregular parallel loops or tasks that exhibit stochastic behavior leading to load imbalance. Load imbalance often manifests during the execution of parallel scientific applications on large and complex high performance computing (HPC) systems. The extreme scale of HPC systems on the road to Exascale computing only exacerbates the loss in performance due to load imbalance. Dynamic loop self-scheduling (DLS) techniques are instrumental in improving the performance of scientific applications on HPC systems via load balancing. Selecting a DLS technique that results in the best performance for different problem and system sizes requires a large number of exploratory experiments. Currently, a theoretical model that can be used to predict the scheduling technique that yields the best performance for a given problem and system has not yet been identified. Therefore, simulation is the most appropriate approach for conducting such exploratory experiments in a reasonable amount of time. However, conducting realistic and trustworthy simulations of application performance under different configurations is challenging. This work devises an approach to realistically simulate computationally-intensive scientific applications that employ DLS and execute on HPC systems. The proposed approach minimizes the sources of uncertainty in the simulative experiments results by bridging the native and simulative experimental approaches. A new method is proposed to capture the variation of application performance between different native executions. Several approaches to represent the application tasks (or loop iterations) are compared to establish their influence on the simulative application performance. A novel simulation strategy is introduced that applies the proposed approach, which transforms a native application code into simulative code. The native and simulative performance of two computationally-intensive scientific applications that employ eight task scheduling techniques (static, nonadaptive dynamic, and adaptive dynamic) are compared to evaluate the realism of the proposed simulation approach. The comparison of the performance characteristics extracted from the native and simulative performance shows that the proposed simulation approach fully captured most of the performance characteristics of interest. This work shows and establishes the importance of simulations that realistically predict the performance of DLS techniques for different applications and system configurations.

Two-Dimensional Algebraic Codes for Multiple Burst Error Correction

We construct native binary 2D binary cyclic codes capable of correcting multiple occurrences of multiple non-overlapping pre-defined 2D error shapes using frequency domain techniques. The starting location of each error shape is determined using a novel decoding algorithm based on a careful selection of the common zero set. The proposed code construction is generic and offers superior coding rates compared to the native 2D BCH code with the same error correction ability.

Improved Ahead-of-time Compilation of Stack-based JVM Bytecode on Resource-constrained Devices

Many virtual machines exist for sensor nodes with only a few kB RAM and tens- to a few hundred kB Flash memory. They pack an impressive set of features but suffer from a slowdown of one to two orders of magnitude compared to optimised native code, reducing throughput and increasing power consumption. Compiling bytecode to native code to improve performance has been studied extensively for larger devices, but the restricted resources on sensor nodes mean most modern techniques cannot be applied. Simply replacing bytecode instructions with predefined sequences of native instructions is known to improve performance but produces code several times larger than the optimised C equivalent, limiting the size of programmes that can fit onto a device. This article identifies the major sources of overhead resulting from this basic approach and presents optimisations to remove most of the remaining performance overhead, and over half the size overhead, reducing them to 67% and 77%, respectively. While this increases the size of the VM, the break-even point at which this fixed cost is compensated for by the smaller code it generates, is well within the range of memory available on a sensor device, allowing us to both improve performance and load more code on a device.

Flare & lantern

Running machine learning (ML) workloads at scale is as much a data management problem as a model engineering problem. Big performance challenges exist when data management systems invoke ML classifiers as user-defined functions (UDFs) or when stand-alone ML frameworks interact with data stores for data loading and pre-processing (ETL). In particular, UDFs can be precompiled or simply a black box for the data management system and the data layout may be completely different from the native layout, thus adding overheads at the boundaries. In this demo, we will show how bottlenecks between existing systems can be eliminated when their engines are designed around runtime compilation and native code generation, which is the case for many state-of-the-art relational engines as well as ML frameworks. We demonstrate an integration of Flare (an accelerator for Spark SQL), and Lantern (an accelerator for TensorFlow and PyTorch) that results in a highly optimized end-to-end compiled data path, switching between SQL and ML processing with negligible overhead.

Code generator framework for smart TV platforms

In recent years, smart TVs have become more common, making them need to be included as targets for the software industry. In this study, the authors developed a code generator framework and demonstrated it in an architectural view. The proposed framework converts C# programming language based projects, in a Windows Forms or a Windows Phone Application project, into native smart TV Platform applications. The selected primary smart TV platforms assigned for application conversion were Android TV, Firefox OS, and Tizen OS. The authors enabled developers to generate native codes for all three platforms from a single code base using model to model conversion, as in the model driven architecture approach with the use of the open source Roslyn C# language compiler. The need for creating projects for every single platform to make them run on different platforms will thus be eliminated and development cycles shortened. By doing so, the time required to develop an application for each platform is reduced while keeping the generated applications’ quality as high as the original application. To show the functionality, the proposed approach is applied in three case studies. The success of the code conversion is satisfactory and converted applications are functional.

Identifying Android Malware Using Network-Based Approaches

The proliferation of Android apps has resulted in many malicious apps entering the market and causing significant damage. Robust techniques that determine if an app is malicious are greatly needed. We propose the use of a network-based approach to effectively separate malicious from benign apps, based on a small labeled dataset. The apps in our dataset come from the Google Play Store and have been scanned for malicious behavior using Virus Total to produce a ground truth dataset with labels malicous or benign. The apps in the resulting dataset have been represented using binary feature vectors (where the features represent permissions, intent actions, discriminative APIs, obfuscation signatures, and native code signatures). We have used the feature vectors corresponding to apps to build a weighted network that captures the “closeness” between apps. We propagate labels from the labeled apps to unlabeled apps, and evaluate the effectiveness of the proposed approach using the F1-measure. We have conducted experiments to compare three variants of the label propagation approaches on datasets that include increasingly larger amounts of labeled data. The results have shown that a variant proposed in this study gives the best results overall.

Static Identification of Injection Attacks in Java

The most dangerous security-related software errors, according to the OWASP Top Ten 2017 list, affect web applications. They are potential injection attacks that exploit user-provided data to execute undesired operations: database access and updates ( SQL injection ); generation of malicious web pages ( cross-site scripting injection ); redirection to user-specified web pages ( redirect injection ); execution of OS commands and arbitrary scripts ( command injection ); loading of user-specified, possibly heavy or dangerous classes at run time ( reflection injection ); access to arbitrary files on the file system ( path-traversal ); and storing user-provided data into heap regions normally assumed to be shielded from the outside world ( trust boundary violation ). All these attacks exploit the same weakness: unconstrained propagation of data from sources that the user of a web application controls into sinks whose activation might trigger dangerous operations. Although web applications are written in a variety of languages, Java remains a frequent choice, in particular for banking applications, where security has tangible relevance. This article defines a unified, sound protection mechanism against such attacks, based on the identification of all possible explicit flows of tainted data in Java code. Such flows can be arbitrarily complex, passing through dynamically allocated data structures in the heap. The analysis is based on abstract interpretation and is interprocedural, flow-sensitive, and context-sensitive. Its notion of taint applies to reference (non-primitive) types dynamically allocated in the heap and is object-sensitive and field-sensitive. The analysis works by translating the program into Boolean formulas that model all possible data flows. Its implementation, within the Julia analyzer for Java and Android, found injection security vulnerabilities in the Internet banking service and in the customer relationship management of large Italian banks, as well as in a set of open-source third-party applications. It found the command injection, which is at the origin of the 2017 Equifax data breach, one of the worst data breaches ever. For objective, repeatable results, this article also evaluates the implementation on two open-source security benchmarks: the Juliet Suite and the OWASP Benchmark for the automatic comparison of static analyzers for cybersecurity. We compared this technique against more than 10 other static analyzers, both free and commercial. The result of these experiments is that ours is the only analysis for injection that is sound (up to well-stated limitations such as multithreading and native code) and works on industrial code, and it is also much more precise than other tools.

The Case for Native Instructions in the Detection of Mobile Ransomware

Recently, the mobile segment observed the emergence of a new class of malware known as ransomware. In 2017, more than 468,830 unique mobile ransomware samples were discovered marking a 415 percent year-over-year increase in new ransomware. This trend presents a major concern for mobile users as they increasingly rely on their devices to safeguard sensitive information. Previous solutions have relied on high level bytecode and XML-based permission files to detect malicious applications. Unfortunately, attackers are resorting to obfuscation techniques that involve repackaging apps with malicious content directly in native machine code. As such, the aforementioned methods are insufficient for detecting modern mobile ransomware. To address these concerns, this work evaluates the effectiveness of using native instructions in detecting ransomware. We characterize different machine learning models and demonstrate that opcodes in native instructions can be used for detecting mobile ransomware with near ideal accuracy. In addition, we make the observation that the number of instruction opcodes that contribute to the detection of ransomware is significantly less than the full range of supported opcodes within a contemporary instruction set. Finally, we evaluate the robustness of our approach against six different ransomware families available in a state-of-the-art Android malware dataset.