Letteratura scientifica selezionata sul tema "Just-in-time (JIT) compiler"
Cita una fonte nei formati APA, MLA, Chicago, Harvard e in molti altri stili
Consulta la lista di attuali articoli, libri, tesi, atti di convegni e altre fonti scientifiche attinenti al tema "Just-in-time (JIT) compiler".
Accanto a ogni fonte nell'elenco di riferimenti c'è un pulsante "Aggiungi alla bibliografia". Premilo e genereremo automaticamente la citazione bibliografica dell'opera scelta nello stile citazionale di cui hai bisogno: APA, MLA, Harvard, Chicago, Vancouver ecc.
Puoi anche scaricare il testo completo della pubblicazione scientifica nel formato .pdf e leggere online l'abstract (il sommario) dell'opera se è presente nei metadati.
Articoli di riviste sul tema "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», n. 4 (29 dicembre 2023): 171–75. http://dx.doi.org/10.18137/rnu.v9187.23.04.p.171.
Testo completoAbstract (sommario):
Статья посвящена исследованию 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.
2
Știrb, Iulia, e 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, n. 19 (23 settembre 2023): 6781. http://dx.doi.org/10.3390/en16196781.
Testo completoAbstract (sommario):
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.
3
Agosta, Giovanni, Stefano Crespi Reghizzi, Gerlando Falauto e Martino Sykora. "JIST: Just-In-Time Scheduling Translation for Parallel Processors". Scientific Programming 13, n. 3 (2005): 239–53. http://dx.doi.org/10.1155/2005/127158.
Testo completoAbstract (sommario):
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.
4
Serrano, Manuel. "Of JavaScript AOT compilation performance". Proceedings of the ACM on Programming Languages 5, ICFP (22 agosto 2021): 1–30. http://dx.doi.org/10.1145/3473575.
Testo completoAbstract (sommario):
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.
5
Shelke, Rahul, Aditya Kuwar e M. Ramachandran. "A Study on Just in Time Application in Flexible Manufacturing System". 1 7, n. 1 (1 marzo 2021): 1–5. http://dx.doi.org/10.46632/jemm/7/1/1.
Testo completoAbstract (sommario):
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.
6
Zang, Zhiqiang, Fu-Yao Yu, Aditya Thimmaiah, August Shi e Milos Gligoric. "Java JIT Testing with Template Extraction". Proceedings of the ACM on Software Engineering 1, FSE (12 luglio 2024): 1129–51. http://dx.doi.org/10.1145/3643777.
Testo completoAbstract (sommario):
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.
7
D'Souza, Matt, James You, Ondřej Lhoták e Aleksandar Prokopec. "TASTyTruffle: Just-in-Time Specialization of Parametric Polymorphism". Proceedings of the ACM on Programming Languages 7, OOPSLA2 (16 ottobre 2023): 1561–88. http://dx.doi.org/10.1145/3622853.
Testo completoAbstract (sommario):
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.
8
Barrière, Aurèle, Sandrine Blazy e 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 (9 gennaio 2023): 249–77. http://dx.doi.org/10.1145/3571202.
Testo completoAbstract (sommario):
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.
9
Clemente-López, Daniel, Esteban Tlelo-Cuautle, Luis-Gerardo de la Fraga, José de Jesús Rangel-Magdaleno e 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, n. 4 (2022): 5871–94. http://dx.doi.org/10.3934/math.2022326.
Testo completoAbstract (sommario):
<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>
10
Alam, Marzia, Mehreen Saleem Gul e Tariq Muneer. "Radiation View Factor for Building Applications: Comparison of Computation Environments". Energies 12, n. 20 (10 ottobre 2019): 3826. http://dx.doi.org/10.3390/en12203826.
Testo completoAbstract (sommario):
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.
Tesi sul tema "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.
Testo completoAbstract (sommario):
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 testLanguage 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
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.
Testo completoAbstract (sommario):
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.
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.
Testo completo
4
Pramod, B. S. "Performance Measurement Of A Java Virtual Machine". Thesis, 1999. https://etd.iisc.ac.in/handle/2005/1530.
Testo completo
5
Pramod, B. S. "Performance Measurement Of A Java Virtual Machine". Thesis, 1999. http://etd.iisc.ernet.in/handle/2005/1530.
Testo completoLibri sul tema "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.
Cerca il testo completoCapitoli di libri sul tema "Just-in-time (JIT) compiler"
1
Yuan, Shenghao, Frédéric Besson e 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.
Testo completoAbstract (sommario):
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.
Atti di convegni sul tema "Just-in-time (JIT) compiler"
1
Caamaño, Juan Manuel Martinez, e Serge Guelton. "Easy::Jit: compiler assisted library to enable just-in-time compilation in C++ codes". In