The subject of this thesis is the topic of the resilience and stability of web applications with a focus on the Java platform. Many existing information systems based not only upon this platform face problems that disturb the stability of applications. These problems may result in the failure, downtime and, consequently, financial or business loss due to the malfunction of the whole service. The aim is to show the problems that the applications face in a production environment and to show how to address them proactively. A possible partial solution to increase the stability may be an appropriate configuration of JVM (Java Virtual Machine), an analysis and corrections of detected errors, or a technique called Sandboxing to increase the stability, which this thesis deals with. Using this technique, it is possible to divide the application into separate parts that cannot influence each other. This prevents the propagation of errors among the parts of the application and thereby increases the stability of the entire application. The target applications include the Java applications made with the help of Spring framework. The Sanboxing technique can be implemented into the applications built this way by means of suitable configuration, which ensures that the application run will be divided into specified parts that will be automatically tested and possibly restarted. The application then recovers itself in the affected areas without a complete failure. The project is called Java Capsules.

This paper deals with the Java bytecode size optimization. It describes the Java Virtual Machine and the Java class file format. It also presents some tools for the bytecode manipulation. Using these tools, I have analyzed selected data and found sequences of instructions, that could be optimized. Based on the results of the analysis, I have designed and implemented methods for bytecode size optimization. The bytecode size of the selected data was reduced by roughly 25%.

Immutable data and persistent data structures are seeing more and more use. Many common programming errors can be solved by simply using immutable data, and in concurrent and parallel programming, they remove the need for data synchronization. There are many benefits of immutable data, but few modern languages provide a way to declare or control immutability. By analyzing a class, it is possible to know whether creating an object of that specific class will make an immutable object. This means that for final classes, which can't be extended, immutability can be inferred from the type. The same is not true for non-final classes. A mutable subclass can be made without recompiling the original, immutable superclass, making it possible to make mutable objects of the previously immutable class. This makes all non-final classes potentially mutable, ruling out many interesting class hierarchies. This thesis explores how the use of such unwanted class extensions could be detected. The solution introduces \emph{phantom classes}, synthetic final classes that are used in place of the original classes. These classes are essentially empty class extensions, behaving exactly the same as the original classes, but since they are final, can not be extended. An object can be verified by downcasting. If the cast fails, the object have been created in foreign code.A proof-of-concept is implemented as a fork of Dotty, what will become version 3 of the Scala compiler. The implementation is called Mållgan.Mållgan is able to compile real code, and produces executable JVM bytecode.Tests show that the code compiled with Mållgan can still be used normally by code compiled with regular Dotty, indicating that the solution is transparent to any code not aware of it. Overall the study shows that the solution is feasible, but a formal proof would be needed to provide definite proof for the correctness. / Omuterbar data och beständiga datastrukturer används mer och mer. Många vanliga programmeringsfel kan undvikas genom att använda omuterbar data, och i parallell och flertrådig programmering slipper man datasynkronisering. Det finns många fördelar med omuterbar data, men få moderna programmeringsspråk stödjer ett sätt att deklarera eller kontrollera omuterbarhet. Genom att analysera en klass är det möjligt att ta reda på om ett objekt som skapats från klassen är omuterbar. För klasser som inte går att ärva går det alltså att härleda om ett objekt är omuterbart eller inte från typen. För klasser som går att ärva finns inga garantier för att subklasserna är omuterbara, och subklasser kan skapas utan att orginalklassen måste kompileras om. Det här gör att alla klasser som går att ärva är potentiellt muterbara, vilket omöjliggör många intressanta klasshierarkier. Den här uppsatsen utforskar hur sådana oönskade subklasser kan upptäckas. Lösningen heter \emph{fantomklasser} (phantom classes), syntetiska klasser som inte går att ärva. Dessa är i grund och botten tomma subklasser som beter sig exakt likadant som orginalklasserna. Ett objekt kan verifieras genom att verifiera typen. Om de inte kan göras till fantomklassen måste de ha gjorts av främmande kod. Som proof-of-concept implementerades lösningen som en fork av Dotty, det som kommer att bli version 3 av Scala-kompilatorn. Implementationen heter Mållgan. Mållgan klarar att kompilera verklig kod och producerar exekverbar JVM bytekod. Tester visar att kod kompilerad med Mållgan fortfarande kan användas som vanligt med vanlig Dotty. Det här indikerar att lösningen är transparent för kod som inte är medveten om implementationen. Studien visar att lösningen är genomförbar, men ett mer formellt bevis krävs för att visa att lösningen är korrekt.

The widespread adoption of containerization for application deployment emphasizes the need for improved performance and efficiency, particularly in Java Virtual Machine (JVM)-based applications. Traditional JVMs often struggle with resource efficiency and long startup times, leading to increased operational costs and a larger environmental footprint. This is especially significant in microservices architectures where resource optimization is crucial for sustainability and cost-effectiveness. This thesis aims to evaluate the effectiveness of GraalVM’s Ahead-of-Time (AOT)compilation and native image support in enhancing the performance of JVM-based applications within a microservices architecture. The focus is reducing startup times, improving resource utilization, and overall operational efficiency at Ericsson, contributing to a greener economy. The research involved migrating a JVM-based program to run on GraalVM. Systematic performance tests measured key metrics such as startup time, memory usage, and performance. Semi-structured interviews with industry professionals were also utilized to gather qualitative insights into the migration challenges and benefits. The results indicated that native images significantly reduced startup times and memory usage compared to standard JVMs. Profile Guided Optimization (PGO)massively increased performance but at the cost of compilation time, memory usage, and build size. Interviews revealed that developers are cautiously optimistic about the benefits of AOT compilation with GraalVM but also revealed major concerns about complexity and compatibility. GraalVM’s AOT benefits make it a viable option for both microservice and serverless architectures. However, the decision to adopt GraalVM requires careful consideration of the trade-offs. These include larger build sizes, longer compilation times, and the need for specialized knowledge to maintain stability. Future work should focus on case studies in real-world environments to further validate and explore the benefits and drawbacks of AOT compilation..

A dynamic program analysis provides essential information during later phases of an application development. It helps with debugging, profiling, performance optimizations or vulnerability detection. Despite that, support for creating custom dynamic analysis tools, especially in the domain of managed languages, is rather limited. In this thesis, we present two systems to help improve application observability on the Java platform. DiSL is a language accompanied with a framework allowing simple and flexible instrumentation for the dynamic program analysis. DiSL provides high level abstractions to enable quick prototyping even for programmers not possessing a knowledge of Java internals. A skilled analysis developer gains full control over the instrumentation process, thus does not have to worry about unwanted allocations or hidden execution overhead. ShadowVM is a platform that provides isolation between the observed application and the analysis environment. To reduce the amount of possible interactions between the analysis and the application, ShadowVM offloads analysis events out of the context of the application. Even though the isolation is the primary focus of the platform, ShadowVM introduces a number of techniques to stay performance comparable and provide a similar programming model as existing...

No description available.

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.

<p>This thesis presents an in-depth investigation into the opportunities of optimizing the performance (throughput) of fuzzing on Java Virtual Machine (JVM)-based languages. The study identifies five main areas for potential optimization, each of which contributes to the performance bottlenecks in the existing state-of-the-art Java fuzzer, Jazzer.</p> <p><br></p> <p>Firstly, the use of coverage probes is recognized as costly due to the native method call, including call frame generation and destruction, while it only performs a simple byte increment. Secondly, the probes may become exhausted, which subsequently cease to generate signals for new interesting inputs, while the associated costs persist. Thirdly, the scanning of the coverage map is expensive, particularly for targets with a large loaded bytecode. Given that test inputs can only execute a portion of these, the probes for most bytecodes are scanned repeatedly without generating any signals, indicating a need for a more structured coverage map design to skip the code probes effectively. Lastly, exception handling in JVM is costly as it automatically fills in the stack trace whenever an exception object is created, even when most targets don't utilize this information. </p> <p><br></p> <p>The study then designs and implements optimization techniques for these opportunities. We believe we provide the optimal solution for the first opportunity, while better optimizations could be proposed for the second, third, and fourth. The collective improvement brought about by these implementations is on average 138% and up to 441% in throughput. This work, thus, offers valuable insights into enhancing the efficiency of fuzz testing in JVM languages and paves the way for further research in optimizing other areas of JVM-based-language fuzzing performance.</p>

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.

<p>The Ericsson AXE-based systems are programmed using an internally developed language called Plex-C. Plex-C is normally compiled to execute on an Ericsson internal processor architecture. A transition to standard processors is currently in progress. This makes it interesting to examine if Plex-C can be compiled to execute on the JVM, which would make it processor independent. </p><p>The purpose of the thesis is to examine if parts of the run-time environment of Plex-C can be translated to Java and if this can be done so that sufficient performance is obtained. It includes how language constructions in Plex-C can be translated to Java. </p><p>The thesis describes how a limited part of the Plex-C run-time environment is implemented in Java. Optimizations are an important part of the implementation. </p><p>It is also described how the JVM system was tested with a benchmark test. </p><p>The test results indicate that the implemented system is a few times faster than the Ericsson internal processor architecture. But this performance is still not sufficient for the JVM system to be an interesting replacement for the currently used processor architecture. It might still be useful as a processor independent test platform.</p>