RFR: 8288327: Executable.hasRealParameterData should not be volatile [v7]

[Сергей Цыпанов]

On Fri, 1 Jul 2022 10:48:32 GMT, Peter Levart <plevart at openjdk.org> wrote:

>> But, ... is any code path accessing the elements of the @Stable array by constant indexes? Only in that case would the annotation have any effect on the JIT-ed code. Otherwise it's just a waste of space.
>
> ... I can only see the array being cloned and not accessed directly. I don't belive cloning a @stable array is any different in JIT-ed code as cloning normal "mutable" array unless JIT "sees" through it and scalarizes the values of the cloned array. For example, if you have the following:
> 
> 
> static final Method method = ....;
> 
> @Benchmark
> public Object getParameter0() {
>   return method.getParameters()[0];
> }
> 
> 
> ...would it run faster when the parameters field was marked as @stable as opposed to not?

@plevart I've checked it with and without `@stable`, it's the same:

with
Benchmark                            Mode  Cnt  Score   Error  Units
AccessParamsBenchmark.getParameter0  avgt   50  6,196 ± 0,142  ns/op
AccessParamsBenchmark.getParameters  avgt   50  4,636 ± 0,075  ns/op

without
Benchmark                            Mode  Cnt  Score   Error  Units
AccessParamsBenchmark.getParameter0  avgt   50  6,196 ± 0,142  ns/op
AccessParamsBenchmark.getParameters  avgt   50  4,636 ± 0,075  ns/op

This seems logical as effects of `@Stable` aren not propagated into cloned array.
This is the benchmark I used:

@State(Scope.Thread)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Fork(jvmArgsAppend = {"-Xms1g", "-Xmx1g"})
public class AccessParamsBenchmark {

  private final Method method;

  public AccessParamsBenchmark() {
    try {
      method = getClass().getMethod("foo", int.class, String.class);
    } catch (NoSuchMethodException e) {
      throw new RuntimeException(e);
    }
  }

  @Benchmark
  public Object getParameters() {
    return method.getParameters();
  }

  @Benchmark
  public Object getParameter0() {
    return method.getParameters()[0];
  }

  public void foo(int parameter1, String parameter2) {
  }
}


So, should we rid the annotation from `parameters` field?

-------------

PR: https://git.openjdk.org/jdk/pull/9143