[External] : ComputedConstant: rename to Lazy?

[Per-Ake Minborg]

Hi again Chen,

We are working with "condensers" in project Leyden, which may run before runtime. These might evaluate ComputedConstants. For example, a MethodHandle might be resolved in this phase and can be directly obtained from byte code.

Here is an article about condensers: https://openjdk.org/projects/leyden/notes/03-toward-condensers

Best, Per
________________________________
From: liangchenblue at gmail.com <liangchenblue at gmail.com>
Sent: Friday, September 1, 2023 9:53 AM
To: Per-Ake Minborg <per-ake.minborg at oracle.com>
Cc: leyden-dev at openjdk.org <leyden-dev at openjdk.org>
Subject: Re: [External] : ComputedConstant: rename to Lazy?

Thank you for this clarification.

The main reason that I considered the "Lazy" name is that "Constant" as a term isn't well-defined in our API specification: simply put, it's like a final with lazy semantics like described in John Rose's JEP draft [1] (which also seems to consider Leyden's development and overlaps partially with CC proposal), where it can be optimized (constant fold) like final (static or non-static with -XX:+TrustFinalNonStaticFields) fields. Can we emphasize such a "final" nature without confusing it with actual constants?

In addition, in what case can the computation of a CC start before VM startup? I cannot think of any example and would like to know one.

Chen

[1] https://openjdk.org/jeps/8209964

On Fri, Sep 1, 2023 at 2:27 PM Per-Ake Minborg <per-ake.minborg at oracle.com<mailto:per-ake.minborg at oracle.com>> wrote:
Hi Chen,

In the beginning, we used Lazy but it became apparent that CCs are more than that. In fact, computation might occur even BEFORE the JVM starts and then the name Lazy becomes confusing. It is all but lazy in this case.

So, we arrived at the more general name ComputedConstant. It does not carry any indication as to when the constant is computed.

Best, Per
________________________________
From: liangchenblue at gmail.com<mailto:liangchenblue at gmail.com> <liangchenblue at gmail.com<mailto:liangchenblue at gmail.com>>
Sent: Friday, September 1, 2023 6:59 AM
To: leyden-dev at openjdk.org<mailto:leyden-dev at openjdk.org> <leyden-dev at openjdk.org<mailto:leyden-dev at openjdk.org>>; Per-Ake Minborg <per-ake.minborg at oracle.com<mailto:per-ake.minborg at oracle.com>>
Subject: [External] : ComputedConstant: rename to Lazy?

Hello,
I noticed that ComputedConstant, in addition to ensuring constant-folding of lazy values, is a general-purpose lazy wrapper, and can be used even outside of constant-folding scenarios to offer thread safety and error handling in lazy computations.

Thus, I recommend renaming it into Lazy, or some other name more simple and concise than ComputedConstant, to the ease of users.

A similar scenario exists in JDK already: List.of() factory wraps an array with stable annotation, thereby offering constant-folded arrays/lists that's faster to iterate (random access via List.get() in an index loop, not using iterators) by index compared to a plain array when both are stored in static final fields. However, we are not calling such a factory list a "Constant List," but simply an immutable list.

This proposal only changes the name of CC; it will not affect the specification (thread safety, error handling, constant-foldability) in any way, and it does not propose to change the method names.

Best,
Chen Liang
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://mail.openjdk.org/pipermail/leyden-dev/attachments/20230901/3a0a5ffa/attachment.htm>