RFR: updated draft API for JEP 269 Convenience Collection Factories

[Stuart Marks]

On 11/6/15 5:12 AM, Michael Hixson wrote:
> +     static <E> List<E> of(E... es) {
> +         for (E e : es) {
> +             Objects.requireNonNull(e);
> +         }
> +         // NOTE: this can allow a null element to slip through
> +         return Collections.unmodifiableList(Arrays.asList(es));
> +     }
>
> Even as a skeletal implementation, this one has to be changed to be
> truly immutable, right?  It currently returns a view of the (mutable)
> argument array rather than new storage.  Sorry for not providing a
> proper test:

Good catch! Funnily I had noticed the TOCTOU case that allowed null elements in 
the array to slip through, but not that the array itself was still modifiable 
from the outside. Anyway, I'll fix this. No worries about the test.

> Has anyone been able to quantify the advantage of having these
> overloads as opposed to having the varargs versions only?  Is it a
> matter of performance?
>
> I ask because the overloads seem like warts on the APIs (which is a
> shame -- List and Set are such important APIs).  I'm imagining a
> future where:
>
> 1. We add these overloads for performance gains now.
> 2. But they're all skeletal implementations that aren't that perfomant
> anyway.  Efficient versions don't make it into Java SE 9.  People that
> care a lot about performance avoid using these ones.
> 3. A few years later, varargs performance or some other language / VM
> / compiler-level change renders the overloads obsolete.

Yeah, the overloads seem like warts on the API, though probably necessary ones.

At present, and for the forseeable future, varargs calls allocate an array on 
the heap, whereas fixed-args calls do not. I don't know how to quantify the 
difference though. Certainly the cost of allocation and initialization is borne 
in-line. Then there is the cost of collection. Collecting short-lived objects is 
cheap (but not free). There is also the possibility of escape analysis 
eliminating the allocation. This seems unlikely to me; certainly not something 
to be relied upon.

The most likely possible future optimization is "frozen arrays," part of the 
"Arrays 2.0" stuff that John Rose has talked about. This is basically about 
immutable arrays. Here, the possibility is to eliminate the defensive copy, if 
the array created to hold the varargs arguments is made immutable. (This will 
require some adjustment on the callee side, as yet unspecified.) There's still 
an array, though. And a defensive copy would still have to be made if the caller 
passes an actual array, as opposed to a varargs list.

While I can't quantify it, I do think there's an expense to creating the varargs 
array, and there is only a possibility to reduce (but not eliminate) its cost in 
future JDK releases. This cost is entirely avoided by fixed-args overloads. 
(There is the cost of cluttering up the API, though.)

Turning to the skeletal vs. optimized implementation, my plan is certainly to 
ensure that the optimized implementations get into JDK 9. Of course, plans can 
change. If the APIs get in without the optimized implementations, I think the 
big attractor will still be the convenience of using these static factory 
methods as opposed to conventional code. They're no slower than conventional 
code, and the space consumed is the same. So I think they'll be popular even if 
the space efficiency benefits aren't there initially.

When the optimized implementations do get in, callers will benefit, even without 
recompilation. Thus there is some present value added based on potential future 
benefits.

There is always the set of possible future events that cause something not to 
work out, but I think pursuing the approach I've outlined has a good chance of 
benefiting the platform in the long term.

s'marks