Dissertations / Theses on the topic 'Java and Virtual Machine Semantics'
To see the other types of publications on this topic, follow the link: Java and Virtual Machine Semantics.
Create a spot-on reference in APA, MLA, Chicago, Harvard, and other styles
Consult the top 50 dissertations / theses for your research on the topic 'Java and Virtual Machine Semantics.'
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.
Browse dissertations / theses on a wide variety of disciplines and organise your bibliography correctly.
1
Lagerkvist, Mikael Zayenz. "Machine Assisted Reasoning for Multi-Threaded Java Bytecode." Thesis, KTH, Electronic, Computer and Software Systems, ECS, 2005. http://urn.kb.se/resolve?urn=urn:nbn:se:kth:diva-9512.
Full textAbstract:
In this thesis an operational semantics for a subset of the Java Virtual Machine (JVM) is developed and presented. The subset contains standard operations such as control flow, computation, and memory management. In addition, the subset contains a treatment of parallel threads of execution.
The operational semantics are embedded into a $µ$-calculus based proof assistant, called the VeriCode Proof Tool (VCPT). VCPT has been developed at the Swedish Institute of Computer Science (SICS), and has powerful features for proving inductive assertions.
Some examples of proving properties of programs using the embedding are presented.
I det här examensarbetet presenteras en operationell semantik för en delmängd av Javas virtuella maskin. Den delmängd som hanteras innehåller kontrollflöde, beräkningar och minneshantering. Vidare beskrivs semantiken för parallella exekveringstrådar.
Den operationella semantiken formaliseras i en bevisassistent for $µ$-kalkyl, VeriCode Proof Tool (VCPT). VCPT har utvecklats vid Swedish Institiute of Computer Science (SICS), och har kraftfulla tekniker för att bevisa induktiva påståenden.
Några exempel på bevis av egenskaper hos program användandes formaliseringen presenteras också.
2
Zhu, Wenzhang. "Distributed JAVA virtual machine with thread migration /." View the Table of Contents & Abstract, 2004. http://sunzi.lib.hku.hk/hkuto/record/B30396773.
Full text
3
Preußer, Thomas B., Martin Zabel, and Peter Reichel. "The SHAP Microarchitecture and Java Virtual Machine." Saechsische Landesbibliothek- Staats- und Universitaetsbibliothek Dresden, 2012. http://nbn-resolving.de/urn:nbn:de:bsz:14-qucosa-98647.
Full textAbstract:
This report presents the SHAP platform consisting of its microarchitecture and its implementation of the Java Virtual Machine (JVM). Like quite a few other embedded implementations of the Java platform, the SHAP microarchitecture relies on an instruction set architecture based on Java bytecode. Unlike them, it, however, features a design with well-encapsulated components autonomously managing their duties on rather high abstraction levels. Thus, permanent runtime duties are transferred from the central computing core to concurrently working components so that it can actually spent a larger fraction of time executing application code. The degree of parallelity between the application and the runtime implementation is increased. Currently, the stack and heap management including the automatic garbage collection are implemented this way. After detailing the design of the microarchitecture, the SHAP implementation of the Java Virtual Machine is described. A major focus is laid on the presentation of the layout and the use of the runtime data structures representing the various language abstractions provided by Java. Also, the boot sequence starting the JVM is described.
4
Mandal, Abhijit. "Design and Implementation of Java Virtual Machine." Thesis, Indian Institute of Science, 2000. http://hdl.handle.net/2005/81.
Full textAbstract:
Interpretation of Java bytecode results in slow execution of program.First version of Java Virtual Machine(JVM) implementation was relied
on interpretation techniques. On the other hand performance can be improved by translating the Java bytecode into machine code by a Just-In-Time(JIT) compiler and this technique is being integrated into most JVM implementations.
Java is an automatic garbage collected language, freeing the programmer from the explicit memory management. Garbage collection "pause" time can
be reduced by using a generational garbage collection.
This thesis describes an implementation of a JVM. The specific contributions made in this thesis include: development of a Just-In-Time(JIT) compiler using DAG construction technique, a bytecode interpreter, a generational
garbage collector. Our implementation can execute Java bytecode either by an interpreter or the bytecode can be translated into machine code
using the JIT compiler and the translated code is directly executed by the processor. We have implemented the Java Native Interface (JNI) to enable using C and assembly language programs with Java.
5
Zhu, Wenzhang, and 朱文章. "Distributed JAVA virtual machine with thread migration." Thesis, The University of Hong Kong (Pokfulam, Hong Kong), 2004. http://hub.hku.hk/bib/B45015260.
Full text
6
Preußer, Thomas B., Martin Zabel, and Peter Reichel. "The SHAP Microarchitecture and Java Virtual Machine." Technische Universität Dresden, 2007. https://tud.qucosa.de/id/qucosa%3A26193.
Full textAbstract:
This report presents the SHAP platform consisting of its microarchitecture and its implementation of the Java Virtual Machine (JVM). Like quite a few other embedded implementations of the Java platform, the SHAP microarchitecture relies on an instruction set architecture based on Java bytecode. Unlike them, it, however, features a design with well-encapsulated components autonomously managing their duties on rather high abstraction levels. Thus, permanent runtime duties are transferred from the central computing core to concurrently working components so that it can actually spent a larger fraction of time executing application code. The degree of parallelity between the application and the runtime implementation is increased. Currently, the stack and heap management including the automatic garbage collection are implemented this way. After detailing the design of the microarchitecture, the SHAP implementation of the Java Virtual Machine is described. A major focus is laid on the presentation of the layout and the use of the runtime data structures representing the various language abstractions provided by Java. Also, the boot sequence starting the JVM is described.
7
Klein, Gerwin. "Verified Java bytecode verification." [S.l. : s.n.], 2003. http://deposit.ddb.de/cgi-bin/dokserv?idn=967128749.
Full text
8
Fang, Weijian. "Distributed object sharing for cluster-based Java virtual machine /." View the Table of Contents & Abstract, 2004. http://sunzi.lib.hku.hk/hkuto/record/B30575163.
Full text
9
Fang, Weijian, and 方維堅. "Distributed object sharing for cluster-based Java virtual machine." Thesis, The University of Hong Kong (Pokfulam, Hong Kong), 2004. http://hub.hku.hk/bib/B45014772.
Full text
10
Pande, Monali. "Visual Analytics Tool for Java Virtual Machine Execution Traces." Thesis, KTH, Skolan för elektroteknik och datavetenskap (EECS), 2019. http://urn.kb.se/resolve?urn=urn:nbn:se:kth:diva-249716.
Full textAbstract:
The usage of multithreaded programs is continuously increasing, which leads to various concurrency issues. The non-deterministic approach of the thread scheduler makes the analysis of such programs complex. Thread-based visualization of the concurrent events helps to analyze a concurrent program efficiently. The extension of such visual analytics jpf-visual tool for regular JVM traces will help Java programmers to better understand and analyze the runtime execution of concurrent programs. AspectJ instrumentation with its lock() and unlock() pointcut extension makes it possible to capture important runtime events information in order to generate the JVM event trace. A successful integration of the JVM trace into the jpf-visual tool is achieved through code refactoring and the use of adapter classes. In this thesis, the implementation of such an approach is shown to analyze the concurrent events using the regular JVM. Such implementation can help to provide a generic approach for the concurrency issue analysis.Användandet av flertrådade program ökar numera ständigt, och det kan leda till en mängd olika problem rörande samtidighet. Analysen av sådana program är komplicerad på grund av den icke-deterministiska algoritmen som används av operativsystemets schemaläggare. Visualiseringen av samtidiga händelser, baserad på trådar, hjälper oss analysera samtidiga program effektivt. Utvidgningar så som det visuella analytiska verktyget jpf-visual för JVM kommer att hjälpa Javaprogrammerare att bättre förstå och analysera körning av samtidiga program. AspectJ instrumentationen med dess brytpunktsutvidningar lock() och unlock() gör det möjligt att fånga upp viktig information rörande körningshändelser för att kunna generera ett JVM händelsespår. En lyckad integrering av JVM-spåret med verktyget jpf-visual utförs genom omstrukturering av kod och användning av adapterklasser i det existerande verktyget. Implementationen av en sådant tillvägagångssätt för standard JVM presenteras preliminärt i detta arbete, och det visar att det är möjligt att analysera samtidiga händelser genom att använda standard JVM. En sådan implementation kan bidra med en generisk lösning för analys av samtidiga program.
11
KUHN, BRADLEY M. "CONSIDERATIONS ON PORTING PERL TO THE JAVA VIRTUAL MACHINE." University of Cincinnati / OhioLINK, 2001. http://rave.ohiolink.edu/etdc/view?acc_num=ucin983387768.
Full text
12
Amundsen, Kai Kristian. "Java Virtual Machine - Memory-Constrained Copying : Part 1: Main report." Thesis, Norwegian University of Science and Technology, Department of Computer and Information Science, 2005. http://urn.kb.se/resolve?urn=urn:nbn:no:ntnu:diva-9172.
Full textAbstract:
Atmel is inventing a new microcontroller that is capable of running Java pro- grams through an implementation of the Java Virtual Machine. Compared to industry standard PCs the microcontroller has limited processing power and main memory. When running interactive programs on this microcontroller it is important that the program interruption time is kept to a minimum. In a Java Virtual machine the garbage collector is responsible for reclaiming unused main memory and making it available for the Java program again. This process creates a program interruption where the Java program is halted and the garbage collector is working. At the project start the Atmel Virtual Machine was using the mark-sweep garbage collector. This garbage collector could produce a program interruption greater than one second and was not suitable for interactive programs. The Memory-Constrained Copying algorithm is a new garbage collection algorithm that is incremental and therefore only collects a little bit of main memory at a time compared to the implemented mark-sweep garbage collector. A theoretical comparison of the mark sweep algorithm and the Memory- Constrained Copying algorithm was performed. This comparison showed that the mark-sweep algorithm would have a much longer program interruption than the Memory-Constrained Copying algorithm. The two algorithms should in the- ory also produce equal throughput. The penalty for the short program interrup- tion time in the Memory-Constrained Copying algorithm is its high algorithmic complexity. After a few modfications to the Virtual Machine, the Memory-Constrained Copying algorithm was implemented and tested functionally. To test the pro- gram interruption and throughput of the garbage collection algorithms a set of benchmarks were chosen. The EDN Embedded Microprocessor Benchmark Consortium Java benchmark suite was selected as the most accurate benchmarks available. The practical comparison of the two garbage collection algorithms showed that the theoretical comparison was correct. The mark-sweep algorithm pro- duced in the worst case an interruption of 3 seconds, while the Memory-Constrained Copying algorithm's maximum program interruption was 44 milliseconds. The results of the benchmarking confirms the results that the inventors of the Memory-Constrained Copying algorithm achieved in their test. Their test was not performed on a microcontroller, but on a standard desktop computer. This implementation has also confirmed that it is possible to implement the Memory-Constrained Copying algorithm in a microcontroller. During the implementation of the Memory-Constrained Copying algorithm a hardware bug was found in the microcontroller. This bug was identified and reported so the hardware could be modified.
13
Pape, Tobias, Arian Treffer, Robert Hirschfeld, and Michael Haupt. "Extending a Java Virtual Machine to Dynamic Object-oriented Languages." Universität Potsdam, 2013. http://opus.kobv.de/ubp/volltexte/2013/6743/.
Full textAbstract:
There are two common approaches to implement a virtual machine (VM) for a dynamic object-oriented language. On the one hand, it can be implemented in a C-like language for best performance and maximum control over the resulting executable. On the other hand, it can be implemented in a language such as Java that allows for higher-level abstractions. These abstractions, such as proper object-oriented modularization, automatic memory management, or interfaces, are missing in C-like languages but they can simplify the implementation of prevalent but complex concepts in VMs, such as garbage collectors (GCs) or just-in-time compilers (JITs). Yet, the implementation of a dynamic object-oriented language in Java eventually results in two VMs on top of each other (double stack), which impedes performance.
For statically typed languages, the Maxine VM solves this problem; it is written in Java but can be executed without a Java virtual machine (JVM). However, it is currently not possible to execute dynamic object-oriented languages in Maxine.
This work presents an approach to bringing object models and execution models of dynamic object-oriented languages to the Maxine VM and the application of this approach to Squeak/Smalltalk. The representation of objects in and the execution of dynamic object-oriented languages pose certain challenges to the Maxine VM that lacks certain variation points necessary to enable an effortless and straightforward implementation of dynamic object-oriented languages' execution models. The implementation of Squeak/Smalltalk in Maxine as a feasibility study is to unveil such missing variation points.Es gibt zwei übliche Wege, um eine virtuelle Maschine (VM) für eine dynamische objektorientierte Programmiersprache zu implementieren. Einerseits kann sie in einer C-ähnlichen Programmiersprache geschrieben werden, um bestmögliche Leistung zu erzielen und größtmöglichen Einfluss auf das sich ergebende ausführbare Programm zu haben. Andererseits kann sie in einer Sprache wie Java geschrieben werden, die weitreichendere Abstraktionen als die C-ähnlichen Sprachen erlaubt. Diese Abstraktionen, beispielsweise echte objektorientierte Modularisierung, automatische Speicherverwaltung oder explizite Schnittstellen, erlauben eine vereinfachtes Implementieren von VM-typischen, aber komplexen Konzepten, wie Speicherbereinigung (garbage collector, GCs) oder just-in-time-Compilern (JITs). Wird eine dynamische objektorientierte Programmiersprache in Java geschrieben, ist jedoch mit Leistungseinbußen zu rechen, da effektiv zwei aufeinander aufbauende virtuelle Maschinen entstehen. Die Maxine VM löst diese Problem für statisch getypte Programmiersprachen; sie ist in Java geschrieben, kann aber ohne jegliche Java VM (JVM) laufen. Es ist jedoch momentan nicht möglich, dynamische objektorientierte Programmiersprachen in Maxine auszuführen. Diese Arbeit stellt einen Ansatz zur Umsetzung von Objekt- und Ausführungsmodellen dynamischer objektorientierter Programmiersprachen innerhalb der Maxine VM vor, sowie dessen Anwendung auf Squeak/Smalltalk. Dabei stellt die Representation von Objekten und die Ausführung dynamischer objektorientierter Programmiersprachen bestimmte Heraus- und Anforderungen an die Maxine VM, die trotz des Fokus auf Modularität und Konfigurierbarkeit einige Variationspunkte vermissen lässt, welche wiederum für eine einfache Implementierung von besagten Ausführungsmodellen jedoch unerlässlich sind. Daher sollen durch eine testweise Implementierung von Squeak/Smalltalk in Maxine eben jene Variationspunkte identifiziert werden.
14
Luo, Yang, and 羅陽. "Performance modeling and load balancing for Distributed Java Virtual Machine." Thesis, The University of Hong Kong (Pokfulam, Hong Kong), 2008. http://hub.hku.hk/bib/B41509043.
Full text
15
Lam, King-tin, and 林擎天. "Efficient shared object space support for distributed Java virtual machine." Thesis, The University of Hong Kong (Pokfulam, Hong Kong), 2012. http://hub.hku.hk/bib/B47752877.
Full textAbstract:
Given the popularity of Java, extending the standard Java virtual machine (JVM) to become cluster-aware effectively brings the vision of transparent horizontal scaling of applications to fruition. With a set of cluster-wide JVMs orchestrated as a virtually single system, thread-level parallelism in Java is no longer confined to one multiprocessor. An unmodified multithreaded Java application running on such a Distributed JVM (DJVM) can scale out transparently, tapping into the vast computing power of the cluster.
While this notion creates an easy-to-use and powerful parallel programming paradigm, research on DJVMs has remained largely at the proof-of-concept stage where successes were proven using trivial scientific computing workloads only. Real-life Java applications with commercial server workloads have not been well-studied on DJVMs. Their natures including complex and sometimes huge object graphs, irregular access patterns and frequent synchronizations are key scalability hurdles. To design a scalable DJVM for real-life applications, we identify three major unsolved issues calling for a top-to-bottom overhaul of traditional systems.
First, we need a more time- and space-efficient cache coherence protocol to support fine-grained object sharing over the distributed shared heap. The recent prevalence of concurrent data structures with heavy use of volatile fields has added complications to the matter. Second, previous generations of DJVMs lack true support for memory-intensive applications. While the network-wide aggregated physical memory can be huge, mutual sharing of huge object graphs like Java collections may cause nodes to eventually run out of local heap space because the cached copies of remote objects, linked by active references, can’t be arbitrarily discarded. Third, thread affinity, which determines the overall communication cost, is vital to the DJVM performance. Data access locality can be improved by collocating highly-correlated threads, via dynamic thread migration. Tracking inter-thread correlations trades profiling costs for reduced object misses. Unfortunately, profiling techniques like active correlation tracking used in page-based DSMs would entail prohibitively high overheads and low accuracy when ported to fine-grained object-based DJVMs.
This dissertation presents technical contributions towards all these problems. We use a dual-protocol approach to address the first problem. Synchronized (lock-based) and volatile accesses are handled by a home-based lazy release consistency (HLRC) protocol and a sequential consistency (SC) protocol respectively. The two protocols’ metadata are maintained in a conflict-free, memory-efficient manner. With further techniques like hierarchical passing of lock ownerships, the overall communication overheads of fine-grained distributed object sharing are pruned to a minimal level. For the second problem, we develop a novel uncaching mechanism to safely break a huge active object graph. When a JVM instance runs low on free memory, it initiates an uncaching policy, which eagerly assigns nulls to selected reference fields, thus detaching some older or less useful cached objects from the root set for reclamation. Careful orchestration is made between uncaching, local garbage collection and the coherence protocol to avoid possible data races. Lastly, we devise lightweight sampling-based profiling methods to derive inter-thread correlations, and a profile-guided thread migration policy to boost the system performance. Extensive experiments have demonstrated the effectiveness of all our solutions.published_or_final_version
Computer Science
Doctoral
Doctor of Philosophy
16
Mahmoud, Mohamedin Mohamed Ahmed. "ByteSTM: Java Software Transactional Memory at the Virtual Machine Level." Thesis, Virginia Tech, 2012. http://hdl.handle.net/10919/31314.
Full textAbstract:
As chip vendors are increasingly manufacturing a new generation of multi-processor chips called multicores, improving software performance requires exposing greater concurrency in software. Since code that must be run sequentially is often due to the need for synchronization, the synchronization abstraction has a significant effect on program performance. Lock-based synchronization — the most widely used synchronization method — suffers from programability, scalability, and composability challenges.
Transactional memory (TM) is an emerging synchronization abstraction that promises to alleviate the difficulties with lock-based synchronization. With TM, code that read/write shared memory objects is organized as transactions, which speculatively execute. When two transactions conflict (e.g., read/write, write/write), one of them is aborted, while the other commits, yielding (the illusion of) atomicity. Aborted transactions are re-started, after rolling-back changes made to objects. In addition to a simple programming model, TM provides performance comparable to lock-based synchronization. Software transactional memory (STM) implements TM entirely in software, without any special hardware support, and is usually implemented as a library, or supported by a compiler or by a virtual machine.
In this thesis, we present ByteSTM, a virtual machine-level Java STM implementation. ByteSTM implements two STM algorithms, TL2 and RingSTM, and transparently supports implicit transactions. Program bytecode is automatically modified to support transactions: memory load/store bytecode instructions automatically switch to transactional mode when a transaction starts, and switch back to normal mode when the transaction successfully commits. Being implemented at the VM-level, it accesses memory directly and uses absolute memory addresses to uniformly handle memory. Moreover, it avoids Java garbage collection (which has a negative impact on STM performance), by manually allocating and recycling memory for transactional metadata. ByteSTM uses field-based granularity, and uses the thread header to store transactional metadata, instead of the slower Java ThreadLocal abstraction.
We conducted experimental studies comparing ByteSTM with other state-of-the-art Java STMs including Deuce, ObjectFabric, Multiverse, DSTM2, and JVSTM on a set of micro- benchmarks and macro-benchmarks. Our results reveal that, ByteSTM's transactional throughput improvement over competitors ranges from 20% to 75% on micro-benchmarks and from 36% to 100% on macro-benchmarks.Master of Science
17
Luo, Yang. "Performance modeling and load balancing for Distributed Java Virtual Machine." Click to view the E-thesis via HKUTO, 2008. http://sunzi.lib.hku.hk/hkuto/record/B41509043.
Full text
18
Fick, David. "A virtual machine framework for domain-specific languages." Diss., Pretoria : [S.n.], 2007. http://upetd.up.ac.za/thesis/available/etd-10192007-163559/.
Full text
19
Mourad, Azzam. "A Selective Dynamic Compiler for Embedded Java Virtual Machine Targeting ARM Processors." Thesis, Université Laval, 2005. http://www.theses.ulaval.ca/2005/22534/22534.pdf.
Full textAbstract:
Ce travail présente une nouvelle technique de compilation dynamique sélective pour
les systèmes embarqués avec processeurs ARM. Ce compilateur a été intégré dans la
plateforme J2ME/CLDC (Java 2 Micro Edition for Connected Limited Device Con-
figuration). L’objectif principal de notre travail est d’obtenir une machine virtuelle
accélérée, légère et compacte prête pour l’exécution sur les systèmes embarqués. Cela
est atteint par l’implémentation d’un compilateur dynamique sélectif pour l’architecture
ARM dans la Kilo machine virtuelle de Sun (KVM). Ce compilateur est appelé Armed
E-Bunny. Premièrement, on présente la plateforme Java, le Java 2 Micro Edition(J2ME)
pour les systèmes embarqués et les composants de la machine virtuelle Java. Ensuite,
on discute les différentes techniques d’accélération pour la machine virtuelle Java et on
détaille le principe de la compilation dynamique. Enfin, on illustre l’architecture, le
design (la conception), l’implémentation et les résultats expérimentaux de notre compilateur
dynamique sélective Armed E-Bunny. La version modifiée de KVM a été portée
sur un ordinateur de poche (PDA) et a été testée en utilisant un benchmark standard
de J2ME. Les résultats expérimentaux de la performance montrent une accélération de
360 % par rapport à la dernière version de la KVM de Sun avec un espace mémoire
additionnel qui n’excède pas 119 kilobytes.This work presents a new selective dynamic compilation technique targeting ARM 16/32-bit embedded system processors. This compiler is built inside the J2ME/CLDC (Java 2 Micro Edition for Connected Limited Device Configuration) platform. The primary objective of our work is to come up with an efficient, lightweight and low-footprint accelerated Java virtual machine ready to be executed on embedded machines. This is achieved by implementing a selective ARM dynamic compiler called Armed E-Bunny into Sun’s Kilobyte Virtual Machine (KVM). We first present the Java platform, Java 2 Micro Edition (J2ME) for embedded systems and Java virtual machine components. Then, we discuss the different acceleration techniques for Java virtual machine and we detail the principle of dynamic compilation. After that we illustrate the architecture, design, implementation and experimental results of our selective dynamic compiler Armed E-Bunny. The modified KVM is ported on a handheld PDA and is tested using standard J2ME benchmarks. The experimental results on its performance demonstrate that a speedup of 360% over the last version of Sun’s KVM is accomplished with a footprint overhead that does not exceed 119 kilobytes.
Inscrit au Tableau d'honneur de la Faculté des études supérieures
20
Sun, Yu. "JAVA VIRTUAL MACHINE DESIGN FOR EMBEDDED SYSTEMS: ENERGY, TIME PREDICTABILITY AND PERFORMANCE." OpenSIUC, 2010. https://opensiuc.lib.siu.edu/dissertations/186.
Full textAbstract:
Embedded systems can be found everywhere in our daily lives. Due to the great variety of embedded devices, the platform independent Java language provides a good solution for embedded system development. Java virtual machine (JVM) is the most critical component of all kinds of Java platforms. Hence, it is extremely important to study the special design of JVM for embedded systems. The key challenges of designing a successful JVM for embedded systems are energy efficiency, time predictability and performance, which are investigated in this dissertation, respectively. We first study the energy issue of JVM on embedded systems. With a cycle-accurate simulator, we study each stage of Java execution separately to test the effects of different configurations in both software and hardware. After that, an alternative Adaptive Optimization System (AOS) model is introduced, which estimated the cost/benefit using energy data instead of running time. We tuned the parameters of this model to study how to improve the dynamic compilation and optimization in Jikes RVM in terms of energy consumption. In order to further reduce the energy dissipation of JVM on embedded systems, we study adaptive drowsy cache control for Java applications, where JVM can be used to make better decision on drowsy cache control. We explore the impact of different phases of Java applications on the timing behavior of cache usage. Then we propose several techniques to adaptively control drowsy cache to reduce energy consumption with minimal impact on performance. It is observed that traditional Java code generation and instruction fetch path are not efficient. So we study three hardware-based code caching strategies, which attempt to write and read the dynamically generated Java code faster and more energy-efficiently. Time predictability is another key challenge for JVM on embedded systems. So we exploit multicore computing to reduce the timing unpredictability caused by dynamic compilation and adaptive optimization. Our goal is to retain high performance comparable to that of traditional dynamic compilation and, at the same time, obtain better time predictability for JVM. We study pre-compilation techniques to utilize another core more efficiently. Furthermore, we develop Pre-optimization on Another Core (PoAC) scheme to replace AOS in Jikes JVM, which is very sensitive to execution time variation and impacts time predictability greatly. Finally, we propose two new approaches that automatically parallelizes Java programs at run-time, in order to meet the performance challenge of JVM on embedded systems. These approaches rely on run-time trace information collected during program execution, and dynamically recompiles Java byte code that can be executed in parallel. One approach utilizes trace information to improve traditional loop parallelization, and the other parallelizes traces instead of loop iterations.
21
Aslam, Faisal [Verfasser], and Christian [Akademischer Betreuer] Schindelhauer. "Challenges and solutions in the design of a Java Virtual Machine for resource constrained microcontrollers = Herausforderungen und Lösungen in der Entwicklung einer Java Virtual Machine für Microcontroller mit begrenzten Ressourcen." Freiburg : Universität, 2011. http://d-nb.info/1123458472/34.
Full text
22
Durelli, Vinicius Humberto Serapilha. "Toward harnessing a Java high-level language virtual machine for supporting software testing." Universidade de São Paulo, 2013. http://www.teses.usp.br/teses/disponiveis/55/55134/tde-06012014-150025/.
Full textAbstract:
High-level language virtual machines (HLL VMs) have been playing a key role as a mechanism for implementing programming languages. Languages that run on these execution environments have many advantages over languages that are compiled to native code. These advantages have led HLL VMs to gain broad acceptance in both academy and industry. However, much of the research in this area has been devoted to boosting the performance of these execution environments. Few eorts have attempted to introduce features that automate or facilitate some software engineering activities, including software testing. This research argues that HLL VMs provide a reasonable basis for building an integrated software testing environment. To this end, two software testing features that build on the characteristics of a Java virtual machine (JVM) were devised. The purpose of the rst feature is to automate weak mutation. Augmented with mutation support, the chosen JVM achieved speedups of as much as 95% in comparison to a strong mutation tool. To support the testing of concurrent programs, the second feature is concerned with enabling the deterministic re-execution of Java programs and exploration of new scheduling sequencesMáquinas virtuais de linguagens de programação têm desempenhado um papel importante como mecanismo para a implementação de linguagens de programação. Linguagens voltadas para esses ambientes de execução possuem várias vantagens em relação às linguagens compiladas. Essas vantagens fizeram com que tais ambientes de execução se tornassem amplamente utilizados pela indústria e academia. Entretanto, a maioria dos estudos nessa area têm se dedicado a aprimorar o desempenho desses ambientes de execução e poucos têm enfocado o desenvolvimento de funcionalidades que automatizem ou facilitem a condução de atividades de engenharia de software, incluindo atividades de teste de software. Este trabalho apresenta indícios de que máquinas virtuais de linguagens de programação podem apoiar a criação de ambientes de teste de software integrado. Para tal, duas funcionalidades que tiram proveito das características de uma máquina virtual Java foram desenvolvidas. O propósito da primeira funcionalidade e automatizar a condução de atividades de mutação fraca. Após a implementação de tal funcionalidade na máquina virtual Java selecionada, observou-se um desempenho até 95% melhor em relação a uma ferramenta de mutação forte. Afim de apoiar o teste de programas concorrentes, a segunda funcionalidade permite reexecutá-los de forma determinística além de automatizar a exploração de que novas sequências de escalonamento
23
Pinto, Randal Juliano Pereira. "Tecnicas de otimização para o interpretador da K virtual machine." [s.n.], 2003. http://repositorio.unicamp.br/jspui/handle/REPOSIP/276340.
Full textAbstract:
Orientador : Rodolfo Jardim de AzevedoDissertação (mestrado) - Universidade Estadual de Campinas, Instituto de Computação
Made available in DSpace on 2018-08-03T22:42:38Z (GMT). No. of bitstreams: 1 Pinto_RandalJulianoPereira_M.pdf: 1892190 bytes, checksum: d5c7c9a843bf9760d761e985a3df1b3c (MD5) Previous issue date: 2003
Resumo: Dispositivos portáteis e personalizáveis têm se tornado Ítens cada vez mais importantes em nossas vidas. Telefones celulares, organizadores pessoais, terminais de serviço pos-suem algumas características em comum como a funcionalidade limitada, restrições de tamanho e custo e, principalmente, são um mercado em plena expansão. Para atender a esta demanda, a Sun Microsystems Inc. extendeu o escopo da sua tecnologia Java com a introdução do Java 2 Platform Micro Edition (J2ME). Tendo em vista a característica limitada deste tipo de dispositivo, melhorias no desempenho da plataforma J2ME são essenciais para o seu desenvolvimento e aceitação. Diversas propostas de otimização são encontradas na literatura com enfoque principal nas tecnologias J2SE (Java 2 Standard Edition) e J2EE (Java 2 Enterprise Edition), porém quase nenhuma delas visa exclusi-vamente as necessidades da plataforma J2ME. Este trabalho propõe a aplicação de duas técnicas de otimização no interpretador da KVM. A primeira técnica baseia-se na redução da freqüência de acessos à memória e resultou em ganhos totais nos benchmarks analisa- dos de 0,14% a 5,66% e ganhos em alguns testes de até 37,71%, com aumento no código fonte de apenas 0,62% em relação ao tamanho do executável original. A segunda baseia-se na redução de alguns passos do ciclo de interpretação de bytecodes e seu resultado geral variou de -0,90% até 5,32%, obtendo ganhos em alguns testes de até 18%, com aumento nos códigos fonte variando entre 0,0052% e 0,0142%
Abstract: Mobile and customizable devices are increasingly becoming important items in our lives. Cellular phones, personal organizers, service terminaIs have many characteristics in com- mon such as limited functionality, size and cost restrictions and specially are an expanding market. To attend this demanding market, Sun Microsystems Inc. extended the scope of the Java technology, introducing the Java 2 Platform Micro Edition (J2ME). Considering the limitations on this kind of device, performance improvements on the J2ME platform are essential to its development and general acceptance. Several optimization proposals can be found in the technicalliterature focused on J2SE (Java 2 Standard Edition) and J2EE (Java 2 Enterprise Edition) platforms, but almost none aims at the needs of the J2ME platform. The goal of this dissertation is to apply two optimization techniques to the KVM's interpreter. The first technique is based on reducing the number of memory accesses and resulted in a general performance increase from 0.14% to 5.66% and up to 37% for some benchmark programs. The increase on the source code size was only 0.62%, when compared to the original executable size. The second technique is based on reducing some steps of the bytecode interpretation cycle and its general results varied from a per-formance overhead of 0.90% to a performance increase of 5.32%, and up to 18% speedup for some of the benchmark programs. The increase in the source code size varied from 0.0052% to 0.0142%, when compared to the original executable size
Mestrado
Mestre em Ciência da Computação
24
Lochbihler, Andreas [Verfasser], and G. [Akademischer Betreuer] Snelting. "A Machine-Checked, Type-Safe Model of Java Concurrency : Language, Virtual Machine, Memory Model, and Verified Compiler / Andreas Lochbihler ; Betreuer: G. Snelting." Karlsruhe : KIT Scientific Publishing, 2012. http://d-nb.info/1184492581/34.
Full text
25
Perez, Taciano Dreckmann. "Persistent memory and orthogonal persistence : a persistent heap design and its implementation for the Java virtual machine." Pontif?cia Universidade Cat?lica do Rio Grande do Sul, 2017. http://tede2.pucrs.br/tede2/handle/tede/7562.
Full textAbstract:
Submitted by Caroline Xavier (caroline.xavier@pucrs.br) on 2017-07-03T15:03:25Z
No. of bitstreams: 1
TES_TACIANO_DRECKMANN_PEREZ_COMPLETO.pdf: 1779781 bytes, checksum: 2111ccea963be0eea76bdbb7d24321d9 (MD5)Made available in DSpace on 2017-07-03T15:03:25Z (GMT). No. of bitstreams: 1 TES_TACIANO_DRECKMANN_PEREZ_COMPLETO.pdf: 1779781 bytes, checksum: 2111ccea963be0eea76bdbb7d24321d9 (MD5) Previous issue date: 2017-05-03
Sistemas computacionais da atualidade tradicionalmente separam mem?ria e armazenamento. Linguagens de programa??o tipicamente refletem essa distin??o usando diferentes representa??es para dados em mem?ria (ex. estruturas de dados, objetos) e armazenamento (ex. arquivos, bancos de dados). A movimenta??o de dados entre esses dois n?veis e representa??es, bidirecionalmente, compromete tanto a efici?ncia do programador quanto de execu??o dos programas. Tecnologias recentes de memoria n?o-vol?til, tais como mem?ria de transi??o de fase, resistiva e magnetoresistiva, possibilitam combinar mem?ria principal e armazenamento em uma ?nica entidade de mem?ria persistente, abrindo caminho para abstra??es mais eficientes para lidar com persist?ncia de dados. Essa tese de doutorado introduz uma abordagem de projeto para o ambiente de execu??o de linguagens com ger?ncia autom?tica de mem?ria, baseado numa combina??o original de persist?ncia ortogonal, programa??o para mem?ria persistente, persist?ncia por alcance, e transa??es com atomicidade em caso de falha. Esta abordagem pode melhorar significativamente a produtividade do programador e a efici?ncia de execu??o dos programas, uma vez que estruturas de dados em mem?ria passam a ser persistentes de forma transparente, sem a necessidade de programar explicitamente o armazenamento, e removendo a necessidade de cruzar fronteiras sem?nticas. De forma a validar e demonstrar a abordagem proposta, esse trabalho tamb?m apresenta JaphaVM, a primeira M?quina Virtual Java especificamente projetada para mem?ria persistente. Resultados experimentais usando benchmarks e aplica??es reais demonstram que a JaphaVM, na maioria dos casos, executa as mesmas opera??es cerca de uma a duas ordens de magnitude mais rapidamente do que implementa??es equivalentes usando bancos de dados ou arquivos, e, ao mesmo tempo, requer significativamente menos linhas de c?digo.
Current computer systems separate main memory from storage. Programming languages typically reflect this distinction using different representations for data in memory (e.g. data structures, objects) and storage (e.g. files, databases). Moving data back and forth between these different layers and representations compromise both programming and execution efficiency. Recent nonvolatile memory technologies, such as Phase-Change Memory, Resistive RAM, and Magnetoresistive RAM make it possible to collapse main memory and storage into a single layer of persistent memory, opening the way for simpler and more efficient programming abstractions for handling persistence. This Ph.D. thesis introduces a design for the runtime environment for languages with automatic memory management, based on an original combination of orthogonal persistence, persistent memory programming, persistence by reachability, and lock-based failure-atomic transactions. Such design can significantly increase programming and execution efficiency, as in-memory data structures are transparently persistent, without the need for programmatic persistence handling, and removing the need for crossing semantic boundaries. In order to validate and demonstrate the proposed concepts, this work also presents JaphaVM, the first Java Virtual Machine specifically designed for persistent memory. In experimental results using benchmarks and real-world applications, JaphaVM in most cases executed the same operations between one and two orders of magnitude faster than database- and file-based implementations, while requiring significantly less lines of code.
26
Мірошниченко, Є. О. "Моделювання та розробка інтерпретатора байт-коду JVM з використанням скрипкової мови Python." Thesis, Київський національний університет технологій та дизайну, 2017. https://er.knutd.edu.ua/handle/123456789/7955.
Full text
27
Leon, Santiago Andres. "A Self-Reconfiguring Platform For Embedded Systems." Thesis, Virginia Tech, 2001. http://hdl.handle.net/10919/34725.
Full textAbstract:
The JBits Application Programming Interface has significantly shortened FPGA reconfiguration times by manipulating the configurable resources of the FPGAs directly under software control. The execution of JBits programs, however, requires a Java Virtual Machine to be implemented on the platform where the configurations will be modified. This presents a problem for embedded systems where a microprocessor to run a Java Virtual Machine may not be available or desirable. This thesis discusses the implementation of a FPGA platform that allows the execution of JBits programs, effectively changing the configuration of a FPGA within a FPGA. This thesis also presents a four step developing and testing strategy for JBits programs that are intended to run on this FPGA platform.Master of Science
28
Bonasegale, Simone. "Build automation systems per Java: analisi dello stato dell'arte." Bachelor's thesis, Alma Mater Studiorum - Università di Bologna, 2021. http://amslaurea.unibo.it/23316/.
Full textAbstract:
Il processo di sviluppo di un software richiede tanti compiti da svolgere, ed è interesse dello sviluppatore che questi vengano automatizzati per potersi concentrare sugli aspetti specifici dell'ambito del software che viene costruito. I build systems sono gli strumenti preposti a tale scopo, in questo documento ne viene analizzato lo stato dell'arte dei principali che lavorano per la Java Virtual Machine (JVM), anche attraverso lo stile di programmazione con cui essi vengono implementati.
29
Kubernát, Tomáš. "Emulátor byte kódu jazyka Java vhodný pro detekci a analýzu malware." Master's thesis, Vysoké učení technické v Brně. Fakulta informačních technologií, 2013. http://www.nusl.cz/ntk/nusl-412888.
Full textAbstract:
The goal of this thesis is to create a virtual machine that emulates a running programs written in Java programing language, which would be suitable for malware analysis and detection. The emulator is able to detect arguments of exploitable methods from Java standard classes, the order of calling these exploitable methods and also execution the test application. Overall functionality was tested on appropriate examples in which held its own measurements. At the end of the paper we describe testing of the emulator, which also contains tables and graphs for better results visualization.
30
Jonsson, Alexander. "The Usefulness of Programming Languages Beyond Java." Thesis, Linköpings universitet, Programvara och system, 2019. http://urn.kb.se/resolve?urn=urn:nbn:se:liu:diva-157413.
Full textAbstract:
Beyond Java, new programming languages running on the Java virtual machine (JVM) have been developed, such as Kotlin, Scala, JRuby and Clojure amongst others. Since all those languages compile to Java bytecode, they should theoretically be able to be used together in a project. This paper investigates if it is possible and what benefits it gives using those programming languages together in a project. The languages chosen to be used together were Jython, Scala and Kotlin. An experiment was conducted where in a single project, each programming language was assigned a problem to be solved. The experiment was then conducted in two iterations where in each iteration, the problems to be solved was assigned to a different programming language. From the experiment it was shown that using those languages together in a project was possible but resulted in some complications needed to be solved. It was also shown that the following division amongst the languages worked best in the present use case: Jython for graphical handling, Scala for calculating and computing and Kotlin for data-handling.
31
Sewe, Andreas [Verfasser], Ermira [Akademischer Betreuer] Mezini, and Richard E. [Akademischer Betreuer] Jones. "Design and Analysis of a Scala Benchmark Suite for the Java Virtual Machine / Andreas Sewe. Betreuer: Ermira Mezini ; Richard E. Jones." Darmstadt : Universitäts- und Landesbibliothek Darmstadt, 2012. http://d-nb.info/1106454464/34.
Full text
32
Nyblom, Hanna. "An Experimental Study on the Behavioural Tendencies of Objects Classified As Hot and Cold by a Java Virtual Machine Garbage Collector." Thesis, KTH, Skolan för elektroteknik och datavetenskap (EECS), 2020. http://urn.kb.se/resolve?urn=urn:nbn:se:kth:diva-277833.
Full textAbstract:
A constitutive hypothesis of the Java Virtual Machine garbage collector ”ThinGC”, presented by Mingkun Yang et al. [1], an extension of Oracle’s ”ZGC”, is that capitalising on possible temporal locality could optimise collection by limiting the total number of objects to manage. To achieve GC optimisations, ThinGC classifies objects as hot (recently referenced) or cold, separates the hot and cold objects into distinct memory spaces, and collects the spaces separately using two garbage collectors. In order to examine to what extent this temporal locality can actually be observed, this thesis analyses the behaviour of objects classified as hot and cold by ThinGC. Reviewed behaviour includes: tendency of cold objects to remain cold, expected length of cold streaks, and if the tendency to remain hot or cold is related to the type of the object. In order to examine object behaviour, hotness information for all objects in selected benchmarks from the DaCapo benchmark suite is logged in each GC cycle of ThinGC. The hotness information of each object is then compiled following address forwardings, and metrics estimating the behaviour of each object is calculated. Analysis of the charts and tables presenting the results of the metric calcu- lations show for instance that ”reheats” of objects are uncommon, cold objects usually stay steadily cold, and long cold streaks are more common than long hot streaks. The results highlight distinctly different behaviours of hot and cold objects and indicate that the concept of classifying objects by hotness and treating cold objects separately could be well founded. The results also show some classes of objects being more or less likely to stay cold. If these class behaviours could eventually be proven to be reliable by examining a larger set of programs, the information could be useful as a baseline for GC tuning. Also, if hotness information were collected and similar metrics were calculated concurrently, this information could aid in live GC decision making.En grundläggande hypotes för Java virtual machine skräpsamlaren ”ThinGC”, presenterad av Mingkun Yang m. fl. [1], en utveckling av Oracles ”ZGC”, är att ett nyttjande av eventuell temporal lokalitet skulle kunna optimisera skräp- samling genom att begränsa den totala mängden objekt som behöver behand- las. För att optimisera skräpsamling klassificerar ThinGC objekt som varma (dvs. nyligen refererade) eller kalla, separerar heta och kalla objekt i skilda minnesutrymmen, och skräpsamlar dessa minnesutrymmen separat med två skräpsamlare. För att undersöka i vilken utsträckning denna temporala lokalitet faktiskt kan observeras, granskar denna uppsats beteende av objekt klassificerade som heta eller kalla av ThinGC. Undersökta beteenden inkluderar: tendens bland kalla objekt att förbli kalla, antal cykler objekt förväntas förbli kalla och om tendenser bland objekt att förbli heta eller kalla är relaterade till objekttyp. För att kunna granska objekts beteenden loggas värmeinformation för al- la objekt i utvalda ”benchmarks” från benchmarksviten DaCapo under varje skräpsamlingscykel av ThinGC. Varje objekts värmeinformation kompileras sedan genom att följa vidarebefodringar av adresser, och till slut beräknas mä- tetal som uppskattar objektens beteende. Analys av de diagram och tabeller som presenterar resultaten av beräkning- en av mätetalen visar, till exempel, att återuppvärmningar av objekt är säll- synta, att kalla objekt oftast håller sig stadigt kalla, och att kalla objekt oftast håller sig kalla längre än varma objekt håller sig varma. Resultaten visar tydligt skilda beteenden för heta och kalla objekt och indi- kerar att konceptet att klassificera objekt efter värmeinformation och behandla heta och kalla objekt separat kan vara välgrundat. Resultaten visar också att vissa objektklasser är mer eller mindre benägna att hålla sig kalla. Om dessa klassbeteenden kan visas vara pålitliga genom att undersöka en större mängd program skulle informationen kunna vara använd- bar som en baslinje för finjustering av skräpsamling. Om värmeinformation kan samlas, och liknande mätetal beräknas parallellt med exekvering, skulle denna information också kunna bistå skräpsamlaren med att ta direkta beslut.
33
Herzog, Almut. "Usable Security Policies for Runtime Environments." Doctoral thesis, Linköpings universitet, IISLAB - Laboratoriet för intelligenta informationssystem, 2007. http://urn.kb.se/resolve?urn=urn:nbn:se:liu:diva-8809.
Full textAbstract:
The runtime environments provided by application-level virtual machines such as the Java Virtual Machine or the .NET Common Language Runtime are attractive for Internet application providers because the applications can be deployed on any platform that supports the target virtual machine. With Internet applications, organisations as well as end users face the risk of viruses, trojans, and denial of service attacks. Virtual machine providers are aware of these Internet security risks and provide, for example, runtime monitoring of untrusted code and access control to sensitive resources. Our work addresses two important security issues in runtime environments. The first issue concerns resource or release control. While many virtual machines provide runtime access control to resources, they do not provide any means of limiting the use of a resource once access is granted; they do not provide so-called resource control. We have addressed the issue of resource control in the example of the Java Virtual Machine. In contrast to others’ work, our solution builds on an enhancement to the existing security architecture. We demonstrate that resource control permissions for Java-mediated resources can be integrated into the regular Java security architecture, thus leading to a clean design and a single external security policy. The second issue that we address is the usabilityhttps://www.diva-portal.org/liu/webform/form.jsp DiVA Web Form and security of the setup of security policies for runtime environments. Access control decisions are based on external configuration files, the security policy, which must be set up by the end user. This set-up is security-critical but also complicated and errorprone for a lay end user and supportive, usable tools are so far missing. After one of our usability studies signalled that offline editing of the configuration file is inefficient and difficult for end users, we conducted a usability study of personal firewalls to identify usable ways of setting up a security policy at runtime. An analysis of general user help techniques together with the results from the two previous studies resulted in a proposal of design guidelines for applications that need to set up a security policy. Our guidelines have been used for the design and implementation of the tool JPerM that sets the Java security policy at runtime. JPerM evaluated positively in a usability study and supports the validity of our design guidelines.
34
Duff, Gerard. "App enabling environment to Volvo CE platforms." Thesis, Mälardalens högskola, Akademin för innovation, design och teknik, 2014. http://urn.kb.se/resolve?urn=urn:nbn:se:mdh:diva-26535.
Full textAbstract:
This thesis was submitted to the faculty of Innovation, Design and Technology, IDT, at Mälardalen university in Västerås, Sweden as a partial fulfillment of the requirements to obtain the M.Sc. in computer science, specializing in embedded systems. The work presented was carried out in the months January to June in 2014 partially in Volvo Construction Equipment, Volvo CE, Eskilstuna, and partially at Mälardalen university in Västerås. Federated Resilient Embedded Systems Technology for AUTOSAR, FRESTA, is a collaborative project between Volvo and the Swedish Institute of Computer Science, SICS, that aims to make it possible to add third party applications to vehicle’s computer systems without compromising system security and robustness. The mechanism is developed by SICS for AUTOSAR, AUTomotive Open System ARchitecture, an open standardized automotive software architecture for vehicles. The following report documents the efforts to study and port the FRESTA mechanism to the Volvo CE platform, and develop a Java application to test the porting. The investigation will aspire to determine if it is feasible to introduce Java based third party applications to resource constrained embedded systems, without causing a deterioration in the predictability and security of the system.Avhandlingen lades fram för fakulteten för innovation, design och teknik, IDT, vid Mälardalens högskola i Västerås som en del av kraven för att erhålla M.Sc. i datavetenskap med inriktning mot inbyggda system. Arbetet genomfördes under månaderna januari till juni 2014 delvis i Volvo Construction Equipment, Volvo CE, Eskilstuna, och delvis vid Mälardalens högskola i Västerås. Federated Resilient Embedded Systems Technology for AUTOSAR, FRESTA, är ett samarbetsprojekt mellan Volvo och Svenska Institutet för datavetenskap, SICS, som syftar till att göra det möjligt att lägga tredjepartsapplikationer till fordonets datorsystem utan att äventyra systemets säkerhet och robusthet. Mekanismen är utvecklat av SICS för AUTOSAR, Automotive Open System Architecture, en öppen standardiserad fordons programvaruarkitektur för fordon. Följande rapport dokumenterar arbetet med att studera Fresta mekanismen till Volvo CE-plattformen, och utveckla ett Java-program för att testa portning. Undersökningen kommer att sträva efter att avgöra om det är genomförbart att införa en Java-baserad tredje part för att resursbegränsa inbyggda system, utan att orsaka en försämring av förutsägbarhet och säkerhet i systemet.
35
Steinhoff, Robert J. "A Performance Comparison of Tree-Based Genetic Programming versus Stack-Based Genetic Programming versus Stack-Based Genetic Programming Using the Java Virtual Machine." NSUWorks, 2000. http://nsuworks.nova.edu/gscis_etd/859.
Full textAbstract:
Stack-based genetic programming uses variable length, linear programs executing on a virtual stack machine. This concept was proposed and evaluated by Timothy Perkis. The Java programming language uses a stack-based virtual machine to perform operations. This paper examined the possibility of performing stack-based genetic programming directly using the stack on the Java virtual machine. The problems of combining stack based genetic programming with the Java virtual machine stack were explored. Excessive runtime delay on bytecode verification of the chromosome carrying classes undergoing fitness evaluation was identified. Another problem is that the Java virtual machine stack must be tightly controlled and cannot have illegal operands. Direct comparison of stack-based genetic programming on the Java virtual machine to common tree-based genetic programming was not performed due to discovered flaws in the architecture. A practical model to implement stack-based genetic programming on the Java virtual machine using a class bytecode assembler was proposed. This model combines the GPsys genetic programming system with the JAS bytecode assembler resulting in an architecture called GPsys-JAS. A further recommendation to compare stack-based genetic programming on the Java virtual machine against stack-based genetic programming using the Java Stack class was suggested.
36
Lima, Gleydson de Azevedo Ferreira. "An?lise de desempenho de sistemas distribu?dos de grande porte na plataforma Java." Universidade Federal do Rio Grande do Norte, 2007. http://repositorio.ufrn.br:8080/jspui/handle/123456789/15231.
Full textAbstract:
Made available in DSpace on 2014-12-17T14:55:13Z (GMT). No. of bitstreams: 1
GleydsonAFL.pdf: 2185056 bytes, checksum: 094b58b4341884e4f12979b1aa1e99e0 (MD5)
Previous issue date: 2007-02-02The lava Platform is increasing1y being adopted in the development of distributed sys?tems with higb user demando This kind of application is more complex because it needs beyond attending the functional requirements, to fulfil1 the pre-established performance parameters. This work makes a study on the Java Vutual Machine (JVM), approaching its intemal aspects and exploring the garbage collection strategies existing in the literature and used by the NM. It also presents a set of tools that helps in the job of optimizing applications and others that help in the monitoring of applications in the production envi?ronment. Doe to the great amount of technologies that aim to solve problems which are common to the application layer, it becomes difficult to choose the one with best time response and less memory usage. This work presents a brief introduction to each one of tbe possible technologies and realize comparative tests through a statistical analysis of the response time and garbage collection activity random variables. The obtained results supply engineers and managers with a subside to decide which technologies to use in large applications through the knowledge of how they behave in their environments and the amount of resources that they consume. The relation between the productivity of the technology and its performance is also considered ao important factor in this choice
A plataforma Java vem sendo crescentemente adotada no desenvolvimento de siste?mas distribu?dos de alta demanda de usu?rios. Este tipo de aplica??o ? mais complexa pois necessita al?m de atender os requisitos funcionais cumprir os par?metros de desem?penho pr?-estabelecidos. Este trabalho realiza um estudo da m?quina virtual lava (NM) abordando seus aspectos internos e explorando as pol?ticas de coleta de lixo existentes na literatura e as usadas pela JVM. Apresenta tamb?m um conjunto de ferramentas que auxiliam Da tarefa de otimizar aplica??es e outras que auxiliam no monitoramento das aplica??es em produ??o. Diante da grande quantidade de tecnologias que se apresentam para solucionar pro?blemas inerentes ?s camadas das aplica??es, toma-se dif?cil realizar escolha daquela que possui o melhor tempo de resposta e o menor uso de mem?ria. O trabalho apresenta um breve referencial te?rico de cada uma das poss?veis tecnologias e realiza testes compara?tivos atrav?s de uma an?lise estat?stica da vari?vel aleat?ria do tempo de resposta e das atividades de coleta de lixo. Os resultados obtidos fornecem um subs?dio para engenheiros e gerentes decidirem quais tecnologias utilizarem em aplica??es de grande porte atrav?s do conhecimento de como elas se comportam nestes ambientes e a quantidade de recursos que consomem. A rela??o entre produtividade da tecnologia e seu desempenho tamb?m ? considerada como um fator importante nesta escolha
37
Xu, Guoqing. "Analyzing Large-Scale Object-Oriented Software to Find and Remove Runtime Bloat." The Ohio State University, 2011. http://rave.ohiolink.edu/etdc/view?acc_num=osu1313168204.
Full text
38
Duff, Gerard. "App enabling environment for Volvo CE platforms." Thesis, Mälardalens högskola, Inbyggda system, 2015. http://urn.kb.se/resolve?urn=urn:nbn:se:mdh:diva-27818.
Full text
39
Kim, Dong Kwan. "Applying Dynamic Software Updates to Computationally-Intensive Applications." Diss., Virginia Tech, 2009. http://hdl.handle.net/10919/28206.
Full textAbstract:
Dynamic software updates change the code of a computer program while it runs,
thus saving the programmerâ s time and using computing resources more productively.
This dissertation establishes the value of and recommends practices for applying dynamic software
updates to computationally-intensive applicationsâ a computing domain characterized
by long-running computations, expensive computing resources, and a tedious deployment
process. This dissertation argues that updating computationally-intensive applications dynamically
can reduce their time-to-discovery metricsâ the total time it takes from posing
a problem to arriving at a solutionâ and, as such, should become an intrinsic part of their
software lifecycle. To support this claim, this dissertation presents the following technical
contributions: (1) a distributed consistency algorithm for synchronizing dynamic software
updates in a parallel HPC application, (2) an implementation of the Proxy design pattern
that is more efficient than the existing implementations, and (3) a dynamic update approach
for Java Virtual Machine (JVM)-based applications using the Proxy pattern to offer flexibility
and efficiency advantages, making it suitable for computationally-intensive applications.
The contributions of this dissertation are validated through performance benchmarks and
case studies involving computationally-intensive applications from the bioinformatics and
molecular dynamics simulation domains.Ph. D.
40
Saad, Ibrahim Mohamed Mohamed. "Extracting Parallelism from Legacy Sequential Code Using Transactional Memory." Diss., Virginia Tech, 2016. http://hdl.handle.net/10919/71861.
Full textAbstract:
Increasing the number of processors has become the mainstream for the modern chip design approaches. However, most applications are designed or written for single core processors; so they do not benefit from the numerous underlying computation resources. Moreover, there exists a large base of legacy software which requires an immense effort and cost of rewriting and re-engineering to be made parallel.
In the past decades, there has been a growing interest in automatic parallelization. This is to relieve programmers from the painful and error-prone manual parallelization process, and to cope with new architecture trend of multi-core and many-core CPUs. Automatic parallelization techniques vary in properties such as: the level of paraellism (e.g., instructions, loops, traces, tasks); the need for custom hardware support; using optimistic execution or relying on conservative decisions; online, offline or both; and the level of source code exposure.
Transactional Memory (TM) has emerged as a powerful concurrency control abstraction. TM simplifies parallel programming to the level of coarse-grained locking while achieving fine-grained locking performance. This dissertation exploits TM as an optimistic execution approach for transforming a sequential application into parallel. The design and the implementation of two frameworks that support automatic parallelization: Lerna and HydraVM, are proposed, along with a number of algorithmic optimizations to make the parallelization effective.
HydraVM is a virtual machine that automatically extracts parallelism from legacy sequential code (at the bytecode level) through a set of techniques including code profiling, data dependency analysis, and execution analysis. HydraVM is built by extending the Jikes RVM and modifying its baseline compiler. Correctness of the program is preserved through exploiting Software Transactional Memory (STM) to manage concurrent and out-of-order memory accesses. Our experiments show that HydraVM achieves speedup between 2×-5× on a set of benchmark applications.
Lerna is a compiler framework that automatically and transparently detects and extracts parallelism from sequential code through a set of techniques including code profiling, instrumentation, and adaptive execution. Lerna is cross-platform and independent of the programming language. The parallel execution exploits memory transactions to manage concurrent and out-of-order memory accesses. This scheme makes Lerna very effective for sequential applications with data sharing. This thesis introduces the general conditions for embedding any transactional memory algorithm into Lerna. In addition, the ordered version of four state-of-art algorithms have been integrated and evaluated using multiple benchmarks including RSTM micro benchmarks, STAMP and PARSEC. Lerna showed great results with average 2.7× (and up to 18×) speedup over the original (sequential) code.
While prior research shows that transactions must commit in order to preserve program semantics, placing the ordering enforces scalability constraints at large number of cores. In this dissertation, we eliminates the need for commit transactions sequentially without affecting program consistency. This is achieved by building a cooperation mechanism in which transactions can forward some changes safely. This approach eliminates some of the false conflicts and increases the concurrency level of the parallel application. This thesis proposes a set of commit order algorithms that follow the aforementioned approach. Interestingly, using the proposed commit-order algorithms the peak gain over the sequential non-instrumented execution in RSTM micro benchmarks is 10× and 16.5× in STAMP.
Another main contribution is to enhance the concurrency and the performance of TM in general, and its usage for parallelization in particular, by extending TM primitives. The extended TM primitives extracts the embedded low level application semantics without affecting TM abstraction. Furthermore, as the proposed extensions capture common code patterns, it is possible to be handled automatically through the compilation process. In this work, that was done through modifying the GCC compiler to support our TM extensions. Results showed speedups of up to 4× on different applications including micro benchmarks and STAMP.
Our final contribution is supporting the commit-order through Hardware Transactional Memory (HTM). HTM contention manager cannot be modified because it is implemented inside the hardware. Given such constraint, we exploit HTM to reduce the transactional execution overhead by proposing two novel commit order algorithms, and a hybrid reduced hardware algorithm. The use of HTM improves the performance by up to 20% speedup.Ph. D.
41
Kugel, Rudolf. "Ein Beitrag zur Problematik der Integration virtueller Maschinen." Phd thesis, [S.l.] : [s.n.], 2005. http://deposit.ddb.de/cgi-bin/dokserv?idn=980016371.
Full text
42
Přerovský, Petr. "Verifikace metadat zvukových záznamů." Master's thesis, Vysoké učení technické v Brně. Fakulta informačních technologií, 2012. http://www.nusl.cz/ntk/nusl-236447.
Full textAbstract:
The work deals with verification of the metadata of audio recordings in an environment of mobile phones running Android. The text work is divided into three main parts. The first part is focused more on theoretical basis, where the main emphasis on the description of Android, application structure, description of the audio MP3 file and theoretical basis of Fourier transform in signal processing. The second part is devoted to solution design, analysis and implementation. The third part deals with testing.
43
Zárybnický, Jakub. "Just-in-time kompilace závisle typovaného lambda kalkulu." Master's thesis, Vysoké učení technické v Brně. Fakulta informačních technologií, 2021. http://www.nusl.cz/ntk/nusl-445576.
Full textAbstract:
Řada programovacích jazyků byla schopna zvýšit svoji rychlost výměnou běhových systémů stavěných na míru za obecné platformy, které pro optimalizaci používají just-in-time překlad, jako jsou GraalVM nebo RPython. V této práci vyhodnocuji, zda je použití takovýchto platforem vhodné i pro jazyky se závislymi typy nebo důkazovými systémy. Tato práce představuje koncepty -kalkulu a teorie typů potřebné pro úvod do závislých typů s relevantními algoritmy, specifikuje malý závisle typovaný jazyk založený na $\lambda\Pi$ kalkulu, a prezentuje dva interpretery tohoto jazyka. Tyto interpretery jsou psané v jazyce Kotlin, první je jednoduchý, psaný ve funkcionálním stylu a druhý používá platformu GraalVM a Truffle. GraalVM je platforma založená na virtuálním stroji Javy (JVM), která přidává just-in-time překladač založený na částečném vyhodnocení (partial evaluation) a Truffle je knihovna pro tvorbu programovacích jazyků využívající tento překladač. Závěr práce vyhodnocuje běhové charakteristiky těchto interpreterů na různých zátěžových testech.Závěry práce jsou ale silně negativní. Vliv JIT překladu není znatelný ani přes snahu optimalizovat běžné algoritmy z teorie typů, které jsou zjevně nevhodné pro platformu JVM. Práce končí návrhy několika navazujících projektů, které by lépe využily možnosti Truffle a které by byly vhodnější pro implementaci závisle typovaných jazyků.
44
Mertlík, Tomáš. "Technologie NFC a její zabezpečení." Master's thesis, Vysoké učení technické v Brně. Fakulta elektrotechniky a komunikačních technologií, 2013. http://www.nusl.cz/ntk/nusl-220202.
Full textAbstract:
The first objective of this paper is to describe the Android operating system. The chapter presents history and architecture regarding to all versions of the operating system. The significant part of chapter is focused on security. The second main topic of this paper is analysing the NFC (Near Field Communication) technology. This technology is based on an older contactless system RFID (Radio Frequency Communication), so RFID is described either. The NFC technology chapter contains the description of usability, history and the definitions of physical layer, link layer and NDEF (NFC Data Exchange) data format, used for data transmitting. The next chapter is focusing on the analysis of the NFC vulnerability. It contains a possible attacks methods and solutions how to prevent them. The output of this paper is the projection and creation of an application, which allow sending an arbitrary data between two devices using the NFC technology. Additional Bluetooth technology can be used for larger files. In this case, NFC helps to create Bluetooth communication channel which is utilized for data transfer.
45
Liu, Hanbing. "Formal specification and verification of a JVM and its bytecode verifier." Thesis, 2006. http://hdl.handle.net/2152/2763.
Full text
46
Pramod, B. S. "Performance Measurement Of A Java Virtual Machine." Thesis, 1999. http://etd.iisc.ernet.in/handle/2005/1530.
Full text
47
Chen, Guangyu ?UNAUTHORIZED. "Java virtual machine for resource constrained environments." 2006. http://etda.libraries.psu.edu/theses/approved/WorldWideIndex/ETD-1323/index.html.
Full text
48
Chen, Guangyu. "Java virtual machine for resource constrained environments." 2006. http://etda.libraries.psu.edu/theses/approved/WorldWideIndex/ETD-1323/index.html.
Full text
49
Ching-Shiu, Tseng. "Low Power Design for Java Virtual Machine." 2005. http://www.cetd.com.tw/ec/thesisdetail.aspx?etdun=U0001-1507200516020900.
Full text
50
Tseng, Ching-Shiu, and 曾清旭. "Low Power Design for Java Virtual Machine." Thesis, 2004. http://ndltd.ncl.edu.tw/handle/73166792270398679279.
Full textAbstract:
碩士國立臺灣大學
資訊工程學研究所
93
Memory system is a main concern to embedded system engineers since it dominates the cost, power and performance of mobile embedded systems. In particular, emerging memory technology, the flash memory is becoming an indispensable component in mobile embedded systems due to its versatile features: non-volatility, solid-state reliability, low power consumption. NAND flash has the nature of high density and low cost. With the shadowing technique support, NAND flash will replace NOR flash for the embedded memory system code storage in nearly future. The more advanced solution is NAND+RAM. Neither NOR flash memory nor mask ROM is used in this architecture; it uses NAND flash memory for code storage. Copying the whole software executable binary code into RAM offers the best performance possible at run time. With the advantage of portability, it is more important to implement Java system for embedded devices. The performance is a major drawback of Java system, especially for resource-limited embedded devices. Therefore, if becomes an interesting topic to improve the Java performance for embedded devices. In our thesis, we present three KVM interpreter optimization schemes based on the NAND+RAM memory architecture and the drawback of NAND page sequential access latency. By reducing of page fault ratio from NAND to RAM, the J2ME execution performance and the NAND flash energy consumption will both be decreased.