Summary
-------

Add two new cross-lane vector operations, `compress` and `expand`.

Problem
-------

It can be useful to leverage a cross lane operation that is an ordered movement up to the vector length of elements mapping from a source vector to a destination vector. Such an operation can be applied to query plan execution when results need to be filtered. 

This can be expressed using the existing and flexible `rearrange` operations with shuffles. However, the code tends to be less readable and hard for the compiler to optimize a loop consisting of compressed stores of vector results. Further, `compress` might be composed of an underlying primitive different to that of `rearrange`, related to sorting that we intend to explore in future enhancements.

Solution
--------

Add two new cross-lane vector operations, `compress` and its inverse `expand`. Complementary to the vector operation `compress`, add a vector mask operation, `compress`.

An example of such usage might be code that selects elements from array `a` and stores those selected elements in array `z`:

    int[] a = ...;
    int[] z = ...;
    int ai = 0, zi = 0;
    while (ai < a.length) {
        IntVector av = IntVector.fromArray(SPECIES, a, ai);
        // query over elements of vector av
        // returning a mask marking elements of interest
        VectorMask<Integer> m = interestingBits(av, ...);
        IntVector zv = av.compress(m);
        zv.intoArray(z, zi, m.compress());
        ai += SPECIES.length();
        zi += m.trueCount();
    }

Specification
-------------

The class documentation of `Vector` is updated to include the following new list item in the section on "Moving data across lane boundaries":
 
     * <li>The {@link #compress(VectorMask)} and {@link #expand(VectorMask)}
     * methods, which select up to {@code VLENGTH} lanes from an
     * input vector, and assemble them in lane order.  The selection of lanes
     * is controlled by a {@code VectorMask}, with set lane elements mapping, by
     * compression or expansion in lane order, source lanes to destination lanes.

Two new methods are added to `Vector`:

    /**
     * Compresses the lane elements of this vector selecting lanes
     * under the control of a specific mask.
     *
     * This is a cross-lane operation that compresses the lane
     * elements of this vector as selected by the specified mask.
     *
     * For each lane {@code N} of the mask, if the mask at
     * lane {@code N} is set, the element at lane {@code N}
     * of input vector is selected and stored into the output
     * vector contiguously starting from the lane {@code 0}.
     * All the upper remaining lanes, if any, of the output
     * vector are set to zero.
     *
     * @param m the mask controlling the compression
     * @return the compressed lane elements of this vector
     */
    public abstract Vector<E> compress(VectorMask<E> m);
    
    /**
     * Expands the lane elements of this vector
     * under the control of a specific mask.
     *
     * This is a cross-lane operation that expands the contiguous lane
     * elements of this vector into lanes of an output vector
     * as selected by the specified mask.
     *
     * For each lane {@code N} of the mask, if the mask at
     * lane {@code N} is set, the next contiguous element of input vector
     * starting from lane {@code 0} is selected and stored into the output
     * vector at lane {@code N}.
     * All the remaining lanes, if any, of the output vector are set to zero.
     *
     * @param m the mask controlling the compression
     * @return the expanded lane elements of this vector
     */
    public abstract Vector<E> expand(VectorMask<E> m);

Co-variant overrides are added to extending and specialized vector classes `ByteVector`, `ShortVector`, `IntVector`, `LongVector`, `FloatVector` and `DoubleVector`. 

One new method is added to `VectorMask`:

    /**
     * Compresses set lanes from this mask.
     *
     * Returns a mask which is a series of {@code N} set lanes
     * followed by a series of unset lanes, where {@code N} is
     * the true count of this mask.
     *
     * @return the compressed mask of this mask
     */
    public abstract VectorMask<E> compress();

Link to the java doc and specdiff:

http://cr.openjdk.java.net/~psandoz/panama/JDK-8277155-vector-api-compress-expand/