Reduce some unnecessary ArrayUtil#grow calls

[easyice]

This change will slightly improve the performance of DataOutput#writeGroupVInts and some other methods related to XXXRefBuilder#append.

Here is a JMH benchmark for Util.toIntsRef, using java 21 on my MAC (intel chip).

Benchmark                    Mode  Cnt   Score   Error   Units
PR   ToIntsRefBenchMark.run  thrpt    5  38.208 ± 1.054  ops/us
main ToIntsRefBenchMark.run  thrpt    5   7.862 ± 0.832  ops/us

JMH benchmark code for Util#toIntsRef:

public class ToIntsRefBenchMark {
  IntsRefBuilder intsRefBuilder = new IntsRefBuilder();
  BytesRef bytesRef = new BytesRef(new byte[32]);

  @Benchmark
  public void run() {
    Util.toIntsRef(bytesRef, intsRefBuilder);
  }
}

[github-actions]

This PR has not had activity in the past 2 weeks, labeling it as stale. If the PR is waiting for review, notify the dev@lucene.apache.org list. Thank you for your contribution!

[stefanvodita]

@easyice - I'm probably missing something obvious, but I thought ArrayUtil.grow already made the same check. Can you explain why this PR helps?

lucene/lucene/core/src/java/org/apache/lucene/util/ArrayUtil.java

Lines 430 to 435 in 04f335a

	public static byte[] grow(byte[] array, int minSize) {
	assert minSize >= 0 : "size must be positive (got " + minSize + "): likely integer overflow?";
	if (array.length < minSize) {
	return growExact(array, oversize(minSize, Byte.BYTES));
	} else return array;
	}

[easyice]

@stefanvodita Thank you for looking into this! when an array does not need to grow, The ArrayUtil.grow will return the input array, then it will call an extra assignment like ref.bytes = ref.bytes in BytesRefBuilder#grow. I observed there was some performance impact, which was noticeable in the append method. Maybe i'm being overly picky, Overall, it doesn't have a significant impact on performance.

[stefanvodita]

Thanks for the explanation! The way I think about it is whether it would be ok to make this check every time we call grow. Probably not, it's nice that grow does the check for you. Maybe simplicity is worth more than the performance gain here? If you think the performance win is compelling, I won't argue against it.

[easyice]

I originally wanted to speed up writeGroupVInts in this way. Now there is a better way to speed up it (by #13203) . I agree with you that only make the change where performance is important to keep things simple, Currently, I haven't seen any other places yet, so i will close it. Thank you!