Comparative Performance and Energy Efficiency Analysis of JVM Variants and GraalVM in Java Applications

Java has dominated the ICT market for almost thirty years with various applications in nearly every sector all over the world. One of Java’s main drawbacks comes from its heavyweight core - the Java Virtual Machine (JVM). Therefore, several JVM distributions have been developed to address this issue. GraalVM is the most promising amongst the recent distributions, providing better performance, low power consumption, and reduced carbon footprint emissions. In this research, a comparative analysis based on performance and energy efficiency metrics was conducted to assess this JVM distribution in light of three other classic JVM distributions: Amazon Corretto, Adopt OpenJDK, and Zulu. Findings showed that, although there was no significant difference between the test candidates, GraalVM seemed to be the leading JVM distribution. It is recommended that programmers and technology businesses consider adopting GraalVM in their future Java applications because of its energy efficiency.


Background Context
Since its introduction approximately thirty years ago by James Gosling and his colleagues at Sun Microsystems (Rauf, 2018), Java has grown to become one of the most extensively used programming languages.It has acquired popularity and become a market leader in almost every programming environment, particularly enterprise applications, server-side Web development, and mobile phone programming (Evans, 2015).According to Floyer (2020), a survey carried out by Wikibon in 2020 showed that 93% of enterprises chose Java as their leading application development platform, with C++ and Python ranking far behind with, respectively, 51% and 29% of respondents.However, Java is still a heavyweight programming language, mainly due to applications processed on the Java Virtual Machine (JVM).Thus, every Java program needs considerable memory and processing resources (GeeksForGeeks, 2019), which creates a financial burden for small and medium enterprises (SMEs) due to its high energy consumption.Understanding this problem, various JVM providers have released improved JVM distributions with reduced runtime memory CPU usage, such as Adopt OpenJDK HotSpot, Amazon Corretto, and Redhat Mandrel.These variants have, to different extent, addressed the original JVM's issues.The most noticeable JVM distribution, however, is Oracle's GraalVM, which provides several significant improvements and the ability to compile Java source code into a standalone binary executable program called native image (Graalvm.org, n. d.).Although several studies have been conducted to compare the performance of the GraalVM with other improved JVM distributions, limited work focuses on the sustainability aspect (Ournani et al., 2021).This paper considers both aspects by carrying out practical experiments with different scenarios to explore whether GraalVM is a worthy upgrade for SMEs in terms of performance and energy efficiency.

Aim and objectives
With the support of eight benchmark tests, this study investigates the performance and energy consumption of three selected JVM distributions (Amazon Corretto, Adopt OpenJDK, Zulu), and GraalVM.The research objectives are listed below: 1. Based on the appropriate literature review, design scenarios and test suites to measure performance and energy consumption for chosen JVM distribution candidates.2. To identify optimal performance and energy consumption measuring methods and tools to apply.3. Based on outcomes from (1) and (2), carry out experiments and conduct a comparative analysis of these JVM distributions and GraalVM based on performance and energy efficiency criteria.4. To apply data analysis approaches to the experimental data to answer three research questions: 1.2.1 Level 1: Descriptive Statistical Analysis a. Utilizing the same specified scenarios and test suites, how do the selected JVM distributions compare with GraalVM in terms of performance and energy consumption?
1.2.2Level 2: Inferential Statistical Analysis b.Are there any remarkable differences in performance and energy consumption between GraalVM and the selected JVM distributions? c.How can GraalVM support SMEs in monthly energy costs reduction? 5. To present conclusions and possible recommendations based on analytical findings and suggest future research work.

Rationale
Energy efficiency is becoming a serious challenge due to the prevalence of Information Technology systems and their impact on global energy usage (Ergasheva et al., 2020).If we do not address this problem satisfactorily, it might lead to severe consequences for current and future generations, such as resource depletion and global warming.Software developers frequently state that sustainable solutions should come from more energy-efficient hardware components or efficient algorithms (Ournani et al., 2021).However, given the complexity of today's software environments, the composition of software layers makes this goal particularly difficult to attain.Therefore, modifying the abstraction layer for a programming language is extremely important, especially for Java, which is one of the current top five programming languages (TIOBE Software, 2023).When comparing Java's JVM distributions, decisive criteria (i.e., performance, memory usage, and CPU usage) would help ascertain which distribution is better for Java applications development.There is limited research on energy efficiency and its trade-off with performance for different JVM distributions.Therefore, this research is conducted to address this pressing issue.

Scope
Three distribution candidates were selected, and their performance and energy consumption measured by the experiments in this paper.Apart from GraalVM, the criteria to choose the other JVM distributions were current market usage and non-commercial usage.The latter makes this research particularly relevant to SMEs.Therefore, based on the information reported by Vermeer in 2020, Adopt OpenJDK, Amazon Corretto OpenJDK, and Azul Zulu were identified as ideal candidates with 24%, 4%, and 4% of usage respondents, respectively.This research aims to extend the scope so that it encompasses a comparative analysis of the carbon footprint for GraalVM and selected JVM distributions followed by a discussion of their environmental impact in eight different scenarios based on benchmark tests.This paper will not consider variations in the JVM configurations of any distributions.Therefore, all configurations were set to default before conducting experiments to ensure objectivity and consistency.All experiments were conducted on a Dell Vostro 5502 personal computer powered by an 11th Gen Intel Core i7 processor (8 CPU) with 16GB RAM, 512GB SSD, and running the Windows 11 Pro 64-bit operating system, as specified in Table 1.Performance was measured based on the CPU and memory usage of the computer during the experiments.

Contribution of Research
In this study, the three most popular JVM distributions and GraalVM are assessed and compared with each other by using software-defined power toolkit benchmarks and carbon emission estimation metrics in different test scenarios.The study entailed Descriptive and Inferential Statistical Analyses on the experimental data to derive conclusions which might be utilized to inform JVM selection.The positive findings could lead to further future research, enabling software engineers and organizations, especially SMEs, to make optimal evidence informed decisions.

Organization of Report
There are five sections in this paper.The first section describes the background context and clarifies the research's main research questions and objectives.The second section provides an overview of related work that supports this research.The methodologies used to design and conduct the experiments and analyse the results are presented in Section 3. In Section 4, the experimental results are collected, analysed, and discussed.Finally, Section 5 utilizes these results to conclude the paper and provide evidence-based recommendations.

ICT and Environment Impact
It is an accepted fact that rapid advancements in ICT have been matched by an increase in the number of digitized devices and services over the last two decades.These have been beneficial in different ways.With the support of AI and big data, for instance, technology devices have been utilized for patient screening, outbreak monitoring, case tracking and tracing, disease prediction, and infection risk assessment.Another beneficial example is 3D printing which enables quicker and more affordable low-volume production as well as quick, iterative product prototyping (United Nations, 2021).However, according to Mahdavi and Sojoodi (2021), this sector is a double-edged sword for the environment.It can have both positive and negative impacts on environmental sustainability.On the one hand, technology products allow humanity to monitor and control the environment, such as measuring GHG emissions to inform drivers to modify their driving behaviour to be more environment friendly.Moreover, by modifying the pattern of household energy usage, ICT could reduce power consumption and improve energy efficiency (Bastida et al., 2019).Other research seems to confirm that ICT mitigates energy loss through optimal solutions, such as intelligent networks and automated lighting, heating, and cooling management systems (Houghton, 2009).On the other hand, ICT applications without environmental awareness might lead to severe problems to our fragile ecosystem.To be more specific, Avom et al. (2020) found that mobile phone and Internet penetration have a significantly negative effect on the environment by increasing the volume of CO2 emissions.
In a study conducted by Arushanyan et al. (2014), ICT products and services were found to play a vital role in global energy consumption and global warming.An enhanced ICT use efficiency has the potential to lower energy prices, thus encouraging greater efficient energy consumption.

Java and the JVM
Back in the 1990s, the Internet blossomed in a way that we have never seen before.Due to this remarkable growth, several new general-purpose programming languages were developed and applied to various sectors in that period, namely Haskell (1990), Python (1991), Visual Basic (1991), Ruby (1993), Lua (1993), R (1993), Java (1995), Javascript (1995), and PHP (1995) (Long, 2017).Among these programming languages, Java has dominated the popularity chart for almost 20 years, ranking first from 2002 to 2017, and staying amongst the top three programming languages since 1987, as shown in Figure 1.
In the past 20 years, platform independence is one of the most distinctive features that has made Java stand out compared with other programming languages.The applications of Java can be found in various places, including computers, smartphones, and even parking metres (Lestal, 2021).This was also the most important principle when James Gosling and a group of engineers at the United States's Sun Microsystems decided to create it in 1991 (Ikedilo et al., 2021).It was later promoted as "Write once, run anywhere" (WORA) to draw the attention of the technology community at that time.Apart from this principle, as Gosling et al. clarified in 2018, Java is a general-purpose, concurrent, class-based, object-oriented programming language.It is designed to be basic enough that even inexperienced coders can quickly pick it up.The Java programming language is similar to C and C++, although it is organised differently, with some C and C++ features eliminated, and a few concepts from other languages incorporated.A typical Java application is illustrated in Figure 2.
The first and the second phases are done by programmers (Figure 3 and Figure 4), while the remaining three phases are handled by the core of the programming language: the Java Virtual Machine (JVM).Basically, when executing a compiled java program with the command "java className," the JVM loads the program into memory for execution by a component named ClassLoader (Figure 5).After the program has been loaded, the Bytecode Verifier component checks whether the program is valid or not based on Java's security restrictions (Figure 6).Subsequently, in the final phase, the JVM executes the bytecodes to run the program's stated instructions (Figure 7).Deitel and Deitel (2019) also stated that the JVM was originally just a Java bytecode interpreter because the JVM interpreted and executed one bytecode at a time and, consequently, most programs would run slowly.Nowadays, it uses a combination of interpretation and just-in-time (JIT) compilation to execute bytecode faster (Deitel & Deitel, 2019).
As illustrated in Figures 3 and 4, the JVM is required for a Java program to be executable.Therefore, a compiled language program such as Java normally utilizes more memory and processing power than its interpreted alternatives.Many JVM improvements and distributions have been released to address this issue and improve Java applications' performance while utilising as minimal computing resources as possible (Ournani et al., 2021).When writing this paper, Java 17 has been published as the latest Long Term Support (LTS) version.Oracle urges developers to upgrade to the most recent version or an LTS release as soon as possible since the legacy versions incur lower performance and will phase out of support in the near future (Ournani et al., 2021).

GraalVM
As previously mentioned, JVM improvements and distributions have been published continuously to enhance performance and/or patch existing problems.Amongst all distributions, GraalVM is the most distinctive, since it is a high-performance VM built on the JVM and provides a number of optimisation facilities (Kumar, 2021a).It was created as part of OpenJDK's Graal Project in 2012, which aimed to create a next-generation high-performance polyglot virtual machine with an extensive ecosystem that included the Graal Compiler, GraalVM Native Image Mechanism, Truffle Language Implementation Framework, and Sulong Language Implementation Framework (LLVM) (Sipek et al., 2020).Figure 8 below is an illustration of the Graal stack.
In his blog post, Kumar explained every component in this stack in detail.The JVM (Hotspot) is simply a JVM in the JDK (Kumar, 2021b).The JVM Compiler Interface (JVMCI) was introduced with Java 9, making it possible to write compilers as plugins that the JVM could use for dynamic compilation.It included an API and a protocol for creating compilers with customized implementations and optimisations.Noticeably, the Graal Compiler and Substrate VM offer memory management, garbage collection, thread scheduling, and other necessary VM functionality.Additionally, the GraalVM can build native images for a specific target OS/architecture utilising the Ahead-Of-Time application compilation mechanism.This feature is responsible for a reduced footprint, quick startups, and embeddable runtimes, therefore playing a pivotal role in cloud-native and serverless workloads.Based on the target OS, a native image is compiled which includes the application source code, dependencies, the JDK, and Substrate VM.This means the target OS does not need to install a specific JVM to get the application up and running as the image is executable for the target OS without any further requirements.The whole process is presented in Figure 9.
Lastly, Truffle and Sulong are two components on top of the stack which ensure the polyglot capability, as well as interoperability in a cloud-native environment by enabling multiple non-JVM programming languages compilation such as C, C++, Rust, Swift, Fortran, Javascript, Python, and R (Kumar, 2021b).Given these advancements, GraalVM is projected to be a pioneering multilingual virtual machine that is already supporting companies to save computer resources and costs (Morales, 2019).In fact, a study conducted by Ournani with eleven JVM distributions showed that, in most cases, GraalVM was the most energy efficient distribution (Ournani et al., 2021).Their results are in line with and corroborate the research presented in this paper.

Energy Measurement and optimisation Tools
Energy management at a higher level requires monitoring or estimation of hardware and software energy as well as resource consumption (Noureddine et al., 2013).Therefore, energy measurement and optimisation tools are vital for optimal energy management.Nowadays, such tools are diverse and could provide insightful energy consumption-related information for various types of applications such as software and media players (Kor et al., 2015).
PowerAPI, developed by the Inria ADAM project team, is one of the most popular energy monitoring tools.It could measure energy consumption at the granularity of a system process, in realtime, and without any external device.To assess the power usage of a software system, PowerAPI uses energy analytical models to estimate based on the consumption of a computer's hardware components such as CPU, memory, and disk (Bourdon et al., 2013).
Another widely used alternative is Microsoft Joulemeter.This software could measure and record the energy consumption of hardware resources such as CPU, base system, and disk in Watt (W) (Sehgal et al., 2022).A study conducted by Kansal et al. (2009) showed that proper usage of Joulemeter might result in about an 8-12% reduction of power provisioning costs when operating in a Virtual Machine environment.

Macro Methodology
There are three widely used standards, originating from ISO 14040 and 14044, to assess the environmental impact of ICT products/services lifecycle (Stephens & Didden, 2013): • ETSI -TS 103 199 "Life Cycle Assessment (LCA) of ICT equipment, networks, and services: General methodology and common requirements."• ITU-T L.1410 "Methodology for environmental impact assessment of information."• IEC TR 62725 "Quantification methodology of greenhouse gas emissions for electrical and electronic products and systems." This study will follow the ITU-T L.1410 methodology issued by the International Telecommunication Union (ITU) to conduct an analysis of the energy consumption and carbon emissions of GraalVM and other JVM distributions.According to ITU's recommendation, the environmental effects of ICT goods, networks, and services are assessed by a systematic analytical method called Life Cycle Assessment (LCA) (ITU-T, 2012).This method provides a cradle-to-grave scope that considers all stages of a product such as raw material acquisition, manufacturing, use/reuse/ maintenance, and recycle/waste management.The four phases of this methodology are illustrated in Figure 10.
• Goal and scope definition: research purpose, boundaries of the systems, requirements of data quality, and functional units are clearly explained in this phase to provide a solid background for the study.• Life cycle inventory (LCI): in the second phase, data collection, calculation, and allocation procedures are carried out using information obtained in the first phase.• Life cycle impact assessment (LCIA): this phase involves evaluating the data that has been obtained.The data gathered throughout the studies will be examined to determine the environmental impact of power consumption and carbon emissions.• Life cycle interpretation: using results from LCI and LCIA, this phase highlights significant problems, completeness, sensitivity, consistency assessment, and provides conclusions and recommendations for the system.• Reporting (additional phase): after interpreting the results, reporting is crucial to convey the findings to stakeholders conveniently and support users to make evidence-informed decisions.

Micro Methodology
To measure the performance and energy consumption of GraalVM and other JVM distributions, a dedicated test environment was designed and installed on a laptop with the specifications shown in Table 1.
Based on these hardware specifications, Joulemeter 1.2 was the ideal candidate to quantitatively measure and gather program execution duration and energy usage data.This tool is Windows-friendly, easy to use, and provides detailed data on the CPU, software applications, and the monitor (Kor et al., 2015).
Windows Subsystem for Linux (WSL) 2 was used as a standalone testing environment for all experiments conducted in this paper to ensure flexibility when switching between several experiments and the objectivity of the results.This impressive feature has been introduced since Windows 10 version 1607, which provides identical capabilities to utilising Linux applications and libraries within the Bash shell (Singh & Gupta, 2019).

Environment Setup
As mentioned above, all experiments in this paper were conducted in a standalone environment, and the results were collected via Joulemeter as another process in Windows. Figure 11 shows the overall experiment design.
Inside the Windows 11 host machine, there are three components: WSL2 with Ubuntu 20.04 Distribution, Joulemeter 1.2, and SSD storage to store CSV files: To assess the performance and power consumption of these JVM distributions, the Renaissance benchmark suite was used as a benchmark suite.It comprises 21 benchmarks created in popular Java and Scala frameworks that illustrate modern concurrency and parallelism workloads.The Renaissance benchmark suite was invented to provide a more efficient tool to identify new compiler optimisations compared with existing test benchmarks such as DaCapo (used by Ournani et al., 2021), ScalaBench, and SPECjvm2008 (Prokopec et al., 2019).This paper has considered all Apache Spark test cases in the benchmark to measure performance and power consumption.• Before measurement, it was necessary to configure Joulemeter in advance.In fact, the configurations depend on the computer model and hardware.Based on the information from the previous section, the laptop profile was chosen as the profile configuration for Joulemeter.The configuration information is shown in Figure 12.On the power usage tab, the program name 'vmmem' is specified as the target process to measure and collect the power consumption data.Figure 13 depicts this step in detail.

Conducting the Experiments
Eight benchmark tests were used to conduct experiments for five test candidates: OpenJDK 11.0.12,Amazon Corretto 11.0.14.1, Zulu 11.0.14,GraalVM 21.3.1 (build 11.0.14), and GraalVM 21.3.1 (build 11.0.14) with the native image.Each test was repeated five times to ensure fairness and consistency.The specification of each benchmark test is summarised in Table 2.The results obtained from each test iteration were stored in a CSV file.Subsequently, information from the CSV files was grouped by individual benchmark test to be analysed and discussed.

FINdINGS ANd dISCUSSIoN
In this study, a total of 200 experiments were carried out using 8 benchmark tests.The results for both performance and energy consumption criteria are discussed for two distinct groups: Classic JVM distribution candidates (OpenJDK, Amazon Corretto and Zulu) and GraalVM-based JVM distribution candidates (GraalVM and GraalVM's native image).Furthermore, the carbon footprint (based on This study also focuses on energy consumption and carbon emissions analyses.Apart from descriptive statistics, Welch's t-test and ANOVA test were used to explore if there was any significant difference between the two candidate groups.The following sub-section presents this analysis in detail.

Performance Analysis
The aggregate of all five experimental runs for each benchmark test was used to calculate the total execution time for three classic JVM distribution candidates and two GraalVM-based candidates, as shown in Table 3.
The figures in Table 3 also show there are differences between the first and second groups.To be more specific, GraalVM 21.3.1 (build 11.0.14) and its native image performed well in ALS, Chisquare, Decision Tree, Log Regression, Movie Lens, and Page Rank benchmark tests with the lowest aggregated execution time over five iterations amongst all candidates.In contrast, they had poor results when used in Gauss-mix and Naive Bayes benchmark tests, occupying the fourth and fifth ranked positions, respectively.Figure 14 below uses Table 3's data to illustrate the total execution time gap in graphs, and Table 4 utilizes experiment results to conclude the overall performance ranking of each candidate.
From these tables and the figure, it seems to imply that in general GraalVM 21.3.1 applications provide better performance compared with applications utilising OpenJDK 11.0.12,Amazon Corretto 11.0.14.1, and Zulu 11.0.14.Although the difference is not significant, saving even one second of execution time might bring enormous technology benefits for SMEs in the long run.

Energy Consumption Analysis
A one-way ANOVA one-tailed test and a two-tailed Welch's t-test were employed as inferential analysis methods for Aggregated Average Energy Consumption per second.ANOVA statistical analysis were  • ANOVA test • H0 (Null hypothesis): There is no significant energy consumption difference between OpenJDK, Amazon Corretto, Zulu, GraalVM, and GraalVM's native image.• H1: There is a significant energy consumption difference between OpenJDK, Amazon Corretto, Zulu, GraalVM, and GraalVM's native image.• Welch's t-test • H0 (Null hypothesis): There is no significant energy consumption difference between classic JVM distribution candidates (OpenJDK, Amazon Corretto, and Zulu) and GraalVM-based candidates in the benchmark test.• H1: There is a significant energy consumption difference between classic JVM distribution candidates (OpenJDK, Amazon Corretto, and Zulu) and GraalVM-based candidates in the benchmark test.
The chosen confidence level in both tests was 95%, and the alpha value was 0.05.The data presented in Table 5 and Figure 15 was used as inputs for implementing these two tests.A detailed discussion of the results is delivered in the following subsection.

ANoVA test
Given the data in Table 5, the p-value for the one-way ANOVA one-tailed test is 0.999821686.Since this p-value is greater than the alpha value (0.05), the null hypothesis is accepted.The overall conclusion is that there is no significant difference between all testing candidates in terms of energy consumption when implementing the eight benchmark tests with five iterations.Table 6 presents this result and other relevant information.

welch's T-Test
Results from conducting the two-tailed Welch's t-test for unequal variances are reported for each individual benchmark test in Tables 7-14.A t-test was used in this manner to test the hypothesis for candidates in every specific benchmark test.
1. ALS: p-value = 0.260367 > alpha = 0.05, therefore, the null hypothesis is accepted for ALS benchmark test.2. Chi-square: p-value = 0.066003 > alpha = 0.05, therefore, the null hypothesis is accepted for the Chi-square benchmark test.3. Decision Tree: p-value = 0.023023 < alpha = 0.05, therefore, the null hypothesis is rejected for the Decision Tree benchmark test.4. Gaussian Mixture: p-value = 0.60798 > alpha = 0.05, therefore, the null hypothesis is accepted for the Gaussian Mixture benchmark test. 5. Log Regression: p-value = 0.061698 > alpha = 0.05, therefore, the null hypothesis is accepted for the Log Regression benchmark test.6. Movie Lens: p-value = 0.165228 > alpha = 0.05, therefore, the null hypothesis is accepted for the Movie Lens benchmark test.7. Naive Bayes: p-value = 0.011279 < alpha = 0.05, therefore, the null hypothesis is rejected for the Naive Bayes benchmark test.8. Page Rank: p-value = 0.086889 > alpha = 0.05, therefore, the null hypothesis is accepted for the Page Rank benchmark test.From the above-reported results, it is clear that in 6/8 cases the null hypothesis can be accepted.It means there is no significant difference in power consumption between the classic JVM distribution candidates and the GraalVM-based candidates when executing algorithms or programs related to ALS, Chi-square, Gaussian Mixture, Movie Lens, Page Rank, and Log Regression.For Decision Tree and Naive Bayes relevant programs, however, the energy consumption of candidate groups is significantly different.
Although the t-test results (table 8-14) showed that the difference between these two groups is not significant, GraalVM-based candidates were still leading in most cases.Based on Table 5, a ranking table was generated to rank the energy consumption between candidates (Table 15).This result matches the finding of Ournani et al. in 2021 that GraalVM's energy consumption was lower than other candidates in most cases.

other Factors
The previous subsections clearly demonstrated that, when analysing the aggregated average energy consumption, GraalVM and its native image use less power than classic JVM distributions.In this sub-section, to further support this conclusion, sub-factors such as aggregated CPU, aggregated monitor, aggregate disk, aggregated base, and aggregated application energy consumed when executing benchmark tests are also considered.The following tables (Table 16-23) and figures (Figure 16 -31) for each benchmark test's power consumption components follow the same pattern as aggregated average energy consumption statistics.In terms of total hardware energy and aggregated application  and performance results, they performed poorly in Naive Bayes and Gaussian Mixture test cases with high total hardware energy and aggregated application consumption.

Carbon Equivalent Footprint Analysis
The carbon equivalent emissions statistical analyses in this paper are computed based on the aggregated total energy consumption in each benchmark test.Using GHG conversion factors for electricity in the UK as a reference, four types of emission metrics were considered: kgCO2e/kWh, kgCO2/kWh, kgCH4/kWh, and kgN2O/kWh (Department for Business, Energy & Industrial Strategy, 2021).Table 24 below presents calculated data for all these constructs.To reiterate, the aggregated total energy

CoNCLUSIoN ANd RECoMMENdATIoNS
Overall, this study has clearly demonstrated that, in most cases, GraalVM-based Java 11 applications provide better performance, consume less energy, and emit less carbon equivalent footprint than those utilising OpenJDK and two other popular JVM distributions in the market (Amazon Corretto and Zulu).In terms of energy efficiency, this result supports Ournani's research outcome, which indicated that GraalVM had the highest energy efficiency for most benchmarks (Ournani et al., 2021).
To achieve these results, eight Apache Spark benchmark tests from the Renaissance benchmark suite have been chosen for analysing three classic JVM distribution candidates and two GraalVMbased distribution candidates.Each test was conducted five times to ensure fairness and consistency of the experiments.
Although the outcomes of the test groups are not significantly different, in the long term GraalVM would still add technology-related value to SMEs in terms of reduced monthly electricity bills and carbon equivalent footprint emissions while maximising business profits (as a results of such technological acceptance).For GraalVM's founders and contributors, their products reveal weakness in specific benchmark tests such as Naive Bayes and Gaussian Mixture Model, with poor performance, high energy consumption, and high carbon equivalent emissions.Therefore, some work is still needed to enable GraalVM categorically outperform other JVM choices.Due to hardware and software limitations, this research was conducted in a non-dedicated environment.Thus, external factors could have interfered with the final results, such as phantom processes within the WSL2 environment, or CPU usage from other Windows background processes.For this reason, future work can utilize a more specialised environment with more advanced tools to measure performance, energy consumption, and carbon equivalent footprint emissions of the

Figure
Figure 2. A Java application

Figure 10 .
Figure 10.Fixed Phases of an LCA

Figure 15 .
Figure 15.A comparison on aggregated average energy Consumption

Figure 16 .
Figure 16.Total hardware and application energy consumption of ALS

Figure 31 .
Figure 31.Comparison of hardware energy consumption on page rank

Table 1 . Laptop specifications
• WSL2 with Ubuntu 20.04 Distribution hosts all necessary applications and libraries for executing the benchmark tests.The two most important parts of this component are Software Development Kit Manager (SDKMAN) and renaissance-benchmarks.SDKMAN is a program for managing the installation and selection of Software Development Kits, which includes multiple versions and releases of Java and tools for creating, debugging, monitoring, documenting, and deploying applications.It is compatible with Windows (not natively supported, it needs to be installed via WSL, Cygwin, or MinGW), Linux, and macOS (Gilliard, 2020).Before carrying out the experiments, several JDK candidates were installed using SDKMAN.OpenJDK 11.0.2,Amazon Corretto 11.0.14.1, and Zulu 11.0.14 (three examples of classic JVM distributions) and GraalVM 21.3.1 (build 11.0.14)(as a GraalVM alternative) were selected for this study.

Table 2 . Benchmark test specifications (Renaissance, no date) JVM Distributions Aggregated Test Case Execution Time (s) ALS Chi- square Decision Tree Gauss- mix Log Regression Movie Lens Naive Bayes Page Rank
conducted for all 8 benchmark tests while Welch's t-tests were conducted for each pair of benchmark tests.Before implementing the ANOVA test and Welch's t-test, two hypotheses were drawn as below:

Table 3 . Aggregated execution time in second
This paper also analyses and compares other factors in each benchmark test.Those factors include Aggregated Hardware Energy Consumption, Aggregated Application Energy Consumption, Aggregated CPU, Aggregated Monitor, Aggregated Disk, and Aggregated Base Energy Consumption.

Figure 14. Comparison of total program execution time in seconds
power consumption, GraalVM 21.3.1 and its native image are the least energy consumption candidates among five JVM distributions in ALS, Chi-square, Decision Tree, Logistic Regression, Movie Lens, and Page Rank test cases.However, similar to the aggregated average energy consumption statistics