Mercurial > hg > truffle
comparison src/share/vm/opto/superword.hpp @ 6179:8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
Summary: Increase vector size up to 256-bits for YMM AVX registers on x86.
Reviewed-by: never, twisti, roland
author | kvn |
---|---|
date | Fri, 15 Jun 2012 01:25:19 -0700 |
parents | c7b60b601eb4 |
children | 6f8f439e247d |
comparison
equal
deleted
inserted
replaced
6146:eba1d5bce9e8 | 6179:8c92982cbbc4 |
---|---|
1 /* | 1 /* |
2 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. | 2 * Copyright (c) 2007, 2012, Oracle and/or its affiliates. All rights reserved. |
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 * | 4 * |
5 * This code is free software; you can redistribute it and/or modify it | 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 | 6 * under the terms of the GNU General Public License version 2 only, as |
7 * published by the Free Software Foundation. | 7 * published by the Free Software Foundation. |
262 LoopNode* lp() { return _lp; } | 262 LoopNode* lp() { return _lp; } |
263 void set_lp(LoopNode* lp) { _lp = lp; | 263 void set_lp(LoopNode* lp) { _lp = lp; |
264 _iv = lp->as_CountedLoop()->phi()->as_Phi(); } | 264 _iv = lp->as_CountedLoop()->phi()->as_Phi(); } |
265 int iv_stride() { return lp()->as_CountedLoop()->stride_con(); } | 265 int iv_stride() { return lp()->as_CountedLoop()->stride_con(); } |
266 | 266 |
267 int vector_width_in_bytes() { return Matcher::vector_width_in_bytes(); } | 267 int vector_width_in_bytes(BasicType bt) { |
268 return MIN2(ABS(iv_stride())*type2aelembytes(bt), | |
269 Matcher::vector_width_in_bytes(bt)); | |
270 } | |
268 | 271 |
269 MemNode* align_to_ref() { return _align_to_ref; } | 272 MemNode* align_to_ref() { return _align_to_ref; } |
270 void set_align_to_ref(MemNode* m) { _align_to_ref = m; } | 273 void set_align_to_ref(MemNode* m) { _align_to_ref = m; } |
271 | 274 |
272 Node* ctrl(Node* n) const { return _phase->has_ctrl(n) ? _phase->get_ctrl(n) : n; } | 275 Node* ctrl(Node* n) const { return _phase->has_ctrl(n) ? _phase->get_ctrl(n) : n; } |
296 int depth(Node* n) { return _node_info.adr_at(bb_idx(n))->_depth; } | 299 int depth(Node* n) { return _node_info.adr_at(bb_idx(n))->_depth; } |
297 void set_depth(Node* n, int d) { int i = bb_idx(n); grow_node_info(i); _node_info.adr_at(i)->_depth = d; } | 300 void set_depth(Node* n, int d) { int i = bb_idx(n); grow_node_info(i); _node_info.adr_at(i)->_depth = d; } |
298 | 301 |
299 // vector element type | 302 // vector element type |
300 const Type* velt_type(Node* n) { return _node_info.adr_at(bb_idx(n))->_velt_type; } | 303 const Type* velt_type(Node* n) { return _node_info.adr_at(bb_idx(n))->_velt_type; } |
304 BasicType velt_basic_type(Node* n) { return velt_type(n)->array_element_basic_type(); } | |
301 void set_velt_type(Node* n, const Type* t) { int i = bb_idx(n); grow_node_info(i); _node_info.adr_at(i)->_velt_type = t; } | 305 void set_velt_type(Node* n, const Type* t) { int i = bb_idx(n); grow_node_info(i); _node_info.adr_at(i)->_velt_type = t; } |
306 bool same_velt_type(Node* n1, Node* n2); | |
302 | 307 |
303 // my_pack | 308 // my_pack |
304 Node_List* my_pack(Node* n) { return !in_bb(n) ? NULL : _node_info.adr_at(bb_idx(n))->_my_pack; } | 309 Node_List* my_pack(Node* n) { return !in_bb(n) ? NULL : _node_info.adr_at(bb_idx(n))->_my_pack; } |
305 void set_my_pack(Node* n, Node_List* p) { int i = bb_idx(n); grow_node_info(i); _node_info.adr_at(i)->_my_pack = p; } | 310 void set_my_pack(Node* n, Node_List* p) { int i = bb_idx(n); grow_node_info(i); _node_info.adr_at(i)->_my_pack = p; } |
306 | 311 |
309 // Extract the superword level parallelism | 314 // Extract the superword level parallelism |
310 void SLP_extract(); | 315 void SLP_extract(); |
311 // Find the adjacent memory references and create pack pairs for them. | 316 // Find the adjacent memory references and create pack pairs for them. |
312 void find_adjacent_refs(); | 317 void find_adjacent_refs(); |
313 // Find a memory reference to align the loop induction variable to. | 318 // Find a memory reference to align the loop induction variable to. |
314 void find_align_to_ref(Node_List &memops); | 319 MemNode* find_align_to_ref(Node_List &memops); |
320 // Calculate loop's iv adjustment for this memory ops. | |
321 int get_iv_adjustment(MemNode* mem); | |
315 // Can the preloop align the reference to position zero in the vector? | 322 // Can the preloop align the reference to position zero in the vector? |
316 bool ref_is_alignable(SWPointer& p); | 323 bool ref_is_alignable(SWPointer& p); |
317 // Construct dependency graph. | 324 // Construct dependency graph. |
318 void dependence_graph(); | 325 void dependence_graph(); |
319 // Return a memory slice (node list) in predecessor order starting at "start" | 326 // Return a memory slice (node list) in predecessor order starting at "start" |
392 // Alignment within a vector memory reference | 399 // Alignment within a vector memory reference |
393 int memory_alignment(MemNode* s, int iv_adjust_in_bytes); | 400 int memory_alignment(MemNode* s, int iv_adjust_in_bytes); |
394 // (Start, end] half-open range defining which operands are vector | 401 // (Start, end] half-open range defining which operands are vector |
395 void vector_opd_range(Node* n, uint* start, uint* end); | 402 void vector_opd_range(Node* n, uint* start, uint* end); |
396 // Smallest type containing range of values | 403 // Smallest type containing range of values |
397 static const Type* container_type(const Type* t); | 404 const Type* container_type(Node* n); |
398 // Adjust pre-loop limit so that in main loop, a load/store reference | 405 // Adjust pre-loop limit so that in main loop, a load/store reference |
399 // to align_to_ref will be a position zero in the vector. | 406 // to align_to_ref will be a position zero in the vector. |
400 void align_initial_loop_index(MemNode* align_to_ref); | 407 void align_initial_loop_index(MemNode* align_to_ref); |
401 // Find pre loop end from main loop. Returns null if none. | 408 // Find pre loop end from main loop. Returns null if none. |
402 CountedLoopEndNode* get_pre_loop_end(CountedLoopNode *cl); | 409 CountedLoopEndNode* get_pre_loop_end(CountedLoopNode *cl); |
460 bool valid() { return _adr != NULL; } | 467 bool valid() { return _adr != NULL; } |
461 bool has_iv() { return _scale != 0; } | 468 bool has_iv() { return _scale != 0; } |
462 | 469 |
463 Node* base() { return _base; } | 470 Node* base() { return _base; } |
464 Node* adr() { return _adr; } | 471 Node* adr() { return _adr; } |
472 MemNode* mem() { return _mem; } | |
465 int scale_in_bytes() { return _scale; } | 473 int scale_in_bytes() { return _scale; } |
466 Node* invar() { return _invar; } | 474 Node* invar() { return _invar; } |
467 bool negate_invar() { return _negate_invar; } | 475 bool negate_invar() { return _negate_invar; } |
468 int offset_in_bytes() { return _offset; } | 476 int offset_in_bytes() { return _offset; } |
469 int memory_size() { return _mem->memory_size(); } | 477 int memory_size() { return _mem->memory_size(); } |