Comparative Benchmarking of Multithreading Solutions for JVM Languages: the case of the Alchemist Simulator

Re-implementing sequential algorithms with parallelization support often leads to a tangible improvement in the time and throughput of the execution. Designing for multithreading is especially beneficial in the context of long and slow computations such as discrete event simulation, where even a relatively small increment in throughput may cut down simulation time by a significant cumulative margin. Discrete event simulation is a notoriously challenging domain to parallelize due to the complexity of the nature of the discrete events and the necessity to account for and resolve the causality conflicts. A truly deterministic solution is difficult and is not always possible for some of the more complex simulation models and domains. However, some compromises may be reached by relaxing the determinism constraints and adopting the so-called optimistic approach to conflict resolution, sacrificing some degree of predictability and determinism for performance. Furthermore, when considering the goodness of a solution, a simple naive approach is not sufficient. The programming languages running on the \ac{jvm} have certain quirks and properties that must be taken into consideration to produce valuable and insightful results. Hence adopting a thorough method of testing and benchmarking is necessary. The recent developments in the Java programming language have introduced novel solutions to structuring multithreaded code such as virtual threads that compete with a more mature analogous implementation found in the Kotlin programming language. This thesis project explores the optimistic parallelization of a general discrete event simulator "Alchemist", building a robust benchmarking harness and testbed and comparing the results of equivalent implementations of the algorithm in traditional Java threads, the new Java virtual threads, and the consolidated Kotlin co-routines.