< prev index next >

src/share/vm/jfr/leakprofiler/chains/edgeUtils.cpp

Print this page
rev 9055 : 8214542: JFR: Old Object Sample event slow on a deep heap in debug builds
Reviewed-by: egahlin, rwestberg

*** 1,7 **** /* ! * Copyright (c) 2014, 2018, 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. --- 1,7 ---- /* ! * Copyright (c) 2014, 2019, 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.
*** 36,50 **** bool EdgeUtils::is_leak_edge(const Edge& edge) { return (const Edge*)edge.pointee()->mark() == &edge; } ! bool EdgeUtils::is_root(const Edge& edge) { ! return edge.is_root(); ! } ! ! static int field_offset(const Edge& edge) { assert(!edge.is_root(), "invariant"); const oop ref_owner = edge.reference_owner(); assert(ref_owner != NULL, "invariant"); const oop* reference = UnifiedOop::decode(edge.reference()); assert(reference != NULL, "invariant"); --- 36,46 ---- bool EdgeUtils::is_leak_edge(const Edge& edge) { return (const Edge*)edge.pointee()->mark() == &edge; } ! static int field_offset(const StoredEdge& edge) { assert(!edge.is_root(), "invariant"); const oop ref_owner = edge.reference_owner(); assert(ref_owner != NULL, "invariant"); const oop* reference = UnifiedOop::decode(edge.reference()); assert(reference != NULL, "invariant");
*** 54,64 **** const int offset = (int)pointer_delta(reference, ref_owner, sizeof(char)); assert(offset < (ref_owner->size() * HeapWordSize), "invariant"); return offset; } ! static const InstanceKlass* field_type(const Edge& edge) { assert(!edge.is_root() || !EdgeUtils::is_array_element(edge), "invariant"); return (const InstanceKlass*)edge.reference_owner_klass(); } const Symbol* EdgeUtils::field_name_symbol(const Edge& edge) { --- 50,60 ---- const int offset = (int)pointer_delta(reference, ref_owner, sizeof(char)); assert(offset < (ref_owner->size() * HeapWordSize), "invariant"); return offset; } ! static const InstanceKlass* field_type(const StoredEdge& edge) { assert(!edge.is_root() || !EdgeUtils::is_array_element(edge), "invariant"); return (const InstanceKlass*)edge.reference_owner_klass(); } const Symbol* EdgeUtils::field_name_symbol(const Edge& edge) {
*** 136,312 **** const Edge* parent = current->parent(); while (parent != NULL) { current = parent; parent = current->parent(); } return current; } ! // The number of references associated with the leak node; ! // can be viewed as the leak node "context". ! // Used to provide leak context for a "capped/skipped" reference chain. ! static const size_t leak_context = 100; ! ! // The number of references associated with the root node; ! // can be viewed as the root node "context". ! // Used to provide root context for a "capped/skipped" reference chain. ! static const size_t root_context = 100; ! ! // A limit on the reference chain depth to be serialized, ! static const size_t max_ref_chain_depth = leak_context + root_context; ! ! const RoutableEdge* skip_to(const RoutableEdge& edge, size_t skip_length) { ! const RoutableEdge* current = &edge; ! const RoutableEdge* parent = current->physical_parent(); size_t seek = 0; ! while (parent != NULL && seek != skip_length) { seek++; current = parent; ! parent = parent->physical_parent(); ! } ! return current; ! } ! ! #ifdef ASSERT ! static void validate_skip_target(const RoutableEdge* skip_target) { ! assert(skip_target != NULL, "invariant"); ! assert(skip_target->distance_to_root() + 1 == root_context, "invariant"); ! assert(skip_target->is_sentinel(), "invariant"); ! } ! ! static void validate_new_skip_edge(const RoutableEdge* new_skip_edge, const RoutableEdge* last_skip_edge, size_t adjustment) { ! assert(new_skip_edge != NULL, "invariant"); ! assert(new_skip_edge->is_skip_edge(), "invariant"); ! if (last_skip_edge != NULL) { ! const RoutableEdge* const target = skip_to(*new_skip_edge->logical_parent(), adjustment); ! validate_skip_target(target->logical_parent()); ! return; } - assert(last_skip_edge == NULL, "invariant"); - // only one level of logical indirection - validate_skip_target(new_skip_edge->logical_parent()); - } - #endif // ASSERT - - static void install_logical_route(const RoutableEdge* new_skip_edge, size_t skip_target_distance) { - assert(new_skip_edge != NULL, "invariant"); - assert(!new_skip_edge->is_skip_edge(), "invariant"); - assert(!new_skip_edge->processed(), "invariant"); - const RoutableEdge* const skip_target = skip_to(*new_skip_edge, skip_target_distance); - assert(skip_target != NULL, "invariant"); - new_skip_edge->set_skip_edge(skip_target); - new_skip_edge->set_skip_length(skip_target_distance); - assert(new_skip_edge->is_skip_edge(), "invariant"); - assert(new_skip_edge->logical_parent() == skip_target, "invariant"); - } - - static const RoutableEdge* find_last_skip_edge(const RoutableEdge& edge, size_t& distance) { - assert(distance == 0, "invariant"); - const RoutableEdge* current = &edge; - while (current != NULL) { - if (current->is_skip_edge() && current->skip_edge()->is_sentinel()) { return current; - } - current = current->physical_parent(); - ++distance; - } - return current; - } - - static void collapse_overlapping_chain(const RoutableEdge& edge, - const RoutableEdge* first_processed_edge, - size_t first_processed_distance) { - assert(first_processed_edge != NULL, "invariant"); - // first_processed_edge is already processed / written - assert(first_processed_edge->processed(), "invariant"); - assert(first_processed_distance + 1 <= leak_context, "invariant"); - - // from this first processed edge, attempt to fetch the last skip edge - size_t last_skip_edge_distance = 0; - const RoutableEdge* const last_skip_edge = find_last_skip_edge(*first_processed_edge, last_skip_edge_distance); - const size_t distance_discovered = first_processed_distance + last_skip_edge_distance + 1; - - if (distance_discovered <= leak_context || (last_skip_edge == NULL && distance_discovered <= max_ref_chain_depth)) { - // complete chain can be accommodated without modification - return; - } - - // backtrack one edge from existing processed edge - const RoutableEdge* const new_skip_edge = skip_to(edge, first_processed_distance - 1); - assert(new_skip_edge != NULL, "invariant"); - assert(!new_skip_edge->processed(), "invariant"); - assert(new_skip_edge->parent() == first_processed_edge, "invariant"); - - size_t adjustment = 0; - if (last_skip_edge != NULL) { - assert(leak_context - 1 > first_processed_distance - 1, "invariant"); - adjustment = leak_context - first_processed_distance - 1; - assert(last_skip_edge_distance + 1 > adjustment, "invariant"); - install_logical_route(new_skip_edge, last_skip_edge_distance + 1 - adjustment); - } else { - install_logical_route(new_skip_edge, last_skip_edge_distance + 1 - root_context); - new_skip_edge->logical_parent()->set_skip_length(1); // sentinel - } - - DEBUG_ONLY(validate_new_skip_edge(new_skip_edge, last_skip_edge, adjustment);) - } - - static void collapse_non_overlapping_chain(const RoutableEdge& edge, - const RoutableEdge* first_processed_edge, - size_t first_processed_distance) { - assert(first_processed_edge != NULL, "invariant"); - assert(!first_processed_edge->processed(), "invariant"); - // this implies that the first "processed" edge is the leak context relative "leaf" - assert(first_processed_distance + 1 == leak_context, "invariant"); - - const size_t distance_to_root = edge.distance_to_root(); - if (distance_to_root + 1 <= max_ref_chain_depth) { - // complete chain can be accommodated without constructing a skip edge - return; - } - - install_logical_route(first_processed_edge, distance_to_root + 1 - first_processed_distance - root_context); - first_processed_edge->logical_parent()->set_skip_length(1); // sentinel - - DEBUG_ONLY(validate_new_skip_edge(first_processed_edge, NULL, 0);) - } - - static const RoutableEdge* processed_edge(const RoutableEdge& edge, size_t& distance) { - assert(distance == 0, "invariant"); - const RoutableEdge* current = &edge; - while (current != NULL && distance < leak_context - 1) { - if (current->processed()) { - return current; - } - current = current->physical_parent(); - ++distance; - } - assert(distance <= leak_context - 1, "invariant"); - return current; - } - - /* - * Some vocabulary: - * ----------- - * "Context" is an interval in the chain, it is associcated with an edge and it signifies a number of connected edges. - * "Processed / written" means an edge that has already been serialized. - * "Skip edge" is an edge that contains additional information for logical routing purposes. - * "Skip target" is an edge used as a destination for a skip edge - */ - void EdgeUtils::collapse_chain(const RoutableEdge& edge) { - assert(is_leak_edge(edge), "invariant"); - - // attempt to locate an already processed edge inside current leak context (if any) - size_t first_processed_distance = 0; - const RoutableEdge* const first_processed_edge = processed_edge(edge, first_processed_distance); - if (first_processed_edge == NULL) { - return; - } - - if (first_processed_edge->processed()) { - collapse_overlapping_chain(edge, first_processed_edge, first_processed_distance); - } else { - collapse_non_overlapping_chain(edge, first_processed_edge, first_processed_distance); - } - - assert(edge.logical_distance_to_root() + 1 <= max_ref_chain_depth, "invariant"); } --- 132,151 ---- const Edge* parent = current->parent(); while (parent != NULL) { current = parent; parent = current->parent(); } + assert(current != NULL, "invariant"); return current; } ! const Edge* EdgeUtils::ancestor(const Edge& edge, size_t distance) { ! const Edge* current = &edge; ! const Edge* parent = current->parent(); size_t seek = 0; ! while (parent != NULL && seek != distance) { seek++; current = parent; ! parent = parent->parent(); } return current; }
< prev index next >