truffle: src/share/vm/opto/escape.cpp comparison

comparison src/share/vm/opto/escape.cpp @ 20585:90297adbda9d

8041984: CompilerThread seems to occupy all CPU in a very rare situation Summary: Add new timeout checks to EA. Reviewed-by: iveresov, drchase

author	kvn
date	Fri, 24 Oct 2014 10:28:19 -0700
parents	87f199a9c1b1
children	9e69e8d1c900

comparison

equal deleted inserted replaced

-:ef9eda2c1abe
+:90297adbda9d
 #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
 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();
+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.

Mercurial > hg > truffle

comparison src/share/vm/opto/escape.cpp @ 20585:90297adbda9d