Skip to content

Commit 36993ae

Browse files
jaskarthTobiHartmann
jaskarth
authored and
TobiHartmann
committedOct 16, 2023
8316918: Optimize conversions duplicated across phi nodes
Reviewed-by: thartmann, kvn
1 parent 668d4b0 commit 36993ae

File tree

8 files changed

+575
-98
lines changed

8 files changed

+575
-98
lines changed
 

‎src/hotspot/share/opto/cfgnode.cpp

+46
Original file line numberDiff line numberDiff line change
@@ -1883,6 +1883,17 @@ static Node* split_flow_path(PhaseGVN *phase, PhiNode *phi) {
18831883
return phi;
18841884
}
18851885

1886+
// Returns the BasicType of a given convert node and a type, with special handling to ensure that conversions to
1887+
// and from half float will return the SHORT basic type, as that wouldn't be returned typically from TypeInt.
1888+
static BasicType get_convert_type(Node* convert, const Type* type) {
1889+
int convert_op = convert->Opcode();
1890+
if (type->isa_int() && (convert_op == Op_ConvHF2F || convert_op == Op_ConvF2HF)) {
1891+
return T_SHORT;
1892+
}
1893+
1894+
return type->basic_type();
1895+
}
1896+
18861897
//=============================================================================
18871898
//------------------------------simple_data_loop_check-------------------------
18881899
// Try to determining if the phi node in a simple safe/unsafe data loop.
@@ -2557,6 +2568,41 @@ Node *PhiNode::Ideal(PhaseGVN *phase, bool can_reshape) {
25572568
}
25582569
#endif
25592570

2571+
// Try to convert a Phi with two duplicated convert nodes into a phi of the pre-conversion type and the convert node
2572+
// proceeding the phi, to de-duplicate the convert node and compact the IR.
2573+
if (can_reshape && progress == nullptr) {
2574+
ConvertNode* convert = in(1)->isa_Convert();
2575+
if (convert != nullptr) {
2576+
int conv_op = convert->Opcode();
2577+
bool ok = true;
2578+
2579+
// Check the rest of the inputs
2580+
for (uint i = 2; i < req(); i++) {
2581+
// Make sure that all inputs are of the same type of convert node
2582+
if (in(i)->Opcode() != conv_op) {
2583+
ok = false;
2584+
break;
2585+
}
2586+
}
2587+
2588+
if (ok) {
2589+
// Find the local bottom type to set as the type of the phi
2590+
const Type* source_type = Type::get_const_basic_type(convert->in_type()->basic_type());
2591+
const Type* dest_type = convert->bottom_type();
2592+
2593+
PhiNode* newphi = new PhiNode(in(0), source_type, nullptr);
2594+
// Set inputs to the new phi be the inputs of the convert
2595+
for (uint i = 1; i < req(); i++) {
2596+
newphi->init_req(i, in(i)->in(1));
2597+
}
2598+
2599+
phase->is_IterGVN()->register_new_node_with_optimizer(newphi, this);
2600+
2601+
return ConvertNode::create_convert(get_convert_type(convert, source_type), get_convert_type(convert, dest_type), newphi);
2602+
}
2603+
}
2604+
}
2605+
25602606
// Phi (VB ... VB) => VB (Phi ...) (Phi ...)
25612607
if (EnableVectorReboxing && can_reshape && progress == nullptr && type()->isa_oopptr()) {
25622608
progress = merge_through_phi(this, phase->is_IterGVN());

‎src/hotspot/share/opto/convertnode.cpp

+59-9
Original file line numberDiff line numberDiff line change
@@ -88,6 +88,54 @@ Node* Conv2BNode::Ideal(PhaseGVN* phase, bool can_reshape) {
8888
return nullptr;
8989
}
9090

91+
uint ConvertNode::ideal_reg() const {
92+
return _type->ideal_reg();
93+
}
94+
95+
Node* ConvertNode::create_convert(BasicType source, BasicType target, Node* input) {
96+
if (source == T_INT) {
97+
if (target == T_LONG) {
98+
return new ConvI2LNode(input);
99+
} else if (target == T_FLOAT) {
100+
return new ConvI2FNode(input);
101+
} else if (target == T_DOUBLE) {
102+
return new ConvI2DNode(input);
103+
}
104+
} else if (source == T_LONG) {
105+
if (target == T_INT) {
106+
return new ConvL2INode(input);
107+
} else if (target == T_FLOAT) {
108+
return new ConvL2FNode(input);
109+
} else if (target == T_DOUBLE) {
110+
return new ConvL2DNode(input);
111+
}
112+
} else if (source == T_FLOAT) {
113+
if (target == T_INT) {
114+
return new ConvF2INode(input);
115+
} else if (target == T_LONG) {
116+
return new ConvF2LNode(input);
117+
} else if (target == T_DOUBLE) {
118+
return new ConvF2DNode(input);
119+
} else if (target == T_SHORT) {
120+
return new ConvF2HFNode(input);
121+
}
122+
} else if (source == T_DOUBLE) {
123+
if (target == T_INT) {
124+
return new ConvD2INode(input);
125+
} else if (target == T_LONG) {
126+
return new ConvD2LNode(input);
127+
} else if (target == T_FLOAT) {
128+
return new ConvD2FNode(input);
129+
}
130+
} else if (source == T_SHORT) {
131+
if (target == T_FLOAT) {
132+
return new ConvHF2FNode(input);
133+
}
134+
}
135+
136+
assert(false, "Couldn't create conversion for type %s to %s", type2name(source), type2name(target));
137+
return nullptr;
138+
}
91139

92140
// The conversions operations are all Alpha sorted. Please keep it that way!
93141
//=============================================================================
@@ -193,8 +241,9 @@ const Type* ConvF2DNode::Value(PhaseGVN* phase) const {
193241
const Type* ConvF2HFNode::Value(PhaseGVN* phase) const {
194242
const Type *t = phase->type( in(1) );
195243
if (t == Type::TOP) return Type::TOP;
196-
if (t == Type::FLOAT) return TypeInt::SHORT;
197-
if (StubRoutines::f2hf_adr() == nullptr) return bottom_type();
244+
if (t == Type::FLOAT || StubRoutines::f2hf_adr() == nullptr) {
245+
return TypeInt::SHORT;
246+
}
198247

199248
const TypeF *tf = t->is_float_constant();
200249
return TypeInt::make( StubRoutines::f2hf(tf->getf()) );
@@ -263,14 +312,15 @@ Node *ConvF2LNode::Ideal(PhaseGVN *phase, bool can_reshape) {
263312
const Type* ConvHF2FNode::Value(PhaseGVN* phase) const {
264313
const Type *t = phase->type( in(1) );
265314
if (t == Type::TOP) return Type::TOP;
266-
if (t == TypeInt::SHORT) return Type::FLOAT;
267-
if (StubRoutines::hf2f_adr() == nullptr) return bottom_type();
315+
if (t == TypeInt::SHORT || StubRoutines::hf2f_adr() == nullptr) {
316+
return Type::FLOAT;
317+
}
268318

269319
const TypeInt *ti = t->is_int();
270320
if (ti->is_con()) {
271321
return TypeF::make( StubRoutines::hf2f(ti->get_con()) );
272322
}
273-
return bottom_type();
323+
return Type::FLOAT;
274324
}
275325

276326
//=============================================================================
@@ -280,7 +330,7 @@ const Type* ConvI2DNode::Value(PhaseGVN* phase) const {
280330
if( t == Type::TOP ) return Type::TOP;
281331
const TypeInt *ti = t->is_int();
282332
if( ti->is_con() ) return TypeD::make( (double)ti->get_con() );
283-
return bottom_type();
333+
return Type::DOUBLE;
284334
}
285335

286336
//=============================================================================
@@ -290,7 +340,7 @@ const Type* ConvI2FNode::Value(PhaseGVN* phase) const {
290340
if( t == Type::TOP ) return Type::TOP;
291341
const TypeInt *ti = t->is_int();
292342
if( ti->is_con() ) return TypeF::make( (float)ti->get_con() );
293-
return bottom_type();
343+
return Type::FLOAT;
294344
}
295345

296346
//------------------------------Identity---------------------------------------
@@ -710,7 +760,7 @@ const Type* ConvL2DNode::Value(PhaseGVN* phase) const {
710760
if( t == Type::TOP ) return Type::TOP;
711761
const TypeLong *tl = t->is_long();
712762
if( tl->is_con() ) return TypeD::make( (double)tl->get_con() );
713-
return bottom_type();
763+
return Type::DOUBLE;
714764
}
715765

716766
//=============================================================================
@@ -720,7 +770,7 @@ const Type* ConvL2FNode::Value(PhaseGVN* phase) const {
720770
if( t == Type::TOP ) return Type::TOP;
721771
const TypeLong *tl = t->is_long();
722772
if( tl->is_con() ) return TypeF::make( (float)tl->get_con() );
723-
return bottom_type();
773+
return Type::FLOAT;
724774
}
725775

726776
//=============================================================================

‎src/hotspot/share/opto/convertnode.hpp

+86-89
Original file line numberDiff line numberDiff line change
@@ -42,193 +42,190 @@ class Conv2BNode : public Node {
4242
virtual uint ideal_reg() const { return Op_RegI; }
4343
};
4444

45+
class ConvertNode : public TypeNode {
46+
protected:
47+
ConvertNode(const Type* t, Node* input) : TypeNode(t, 2) {
48+
init_class_id(Class_Convert);
49+
init_req(1, input);
50+
}
51+
public:
52+
virtual const Type* in_type() const = 0;
53+
virtual uint ideal_reg() const;
54+
55+
// Create a convert node for a given input and output type.
56+
// Conversions to and from half float are specified via T_SHORT.
57+
static Node* create_convert(BasicType source, BasicType target, Node* input);
58+
};
59+
4560
// The conversions operations are all Alpha sorted. Please keep it that way!
4661
//------------------------------ConvD2FNode------------------------------------
4762
// Convert double to float
48-
class ConvD2FNode : public Node {
63+
class ConvD2FNode : public ConvertNode {
4964
public:
50-
ConvD2FNode( Node *in1 ) : Node(0,in1) {}
65+
ConvD2FNode(Node* in1) : ConvertNode(Type::FLOAT,in1) {}
5166
virtual int Opcode() const;
52-
virtual const Type *bottom_type() const { return Type::FLOAT; }
67+
virtual const Type* in_type() const { return Type::DOUBLE; }
5368
virtual const Type* Value(PhaseGVN* phase) const;
5469
virtual Node* Identity(PhaseGVN* phase);
55-
virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
56-
virtual uint ideal_reg() const { return Op_RegF; }
70+
virtual Node* Ideal(PhaseGVN* phase, bool can_reshape);
5771
};
5872

5973
//------------------------------ConvD2INode------------------------------------
6074
// Convert Double to Integer
61-
class ConvD2INode : public Node {
75+
class ConvD2INode : public ConvertNode {
6276
public:
63-
ConvD2INode( Node *in1 ) : Node(0,in1) {}
77+
ConvD2INode(Node* in1) : ConvertNode(TypeInt::INT,in1) {}
6478
virtual int Opcode() const;
65-
virtual const Type *bottom_type() const { return TypeInt::INT; }
79+
virtual const Type* in_type() const { return Type::DOUBLE; }
6680
virtual const Type* Value(PhaseGVN* phase) const;
6781
virtual Node* Identity(PhaseGVN* phase);
68-
virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
69-
virtual uint ideal_reg() const { return Op_RegI; }
82+
virtual Node* Ideal(PhaseGVN* phase, bool can_reshape);
7083
};
7184

7285
//------------------------------ConvD2LNode------------------------------------
7386
// Convert Double to Long
74-
class ConvD2LNode : public Node {
87+
class ConvD2LNode : public ConvertNode {
7588
public:
76-
ConvD2LNode( Node *dbl ) : Node(0,dbl) {}
89+
ConvD2LNode(Node* in1) : ConvertNode(TypeLong::LONG, in1) {}
7790
virtual int Opcode() const;
78-
virtual const Type *bottom_type() const { return TypeLong::LONG; }
91+
virtual const Type* in_type() const { return Type::DOUBLE; }
7992
virtual const Type* Value(PhaseGVN* phase) const;
8093
virtual Node* Identity(PhaseGVN* phase);
81-
virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
82-
virtual uint ideal_reg() const { return Op_RegL; }
83-
};
84-
85-
class RoundDNode : public Node {
86-
public:
87-
RoundDNode( Node *dbl ) : Node(0,dbl) {}
88-
virtual int Opcode() const;
89-
virtual const Type *bottom_type() const { return TypeLong::LONG; }
90-
virtual uint ideal_reg() const { return Op_RegL; }
94+
virtual Node* Ideal(PhaseGVN* phase, bool can_reshape);
9195
};
9296

9397
//------------------------------ConvF2DNode------------------------------------
9498
// Convert Float to a Double.
95-
class ConvF2DNode : public Node {
99+
class ConvF2DNode : public ConvertNode {
96100
public:
97-
ConvF2DNode( Node *in1 ) : Node(0,in1) {}
101+
ConvF2DNode(Node* in1) : ConvertNode(Type::DOUBLE,in1) {}
98102
virtual int Opcode() const;
99-
virtual const Type *bottom_type() const { return Type::DOUBLE; }
103+
virtual const Type* in_type() const { return Type::FLOAT; }
100104
virtual const Type* Value(PhaseGVN* phase) const;
101-
virtual uint ideal_reg() const { return Op_RegD; }
102105
};
103106

104107
//------------------------------ConvF2HFNode------------------------------------
105108
// Convert Float to Halffloat
106-
class ConvF2HFNode : public Node {
109+
class ConvF2HFNode : public ConvertNode {
107110
public:
108-
ConvF2HFNode( Node *in1 ) : Node(0,in1) {}
111+
ConvF2HFNode(Node* in1) : ConvertNode(TypeInt::SHORT, in1) {}
109112
virtual int Opcode() const;
110-
virtual const Type *bottom_type() const { return TypeInt::SHORT; }
113+
virtual const Type* in_type() const { return TypeInt::FLOAT; }
111114
virtual const Type* Value(PhaseGVN* phase) const;
112-
virtual uint ideal_reg() const { return Op_RegI; }
113115
};
114116

115117
//------------------------------ConvF2INode------------------------------------
116118
// Convert float to integer
117-
class ConvF2INode : public Node {
118-
public:
119-
ConvF2INode( Node *in1 ) : Node(0,in1) {}
119+
class ConvF2INode : public ConvertNode {
120+
public:
121+
ConvF2INode(Node* in1) : ConvertNode(TypeInt::INT, in1) {}
120122
virtual int Opcode() const;
121-
virtual const Type *bottom_type() const { return TypeInt::INT; }
123+
virtual const Type* in_type() const { return TypeInt::FLOAT; }
122124
virtual const Type* Value(PhaseGVN* phase) const;
123125
virtual Node* Identity(PhaseGVN* phase);
124-
virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
125-
virtual uint ideal_reg() const { return Op_RegI; }
126+
virtual Node* Ideal(PhaseGVN* phase, bool can_reshape);
126127
};
127128

128-
129129
//------------------------------ConvF2LNode------------------------------------
130130
// Convert float to long
131-
class ConvF2LNode : public Node {
132-
public:
133-
ConvF2LNode( Node *in1 ) : Node(0,in1) {}
131+
class ConvF2LNode : public ConvertNode {
132+
public:
133+
ConvF2LNode(Node* in1) : ConvertNode(TypeLong::LONG, in1) {}
134134
virtual int Opcode() const;
135-
virtual const Type *bottom_type() const { return TypeLong::LONG; }
135+
virtual const Type* in_type() const { return TypeInt::FLOAT; }
136136
virtual const Type* Value(PhaseGVN* phase) const;
137137
virtual Node* Identity(PhaseGVN* phase);
138-
virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
139-
virtual uint ideal_reg() const { return Op_RegL; }
138+
virtual Node* Ideal(PhaseGVN* phase, bool can_reshape);
140139
};
141140

142141
//------------------------------ConvHF2FNode------------------------------------
143142
// Convert Halffloat to float
144-
class ConvHF2FNode : public Node {
145-
public:
146-
ConvHF2FNode( Node *in1 ) : Node(0,in1) {}
143+
class ConvHF2FNode : public ConvertNode {
144+
public:
145+
ConvHF2FNode(Node* in1) : ConvertNode(Type::FLOAT, in1) {}
147146
virtual int Opcode() const;
148-
virtual const Type *bottom_type() const { return Type::FLOAT; }
147+
virtual const Type* in_type() const { return TypeInt::SHORT; }
149148
virtual const Type* Value(PhaseGVN* phase) const;
150-
virtual uint ideal_reg() const { return Op_RegF; }
151149
};
152150

153151
//------------------------------ConvI2DNode------------------------------------
154152
// Convert Integer to Double
155-
class ConvI2DNode : public Node {
156-
public:
157-
ConvI2DNode( Node *in1 ) : Node(0,in1) {}
153+
class ConvI2DNode : public ConvertNode {
154+
public:
155+
ConvI2DNode(Node* in1) : ConvertNode(Type::DOUBLE, in1) {}
158156
virtual int Opcode() const;
159-
virtual const Type *bottom_type() const { return Type::DOUBLE; }
157+
virtual const Type* in_type() const { return TypeInt::INT; }
160158
virtual const Type* Value(PhaseGVN* phase) const;
161-
virtual uint ideal_reg() const { return Op_RegD; }
162159
};
163160

164161
//------------------------------ConvI2FNode------------------------------------
165162
// Convert Integer to Float
166-
class ConvI2FNode : public Node {
167-
public:
168-
ConvI2FNode( Node *in1 ) : Node(0,in1) {}
163+
class ConvI2FNode : public ConvertNode {
164+
public:
165+
ConvI2FNode(Node* in1) : ConvertNode(Type::FLOAT, in1) {}
169166
virtual int Opcode() const;
170-
virtual const Type *bottom_type() const { return Type::FLOAT; }
167+
virtual const Type* in_type() const { return TypeInt::INT; }
171168
virtual const Type* Value(PhaseGVN* phase) const;
172169
virtual Node* Identity(PhaseGVN* phase);
173-
virtual uint ideal_reg() const { return Op_RegF; }
174-
};
175-
176-
class RoundFNode : public Node {
177-
public:
178-
RoundFNode( Node *in1 ) : Node(0,in1) {}
179-
virtual int Opcode() const;
180-
virtual const Type *bottom_type() const { return TypeInt::INT; }
181-
virtual uint ideal_reg() const { return Op_RegI; }
182170
};
183171

184172
//------------------------------ConvI2LNode------------------------------------
185173
// Convert integer to long
186-
class ConvI2LNode : public TypeNode {
174+
class ConvI2LNode : public ConvertNode {
187175
public:
188-
ConvI2LNode(Node *in1, const TypeLong* t = TypeLong::INT)
189-
: TypeNode(t, 2)
190-
{ init_req(1, in1); }
176+
ConvI2LNode(Node* in1, const TypeLong* t = TypeLong::INT) : ConvertNode(t, in1) {}
191177
virtual int Opcode() const;
178+
virtual const Type* in_type() const { return TypeInt::INT; }
192179
virtual const Type* Value(PhaseGVN* phase) const;
193-
virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
180+
virtual Node* Ideal(PhaseGVN* phase, bool can_reshape);
194181
virtual Node* Identity(PhaseGVN* phase);
195-
virtual uint ideal_reg() const { return Op_RegL; }
196182
};
197183

198184
//------------------------------ConvL2DNode------------------------------------
199185
// Convert Long to Double
200-
class ConvL2DNode : public Node {
201-
public:
202-
ConvL2DNode( Node *in1 ) : Node(0,in1) {}
186+
class ConvL2DNode : public ConvertNode {
187+
public:
188+
ConvL2DNode(Node* in1) : ConvertNode(Type::DOUBLE, in1) {}
203189
virtual int Opcode() const;
204-
virtual const Type *bottom_type() const { return Type::DOUBLE; }
190+
virtual const Type* in_type() const { return TypeLong::LONG; }
205191
virtual const Type* Value(PhaseGVN* phase) const;
206-
virtual uint ideal_reg() const { return Op_RegD; }
207192
};
208193

209194
//------------------------------ConvL2FNode------------------------------------
210195
// Convert Long to Float
211-
class ConvL2FNode : public Node {
212-
public:
213-
ConvL2FNode( Node *in1 ) : Node(0,in1) {}
196+
class ConvL2FNode : public ConvertNode {
197+
public:
198+
ConvL2FNode(Node* in1) : ConvertNode(Type::FLOAT, in1) {}
214199
virtual int Opcode() const;
215-
virtual const Type *bottom_type() const { return Type::FLOAT; }
200+
virtual const Type* in_type() const { return TypeLong::LONG; }
216201
virtual const Type* Value(PhaseGVN* phase) const;
217-
virtual uint ideal_reg() const { return Op_RegF; }
218202
};
219203

220204
//------------------------------ConvL2INode------------------------------------
221205
// Convert long to integer
222-
class ConvL2INode : public TypeNode {
206+
class ConvL2INode : public ConvertNode {
223207
public:
224-
ConvL2INode(Node *in1, const TypeInt* t = TypeInt::INT)
225-
: TypeNode(t, 2) {
226-
init_req(1, in1);
227-
}
208+
ConvL2INode(Node* in1, const TypeInt* t = TypeInt::INT) : ConvertNode(t, in1) {}
228209
virtual int Opcode() const;
210+
virtual const Type* in_type() const { return TypeLong::LONG; }
229211
virtual Node* Identity(PhaseGVN* phase);
230212
virtual const Type* Value(PhaseGVN* phase) const;
231-
virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
213+
virtual Node* Ideal(PhaseGVN* phase, bool can_reshape);
214+
};
215+
216+
class RoundDNode : public Node {
217+
public:
218+
RoundDNode(Node* in1) : Node(nullptr, in1) {}
219+
virtual int Opcode() const;
220+
virtual const Type* bottom_type() const { return TypeLong::LONG; }
221+
virtual uint ideal_reg() const { return Op_RegL; }
222+
};
223+
224+
class RoundFNode : public Node {
225+
public:
226+
RoundFNode(Node* in1) : Node(nullptr, in1) {}
227+
virtual int Opcode() const;
228+
virtual const Type* bottom_type() const { return TypeInt::INT; }
232229
virtual uint ideal_reg() const { return Op_RegI; }
233230
};
234231

‎src/hotspot/share/opto/node.hpp

+3
Original file line numberDiff line numberDiff line change
@@ -70,6 +70,7 @@ class CodeBuffer;
7070
class ConstraintCastNode;
7171
class ConNode;
7272
class ConINode;
73+
class ConvertNode;
7374
class CompareAndSwapNode;
7475
class CompareAndExchangeNode;
7576
class CountedLoopNode;
@@ -731,6 +732,7 @@ class Node {
731732
DEFINE_CLASS_ID(Con, Type, 8)
732733
DEFINE_CLASS_ID(ConI, Con, 0)
733734
DEFINE_CLASS_ID(SafePointScalarMerge, Type, 9)
735+
DEFINE_CLASS_ID(Convert, Type, 10)
734736

735737

736738
DEFINE_CLASS_ID(Proj, Node, 3)
@@ -889,6 +891,7 @@ class Node {
889891
DEFINE_CLASS_QUERY(ClearArray)
890892
DEFINE_CLASS_QUERY(CMove)
891893
DEFINE_CLASS_QUERY(Cmp)
894+
DEFINE_CLASS_QUERY(Convert)
892895
DEFINE_CLASS_QUERY(CountedLoop)
893896
DEFINE_CLASS_QUERY(CountedLoopEnd)
894897
DEFINE_CLASS_QUERY(DecodeNarrowPtr)

‎src/hotspot/share/runtime/vmStructs.cpp

+1
Original file line numberDiff line numberDiff line change
@@ -1493,6 +1493,7 @@
14931493
declare_c2_type(CastPPNode, ConstraintCastNode) \
14941494
declare_c2_type(CheckCastPPNode, TypeNode) \
14951495
declare_c2_type(Conv2BNode, Node) \
1496+
declare_c2_type(ConvertNode, TypeNode) \
14961497
declare_c2_type(ConvD2FNode, Node) \
14971498
declare_c2_type(ConvD2INode, Node) \
14981499
declare_c2_type(ConvD2LNode, Node) \

‎test/hotspot/jtreg/compiler/c2/irTests/TestPhiDuplicatedConversion.java

+155
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,155 @@
1+
/*
2+
* Copyright (c) 2023, 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.
8+
*
9+
* This code is distributed in the hope that it will be useful, but WITHOUT
10+
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11+
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12+
* version 2 for more details (a copy is included in the LICENSE file that
13+
* accompanied this code).
14+
*
15+
* You should have received a copy of the GNU General Public License version
16+
* 2 along with this work; if not, write to the Free Software Foundation,
17+
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18+
*
19+
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20+
* or visit www.oracle.com if you need additional information or have any
21+
* questions.
22+
*/
23+
24+
package compiler.c2.irTests;
25+
26+
import jdk.test.lib.Asserts;
27+
import compiler.lib.ir_framework.*;
28+
import java.util.Random;
29+
import jdk.test.lib.Utils;
30+
31+
/*
32+
* @test
33+
* @summary Test that patterns involving duplicated conversion nodes behind phi are properly optimized.
34+
* @bug 8316918
35+
* @library /test/lib /
36+
* @requires vm.compiler2.enabled
37+
* @run driver compiler.c2.irTests.TestPhiDuplicatedConversion
38+
*/
39+
public class TestPhiDuplicatedConversion {
40+
public static void main(String[] args) {
41+
TestFramework.run();
42+
}
43+
44+
@Test
45+
@IR(counts = {IRNode.CONV, "1"})
46+
public static float int2Float(boolean c, int a, int b) {
47+
return c ? a : b;
48+
}
49+
50+
@Test
51+
@IR(counts = {IRNode.CONV, "1"})
52+
public static double int2Double(boolean c, int a, int b) {
53+
return c ? a : b;
54+
}
55+
56+
@Test
57+
@IR(counts = {IRNode.CONV, "1"})
58+
public static long int2Long(boolean c, int a, int b) {
59+
return c ? a : b;
60+
}
61+
62+
@Test
63+
@IR(counts = {IRNode.CONV, "1"})
64+
public static int float2Int(boolean c, float a, float b) {
65+
return c ? (int)a : (int)b;
66+
}
67+
68+
@Test
69+
@IR(counts = {IRNode.CONV, "1"})
70+
public static double float2Double(boolean c, float a, float b) {
71+
return c ? (double)a : (double)b;
72+
}
73+
74+
@Test
75+
@IR(counts = {IRNode.CONV, "1"})
76+
public static long float2Long(boolean c, float a, float b) {
77+
return c ? (long)a : (long)b;
78+
}
79+
80+
@Test
81+
@IR(counts = {IRNode.CONV, "1"})
82+
public static int double2Int(boolean c, double a, double b) {
83+
return c ? (int)a : (int)b;
84+
}
85+
86+
@Test
87+
@IR(counts = {IRNode.CONV, "1"})
88+
public static float double2Float(boolean c, double a, double b) {
89+
return c ? (float)a : (float)b;
90+
}
91+
92+
@Test
93+
@IR(counts = {IRNode.CONV, "1"})
94+
public static long double2Long(boolean c, double a, double b) {
95+
return c ? (long)a : (long)b;
96+
}
97+
98+
@Test
99+
@IR(counts = {IRNode.CONV, "1"})
100+
public static float long2Float(boolean c, long a, long b) {
101+
return c ? a : b;
102+
}
103+
104+
@Test
105+
@IR(counts = {IRNode.CONV, "1"})
106+
public static double long2Double(boolean c, long a, long b) {
107+
return c ? a : b;
108+
}
109+
110+
@Test
111+
@IR(counts = {IRNode.CONV, "1"})
112+
public static int long2Int(boolean c, long a, long b) {
113+
return c ? (int)a : (int)b;
114+
}
115+
116+
@Test
117+
@IR(counts = {IRNode.CONV, "1"}, applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"})
118+
public static short float2HalfFloat(boolean c, float a, float b) {
119+
return c ? Float.floatToFloat16(a) : Float.floatToFloat16(b);
120+
}
121+
122+
@Test
123+
@IR(counts = {IRNode.CONV, "1"}, applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"})
124+
public static float halfFloat2Float(boolean c, short a, short b) {
125+
return c ? Float.float16ToFloat(a) : Float.float16ToFloat(b);
126+
}
127+
128+
@Run(test = {"int2Float", "int2Double", "int2Long",
129+
"float2Int", "float2Double", "float2Long",
130+
"double2Int", "double2Float", "double2Long",
131+
"long2Float", "long2Double", "long2Int",
132+
"float2HalfFloat", "halfFloat2Float"})
133+
public void runTests() {
134+
assertResults(true, 10, 20, 3.14f, -1.6f, 3.1415, -1.618, 30L, 400L, Float.floatToFloat16(10.5f), Float.floatToFloat16(20.5f));
135+
assertResults(false, 10, 20, 3.14f, -1.6f, 3.1415, -1.618, 30L, 400L, Float.floatToFloat16(10.5f), Float.floatToFloat16(20.5f));
136+
}
137+
138+
@DontCompile
139+
public void assertResults(boolean c, int intA, int intB, float floatA, float floatB, double doubleA, double doubleB, long longA, long longB, short halfFloatA, short halfFloatB) {
140+
Asserts.assertEQ(c ? (float)intA : (float)intB, int2Float(c, intA, intB));
141+
Asserts.assertEQ(c ? (double)intA : (double)intB, int2Double(c, intA, intB));
142+
Asserts.assertEQ(c ? (long)intA : (long)intB, int2Long(c, intA, intB));
143+
Asserts.assertEQ(c ? (int)floatA : (int)floatB, float2Int(c, floatA, floatB));
144+
Asserts.assertEQ(c ? (double)floatA : (double)floatB, float2Double(c, floatA, floatB));
145+
Asserts.assertEQ(c ? (long)floatA : (long)floatB, float2Long(c, floatA, floatB));
146+
Asserts.assertEQ(c ? (int)doubleA : (int)doubleB, double2Int(c, doubleA, doubleB));
147+
Asserts.assertEQ(c ? (float)doubleA : (float)doubleB, double2Float(c, doubleA, doubleB));
148+
Asserts.assertEQ(c ? (long)doubleA : (long)doubleB, double2Long(c, doubleA, doubleB));
149+
Asserts.assertEQ(c ? (float)longA : (float)longB, long2Float(c, longA, longB));
150+
Asserts.assertEQ(c ? (double)longA : (double)longB, long2Double(c, longA, longB));
151+
Asserts.assertEQ(c ? (int)longA : (int)longB, long2Int(c, longA, longB));
152+
Asserts.assertEQ(c ? Float.floatToFloat16(floatA) : Float.floatToFloat16(floatB), float2HalfFloat(c, floatA, floatB));
153+
Asserts.assertEQ(c ? Float.float16ToFloat(halfFloatA) : Float.float16ToFloat(halfFloatB), halfFloat2Float(c, halfFloatA, halfFloatB));
154+
}
155+
}

‎test/hotspot/jtreg/compiler/lib/ir_framework/IRNode.java

+5
Original file line numberDiff line numberDiff line change
@@ -442,6 +442,11 @@ public class IRNode {
442442
beforeMatchingNameRegex(COMPRESS_BITS, "CompressBits");
443443
}
444444

445+
public static final String CONV = PREFIX + "CONV" + POSTFIX;
446+
static {
447+
beforeMatchingNameRegex(CONV, "Conv");
448+
}
449+
445450
public static final String CONV_I2L = PREFIX + "CONV_I2L" + POSTFIX;
446451
static {
447452
beforeMatchingNameRegex(CONV_I2L, "ConvI2L");

‎test/micro/org/openjdk/bench/vm/compiler/PhiDuplicatedConversion.java

+220
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,220 @@
1+
/*
2+
* Copyright (c) 2023, 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.
8+
*
9+
* This code is distributed in the hope that it will be useful, but WITHOUT
10+
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11+
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12+
* version 2 for more details (a copy is included in the LICENSE file that
13+
* accompanied this code).
14+
*
15+
* You should have received a copy of the GNU General Public License version
16+
* 2 along with this work; if not, write to the Free Software Foundation,
17+
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18+
*
19+
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20+
* or visit www.oracle.com if you need additional information or have any
21+
* questions.
22+
*/
23+
package org.openjdk.bench.vm.compiler;
24+
25+
import org.openjdk.jmh.annotations.*;
26+
import org.openjdk.jmh.infra.Blackhole;
27+
28+
import java.util.Random;
29+
import java.util.concurrent.TimeUnit;
30+
31+
@BenchmarkMode(Mode.AverageTime)
32+
@OutputTimeUnit(TimeUnit.NANOSECONDS)
33+
@Measurement(iterations = 4, time = 1000, timeUnit = TimeUnit.MILLISECONDS)
34+
@Warmup(iterations = 3, time = 1000, timeUnit = TimeUnit.MILLISECONDS)
35+
@Fork(3)
36+
public class PhiDuplicatedConversion {
37+
public static final int SIZE = 300;
38+
39+
// Ints
40+
41+
@Benchmark
42+
public void testInt2Float(Blackhole blackhole, BenchState state) {
43+
for (int i = 0; i < SIZE; i++) {
44+
blackhole.consume(i2f(state.bools[i], state.ints[i], state.ints[SIZE - 1 - i]));
45+
}
46+
}
47+
48+
@Benchmark
49+
public void testInt2Double(Blackhole blackhole, BenchState state) {
50+
for (int i = 0; i < SIZE; i++) {
51+
blackhole.consume(i2d(state.bools[i], state.ints[i], state.ints[SIZE - 1 - i]));
52+
}
53+
}
54+
55+
@Benchmark
56+
public void testInt2Long(Blackhole blackhole, BenchState state) {
57+
for (int i = 0; i < SIZE; i++) {
58+
blackhole.consume(i2l(state.bools[i], state.ints[i], state.ints[SIZE - 1 - i]));
59+
}
60+
}
61+
62+
// Floats
63+
64+
@Benchmark
65+
public void testFloat2Int(Blackhole blackhole, BenchState state) {
66+
for (int i = 0; i < SIZE; i++) {
67+
blackhole.consume(f2i(state.bools[i], state.floats[i], state.floats[SIZE - 1 - i]));
68+
}
69+
}
70+
71+
@Benchmark
72+
public void testFloat2Double(Blackhole blackhole, BenchState state) {
73+
for (int i = 0; i < SIZE; i++) {
74+
blackhole.consume(f2d(state.bools[i], state.floats[i], state.floats[SIZE - 1 - i]));
75+
}
76+
}
77+
78+
@Benchmark
79+
public void testFloat2Long(Blackhole blackhole, BenchState state) {
80+
for (int i = 0; i < SIZE; i++) {
81+
blackhole.consume(f2l(state.bools[i], state.floats[i], state.floats[SIZE - 1 - i]));
82+
}
83+
}
84+
85+
// Doubles
86+
87+
@Benchmark
88+
public void testDouble2Int(Blackhole blackhole, BenchState state) {
89+
for (int i = 0; i < SIZE; i++) {
90+
blackhole.consume(d2i(state.bools[i], state.doubles[i], state.doubles[SIZE - 1 - i]));
91+
}
92+
}
93+
94+
@Benchmark
95+
public void testDouble2Float(Blackhole blackhole, BenchState state) {
96+
for (int i = 0; i < SIZE; i++) {
97+
blackhole.consume(d2f(state.bools[i], state.doubles[i], state.doubles[SIZE - 1 - i]));
98+
}
99+
}
100+
101+
@Benchmark
102+
public void testDouble2Long(Blackhole blackhole, BenchState state) {
103+
for (int i = 0; i < SIZE; i++) {
104+
blackhole.consume(d2l(state.bools[i], state.doubles[i], state.doubles[SIZE - 1 - i]));
105+
}
106+
}
107+
108+
// Longs
109+
110+
@Benchmark
111+
public void testLong2Float(Blackhole blackhole, BenchState state) {
112+
for (int i = 0; i < SIZE; i++) {
113+
blackhole.consume(l2f(state.bools[i], state.longs[i], state.longs[SIZE - 1 - i]));
114+
}
115+
}
116+
117+
@Benchmark
118+
public void testLong2Double(Blackhole blackhole, BenchState state) {
119+
for (int i = 0; i < SIZE; i++) {
120+
blackhole.consume(l2d(state.bools[i], state.longs[i], state.longs[SIZE - 1 - i]));
121+
}
122+
}
123+
124+
@Benchmark
125+
public void testLong2Int(Blackhole blackhole, BenchState state) {
126+
for (int i = 0; i < SIZE; i++) {
127+
blackhole.consume(l2i(state.bools[i], state.longs[i], state.longs[SIZE - 1 - i]));
128+
}
129+
}
130+
131+
@CompilerControl(CompilerControl.Mode.DONT_INLINE)
132+
public static float i2f(boolean c, int a, int b) {
133+
return c ? a : b;
134+
}
135+
136+
@CompilerControl(CompilerControl.Mode.DONT_INLINE)
137+
public static double i2d(boolean c, int a, int b) {
138+
return c ? a : b;
139+
}
140+
141+
@CompilerControl(CompilerControl.Mode.DONT_INLINE)
142+
public static long i2l(boolean c, int a, int b) {
143+
return c ? a : b;
144+
}
145+
146+
@CompilerControl(CompilerControl.Mode.DONT_INLINE)
147+
public static int f2i(boolean c, float a, float b) {
148+
return c ? (int)a : (int)b;
149+
}
150+
151+
@CompilerControl(CompilerControl.Mode.DONT_INLINE)
152+
public static double f2d(boolean c, float a, float b) {
153+
return c ? (double)a : (double)b;
154+
}
155+
156+
@CompilerControl(CompilerControl.Mode.DONT_INLINE)
157+
public static long f2l(boolean c, float a, float b) {
158+
return c ? (long)a : (long)b;
159+
}
160+
161+
@CompilerControl(CompilerControl.Mode.DONT_INLINE)
162+
public static int d2i(boolean c, double a, double b) {
163+
return c ? (int)a : (int)b;
164+
}
165+
166+
@CompilerControl(CompilerControl.Mode.DONT_INLINE)
167+
public static float d2f(boolean c, double a, double b) {
168+
return c ? (float)a : (float)b;
169+
}
170+
171+
@CompilerControl(CompilerControl.Mode.DONT_INLINE)
172+
public static long d2l(boolean c, double a, double b) {
173+
return c ? (long)a : (long)b;
174+
}
175+
176+
@CompilerControl(CompilerControl.Mode.DONT_INLINE)
177+
public static float l2f(boolean c, long a, long b) {
178+
return c ? a : b;
179+
}
180+
181+
@CompilerControl(CompilerControl.Mode.DONT_INLINE)
182+
public static double l2d(boolean c, long a, long b) {
183+
return c ? a : b;
184+
}
185+
186+
@CompilerControl(CompilerControl.Mode.DONT_INLINE)
187+
public static int l2i(boolean c, long a, long b) {
188+
return c ? (int)a : (int)b;
189+
}
190+
191+
@State(Scope.Benchmark)
192+
public static class BenchState {
193+
public boolean[] bools;
194+
public int[] ints;
195+
public long[] longs;
196+
public float[] floats;
197+
public double[] doubles;
198+
public BenchState() {
199+
200+
}
201+
202+
@Setup(Level.Iteration)
203+
public void setup() {
204+
Random random = new Random(1000);
205+
bools = new boolean[SIZE];
206+
ints = new int[SIZE];
207+
longs = new long[SIZE];
208+
floats = new float[SIZE];
209+
doubles = new double[SIZE];
210+
211+
for (int i = 0; i < SIZE; i++) {
212+
bools[i] = random.nextBoolean();
213+
ints[i] = random.nextInt(100);
214+
longs[i] = random.nextLong(100);
215+
floats[i] = random.nextFloat(100);
216+
doubles[i] = random.nextDouble(100);
217+
}
218+
}
219+
}
220+
}

0 commit comments

Comments
 (0)
Please sign in to comment.