Skip to content
Free planNo credit card requiredStart writing
AI for Research home
AI for Research home
Dashboard
Sign inGet started

Search 250 million research papers

Read the abstract, see who wrote it and who cites it, and get the citation in APA, MLA, Chicago or Harvard.

About 10,000 papers for “Machine code”

Machine learning techniques for code generation and optimization

David Padua, Xiaoming Li · 2006

The growing complexity of modern processors has made the generation of highly efficient code increasingly difficult. Manual code generation is very time consuming, but it is often the only choice since the code generated by today's compiler technology often has much lower performance than the best hand-tuned codes. A promising code generation strategy, implemented by systems like ATLAS, FFTW, and SPIRAL, uses empirical search to find the parameter values of the implementation, such as the tile size and instruction schedules, that deliver near-optimal performance for a particular machine. However, this approach has only proven successful on scientific codes whose performance does not depend on the input data. In this thesis we study machine learning techniques that extend empirical search to the generation of algorithms whose performance depends on both the input characteristics and the architecture of the target machine. More specially, we target our study on sorting and recursive matrix-matrix multiplication, which are two fundamental algorithm problems. We observe that various sorting algorithms perform differently depending on input characteristics. We first study if it is possible to predict and select the best sorting algorithm for a specific input. We develop a machine-learning based technique to find the mapping from architectural features and input characteristics to the selection of best algorithm. The mapping is used at runtime to make selection of sorting algorithms. Experiments show that our approach always predict the best sorting algorithm and the runtime overhead due to the selection is below 51%. Built the first study that selects a pure sorting algorithm at the outset of the computation as a function of the input characteristics, we develop algorithms and a classifier system to build hierarchically-organized hybrid sorting algorithms capable of adapting to the input data. Our results show that such algorithms generated using the approach presented in this thesis are quite effective at taking into account the complex interactions between architectural and input data characteristics and that the resulting code performs significantly better than conventional sorting implementations and the code generated by our earlier study. In particular, the routines generated using our approach perform better than all the commercial libraries that we tried including IBM ESSL, INTEL MKL and the C++ STL. We follow a similar approach and use a classifier learning system to generate high performance libraries for matrix-matrix multiplication. Our library generator produces matrix multiplication routines that use recursive layouts and several levels of tiling. Our approach is to use a classifier learning system to search in the space of the different ways to partition the input matrices the one that performs the best. As a result, our system will determine the number of levels of tiling and tile size for each level depending on the target platform and the dimensions of the input matrices.

Cited by 0

Execution backtracking using reverse execution of machine code

Paria Noorkami · Open Collections · 2009

Execution backtracking is the process of restoring the state of a program to an arbitrary point earlier in its execution history. It is used to facilitate program debugging. In this thesis, a novel execution backtracking approach is developed and implemented to assist the task of debugging software. The approach is demonstrated for structured C programs and exploits backtracking the program at machine code level. The approach has a lower run-time overhead than the existing approaches. The execution backtracking approach is integrated with a diagnosis test bed that consists of a symbolic debugger, a C cross-compiler, a virtual machine and a symbolic reasoner. A symbolic debugger is used to debug the target executable which is instrumented with a C cross-compiler. Relative advantages of the approach is that it is language independent, it is able to backtrack in presence of pointer operations, and it supports true execution replay and dynamic slicing. A relative disadvantage of the approach is that it is only able to partially restore a program's data state.

Cited by 0Open access

Code-Expanded Random Access for Machine-Type Communications

Nuno K. Pratas, Henning Thomsen, Čedomir Stefanović et al. · arXiv (Cornell University) · 2012

The random access methods used for support of machine-type communications (MTC) in current cellular standards are derivatives of traditional framed slotted ALOHA and therefore do not support high user loads efficiently. Motivated by the random access method employed in LTE, we propose a novel approach that is able to sustain a wide random access load range, while preserving the physical layer unchanged and incurring minor changes in the medium access control layer. The proposed scheme increases the amount of available contention resources, without resorting to the increase of system resources, such as contention sub-frames and preambles. This increase is accomplished by expanding the contention space to the code domain, through the creation of random access codewords. Specifically, in the proposed scheme, users perform random access by transmitting one or none of the available LTE orthogonal preambles in multiple random access sub-frames, thus creating access codewords that are used for contention. In this way, for the same number of random access sub-frames and orthogonal preambles, the amount of available contention resources is drastically increased, enabling the support of an increased number of MTC users. We present the framework and analysis of the proposed code-expanded random access method and show that our approach supports load regions that are beyond the reach of current systems.

Cited by 1Open access

Machine code verification of a tiny ARM hypervisor

Mads Dam, Roberto Guanciale, Hamed Nemati · KTH Publication Database DiVA (KTH Royal Institute of Technology) · 2013

Hypervisors are low level execution platforms that provide isolated partitions on shared resources, allowing to design secure systems without using dedicated hardware devices. A key requirement of this kind of solution is the formal verification of the software trusted computing base, preferably at the binary level. We accomplish a detailed verification of an ARMv7 tiny hypervisor, proving its correctness at the machine code level. We present our verification strategy, which mixes the usage of the theorem prover HOL4, the computation of weakest preconditions, and the use of SMT solvers to largely automate the verification process. The automation relies on an integration of HOL4 with BAP, the Binary Analysis Platform developed at CMU. To enable the adoption of the BAP back-ends to compute weakest preconditions and control flow graphs, a HOL4-based tool was implemented that transforms ARMv7 assembly programs to the BAP Intermediate Language. Since verifying contracts by computing the weakest precondition depends on resolving indirect jumps, we implemented a procedure that integrates SMT solvers and BAP to discover all the possible assignments to the indirect jumps under the contract precondition.

Cited by 25Open access

Partitioning of code for a massively parallel machine

Michael Ball, C. Cifuentaes, Deepankar Bairagi · 2004

Code partitioning is the problem of dividing sections of code among a set of processors for execution in parallel taking into account the communication overhead between the processors. Code partitioning of large amounts of code onto numerous processors requires variations to the classical partitioning algorithms, in part due to the memory and time requirements to partition a large set of data, but also due to the nature of the target machine and multiple constraints imposed by its architectural features. We present our experience in the design of enhancements to the classical multilevel k-way partitioning algorithm to deal with large graphs of over 1 million nodes, 5 constraints, and nodes of irregular size. Our algorithm was implemented to produce code for a massively parallel machine of up to 40,000 processors, and forms part of a hardware description language compiler. The algorithm and the compiler were tested on RTL designs for a next generation SPARC(R) processor. We present performance results and comparisons for partitioning multiprocessor hardware designs.

Cited by 23

deepKnit: Learning-based Generation of Machine Knitting Code

Fabian Scheidt, Jifei Ou, Hiroshi Ishii et al. · Procedia Manufacturing · 2020

Modern knitting machines allow the manufacturing of various textile products with complex surface structures and patterns. However, programming these machines requires expert knowledge due to constraints of the process and the programming language. We present a long short-term memory (LSTM) based deep learning model that generates low-level code of novel knitting patterns based on high-level style specifications. To be processable by our model, we describe knitting instructions as one-dimensional sequences of tokens, which diverts from image-based approaches reported in previous research. We integrate our model into a design tool, that allows to assemble the atomic patterns to bigger swatches or garments. To evaluate our approach quantitatively, we formalize the requirements for patterns to be syntactically correct and valid to manufacture. Although our generated patterns look more random and seem to resemble less to human patterns, our evaluation shows that their knittability is orders of magnitudes better than randomly generated patterns.

Cited by 9Open access

Identifying Vulnerable C Code using Machine Learning Techniques

Siddharth Phatak, Joel Ramirez · 2024

This report presents the development and evaluation of a machine learning model for identifying vulnerable C code. Using an AI-generated dataset of both vulnerable and non-vulnerable C code snippets, we explore various methodologies including Bag of W

Cited by 0Open access

Machine learning based analysis of object oriented code

Кузьмина Илия Викторовна, Kuzmina Iliia · Research Repository Saint Petersburg State University (Saint Petersburg State University) · 2017

Кузьмина Илия Викторовна Анализ программного кода методами машинного обучения к.т.н., доц. кафедры системного программирования Брыксин Тимофей Александрович Направление математика и механика, кафедра системного программирования Методы машинного обучения широко используются в различных областях, и хотя с анализом кода программ, написанных на объектно-ориентированном языке, человек всё ещё справляется гораздо лучше, определённые инструменты могли бы принести в этом пользу. В работе описывается подход к автоматическому рефакторингу архитектуры объектно-ориентированного кода. Результатами работы является исследование и разработка алгоритмов автоматической реструктуризации кода и создание инструмента для автоматической реструктуризации программ в виде плагина к среде разработки IntelliJ IDEA. Использованных источников: 27 Кузьмина, И. В. Анализ программного кода методами машинного обучения: выпускная квалификационная работа: защищена 08.06.2017 / Кузьмина Илия Викторовна. – СПб., 2017. – 27 с. – Библиография: с. 25–27.

Cited by 0Open access

Retargettable Code Generation using Sim-nML Machine Description

Prashant Pogde · 2000

In embedded systems design, strong need exists for generic processor models using which a set of system specific tool e.g. functional simulator, compiler, assembler, disassembler, code instrumentor can be generated from the processor specification. Sim-nML is one such specification language for describing generic processor models. Design of Sim-nML is aimed at providing more exibility and ease of use in writing machine descriptions along with the intent to design automatic tool generators for tools like functional simulator, assembler etc. So the way instruction semantics are described in Sim-nML makes it difficult to generate compiler back-end directly from the Sim-nML specification. In this

Cited by 0

Classification of malicious web code by machine learning

Ryohei Komiya, Incheon Paik, Masayuki Hisada · 2011

Web applications make life more convenient through on the activities. Many web applications have several kind of user input (e.g. personal information, a user's comment of commercial goods, etc.) for the activities. However, there are various vulnerabilities in input functions of web applications. It is possible to try malicious actions using free accessibility of the web applications. The attacks by exploitation of these input vulnerabilities enable to be performed by injecting malicious web code; it enables one to perform various illegal actions, such as SQL Injection Attacks (SQLIAs) and Cross Site Scripting (XSS). These actions come down to theft, replacing personal information, or phishing. Many solutions have devised for the malicious web code, such as AMNESIA [1] and SQL Check [2], etc. The methods use parser for the code, and limited to fixed and very small patterns, and are difficult to adapt to variations. Machine learning method can give leverage to cover far broader range of malicious web code and is easy to adapt to variations and changes. Therefore, we suggests adaptable classification of malicious web code by machine learning approach such as Support Vector Machine (SVM) [3], Naïve-Bayes [4], and k-Nearest Neighbor Algorithm [5] for detecting the exploitation user inputs.

Cited by 53

Machine Code Caching in PostgreSQL Query JIT-Compiler

Michael Pantilimonov, Ruben Buchatskiy, Roman Zhuykov et al. · 2019

As the efficiency of main and external memory grows, alongside with decreasing hardware costs, the performance of database management systems (DBMS) on certain kinds of queries is more determined by CPU characteristics and the way it is utilized. Relational DBMS utilize diverse execution models to run SQL queries. Those models have different properties, but in either way suffer from substantial overhead during query plan interpretation. The overhead comes from indirect calls to handler functions, runtime checks and large number of branch instructions. One way to solve this problem is dynamic query compilation that is reasonable only in those cases when query interpretation time is larger than the time of compilation and optimized machine code execution. This requirement can be satisfied only when the amount of data to be processed is large enough. If query interpretation takes milliseconds to finish, then the cost of dynamic compilation can be hundreds of times more than the execution time of generated machine code. To pay off the cost of dynamic compilation, the generated machine code has to be reused in subsequent executions, thus saving the cost of code compilation and optimization. In this paper, we examine the method of machine code caching in our query JIT-compiler for DBMS PostgreSQL. The proposed method allows us to eliminate compilation overhead. The results show that dynamic compilation of queries with machine code caching feature gives a significant speedup on OLTP queries.

Cited by 6

How (not) to code a finite state machine

Douglas W. Jones · ACM SIGPLAN Notices · 1988

The standard advice for those coding a finite state machine is to use a while loop, a case statement, and a state variable. This is usually bad advice! The reasons for this are explored here, and better advice is formulated.

Cited by 5

Machine learning based code smell detection through WekaNose

Umberto Azadi, Francesca Arcelli Fontana, Marco Zanoni · 2018

Code smells can be subjectively interpreted, the results provided by detectors are usually different, the agreement in the results is scarce, and a benchmark for the comparison of these results is not yet available. The main approaches used to detect code smells are based on the computation of a set of metrics. However code smell detectors often use different metrics and/or different thresholds, according to their detection rules. As result of this inconsistency the number of detected smells can increase or decrease accordingly, and this makes hard to understand when, for a specific software, a certain characteristic identifies a code smell or not. In this work, we introduce WekaNose, a tool that allows to perform an experiment to study code smell detection through machine learning techniques. The experiment's purpose is to select rules, and/or obtain trained algorithms, that can classify an instance (method or class) as affected or not by a code smell. These rules have the main advantage of being extracted through an example-based approach, rather then a heuristic-based one.

Cited by 14

Cigarette box code recognition based on machine vision

Qifan Wen, Xiaofei Ji · Frontiers in Computing and Intelligent Systems · 2022

This paper addresses this challenge by using machine vision to firstly collect cigarette box image data and process the images with grayscale and binarization, and then extract the characters to be trained by extracting the region of interest and doing threshold segmentation in turn. The SVM classifier was used to train the extracted characters, and finally the characters were recognized in turn, and the recognition effects of different classifiers were compared and analyzed, and it was concluded that the SVM classifier has the best effect and is suitable for enterprise production.

Cited by 0Open access

Network traffic and code for machine learning classification

Labayen, Víctor · Mendeley Data · 2020

The dataset is a set of network traffic traces in pcap/csv format captured from a single user. The traffic is classified in 5 different activities (Video, Bulk, Idle, Web, and Interactive) and the label is shown in the filename. There is also a file (mapping.csv) with the mapping of the host's IP address, the csv/pcap filename and the activity label. Activities: Interactive: applications that perform real-time interactions in order to provide a suitable user experience, such as editing a file in google docs and remote CLI's sessions by SSH. Bulk data transfer: applications that perform a transfer of large data volume files over the network. Some examples are SCP/FTP applications and direct downloads of large files from web servers like Mediafire, Dropbox or the university repository among others. Web browsing: contains all the generated traffic while searching and consuming different web pages. Examples of those pages are several blogs and new sites and the moodle of the university. Vídeo playback: contains traffic from applications that consume video in streaming or pseudo-streaming. The most known server used are Twitch and Youtube but the university online classroom has also been used. Idle behaviour: is composed by the background traffic generated by the user computer when the user is idle. This traffic has been captured with every application closed and with some opened pages like google docs, YouTube and several web pages, but always without user interaction. The capture is performed in a network probe, attached to the router that forwards the user network traffic, using a SPAN port. The traffic is stored in pcap format with all the packet payload. In the csv file, every non TCP/UDP packet is filtered out, as well as every packet with no payload. The fields in the csv files are the following (one line per packet): Timestamp, protocol, payload size, IP address source and destination, UDP/TCP port source and destination. The fields are also included as a header in every csv file. The amount of data is stated as follows: Bulk : 19 traces, 3599 s of total duration, 8704 MBytes of pcap files Video : 23 traces, 4496 s, 1405 MBytes Web : 23 traces, 4203 s, 148 MBytes Interactive : 42 traces, 8934 s, 30.5 MBytes Idle : 52 traces, 6341 s, 0.69 MBytes The code of our machine learning approach is also included. There is a README.txt file with the documentation of how to use the code.

Cited by 0Open access

A machine learning approach towards SKILL code autocompletion

Enrique Dehaerne, Bappaditya Dey, Wannes Meert et al. · Lirias (KU Leuven) · 2024

As Moore’s Law continues to increase the complexity of electronic systems, Electronic Design Automation (EDA) must advance to meet global demand. An important example of an EDA technology is SKILL, a scripting language used to customize and extend EDA software. Recently, code generation models using the transformer architecture have achieved impressive results in academic settings and have even been used in commercial developer tools to improve developer productivity. To the best of our knowledge, this study is the first to apply transformers to SKILL code autocompletion towards improving the productivity of hardware design engineers. In this study, a novel, data-efficient methodology for generating SKILL code is proposed and experimentally validated. More specifically, we propose a novel methodology for (i) creating a high-quality SKILL dataset with both unlabeled and labeled data, (ii) a training strategy where T5 models pre-trained on general programming language code are fine-tuned on our custom SKILL dataset using self-supervised and supervised learning, and (iii) evaluating synthesized SKILL code. We show that models trained using the proposed methodology outperform baselines in terms of human-judgment score and BLEU score. A major challenge faced was the extremely small amount of available SKILL code data that can be used to train a transformer model to generate SKILL code. Despite our validated improvements, the extremely small dataset available to us was still not enough to train a model that can reliably autocomplete SKILL code. We discuss this and other limitations as well as future work that could address these limitations.

Cited by 0Open access