1 /*
2 * Copyright (c) 2017, 2021, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25 package jdk.incubator.vector;
26
27 import jdk.internal.vm.annotation.ForceInline;
28
29 import static jdk.incubator.vector.VectorOperators.*;
30
31 abstract class AbstractMask<E> extends VectorMask<E> {
32 AbstractMask(boolean[] bits) {
33 super(bits);
34 }
35
36 /*package-private*/
37 abstract boolean[] getBits();
38
39 // Unary operator
40
41 interface MUnOp {
42 boolean apply(int i, boolean a);
43 }
44
45 abstract AbstractMask<E> uOp(MUnOp f);
46
47 // Binary operator
48
49 interface MBinOp {
50 boolean apply(int i, boolean a, boolean b);
51 }
52
53 abstract AbstractMask<E> bOp(VectorMask<E> o, MBinOp f);
54
55 /*package-private*/
56 abstract AbstractSpecies<E> vspecies();
57
58 @Override
59 @ForceInline
60 public final VectorSpecies<E> vectorSpecies() {
61 return vspecies();
62 }
63
64 @Override
65 public boolean laneIsSet(int i) {
66 return getBits()[i];
67 }
68
69 @Override
70 public long toLong() {
71 // FIXME: This should be an intrinsic.
72 if (length() > Long.SIZE) {
73 throw new UnsupportedOperationException("too many lanes for one long");
74 }
75 long res = 0;
76 long set = 1;
77 boolean[] bits = getBits();
78 for (int i = 0; i < bits.length; i++) {
79 res = bits[i] ? res | set : res;
80 set = set << 1;
81 }
82 return res;
83 }
84
85 @Override
86 public void intoArray(boolean[] bits, int i) {
87 System.arraycopy(getBits(), 0, bits, i, length());
88 }
89
90 @Override
91 public boolean[] toArray() {
92 return getBits().clone();
93 }
94
95 @Override
96 @ForceInline
97 @SuppressWarnings("unchecked")
98 public
99 <F> VectorMask<F> check(Class<F> elementType) {
100 if (vectorSpecies().elementType() != elementType) {
101 throw AbstractSpecies.checkFailed(this, elementType);
102 }
103 return (VectorMask<F>) this;
104 }
105
106 @Override
107 @ForceInline
108 @SuppressWarnings("unchecked")
109 public
110 <F> VectorMask<F> check(VectorSpecies<F> species) {
111 if (species != vectorSpecies()) {
112 throw AbstractSpecies.checkFailed(this, species);
113 }
114 return (VectorMask<F>) this;
115 }
116
117 @Override
118 public VectorMask<E> andNot(VectorMask<E> m) {
119 return and(m.not());
120 }
121
122 /*package-private*/
123 static boolean anyTrueHelper(boolean[] bits) {
124 // FIXME: Maybe use toLong() != 0 here.
125 for (boolean i : bits) {
126 if (i) return true;
127 }
128 return false;
129 }
130
131 /*package-private*/
132 static boolean allTrueHelper(boolean[] bits) {
133 // FIXME: Maybe use not().toLong() == 0 here.
134 for (boolean i : bits) {
135 if (!i) return false;
136 }
137 return true;
138 }
139
140 /*package-private*/
141 static int trueCountHelper(boolean[] bits) {
142 int c = 0;
143 for (boolean i : bits) {
144 if (i) c++;
145 }
146 return c;
147 }
148
149 /*package-private*/
150 static int firstTrueHelper(boolean[] bits) {
151 for (int i = 0; i < bits.length; i++) {
152 if (bits[i]) return i;
153 }
154 return bits.length;
155 }
156
157 /*package-private*/
158 static int lastTrueHelper(boolean[] bits) {
159 for (int i = bits.length-1; i >= 0; i--) {
160 if (bits[i]) return i;
161 }
162 return -1;
163 }
164
165 @Override
166 @ForceInline
167 public VectorMask<E> indexInRange(int offset, int limit) {
168 int vlength = length();
169 Vector<E> iota = vectorSpecies().zero().addIndex(1);
170 VectorMask<E> badMask = checkIndex0(offset, limit, iota, vlength);
171 return this.andNot(badMask);
172 }
173
174 /*package-private*/
175 @ForceInline
176 AbstractVector<E>
177 toVectorTemplate() {
178 AbstractSpecies<E> vsp = vspecies();
179 Vector<E> zero = vsp.broadcast(0);
180 Vector<E> mone = vsp.broadcast(-1);
181 // -1 will result in the most significant bit being set in
182 // addition to some or all other lane bits.
183 // For integral types, *all* lane bits will be set.
184 // The bits for -1.0 are like {0b10111*0000*}.
185 // FIXME: Use a conversion intrinsic for this operation.
186 // https://bugs.openjdk.java.net/browse/JDK-8225740
187 return (AbstractVector<E>) zero.blend(mone, this);
188 }
189
190 /**
191 * Test if a masked memory access at a given offset into an array
192 * of the given length will stay within the array.
193 * The per-lane offsets are iota*esize.
194 */
195 /*package-private*/
196 @ForceInline
197 void checkIndexByLane(int offset, int alength,
198 Vector<E> iota,
199 int esize) {
200 if (VectorIntrinsics.VECTOR_ACCESS_OOB_CHECK == 0) {
201 return;
202 }
203 // Although the specification is simple, the implementation is
204 // tricky, because the value iota*esize might possibly
205 // overflow. So we calculate our test values as scalars,
206 // clipping to the range [-1..VLENGTH], and test them against
207 // the unscaled iota vector, whose values are in [0..VLENGTH-1].
208 int vlength = length();
209 VectorMask<E> badMask;
210 if (esize == 1) {
211 badMask = checkIndex0(offset, alength, iota, vlength);
212 } else if (offset >= 0) {
213 // Masked access to multi-byte lanes in byte array.
214 // It could be aligned anywhere.
215 int elemCount = Math.min(vlength, (alength - offset) / esize);
216 badMask = checkIndex0(0, elemCount, iota, vlength);
217 } else {
218 // This requires a split test.
219 int clipOffset = Math.max(offset, -(vlength * esize));
220 int elemCount = Math.min(vlength, (alength - clipOffset) / esize);
221 badMask = checkIndex0(0, elemCount, iota, vlength);
222 clipOffset &= (esize - 1); // power of two, so OK
223 VectorMask<E> badMask2 = checkIndex0(clipOffset / esize, vlength,
224 iota, vlength);
225 badMask = badMask.or(badMask2);
226 }
227 badMask = badMask.and(this);
228 if (badMask.anyTrue()) {
229 int badLane = badMask.firstTrue();
230 throw ((AbstractMask<E>)badMask)
231 .checkIndexFailed(offset, badLane, alength, esize);
232 }
233 }
234
235 private
236 @ForceInline
237 VectorMask<E> checkIndex0(int offset, int alength,
238 Vector<E> iota, int vlength) {
239 // An active lane is bad if its number is greater than
240 // alength-offset, since when added to offset it will step off
241 // of the end of the array. To avoid overflow when
242 // converting, clip the comparison value to [0..vlength]
243 // inclusive.
244 int indexLimit = Math.max(0, Math.min(alength - offset, vlength));
245 VectorMask<E> badMask =
246 iota.compare(GE, iota.broadcast(indexLimit));
247 if (offset < 0) {
248 // An active lane is bad if its number is less than
249 // -offset, because when added to offset it will then
250 // address an array element at a negative index. To avoid
251 // overflow when converting, clip the comparison value at
252 // vlength. This specific expression works correctly even
253 // when offset is Integer.MIN_VALUE.
254 int firstGoodIndex = -Math.max(offset, -vlength);
255 VectorMask<E> badMask2 =
256 iota.compare(LT, iota.broadcast(firstGoodIndex));
257 if (indexLimit >= vlength) {
258 badMask = badMask2; // 1st badMask is all true
259 } else {
260 badMask = badMask.or(badMask2);
261 }
262 }
263 return badMask;
264 }
265
266 private IndexOutOfBoundsException checkIndexFailed(int offset, int lane,
267 int alength, int esize) {
268 String msg = String.format("Masked range check failed: "+
269 "vector mask %s out of bounds at "+
270 "index %d+%d in array of length %d",
271 this, offset, lane * esize, alength);
272 if (esize != 1) {
273 msg += String.format(" (each lane spans %d array elements)", esize);
274 }
275 throw new IndexOutOfBoundsException(msg);
276 }
277
278 }