Relevant bibliographies by topics / Just-in-time (JIT) compiler

Contents

  1. Journal articles
  2. Dissertations / Theses
  3. Books
  4. Book chapters
  5. Conference papers

Academic literature on the topic 'Just-in-time (JIT) compiler'

Author: Grafiati
Published: 7 September 2024

Create a spot-on reference in APA, MLA, Chicago, Harvard, and other styles

Select a source type:

Consult the lists of relevant articles, books, theses, conference reports, and other scholarly sources on the topic 'Just-in-time (JIT) compiler.'

Next to every source in the list of references, there is an 'Add to bibliography' button. Press on it, and we will generate automatically the bibliographic reference to the chosen work in the citation style you need: APA, MLA, Harvard, Chicago, Vancouver, etc.

You can also download the full text of the academic publication as pdf and read online its abstract whenever available in the metadata.

Journal articles on the topic "Just-in-time (JIT) compiler"

1

Телегин, В. А. "AHEAD-OF-TIME and JUST-IN-TIME technologies." Vestnik of Russian New University. Series «Complex systems: models, analysis, management», no. 4 (December 29, 2023): 171–75. http://dx.doi.org/10.18137/rnu.v9187.23.04.p.171.

Full text
Abstract:
Статья посвящена исследованию AOT- и JIT-технологий. Обосновывается актуальность и значимость темы исследования. Существует два способа компиляции приложения: своевременная компиляция ( JIT) или компиляция с опережением времени (AOT). Первый вид – это режим по умолчанию, который используется виртуальной машиной Java Hotspot для преобразования байт-кода в машинный код во время выполнения. Второй вид поддерживается новым компилятором GraalVM и позволяет статически компилировать байт-код непосредственно в машинный код во время сборки. Рассматриваются основные различия между этими двумя стратегиями компиляции. The article focuses on the study of Ahead-of-Time and Just-in-Time technologies. The author substantiates the relevance and significance of the research topic. There are two ways to compile an application using JIT or AOT compilation. The first is the default mode and is used by the Java Hotspot virtual machine to convert bytecode to machine code at runtime. The latter is supported by the new GraalVM compiler and allows bytecode to be statically compiled directly into machine code at build time. In this article, the author discusses the main differences between these two compilation strategies.
APA, Harvard, Vancouver, ISO, and other styles
2

Știrb, Iulia, and Gilbert-Rainer Gillich. "A Low-Level Virtual Machine Just-In-Time Prototype for Running an Energy-Saving Hardware-Aware Mapping Algorithm on C/C++ Applications That Use Pthreads." Energies 16, no. 19 (September 23, 2023): 6781. http://dx.doi.org/10.3390/en16196781.

Full text
Abstract:
Low-Level Virtual Machine (LLVM) compiler infrastructure is a useful tool for building just-in-time (JIT) compilers, besides its reliable front end represented by a clang compiler and its elaborated middle end containing different optimizations that improve the runtime performance. This paper specifically addresses the part of building a JIT compiler using an LLVM with the scope of obtaining the hardware architecture details of the underlying machine such as the number of cores and the number of logical cores per processing unit and providing them to the NUMA-BTLP static thread classification algorithm and to the NUMA-BTDM static thread mapping algorithm. Afterwards, the hardware-aware algorithms are run using the JIT compiler within an optimization pass. The JIT compiler in this paper is designed to run on a parallel C/C++ application (which creates threads using Pthreads), before the first time the application is executed on a machine. To achieve this, the JIT compiler takes the native code of the application, obtains the corresponding LLVM IR (Intermediate Representation) for the native code and executes the hardware-aware thread classification and the thread mapping algorithms on the IR. The NUMA-Balanced Task and Loop Parallelism (NUMA-BTLP) and NUMA-Balanced Thread and Data Mapping (NUMA-BTDM) are expected to optimize the energy consumption by up to 15% on the NUMA systems.
APA, Harvard, Vancouver, ISO, and other styles
3

Agosta, Giovanni, Stefano Crespi Reghizzi, Gerlando Falauto, and Martino Sykora. "JIST: Just-In-Time Scheduling Translation for Parallel Processors." Scientific Programming 13, no. 3 (2005): 239–53. http://dx.doi.org/10.1155/2005/127158.

Full text
Abstract:
The application fields of bytecode virtual machines and VLIW processors overlap in the area of embedded and mobile systems, where the two technologies offer different benefits, namely high code portability, low power consumption and reduced hardware cost. Dynamic compilation makes it possible to bridge the gap between the two technologies, but special attention must be paid to software instruction scheduling, a must for the VLIW architectures. We have implemented JIST, a Virtual Machine and JIT compiler for Java Bytecode targeted to a VLIW processor. We show the impact of various optimizations on the performance of code compiled with JIST through the experimental study on a set of benchmark programs. We report significant speedups, and increments in the number of instructions issued per cycle up to 50% with respect to the non-scheduling version of the JITcompiler. Further optimizations are discussed.
APA, Harvard, Vancouver, ISO, and other styles
4

Serrano, Manuel. "Of JavaScript AOT compilation performance." Proceedings of the ACM on Programming Languages 5, ICFP (August 22, 2021): 1–30. http://dx.doi.org/10.1145/3473575.

Full text
Abstract:
The fastest JavaScript production implementations use just-in-time (JIT) compilation and the vast majority of academic publications about implementations of dynamic languages published during the last two decades focus on JIT compilation. This does not imply that static compilers (AoT) cannot be competitive; as comparatively little effort has been spent creating fast AoT JavaScript compilers, a scientific comparison is lacking. This paper presents the design and implementation of an AoT JavaScript compiler, focusing on a performance analysis. The paper reports on two experiments, one based on standard JavaScript benchmark suites and one based on new benchmarks chosen for their diversity of styles, authors, sizes, provenance, and coverage of the language. The first experiment shows an advantage to JIT compilers, which is expected after the decades of effort that these compilers have paid to these very tests. The second shows more balanced results, as the AoT compiler generates programs that reach competitive speeds and that consume significantly less memory. The paper presents and evaluates techniques that we have either invented or adapted from other systems, to improve AoT JavaScript compilation.
APA, Harvard, Vancouver, ISO, and other styles
5

Shelke, Rahul, Aditya Kuwar, and M. Ramachandran. "A Study on Just in Time Application in Flexible Manufacturing System." 1 7, no. 1 (March 1, 2021): 1–5. http://dx.doi.org/10.46632/jemm/7/1/1.

Full text
Abstract:
Just-in-time 'management philosophy not process. Originally it referred to the production of goods to meet customer demand exactly, over time, quality and quantity, whether the 'customer' was the final consumer of the product or other ongoing process in the production line. A just-in-time (JIT) innovation management system that aligns green orders from direct providers with production schedules. JIT’s innovation program is opposed to intervention strategies, in which manufacturers hold sufficient lists to have sufficient product to meet the growing market demand. It is necessary to create a JIT production plan that monitors the total capacity of your equipment and secures the appropriate dates for your production products for sale. A just-in-time (JIT) innovation management system that aligns green orders from direct providers with production schedules. Companies use this innovative strategy to increase efficiency and reduce waste by acquiring goods only as they need them through the production process, which reduces the cost of goods. This approach requires that producers accurately predict demand. just-in-time integration (JIT) (also a dynamic integration or dynamic integration) [1] is a computer-generated method that involves integration during programming - during operation - rather than pre-execution. Usually, this contains the source code or the most common bytecode translation in the machine code, and is done directly. A system that uses the JIT compiler continuously analyzes the code used and identifies parts of the code where the speed achieved in merging or resizing will exceed the integration of that code. This study aims to compare existing perceptions of the Just-in-Time (JIT) issue with the practice reported by companies in existing art courses. This study aims to contribute to the knowledge of the key features of JIT used in performance reported in powerful studies, and to identify the major benefits of using JIT mentioned by companies applying this philosophy. A just-in-time (JIT) innovation management system that aligns green orders from direct providers with production schedules. JIT’s innovative program opposes intervention strategies, in which manufacturers hold sufficient lists to have enough product to get the most demanding in the market. In manufacturing, marketing speed and production costs can make or break a company. Short-term production (JIT) is a workflow approach that aims to reduce flow times within production systems, as well as response times from suppliers and customers.
APA, Harvard, Vancouver, ISO, and other styles
6

Zang, Zhiqiang, Fu-Yao Yu, Aditya Thimmaiah, August Shi, and Milos Gligoric. "Java JIT Testing with Template Extraction." Proceedings of the ACM on Software Engineering 1, FSE (July 12, 2024): 1129–51. http://dx.doi.org/10.1145/3643777.

Full text
Abstract:
We present LeJit, a template-based framework for testing Java just-in-time (JIT) compilers. Like recent template-based frameworks, LeJit executes a template---a program with holes to be filled---to generate concrete programs given as inputs to Java JIT compilers. LeJit automatically generates template programs from existing Java code by converting expressions to holes, as well as generating necessary glue code (i.e., code that generates instances of non-primitive types) to make generated templates executable. We have successfully used LeJit to test a range of popular Java JIT compilers, revealing five bugs in HotSpot, nine bugs in OpenJ9, and one bug in GraalVM. All of these bugs have been confirmed by Oracle and IBM developers, and 11 of these bugs were previously unknown, including two CVEs (Common Vulnerabilities and Exposures). Our comparison with several existing approaches shows that LeJit is complementary to them and is a powerful technique for ensuring Java JIT compiler correctness.
APA, Harvard, Vancouver, ISO, and other styles
7

D'Souza, Matt, James You, Ondřej Lhoták, and Aleksandar Prokopec. "TASTyTruffle: Just-in-Time Specialization of Parametric Polymorphism." Proceedings of the ACM on Programming Languages 7, OOPSLA2 (October 16, 2023): 1561–88. http://dx.doi.org/10.1145/3622853.

Full text
Abstract:
Parametric polymorphism enables programmers to express algorithms independently of the types of values that they operate on. The approach used to implement parametric polymorphism can have important performance implications. One popular approach, erasure, uses a uniform representation for generic data, which entails primitive boxing and other indirections that harm performance. Erasure destroys type information that could be used by language implementations to optimize generic code. We present TASTyTruffle, an implementation for a subset of the Scala programming language. Instead of JVM bytecode, TASTyTruffle interprets Scala's TASTy intermediate representation, a typed representation wherein generic types are not erased. TASTy's precise type information empowers TASTyTruffle to implement generic code more effectively. In particular, it allows TASTyTruffle to reify types as run-time objects that can be passed around. Using reified types, TASTyTruffle supports heterogeneous box-free representations for generic values. TASTyTruffle also uses reified types to specialize generic code, producing monomorphic copies of generic code that can be easily and reliably optimized by its just-in-time (JIT) compiler. Empirically, TASTyTruffle is competitive with standard JVM implementations on a small set of benchmark programs; when generic code is used with multiple types, TASTyTruffle consistently outperforms the JVM. The precise type information in TASTy enables TASTyTruffle to find additional optimization opportunities that could not be uncovered with erased JVM bytecode.
APA, Harvard, Vancouver, ISO, and other styles
8

Barrière, Aurèle, Sandrine Blazy, and David Pichardie. "Formally Verified Native Code Generation in an Effectful JIT: Turning the CompCert Backend into a Formally Verified JIT Compiler." Proceedings of the ACM on Programming Languages 7, POPL (January 9, 2023): 249–77. http://dx.doi.org/10.1145/3571202.

Full text
Abstract:
Modern Just-in-Time compilers (or JITs) typically interleave several mechanisms to execute a program. For faster startup times and to observe the initial behavior of an execution, interpretation can be initially used. But after a while, JITs dynamically produce native code for parts of the program they execute often. Although some time is spent compiling dynamically, this mechanism makes for much faster times for the remaining of the program execution. Such compilers are complex pieces of software with various components, and greatly rely on a precise interplay between the different languages being executed, including on-stack-replacement. Traditional static compilers like CompCert have been mechanized in proof assistants, but JITs have been scarcely formalized so far, partly due to their impure nature and their numerous components. This work presents a model JIT with dynamic generation of native code, implemented and formally verified in Coq. Although some parts of a JIT cannot be written in Coq, we propose a proof methodology to delimit, specify and reason on the impure effects of a JIT. We argue that the daunting task of formally verifying a complete JIT should draw on existing proofs of native code generation. To this end, our work successfully reuses CompCert and its correctness proofs during dynamic compilation. Finally, our prototype can be extracted and executed.
APA, Harvard, Vancouver, ISO, and other styles
9

Clemente-López, Daniel, Esteban Tlelo-Cuautle, Luis-Gerardo de la Fraga, José de Jesús Rangel-Magdaleno, and Jesus Manuel Munoz-Pacheco. "Poincaré maps for detecting chaos in fractional-order systems with hidden attractors for its Kaplan-Yorke dimension optimization." AIMS Mathematics 7, no. 4 (2022): 5871–94. http://dx.doi.org/10.3934/math.2022326.

Full text
Abstract:
<abstract><p>The optimization of fractional-order (FO) chaotic systems is challenging when simulating a considerable number of cases for long times, where the primary problem is verifying if the given parameter values will generate chaotic behavior. In this manner, we introduce a methodology for detecting chaotic behavior in FO systems through the analysis of Poincaré maps. The optimization process is performed applying differential evolution (DE) and accelerated particle swarm optimization (APSO) algorithms for maximizing the Kaplan-Yorke dimension ($ D_{KY} $) of two case studies: a 3D and a 4D FO chaotic systems with hidden attractors. These FO chaotic systems are solved applying the Grünwald-Letnikov method, and the Numba just-in-time (jit) compiler is used to improve the optimization process's time execution in Python programming language. The optimization results show that the proposed method efficiently optimizes FO chaotic systems with hidden attractors while saving execution time.</p></abstract>
APA, Harvard, Vancouver, ISO, and other styles
10

Alam, Marzia, Mehreen Saleem Gul, and Tariq Muneer. "Radiation View Factor for Building Applications: Comparison of Computation Environments." Energies 12, no. 20 (October 10, 2019): 3826. http://dx.doi.org/10.3390/en12203826.

Full text
Abstract:
Computation of view factors is required in several building engineering applications where radiative exchange takes place between surfaces such as ground and vertical walls or ground and sloping thermal or photovoltaics collectors. In this paper, view factor computations are performed for bifacial solar photovoltaic (PV) collectors based on the finite element method (FEM) using two programming languages known as Microsoft Excel-Visual Basic for Applications (VBA) and Python. The aim is to determine the computer response time as well as the performance of the two languages in terms of accuracy and convergence of the numerical solution. To run the simulations in Python, an open source just-in-time (JIT) compiler called Numba was used and the same program was also run as a macro in VBA. It was observed that the simulation response time significantly decreased in Python when compared to VBA. This decrease in time was due to the increase in the total number of iterations from 400 million to 250 billion for a given case. Results demonstrated that Python was 71–180 times faster than VBA and, therefore, offers a better programming platform for the view factor analysis and modelling of bifacial solar PV where computation time is a significant modelling challenge.
APA, Harvard, Vancouver, ISO, and other styles
More sources

Dissertations / Theses on the topic "Just-in-time (JIT) compiler"

1

Ducasse, Quentin. "Sécurisation matérielle de la compilation à la volée des machines virtuelles langage." Electronic Thesis or Diss., Brest, École nationale supérieure de techniques avancées Bretagne, 2024. http://www.theses.fr/2024ENTA0003.

Full text
Abstract:
Les machines virtuelles langage (VM) sont l’environnement d’exécution des langages de haut niveau les plus répandus. Elles permettent une portabilité du code applicatif et la gestion automatique de la mémoire. Leur large diffusion couplée à l’exécution de tâches de bas niveau les rendent intéressantes pour les attaquants. Les solutions purement logicielles entraînent souvent une perte de performance incompatible avec la compilation just-in-time (JIT). Des solutions accélérées matériellement sont ajoutées dans des processeurs commerciaux pour concilier des garanties de sécurité fortes avec la performance. Pour comparer ces solutions, cette thèse s’intéresse au jeu d’instructions RISC-V et à ses capacités d’extension. Nous présentons Gigue, un générateur de binaires similaires au code JIT directement exécutables sur les softcores RISC-V. Il fournit une interface pour des instructions personnalisées et garantit leur exécution. Nous présentons une solution d’isolation de domaine au niveau des instructions ajoutée aux binaires de Gigue et déployée dans un processeur avec des modifications minimales. La solution ajoute un surcoût de performance négligeable tout en garantissant des propriétés fortes sur les domaines. Afin de motiver le déploiement dans des cas d’utilisation réels, nous étendons le compilateur JIT Pharo au jeu d’instructions RISC-V, ainsi que son infrastructure de test
Language Virtual Machines (VMs) are the run-time environment of popular high level managed languages. They offer portability and memory handling for the developer and are deployed on most computing devices. Their widespread distribution, handling of untrusted user inputs, and low-level task execution make them interesting to attackers. Software-only solutions that isolate their different components often incur a high performance overhead incompatible with just-in-time (JIT) compilation. Hardware-accelerated run time protections are pushed in vendor processors as a solution to conciliate strong security guarantees with performance. To allow experimentation in the design and comparison of such solutions, this thesis is interested in the RISC-V instruction set and its extension capabilities. We present Gigue, a workload generator that outputs binaries similar to JIT code directly executable on RISC-V softcores. It provides an interface for custom instructions and guarantees their execution. We present an instruction-level domain isolation solution added to Gigue binaries and implemented in an application-class processor with processor modifications. The solution adds negligible performance overhead while enforcing strong properties on domains. As an effort to motivate deployment in real use cases, we extend the Pharo JIT compiler to the RISC-V instruction set along with its testing infrastructure
APA, Harvard, Vancouver, ISO, and other styles
2

Hostetter, Mathew J. (Mathew James). "JITB : a back end for just-in-time compilers." Thesis, Massachusetts Institute of Technology, 1997. http://hdl.handle.net/1721.1/42707.

Full text
Abstract:
Thesis (M. Eng.)--Massachusetts Institute of Technology, Dept. of Electrical Engineering and Computer Science, 1997.
Includes bibliographical references (leaves 56-57).
by Mathew J. Hostetter.
M.Eng.
APA, Harvard, Vancouver, ISO, and other styles
3

BHALGAT, ASHISH ZUMBARLAL. "INSTRUCTION SCHEDULING TO HIDE LOAN/STORE LATENCY IN IRREGULAR ARCHITECTURE EMBEDDED PROCESSORS." University of Cincinnati / OhioLINK, 2001. http://rave.ohiolink.edu/etdc/view?acc_num=ucin982261963.

Full text
APA, Harvard, Vancouver, ISO, and other styles
4

Pramod, B. S. "Performance Measurement Of A Java Virtual Machine." Thesis, 1999. https://etd.iisc.ac.in/handle/2005/1530.

Full text
APA, Harvard, Vancouver, ISO, and other styles
5

Pramod, B. S. "Performance Measurement Of A Java Virtual Machine." Thesis, 1999. http://etd.iisc.ernet.in/handle/2005/1530.

Full text
APA, Harvard, Vancouver, ISO, and other styles

Books on the topic "Just-in-time (JIT) compiler"

1

Pea, Pehat. Essentials of PHP in a Well-Organized Format, Including New Features in PHP 8 Such As the Just in Time (JIT) Compiler, Union Types... . . Independently Published, 2021.

Find full text
APA, Harvard, Vancouver, ISO, and other styles

Book chapters on the topic "Just-in-time (JIT) compiler"

1

Yuan, Shenghao, Frédéric Besson, and Jean-Pierre Talpin. "End-to-End Mechanized Proof of a JIT-Accelerated eBPF Virtual Machine for IoT." In Computer Aided Verification, 325–47. Cham: Springer Nature Switzerland, 2024. http://dx.doi.org/10.1007/978-3-031-65627-9_16.

Full text
Abstract:
AbstractModern operating systems have adopted Berkeley Packet Filters (BPF) as a mechanism to extend kernel functionalities dynamically, e.g., Linux’s eBPF or RIOT’s rBPF. The just-in-time (JIT) compilation of eBPF introduced in Linux eBPF for performance has however led to numerous critical issues. Instead, RIOT’s rBPF uses a slower but memory-isolating interpreter (a virtual machine) which implements a defensive semantics of BPF; and therefore trades performance for security. To increase performance without sacrificing security, this paper presents a fully verified JIT implementation for RIOT’s rBPF, consisting of: i/ an end-to-end refinement workflow to both proving the JIT correct from an abstract specification and by deriving a verified concrete C implementation; ii/ a symbolic CompCert interpreter for executing binary code; iii/ a verified JIT compiler for rBPF; iv/ a verified hybrid rBPF virtual machine. Our core contribution is, to the best of our knowledge, the first and fully verified rBPF JIT compiler with correctness guarantees from high-level specification to low-level implementation. Benchmarks on microcontrollers hosting the RIOT operating system demonstrate significant performance improvements over the existing implementations of rBPF, even in worst-case application scenarios.
APA, Harvard, Vancouver, ISO, and other styles

Conference papers on the topic "Just-in-time (JIT) compiler"

1

Caamaño, Juan Manuel Martinez, and Serge Guelton. "Easy::Jit: compiler assisted library to enable just-in-time compilation in C++ codes." In 2018: 2nd International Conference on the Art, Science, and Engineering of Programming 2018. New York, NY, USA: ACM, 2018. http://dx.doi.org/10.1145/3191697.3191725.

Full text
APA, Harvard, Vancouver, ISO, and other styles
You might also be interested in the extended bibliographies on the topic 'Just-in-time (JIT) compiler' for particular source types:
Journal articles
We offer discounts on all premium plans for authors whose works are included in thematic literature selections. Contact us to get a unique promo code!

To the bibliography