graal-jvmci-8: src/share/vm/opto/escape.cpp comparison

comparison src/share/vm/opto/escape.cpp @ 20804:7848fc12602b

Merge with jdk8u40-b25

author	Gilles Duboscq <gilles.m.duboscq@oracle.com>
date	Tue, 07 Apr 2015 14:58:49 +0200
parents	52b4284cb496 f913964f3fde
children	dd9cc155639c

comparison

equal deleted inserted replaced

-:84105dcdb05b
+:7848fc12602b
 /*
-* Copyright (c) 2005, 2013, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2005, 2014, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 #include "opto/phaseX.hpp"
 #include "opto/rootnode.hpp"
 ConnectionGraph::ConnectionGraph(Compile * C, PhaseIterGVN *igvn) :
 _nodes(C->comp_arena(), C->unique(), C->unique(), NULL),
+_in_worklist(C->comp_arena()),
+_next_pidx(0),
 _collecting(true),
 _verify(false),
 _compile(C),
 _igvn(igvn),
 _node_map(C->comp_arena()) {
 ideal_nodes.map(C->live_nodes(), NULL);  // preallocate space
 // Initialize worklist
 if (C->root() != NULL) {
 ideal_nodes.push(C->root());
 }
+// Processed ideal nodes are unique on ideal_nodes list
+// but several ideal nodes are mapped to the phantom_obj.
+// To avoid duplicated entries on the following worklists
+// add the phantom_obj only once to them.
+ptnodes_worklist.append(phantom_obj);
+java_objects_worklist.append(phantom_obj);
 for( uint next = 0; next < ideal_nodes.size(); ++next ) {
 Node* n = ideal_nodes.at(next);
 // Create PointsTo nodes and add them to Connection Graph. Called
 // only once per ideal node since ideal_nodes is Unique_Node list.
 add_node_to_connection_graph(n, &delayed_worklist);
 PointsToNode* ptn = ptnode_adr(n->_idx);
-if (ptn != NULL) {
+if (ptn != NULL && ptn != phantom_obj) {
 ptnodes_worklist.append(ptn);
 if (ptn->is_JavaObject()) {
 java_objects_worklist.append(ptn->as_JavaObject());
 if ((n->is_Allocate() || n->is_CallStaticJava()) &&
 (ptn->escape_state() < PointsToNode::GlobalEscape)) {
 add_java_object(n, es);
 break;
 }
 case Op_CreateEx: {
 // assume that all exception objects globally escape
-add_java_object(n, PointsToNode::GlobalEscape);
+map_ideal_node(n, phantom_obj);
 break;
 }
 case Op_LoadKlass:
 case Op_LoadNKlass: {
 // Unknown class is loaded
 strcmp(call->as_CallLeaf()->_name, "g1_wb_post") == 0 ||
 strcmp(call->as_CallLeaf()->_name, "updateBytesCRC32") == 0 ||
 strcmp(call->as_CallLeaf()->_name, "aescrypt_encryptBlock") == 0 ||
 strcmp(call->as_CallLeaf()->_name, "aescrypt_decryptBlock") == 0 ||
 strcmp(call->as_CallLeaf()->_name, "cipherBlockChaining_encryptAESCrypt") == 0 ||
-strcmp(call->as_CallLeaf()->_name, "cipherBlockChaining_decryptAESCrypt") == 0)
+strcmp(call->as_CallLeaf()->_name, "cipherBlockChaining_decryptAESCrypt") == 0 ||
+strcmp(call->as_CallLeaf()->_name, "sha1_implCompress") == 0 ||
+strcmp(call->as_CallLeaf()->_name, "sha1_implCompressMB") == 0 ||
+strcmp(call->as_CallLeaf()->_name, "sha256_implCompress") == 0 ||
+strcmp(call->as_CallLeaf()->_name, "sha256_implCompressMB") == 0 ||
+strcmp(call->as_CallLeaf()->_name, "sha512_implCompress") == 0 ||
+strcmp(call->as_CallLeaf()->_name, "sha512_implCompressMB") == 0 ||
+strcmp(call->as_CallLeaf()->_name, "multiplyToLen") == 0)
 ))) {
 call->dump();
 fatal(err_msg_res("EA unexpected CallLeaf %s", call->as_CallLeaf()->_name));
 }
 #endif
 GrowableArray<FieldNode*>&      oop_fields_worklist) {
 // Normally only 1-3 passes needed to build Connection Graph depending
 // on graph complexity. Observed 8 passes in jvm2008 compiler.compiler.
 // Set limit to 20 to catch situation when something did go wrong and
 // bailout Escape Analysis.
-// Also limit build time to 30 sec (60 in debug VM).
+// Also limit build time to 20 sec (60 in debug VM), EscapeAnalysisTimeout flag.
 #define CG_BUILD_ITER_LIMIT 20
-#ifdef ASSERT
-#define CG_BUILD_TIME_LIMIT 60.0
-#else
-#define CG_BUILD_TIME_LIMIT 30.0
-#endif
 // Propagate GlobalEscape and ArgEscape escape states and check that
 // we still have non-escaping objects. The method pushs on _worklist
 // Field nodes which reference phantom_object.
 if (!find_non_escaped_objects(ptnodes_worklist, non_escaped_worklist)) {
 return false; // Nothing to do.
 }
 // Now propagate references to all JavaObject nodes.
 int java_objects_length = java_objects_worklist.length();
 elapsedTimer time;
+bool timeout = false;
 int new_edges = 1;
 int iterations = 0;
 do {
 while ((new_edges > 0) &&
-(iterations++   < CG_BUILD_ITER_LIMIT) &&
+(iterations++ < CG_BUILD_ITER_LIMIT)) {
-(time.seconds() < CG_BUILD_TIME_LIMIT)) {
+double start_time = time.seconds();
 time.start();
 new_edges = 0;
 // Propagate references to phantom_object for nodes pushed on _worklist
 // by find_non_escaped_objects() and find_field_value().
 new_edges += add_java_object_edges(phantom_obj, false);
 for (int next = 0; next < java_objects_length; ++next) {
 JavaObjectNode* ptn = java_objects_worklist.at(next);
 new_edges += add_java_object_edges(ptn, true);
-}
+#define SAMPLE_SIZE 4
+if ((next % SAMPLE_SIZE) == 0) {
+// Each 4 iterations calculate how much time it will take
+// to complete graph construction.
+time.stop();
+// Poll for requests from shutdown mechanism to quiesce compiler
+// because Connection graph construction may take long time.
+CompileBroker::maybe_block();
+double stop_time = time.seconds();
+double time_per_iter = (stop_time - start_time) / (double)SAMPLE_SIZE;
+double time_until_end = time_per_iter * (double)(java_objects_length - next);
+if ((start_time + time_until_end) >= EscapeAnalysisTimeout) {
+timeout = true;
+break; // Timeout
+}
+start_time = stop_time;
+time.start();
+}
+#undef SAMPLE_SIZE
+}
+if (timeout) break;
 if (new_edges > 0) {
 // Update escape states on each iteration if graph was updated.
 if (!find_non_escaped_objects(ptnodes_worklist, non_escaped_worklist)) {
 return false; // Nothing to do.
 }
 }
 time.stop();
-}
+if (time.seconds() >= EscapeAnalysisTimeout) {
-if ((iterations     < CG_BUILD_ITER_LIMIT) &&
+timeout = true;
-(time.seconds() < CG_BUILD_TIME_LIMIT)) {
+break;
+}
+}
+if ((iterations < CG_BUILD_ITER_LIMIT) && !timeout) {
 time.start();
 // Find fields which have unknown value.
 int fields_length = oop_fields_worklist.length();
 for (int next = 0; next < fields_length; next++) {
 FieldNode* field = oop_fields_worklist.at(next);
 // This code may added new edges to phantom_object.
 // Need an other cycle to propagate references to phantom_object.
 }
 }
 time.stop();
+if (time.seconds() >= EscapeAnalysisTimeout) {
+timeout = true;
+break;
+}
 } else {
 new_edges = 0; // Bailout
 }
 } while (new_edges > 0);
 // Bailout if passed limits.
-if ((iterations     >= CG_BUILD_ITER_LIMIT) ||
+if ((iterations >= CG_BUILD_ITER_LIMIT) || timeout) {
-(time.seconds() >= CG_BUILD_TIME_LIMIT)) {
 Compile* C = _compile;
 if (C->log() != NULL) {
 C->log()->begin_elem("connectionGraph_bailout reason='reached ");
-C->log()->text("%s", (iterations >= CG_BUILD_ITER_LIMIT) ? "iterations" : "time");
+C->log()->text("%s", timeout ? "time" : "iterations");
 C->log()->end_elem(" limit'");
 }
 assert(ExitEscapeAnalysisOnTimeout, err_msg_res("infinite EA connection graph build (%f sec, %d iterations) with %d nodes and worklist size %d",
 time.seconds(), iterations, nodes_size(), ptnodes_worklist.length()));
 // Possible infinite build_connection_graph loop,
 iterations, nodes_size(), ptnodes_worklist.length());
 }
 #endif
 #undef CG_BUILD_ITER_LIMIT
-#undef CG_BUILD_TIME_LIMIT
 // Find fields initialized by NULL for non-escaping Allocations.
 int non_escaped_length = non_escaped_worklist.length();
 for (int next = 0; next < non_escaped_length; next++) {
 JavaObjectNode* ptn = non_escaped_worklist.at(next);
 // related field nodes (same base and offset).
 add_field_uses_to_worklist(use->as_Field());
 }
 }
 }
-while(_worklist.length() > 0) {
+for (int l = 0; l < _worklist.length(); l++) {
-PointsToNode* use = _worklist.pop();
+PointsToNode* use = _worklist.at(l);
 if (PointsToNode::is_base_use(use)) {
 // Add reference from jobj to field and from field to jobj (field's base).
 use = PointsToNode::get_use_node(use)->as_Field();
 if (add_base(use->as_Field(), jobj)) {
 new_edges++;
 // Put on worklist all field's uses (loads) and
 // related field nodes (same base and offset).
 add_field_uses_to_worklist(use->as_Field());
 }
 }
+_worklist.clear();
+_in_worklist.Reset();
 return new_edges;
 }
 // Put on worklist all related field nodes.
 void ConnectionGraph::add_field_uses_to_worklist(FieldNode* field) {
 if (ptadr != NULL) {
 assert(ptadr->is_LocalVar() && ptadr->ideal_node() == n, "sanity");
 return;
 }
 Compile* C = _compile;
-ptadr = new (C->comp_arena()) LocalVarNode(C, n, es);
+ptadr = new (C->comp_arena()) LocalVarNode(this, n, es);
 _nodes.at_put(n->_idx, ptadr);
 }
 void ConnectionGraph::add_java_object(Node *n, PointsToNode::EscapeState es) {
 PointsToNode* ptadr = _nodes.at(n->_idx);
 if (ptadr != NULL) {
 assert(ptadr->is_JavaObject() && ptadr->ideal_node() == n, "sanity");
 return;
 }
 Compile* C = _compile;
-ptadr = new (C->comp_arena()) JavaObjectNode(C, n, es);
+ptadr = new (C->comp_arena()) JavaObjectNode(this, n, es);
 _nodes.at_put(n->_idx, ptadr);
 }
 void ConnectionGraph::add_field(Node *n, PointsToNode::EscapeState es, int offset) {
 PointsToNode* ptadr = _nodes.at(n->_idx);
 bool is_oop = is_oop_field(n, offset, &unsafe);
 if (unsafe) {
 es = PointsToNode::GlobalEscape;
 }
 Compile* C = _compile;
-FieldNode* field = new (C->comp_arena()) FieldNode(C, n, es, offset, is_oop);
+FieldNode* field = new (C->comp_arena()) FieldNode(this, n, es, offset, is_oop);
 _nodes.at_put(n->_idx, field);
 }
 void ConnectionGraph::add_arraycopy(Node *n, PointsToNode::EscapeState es,
 PointsToNode* src, PointsToNode* dst) {
 if (ptadr != NULL) {
 assert(ptadr->is_Arraycopy() && ptadr->ideal_node() == n, "sanity");
 return;
 }
 Compile* C = _compile;
-ptadr = new (C->comp_arena()) ArraycopyNode(C, n, es);
+ptadr = new (C->comp_arena()) ArraycopyNode(this, n, es);
 _nodes.at_put(n->_idx, ptadr);
 // Add edge from arraycopy node to source object.
 (void)add_edge(ptadr, src);
 src->set_arraycopy_src();
 // Add edge from destination object to arraycopy node.
 assert(phi->_idx >= nodes_size(), "only new Phi per instance memory slice");
 return phi->as_Phi();
 }
 }
 }
-if ((int) (C->live_nodes() + 2*NodeLimitFudgeFactor) > MaxNodeLimit) {
+if (C->live_nodes() + 2*NodeLimitFudgeFactor > C->max_node_limit()) {
 if (C->do_escape_analysis() == true && !C->failing()) {
 // Retry compilation without escape analysis.
 // If this is the first failure, the sentinel string will "stick"
 // to the Compile object, and the C2Compiler will see it and retry.
 C->record_failure(C2Compiler::retry_no_escape_analysis());
 // (reflection allocation), the object can't be restored during
 // deoptimization without precise type.
 continue;
 }
 }
+const TypeOopPtr *t = igvn->type(n)->isa_oopptr();
+if (t == NULL)
+continue;  // not a TypeOopPtr
+if (!t->klass_is_exact())
+continue; // not an unique type
 if (alloc->is_Allocate()) {
 // Set the scalar_replaceable flag for allocation
 // so it could be eliminated.
 alloc->as_Allocate()->_is_scalar_replaceable = true;
 }
 //   - non-escaping
 //   - eligible to be a unique type
 //   - not determined to be ineligible by escape analysis
 set_map(alloc, n);
 set_map(n, alloc);
-const TypeOopPtr *t = igvn->type(n)->isa_oopptr();
+const TypeOopPtr* tinst = t->cast_to_instance_id(ni);
-if (t == NULL)
-continue;  // not a TypeOopPtr
-const TypeOopPtr* tinst = t->cast_to_exactness(true)->is_oopptr()->cast_to_instance_id(ni);
 igvn->hash_delete(n);
 igvn->set_type(n,  tinst);
 n->raise_bottom_type(tinst);
 igvn->hash_insert(n);
 record_for_optimizer(n);

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/opto/escape.cpp @ 20804:7848fc12602b