74 // compute the gold standard in interpreter mode
75 init(goldI0, goldF0);
76 test0(goldI0, goldI0, goldF0, goldF0);
77 init(goldI1, goldF1);
78 test1(goldI1, goldI1, goldF1, goldF1);
79 }
80
81 @Run(test = "test0")
82 @Warmup(100)
83 public void runTest0() {
84 int[] dataI = new int[RANGE];
85 float[] dataF = new float[RANGE];
86 init(dataI, dataF);
87 test0(dataI, dataI, dataF, dataF);
88 verify("test0", dataI, goldI0);
89 verify("test0", dataF, goldF0);
90 }
91
92 @Test
93 @IR(counts = {IRNode.MUL_VI, "> 0"},
94 applyIfOr = {"UseCompactObjectHeaders", "false", "AlignVector", "false"},
95 applyIfCPUFeatureOr = {"avx2", "true", "asimd", "true"})
96 static void test0(int[] dataIa, int[] dataIb, float[] dataFa, float[] dataFb) {
97 for (int i = 0; i < RANGE; i+=2) {
98 // We have dependency edges:
99 // A -> X
100 // Y -> B
101 // Still, we can vectorize [X,Y].
102 // We do not vectorize A and B, because they are not isomorphic (add vs mul).
103 //
104 // Imagine this is unrolled at least 2x.
105 // We get order: A0 X0 Y0 B0 A1 X1 Y1 B1
106 // Vectorized: X0 Y0 X1 Y1
107 // Scalar: A0 B0 A1 B1
108 //
109 // However, since the As need to be before, and the Bs after the vector operations,
110 // we need to have all As before all Bs. This means we need to reorder the scalar
111 // operations, and not just the vectorized ones.
112 //
113 // A correct reordering would be: A0 A1 [X0, Y0, X1, Y1] B0 B1
114 //
115 dataFa[i + 0] = dataIa[i + 0] * 1.3f; // A *1.3
116 dataIb[i + 0] = (int)dataFb[i + 0] * 11; // X *11
117 dataIb[i + 1] = (int)dataFb[i + 1] * 11; // Y *11
118 dataFa[i + 1] = dataIa[i + 1] + 1.2f; // B +1.2
119 // With AlignVector, we need 8-byte alignment of vector loads/stores.
120 // UseCompactObjectHeaders=false UseCompactObjectHeaders=true
121 // adr = base + 16 + 8*i -> always adr = base + 12 + 8*i -> never
122 // -> vectorize -> no vectorization
123 }
124 }
125
126 @Run(test = "test1")
127 @Warmup(100)
128 public void runTest1() {
129 int[] dataI = new int[RANGE];
130 float[] dataF = new float[RANGE];
131 init(dataI, dataF);
132 test1(dataI, dataI, dataF, dataF);
133 verify("test1", dataI, goldI1);
134 verify("test1", dataF, goldF1);
135 }
136
137 @Test
138 @IR(counts = {IRNode.MUL_VI, "> 0"},
139 applyIfOr = {"UseCompactObjectHeaders", "false", "AlignVector", "false"},
140 applyIfCPUFeatureOr = {"avx2", "true", "asimd", "true"})
141 static void test1(int[] dataIa, int[] dataIb, float[] dataFa, float[] dataFb) {
142 for (int i = 0; i < RANGE; i+=2) {
143 // Do the same as test0, but without int-float conversion.
144 // This should reproduce on machines where conversion is not implemented.
145 unsafe.putInt(dataFa, unsafe.ARRAY_FLOAT_BASE_OFFSET + 4L * i + 0, dataIa[i+0] + 1); // A +1
146 dataIb[i+0] = 11 * unsafe.getInt(dataFb, unsafe.ARRAY_INT_BASE_OFFSET + 4L * i + 0); // X
147 dataIb[i+1] = 11 * unsafe.getInt(dataFb, unsafe.ARRAY_INT_BASE_OFFSET + 4L * i + 4); // Y
148 unsafe.putInt(dataFa, unsafe.ARRAY_FLOAT_BASE_OFFSET + 4L * i + 4, dataIa[i+1] * 11); // B *11
149 // With AlignVector, we need 8-byte alignment of vector loads/stores.
150 // UseCompactObjectHeaders=false UseCompactObjectHeaders=true
151 // adr = base + 16 + 8*i -> always adr = base + 12 + 8*i -> never
152 // -> vectorize -> no vectorization
153 }
154 }
155
156 static void init(int[] dataI, float[] dataF) {
157 for (int i = 0; i < RANGE; i++) {
158 dataI[i] = i + 1;
159 dataF[i] = i + 0.1f;
160 }
161 }
162
163 static void verify(String name, int[] data, int[] gold) {
164 for (int i = 0; i < RANGE; i++) {
165 if (data[i] != gold[i]) {
166 throw new RuntimeException(" Invalid " + name + " result: data[" + i + "]: " + data[i] + " != " + gold[i]);
167 }
168 }
169 }
170
171 static void verify(String name, float[] data, float[] gold) {
172 for (int i = 0; i < RANGE; i++) {
|
74 // compute the gold standard in interpreter mode
75 init(goldI0, goldF0);
76 test0(goldI0, goldI0, goldF0, goldF0);
77 init(goldI1, goldF1);
78 test1(goldI1, goldI1, goldF1, goldF1);
79 }
80
81 @Run(test = "test0")
82 @Warmup(100)
83 public void runTest0() {
84 int[] dataI = new int[RANGE];
85 float[] dataF = new float[RANGE];
86 init(dataI, dataF);
87 test0(dataI, dataI, dataF, dataF);
88 verify("test0", dataI, goldI0);
89 verify("test0", dataF, goldF0);
90 }
91
92 @Test
93 @IR(counts = {IRNode.MUL_VI, "> 0"},
94 applyIfCPUFeatureOr = {"avx2", "true", "asimd", "true"})
95 static void test0(int[] dataIa, int[] dataIb, float[] dataFa, float[] dataFb) {
96 for (int i = 0; i < RANGE; i+=2) {
97 // We have dependency edges:
98 // A -> X
99 // Y -> B
100 // Still, we can vectorize [X,Y].
101 // We do not vectorize A and B, because they are not isomorphic (add vs mul).
102 //
103 // Imagine this is unrolled at least 2x.
104 // We get order: A0 X0 Y0 B0 A1 X1 Y1 B1
105 // Vectorized: X0 Y0 X1 Y1
106 // Scalar: A0 B0 A1 B1
107 //
108 // However, since the As need to be before, and the Bs after the vector operations,
109 // we need to have all As before all Bs. This means we need to reorder the scalar
110 // operations, and not just the vectorized ones.
111 //
112 // A correct reordering would be: A0 A1 [X0, Y0, X1, Y1] B0 B1
113 //
114 dataFa[i + 0] = dataIa[i + 0] * 1.3f; // A *1.3
115 dataIb[i + 0] = (int)dataFb[i + 0] * 11; // X *11
116 dataIb[i + 1] = (int)dataFb[i + 1] * 11; // Y *11
117 dataFa[i + 1] = dataIa[i + 1] + 1.2f; // B +1.2
118 }
119 }
120
121 @Run(test = "test1")
122 @Warmup(100)
123 public void runTest1() {
124 int[] dataI = new int[RANGE];
125 float[] dataF = new float[RANGE];
126 init(dataI, dataF);
127 test1(dataI, dataI, dataF, dataF);
128 verify("test1", dataI, goldI1);
129 verify("test1", dataF, goldF1);
130 }
131
132 @Test
133 @IR(counts = {IRNode.MUL_VI, "> 0"},
134 applyIfCPUFeatureOr = {"avx2", "true", "asimd", "true"})
135 static void test1(int[] dataIa, int[] dataIb, float[] dataFa, float[] dataFb) {
136 for (int i = 0; i < RANGE; i+=2) {
137 // Do the same as test0, but without int-float conversion.
138 // This should reproduce on machines where conversion is not implemented.
139 unsafe.putInt(dataFa, unsafe.ARRAY_FLOAT_BASE_OFFSET + 4L * i + 0, dataIa[i+0] + 1); // A +1
140 dataIb[i+0] = 11 * unsafe.getInt(dataFb, unsafe.ARRAY_INT_BASE_OFFSET + 4L * i + 0); // X
141 dataIb[i+1] = 11 * unsafe.getInt(dataFb, unsafe.ARRAY_INT_BASE_OFFSET + 4L * i + 4); // Y
142 unsafe.putInt(dataFa, unsafe.ARRAY_FLOAT_BASE_OFFSET + 4L * i + 4, dataIa[i+1] * 11); // B *11
143 }
144 }
145
146 static void init(int[] dataI, float[] dataF) {
147 for (int i = 0; i < RANGE; i++) {
148 dataI[i] = i + 1;
149 dataF[i] = i + 0.1f;
150 }
151 }
152
153 static void verify(String name, int[] data, int[] gold) {
154 for (int i = 0; i < RANGE; i++) {
155 if (data[i] != gold[i]) {
156 throw new RuntimeException(" Invalid " + name + " result: data[" + i + "]: " + data[i] + " != " + gold[i]);
157 }
158 }
159 }
160
161 static void verify(String name, float[] data, float[] gold) {
162 for (int i = 0; i < RANGE; i++) {
|