1 |
JavaFlow : a Java DataFlow MachineAscott, Robert John 10 February 2015 (has links)
The JavaFlow, a Java DataFlow Machine is a machine design concept implementing a Java Virtual Machine aimed at addressing technology roadmap issues along with the ability to effectively utilize and manage very large numbers of processing cores. Specific design challenges addressed include: design complexity through a common set of repeatable structures; low power by featuring unused circuits and ability to power off sections of the chip; clock propagation and wire limits by using locality to bring data to processing elements and a Globally Asynchronous Locally Synchronous (GALS) design; and reliability by allowing portions of the design to be bypassed in case of failures. A Data Flow Architecture is used with multiple heterogeneous networks to connect processing elements capable of executing a single Java ByteCode instruction. Whole methods are cached in this DataFlow fabric, and the networks plus distributed intelligence are used for their management and execution. A mesh network is used for the DataFlow transfers; two ordered networks are used for management and control flow mapping; and multiple high speed rings are used to access the storage subsystem and a controlling General Purpose Processor (GPP). Analysis of benchmarks demonstrates the potential for this design concept. The design process was initiated by analyzing SPEC JVM benchmarks which identified a small number methods contributing to a significant percentage of the overall ByteCode operations. Additional analysis established static instruction mixes to prioritize the types of processing elements used in the DataFlow Fabric. The overall objective of the machine is to provide multi-threading performance for Java Methods deployed to this DataFlow fabric. With advances in technology it is envisioned that from 1,000 to 10,000 cores/instructions could be deployed and managed using this structure. This size of DataFlow fabric would allow all the key methods from the SPEC benchmarks to be resident. A baseline configuration is defined with a compressed dataflow structure and then compared to multiple configurations of instruction assignments and clock relationships. Using a series of methods from the SPEC benchmark running independently, IPC (Instructions per Cycle) performance of the sparsely populated heterogeneous structure is 40% of the baseline. The average ratio of instructions to required nodes is 3.5. Innovative solutions to the loading and management of Java methods along with the translation from control flow to DataFlow structure are demonstrated. / text
|
2 |
Optimisation de code pour application Java haute-performance / Code optimization for high-performance Java applicationHalli, Abderrahmane Nassim 24 October 2016 (has links)
Java est à ce jour l'un des langages, si ce n'est le langage, le plus utilisé toutes catégories de programmation confondues et sa popularité concernant le développement d'applications scientifiques n'est plus à démontrer. Néanmoins son utilisation dans le domaine du Calcul Haute Performance (HPC) reste marginale même si elle s'inscrit au cœur de la stratégie de certaine entreprise comme Aselta Nanographics, éditeur de l'application Inscale pour la modélisation des processus de lithographie par faisceaux d'électron, instigateur et partenaire industriel de cette thèse.Et pour cause, sa définition haut-niveau et machine-indépendante, reposant sur un environnement d'exécution, parait peu compatible avec le besoin de contrôle bas-niveau nécessaire pour exploiter de manière optimale des architectures de microprocesseurs de plus en plus complexes comme les architectures Intel64 (implémentation Intel de l'architecture x86-64).Cette responsabilité est entièrement déléguée à l'environnement d'exécution, notamment par le biais de la compilation dynamique, chargée de générer du code binaire applicatif à la volée. C'est le cas de la JVM HotSpot, au centre de cette étude, qui s'est imposée comme l'environnement de référence pour l'exécution d'applications Java en production.Cette thèse propose, dans ce contexte, de répondre à la problématique suivante : comment optimiser les performances de code séquentiel Java plus particulièrement dans un environnement HotSpot/Intel64 ?Pour tenter d'y répondre, trois axes principaux ont été explorés. Le premier axe est l'analyse des performances du polymorphisme, mécanisme Java haut-niveau omniprésent dans les applications, dans le lequel on tente de mesurer l'impact du polymorphisme sur les performances du code et d'évaluer des alternatives possibles. Le second axe est l'intégration de code natif au sein des applications - afin de bénéficier d'optimisations natives - avec prise en compte du compromis coût d'intégration/qualité du code. Enfin le troisième axe est l'extension du compilateur dynamique pour des méthodes applicatives afin, là encore, de bénéficier d'optimisations natives tout en s'affranchissant du surcout inhérent à l'intégration de code natif.Ces trois axes couvrent différentes pistes exploitables dans un contexte de production qui doit intégrer certaines contraintes comme le temps de développement ou encore la maintenabilité du code. Ces pistes ont permis d'obtenir des gains de performances significatifs sur des sections de code applicatif qui demeuraient jusqu'alors très critiques. / L'auteur n'a pas fourni de résumé en anglais
|
3 |
Compiler for an Embedded Extension Language on AndroidRasmus, Svensson January 2012 (has links)
Bytecode interpreters are a common implementation strategy for scripting languages. Source code is translated to bytecode to improve time and memory performance. The Android platform includes the Dalvik virtual machine, which typically executes bytecode compiled from Java source code. This thesis describes how this virtual machine can be reused to execute bytecode compiled from a scripting language. A compiler is written for a test bed scripting language and the time and memory performance is evaluated. The Dalvik virtual machine, designed for a statically typed object-oriented language, was flexible enough to successfully host a dynamically typed scripting language that allows for objects to be transported cheaply between scripts and Java code. The compiled code executes one to two orders of magnitude faster than with a naive interpreting implemetation. Numeric performance is lacking in general, though simpler cases are optimized.
|
4 |
Správa přepínání procesů v aplikaci Jenkins / Suspending Jenkins Job Execution in Favor of High-Priority JobsOndrušek, Libor January 2012 (has links)
The project deals with design and solution of plug-in for a Jenkins server, which allows management of jobs running on the nodes in the cluster of continuous integration system servers. This plug-in should allow pause the long time job, done process with higher priority and restore original job in state where it was interrupted.
|
5 |
Evaluation of GraalVM Performance for Java ProgramsLarsson, Robin January 2020 (has links)
GraalVM is a new Java Development Kit developed by Oracle that promises improved performance when running Java programs. In this paper we compare the performance of both the community edition and the enterprise edition of GraalVM to OpenJDK and OracleJDK, using both Java 8 and Java 11. We use the DaCapo benchmark suite to test these JDKs. The results are analysed using statistically rigorous methodology. We find that the performance of the different JDKs vary significantly depending on the benchmark, making it difficult to draw any definitive conclusions.In the end we can see that GraalVM Enterprise Edition using Java 8 will outperform the other JDKs tested in the majority of cases.
|
6 |
CONSIDERATIONS ON PORTING PERL TO THE JAVA VIRTUAL MACHINEKUHN, BRADLEY M. 11 October 2001 (has links)
No description available.
|
7 |
Mobilité et persistance des applications dans l'environnement JavaBouchenak, Sara 19 October 2001 (has links) (PDF)
Les travaux de cette thèse portent sur la mobilité et la persistance des applications dans des environnements hétérogènes. Ces fonctions sont utiles à la répartition dynamique de charge dans les systèmes distribués, à la reconfiguration dynamique d'applications réparties ou à la mise en place de techniques de tolérance aux pannes. La mobilité et la persistance des applications ont largement été abordées au niveau du système d'exploitation ou au niveau du langage/modèle de programmation. Mais très peu de travaux ont été menés au niveau des machines virtuelles. L'objet de cette thèse est l'étude et la réalisation de fonctions de mobilité et de persistance dans la machine virtuelle Java. L'environnement Java fournit des outils pour la mobilité et la persistance du code et des données mais il n'adresse pas le problème de mobilité ni de persistance de l'état d'exécution des processus légers (threads). Les travaux de cette thèse portent sur la conception de tels services, une conception guidée par deux principes : la portabilité sur des environnements hétérogènes et le respect des performances des applications. Pour des besoins de performances, plusieurs efforts ont été faits par les concepteurs de Java en matière d'optimisation de l'exécution et de compilation à la volée. Notre solution permet de fournir des fonctions de mobilité et de persistance portables même en présence de compilation à la volée. Ceci est mis en oeuvre en reposant, d'une part, sur des techniques d'inférence dynamique du type des données sur la pile d'exécution à partir du code Java exécuté et, d'autre part, sur des techniques de dés-optimisation dynamique du code Java compilé à la volée. Nos services ont été réalisés via une extension de la machine virtuelle Java de Sun Microsystems. Ils sont opérationnels et ont pu être validés pour des besoins de tolérance aux pannes dans une plate-forme de metacomputing. Notre solution est actuellement l'unique approche qui est complète et qui élimine toute pénalité sur l'exécution des applications.
|
8 |
The SHAP Microarchitecture and Java Virtual MachinePreußer, Thomas B., Zabel, Martin, Reichel, Peter 14 November 2012 (has links) (PDF)
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.
|
9 |
Migration from blocking to non-blocking web frameworksBilski, Mateusz January 2014 (has links)
The problem of performance and scalability of web applications is challenged by most of the software companies. It is difficult to maintain the performance of a web application while the number of users is continuously increasing. The common solution for this problem is scalability. A web application can handle incoming and outgoing requests using blocking or non-blocking Input/Output operation. The way that a single server handles requests affects its ability to scale and depends on a web framework that was used to build the web application. It is especially important for Resource Oriented Architecture (ROA) based applications which consist of distributed Representational State Transfer (REST) web services. This research was inspired by a real problem stated by a software company that was considering the migration to the non-blocking web framework but did not know the possible profits. The objective of the research was to evaluate the influence of web framework's type on the performance of ROA based applications and to provide guidelines for assessing profits of migration from blocking to non-blocking JVM web frameworks. First, internet ranking was used to obtain the list of the most popular web frameworks. Then, the web frameworks were used to conduct two experiments that investigated the influence of web framework's type on the performance of ROA based applications. Next, the consultations with software architects were arranged in order to find a method for approximating the performance of overall application. Finally, the guidelines were prepared based on the consultations and the results of the experiments. Three blocking and non-blocking highly ranked and JVM based web frameworks were selected. The first experiment showed that the non-blocking web frameworks can provide performance up to 2.5 times higher than blocking web frameworks in ROA based applications. The experiment performed on existing application showed average 27\% performance improvement after the migration. The elaborated guidelines successfully convinced the company that provided the application for testing to conduct the migration on the production environment. The experiment results proved that the migration from blocking to non-blocking web frameworks increases the performance of web application. The prepared guidelines can help software architects to decide if it is worth to migrate. However the guidelines are context depended and further investigation is needed to make it more general.
|
10 |
Preprocesor Java bytecode pro verifikační nástroje / Java Bytecode Preprocessor for Program Verification ToolsŠafařík, Tomáš January 2016 (has links)
Both J2BP and PANDA tools verify compiled Java programs. By now, these tools are not able to process some programs with specific JVM bytecode instruction sequences in the correct way. We described these instruction sequences and proposed their transformations. We developed the new application, called BytecodeTransformer, based on these propositions. This application transforms compiled Java programs and replaces the problematic instruction sequences with some others. Usage of BytecodeTransformer enlarges the set of programs that can be verified by both J2BP and PANDA. We also evaluated BytecodeTransformer on several Java programs, including own tests and well-known open-source programs. These tests demonstrated the correct functionality of BytecodeTransformer. Powered by TCPDF (www.tcpdf.org)
|
Page generated in 0.0145 seconds