The OpenJDK JVM has two Just-In-Time compilers, C1 and C2. C2 is a compiler that applies many optimizations to produce a very efficient compiled version of the program. This blog post series presents an improvement that we contributed to C2 scalar replacement optimization. But before we delve into the details of our contributions, we are going to discuss about three optimizations implemented in C2: <\/span>escape analysis<\/span><\/i>, <\/span>method inlining,<\/span><\/i> and <\/span>scalar replacement<\/span><\/i>.<\/span>\u00a0<\/span><\/p>\n Escape analysis (EA) analyzes the code being compiled and decides for each object allocation whether that object might be used outside the current method or thread.<\/span><\/p>\n Method Inlining (MI) is, in very general terms, an optimization that replaces method calls with a copy of the body of the method being called.<\/span>\u00a0<\/span>\u00a0<\/span><\/p>\n Scalar replacement (SR) is an optimization which tries to remove object allocations that it considers unnecessary, and it uses information provided by EA and changes made by MI to achieve that. SR removes object allocations by transforming the code to store object\u2019s fields in local variables and using MI to remove the need to invoke methods on objects.<\/span>\u00a0<\/span><\/p>\n The main benefit of SR may be that it decreases memory allocation rate and pressure on the Garbage Collector (GC). However, there are more benefits. By removing allocations, the method’s code becomes simpler, which may reveal more optimizations. So, in general, doing scalar replacement is a Good Thing <\/span>TM<\/span><\/sup>.<\/span><\/p>\n \u00a0<\/span><\/p>\n We are going to use the <\/span>Message<\/span><\/i> class shown in Listing 1 as the running example in this article. The important things to note in this class are the <\/span>Checksum<\/span><\/i> method and the <\/span>content<\/span><\/i> field. The <\/span>Checksum<\/span><\/i> method iterates on the characters of the <\/span>content<\/span><\/i> field and accumulates their integer value, returning that as the checksum of the message list.<\/span>\u00a0<\/span>\u00a0<\/span><\/p>\n Listing 1:<\/span><\/b> The Message class.<\/span>\u00a0<\/span><\/p>\n Listing 2 shows the <\/span>CompositeChecksum <\/span><\/i>method. This method iterates on a list of messages and for each message it calls the <\/span>Checksum <\/span><\/i>method on it. The method accumulates the checksum of all messages and returns it as the composite checksum of the list. This may not be an example of a piece of code written very carefully, but is the kind of code that is often processed by compilers, especially after many transformations have been applied to the code.<\/span>\u00a0<\/span><\/p>\n Listing 2:<\/span><\/b> The CompositeChecksum method.<\/span>\u00a0<\/span><\/p>\n Listing 3 highlights what is going to happen when MI is performed on this method with respect to the <\/span>Message <\/span><\/i>class constructor and <\/span>Checksum <\/span><\/i>method. Note that the constructor of the <\/span>Message <\/span><\/i>object is going to be copied in the place where the constructor was previously being called and the call to the <\/span>Checksum <\/span><\/i>method is going to be replaced by the code of the <\/span>Checksum <\/span><\/i>method itself. Of course, after the code is copied, it is adjusted to still work correctly in the target location.<\/span>\u00a0<\/span><\/p>\n Listing 3:<\/span><\/b> The CompositeChecksum method during inlining optimization.<\/span>\u00a0<\/span><\/p>\n Listing 4 shows the code <\/span>after<\/span><\/i> MI has been executed. Note that the object allocation is still happening. The body of the <\/span>Message <\/span><\/i>and <\/span>Checksum <\/span><\/i>methods were copied inside the loop, but they still operate on an object, in this case the one pointed to by <\/span>m_ptr<\/span><\/i> \u2013 previously these methods used an object pointed to by <\/span>this<\/span><\/i>. The <\/span>chks<\/span><\/i> variable that was local to the <\/span>Checksum <\/span><\/i>method now is another variable local to the <\/span>CompositeChecksum <\/span><\/i>loop.<\/span>\u00a0<\/span><\/p>\n Listing 4:<\/span><\/b> The CompositeChecksum method after inlining optimization.<\/span>\u00a0<\/span><\/p>\n Note that there is still room for improving the code of the <\/span>CompositeChecksum <\/span><\/i>method. After performing some more analysis C2 will find that some of the assignments in the code do not really need to be performed. For instance, the assignment of the <\/span>msg<\/span><\/i> variable to the <\/span>content<\/span><\/i> variable can be eliminated and we can just iterate on <\/span>msg<\/span><\/i> itself, instead of <\/span>content<\/span><\/i>. The same logic applies to the <\/span>chks<\/span><\/i> variable: instead of doing the computation on the <\/span>chks<\/span><\/i> variable and then later assigning it to <\/span>cs<\/span><\/i> and then accumulating into <\/span>checksum<\/span><\/i> we can just do the computation directly in the <\/span>checksum<\/span><\/i> variable. Listing 5 shows the code after these optimizations.\u00a0<\/span>\u00a0<\/span><\/p>\n Listing 5:<\/span><\/b> The CompositeChecksum method after additional optimizations.<\/span>\u00a0<\/span><\/p>\n \u00a0<\/span><\/p>\n After still some more analysis C2 will note that there are only <\/span>writes<\/span><\/i> to the object pointed to by <\/span>m_ptr<\/span><\/i> and no code is <\/span>reading<\/span><\/i> from it. That observation, together with some other info about the object class, means that this object allocation is not necessary and therefore it can be removed! Listing 6 shows the code after the object allocation is removed.<\/span>\u00a0<\/span><\/p>\n Listing 6:<\/span><\/b> The CompositeChecksum method after Message allocation is removed.<\/span>\u00a0<\/span>\u00a0<\/span><\/p>\n The object allocation removal was only possible because at some point there was no code reading from that object. Scalar replacement is one of the optimizations that replaces loads from objects\u2019 fields with a direct use of the statement (or value) that was last written in the objects\u2019 fields. There are other optimizations that achieve the same effect but usually they work on simple pieces of code, like this example method. Scalar replacement, however, can \u201clook\u201d more thoroughly in the method and find points where these object fields\u2019 writes can be simplified.<\/span>\u00a0<\/span><\/p>\n In conclusion, scalar replacement serves as a critical optimization technique within OpenJDK, transforming complex object instances into simpler scalar variables to enhance runtime performance. By eliminating the need for heap allocation and reducing memory overhead, scalar replacement significantly improves execution speed and resource efficiency. Understanding the fundamental mechanisms behind scalar replacement sets the stage for the second part of this series<\/a> where we describe the improvements we contributed to OpenJDK’s scalar replacement implementation.<\/p>\n","protected":false},"excerpt":{"rendered":" Scalar replacement (SR) is a powerful optimization technique in OpenJDK that aims to enhance the performance of Java applications by breaking down complex objects into simpler, more manageable scalar variables. In this three-part blog series, we will delve into the intricacies of scalar replacement and the enhancements we’ve contributed to the OpenJDK implementation of it. […]<\/p>\n","protected":false},"author":125793,"featured_media":227205,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"image","meta":{"_acf_changed":false,"footnotes":""},"categories":[1,249],"tags":[817,818,820,319,819],"class_list":["post-231049","post","type-post","status-publish","format-image","has-post-thumbnail","hentry","category-java","category-openjdk","tag-compiler","tag-escape-analysis","tag-just-in-time-compiler","tag-openjdk","tag-scalar-replacement","post_format-post-format-image"],"acf":[],"blog_post_summary":" Scalar replacement (SR) is a powerful optimization technique in OpenJDK that aims to enhance the performance of Java applications by breaking down complex objects into simpler, more manageable scalar variables. In this three-part blog series, we will delve into the intricacies of scalar replacement and the enhancements we’ve contributed to the OpenJDK implementation of it. […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/java\/wp-json\/wp\/v2\/posts\/231049","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/java\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/java\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/java\/wp-json\/wp\/v2\/users\/125793"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/java\/wp-json\/wp\/v2\/comments?post=231049"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/java\/wp-json\/wp\/v2\/posts\/231049\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/java\/wp-json\/wp\/v2\/media\/227205"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/java\/wp-json\/wp\/v2\/media?parent=231049"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/java\/wp-json\/wp\/v2\/categories?post=231049"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/java\/wp-json\/wp\/v2\/tags?post=231049"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}A Simple Example<\/span>\u00a0<\/span><\/h2>\n
![\"The](\"https:\/\/devblogs.microsoft.com\/java\/wp-content\/uploads\/sites\/51\/2024\/05\/Picture1.png\")
<\/a><\/p>\n<\/a><\/p>\n<\/a><\/p>\n<\/a><\/p>\n<\/a><\/p>\n<\/a><\/p>\nConclusion<\/h2>\n