dart::RetainingPath Class Reference

Public Member Functions
	RetainingPath (Zone *zone, Isolate *isolate, const Object &from, const Object &to, TraversalRules traversal_rules)
	~RetainingPath ()
bool	WasVisited (ObjectPtr object)
void	MarkVisited (ObjectPtr object)
const char *	FindPath ()

Detailed Description

Definition at line 897 of file object_graph_copy.cc.

Constructor & Destructor Documentation

RetainingPath()

dart::RetainingPath::RetainingPath ( Zone *  zone, Isolate *  isolate, const Object &  from, const Object &  to, TraversalRules  traversal_rules  )

inline

Definition at line 949 of file object_graph_copy.cc.

      : zone_(zone),
        isolate_(isolate),
        from_(from),
        to_(to),
        traversal_rules_(traversal_rules) {
    isolate_->set_forward_table_new(new WeakTable());
    isolate_->set_forward_table_old(new WeakTable());
  }

~RetainingPath()

dart::RetainingPath::~RetainingPath ( )

inline

Definition at line 963 of file object_graph_copy.cc.

                   {
    isolate_->set_forward_table_new(nullptr);
    isolate_->set_forward_table_old(nullptr);
  }

Member Function Documentation

FindPath()

const char * dart::RetainingPath::FindPath ( )

inline

Definition at line 984 of file object_graph_copy.cc.

                         {
    MallocGrowableArray<ObjectPtr>* const working_list =
        isolate_->pointers_to_verify_at_exit();
    ASSERT(working_list->length() == 0);
 
    Visitor visitor(isolate_->group(), this, working_list, traversal_rules_);
 
    MarkVisited(from_.ptr());
    working_list->Add(from_.ptr());
 
    Thread* thread = Thread::Current();
    ClassTable* class_table = isolate_->group()->class_table();
    Closure& closure = Closure::Handle(zone_);
    Array& array = Array::Handle(zone_);
    Class& klass = Class::Handle(zone_);
 
    while (!working_list->is_empty()) {
      thread->CheckForSafepoint();
 
      // Keep node in the list, separated by null value so that
      // if we are to add children, children can find it in case
      // they are on retaining path.
      ObjectPtr raw = working_list->Last();
      if (raw == Object::null()) {
        // If all children of a node were processed, then skip the separator,
        working_list->RemoveLast();
        // then skip the parent since it has already been processed too.
        working_list->RemoveLast();
        continue;
      }
 
      if (raw == to_.ptr()) {
        return CollectPath(working_list);
      }
 
      // Separator null object indicates children goes next in the working_list
      working_list->Add(Object::null());
      int length = working_list->length();
 
      do {  // This loop is here so that we can skip children processing
        const intptr_t cid = raw->GetClassId();
 
        if (traversal_rules_ == TraversalRules::kInternalToIsolateGroup) {
          if (CanShareObjectAcrossIsolates(raw)) {
            break;
          }
          if (cid == kClosureCid) {
            closure ^= raw;
            // Only context has to be checked.
            working_list->Add(closure.RawContext());
            break;
          }
          // These we are not expected to drill into as they can't be on
          // retaining path, they are illegal to send.
          klass = class_table->At(cid);
          if (klass.is_isolate_unsendable()) {
            break;
          }
        } else {
          ASSERT(traversal_rules_ ==
                 TraversalRules::kExternalBetweenIsolateGroups);
          // Skip classes that are illegal to send across isolate groups.
          // (keep the list in sync with message_snapshot.cc)
          bool skip = false;
          switch (cid) {
            case kClosureCid:
            case kFinalizerCid:
            case kFinalizerEntryCid:
            case kFunctionTypeCid:
            case kMirrorReferenceCid:
            case kNativeFinalizerCid:
            case kReceivePortCid:
            case kRecordCid:
            case kRecordTypeCid:
            case kRegExpCid:
            case kStackTraceCid:
            case kSuspendStateCid:
            case kUserTagCid:
            case kWeakPropertyCid:
            case kWeakReferenceCid:
            case kWeakArrayCid:
            case kDynamicLibraryCid:
            case kPointerCid:
            case kInstanceCid:
              skip = true;
              break;
            default:
              if (cid >= kNumPredefinedCids) {
                skip = true;
              }
          }
          if (skip) {
            break;
          }
        }
        if (cid == kArrayCid) {
          array ^= Array::RawCast(raw);
          visitor.VisitObject(array.GetTypeArguments());
          const intptr_t batch_size = (2 << 14) - 1;
          for (intptr_t i = 0; i < array.Length(); ++i) {
            ObjectPtr ptr = array.At(i);
            visitor.VisitObject(ptr);
            if ((i & batch_size) == batch_size) {
              thread->CheckForSafepoint();
            }
          }
          break;
        } else {
          raw->untag()->VisitPointers(&visitor);
        }
      } while (false);
 
      // If no children were added, remove null separator and the node.
      // If children were added, the node will be removed once last child
      // is processed, only separator null remains.
      if (working_list->length() == length) {
        RELEASE_ASSERT(working_list->RemoveLast() == Object::null());
        RELEASE_ASSERT(working_list->RemoveLast() == raw);
      }
    }
    // `to` was not found in the graph rooted in `from`, empty retaining path
    return "";
  }

MarkVisited()

void dart::RetainingPath::MarkVisited ( ObjectPtr  object )

inline

Definition at line 976 of file object_graph_copy.cc.

                                     {
    if (object->IsNewObject()) {
      isolate_->forward_table_new()->SetValueExclusive(object, 1);
    } else {
      isolate_->forward_table_old()->SetValueExclusive(object, 1);
    }
  }

WasVisited()

bool dart::RetainingPath::WasVisited ( ObjectPtr  object )

inline

Definition at line 968 of file object_graph_copy.cc.

                                    {
    if (object->IsNewObject()) {
      return isolate_->forward_table_new()->GetValueExclusive(object) != 0;
    } else {
      return isolate_->forward_table_old()->GetValueExclusive(object) != 0;
    }
  }

---

The documentation for this class was generated from the following file:

• third_party/dart-lang/sdk/runtime/vm/object_graph_copy.cc