reference_counting.h

Go to the documentation of this file.

// Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
 
#ifndef RUNTIME_BIN_REFERENCE_COUNTING_H_
#define RUNTIME_BIN_REFERENCE_COUNTING_H_
 
#include <atomic>
 
#include "platform/assert.h"
 
namespace dart {
namespace bin {
 
// Forward declaration.
template <class Target>
class RefCntReleaseScope;
 
// Inherit from this class where instances of the derived class should be
// reference counted. Reference counts on instances are incremented and
// decremented explicitly with calls to Retain() and Release(). E.g.:
//
// class Foo : public ReferenceCounted<Foo> {
//  public:
//   Foo() : ReferenceCounted() {}
//   ...
// };
//
// void DoStuffWithAFoo() {
//   Foo* foo = new Foo();  // Reference count starts at 1, so no explicit
//                          // call to Retain is needed after allocation.
//   ...
//   foo->Release();
// }
template <class Derived>
class ReferenceCounted {
 public:
  ReferenceCounted() : ref_count_(1) {
#if defined(DEBUG)
    instances_.fetch_add(1u, std::memory_order_relaxed);
#endif  // defined(DEBUG)
  }
 
  virtual ~ReferenceCounted() {
    ASSERT(ref_count_ == 0);
#if defined(DEBUG)
    instances_.fetch_sub(1u, std::memory_order_relaxed);
#endif  // defined(DEBUG)
  }
 
  void Retain() {
    intptr_t old = ref_count_.fetch_add(1u, std::memory_order_relaxed);
    ASSERT(old > 0);
  }
 
  void Release() {
    intptr_t old = ref_count_.fetch_sub(1u, std::memory_order_acq_rel);
    ASSERT(old > 0);
    if (old == 1) {
      delete static_cast<Derived*>(this);
    }
  }
 
#if defined(DEBUG)
  static intptr_t instances() {
    return instances_.load(std::memory_order_relaxed);
  }
#endif  // defined(DEBUG)
 
 private:
#if defined(DEBUG)
  static std::atomic<intptr_t> instances_;
#endif  // defined(DEBUG)
 
  std::atomic<intptr_t> ref_count_;
 
  // These are used only in the ASSERT below in RefCntReleaseScope.
  intptr_t ref_count() const {
    return ref_count_.load(std::memory_order_relaxed);
  }
  friend class RefCntReleaseScope<Derived>;
  DISALLOW_COPY_AND_ASSIGN(ReferenceCounted);
};
 
#if defined(DEBUG)
template <class Derived>
std::atomic<intptr_t> ReferenceCounted<Derived>::instances_ = {0};
#endif
 
// Creates a scope at the end of which a reference counted object is
// Released. This is useful for reference counted objects received by the IO
// Service, which have already been Retained E.g.:
//
// CObject* Foo::FooRequest(const CObjectArray& request) {
//   Foo* foo = CObjectToFoo(request[0]);
//   RefCntReleaseScope<Foo> rs(foo);
//   ...
// }
template <class Target>
class RefCntReleaseScope {
 public:
  explicit RefCntReleaseScope(ReferenceCounted<Target>* t) : target_(t) {
    ASSERT(target_ != nullptr);
    ASSERT(target_->ref_count() > 0);
  }
  ~RefCntReleaseScope() { target_->Release(); }
 
 private:
  ReferenceCounted<Target>* target_;
 
  DISALLOW_ALLOCATION();
  DISALLOW_COPY_AND_ASSIGN(RefCntReleaseScope);
};
 
// Instances of RetainedPointer manage Retaining and Releasing reference counted
// objects. There are two ways to use it. First, it can be used as a field in
// a class, e.g.:
//
// class Foo {
//  private:
//   RetainedPointer<Bar> bar_;
//  public:
//   explicit Foo(Bar* b) : bar_(b) {}
// }
//
// In this case, b will be Retained in Foo's constructor, and Released
// automatically during Foo's destructor.
//
// RetainedPointer can also be used as a scope, as with RefCntReleaseScope,
// with the difference that entering the scope also Retains the pointer, e.g.:
//
// void RetainAndDoStuffWithFoo(Foo* foo) {
//   RetainedPointer<Foo> retained(foo);
//   ..
// }
//
// This Retains foo on entry and Releases foo at every exit from the scope.
//
// The underlying pointer can be accessed with the get() and set() methods.
// Overwriting a non-null pointer with set causes that pointer to be Released.
template <class Target>
class RetainedPointer {
 public:
  RetainedPointer() : target_(nullptr) {}
 
  explicit RetainedPointer(ReferenceCounted<Target>* t) : target_(t) {
    if (target_ != nullptr) {
      target_->Retain();
    }
  }
 
  ~RetainedPointer() {
    if (target_ != nullptr) {
      target_->Release();
    }
  }
 
  void set(ReferenceCounted<Target>* t) {
    if (target_ != nullptr) {
      target_->Release();
    }
    target_ = t;
    if (target_ != nullptr) {
      target_->Retain();
    }
  }
 
  Target* get() const { return static_cast<Target*>(target_); }
 
 private:
  ReferenceCounted<Target>* target_;
 
  DISALLOW_ALLOCATION();
  DISALLOW_COPY_AND_ASSIGN(RetainedPointer);
};
 
}  // namespace bin
}  // namespace dart
 
#endif  // RUNTIME_BIN_REFERENCE_COUNTING_H_