heap_tracer.h

Go to the documentation of this file.

// Copyright 2016 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef SHAKA_EMBEDDED_MEMORY_HEAP_TRACER_H_
#define SHAKA_EMBEDDED_MEMORY_HEAP_TRACER_H_

#include <glog/logging.h>

#include <list>
#include <string>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <vector>

#include "shaka/optional.h"
#include "shaka/variant.h"
#include "src/debug/mutex.h"
#include "src/util/templates.h"

namespace shaka {
class BackingObject;

namespace memory {
class HeapTracer;

class Traceable {
 public:
  static constexpr const uint64_t kShortLiveDurationMs = 5000;


  virtual ~Traceable() {}

  virtual void Trace(HeapTracer* tracer) const = 0;

  virtual bool IsRootedAlive() const;

  virtual bool IsShortLived() const;
};


class HeapTracer {
 public:
  HeapTracer();
  ~HeapTracer();

  const std::unordered_set<const Traceable*>& alive() const {
    return alive_;
  }

  void ForceAlive(const Traceable* ptr);

  void Trace(const Traceable* ptr);

  template <typename T>
  void Trace(const std::vector<T>* array) {
    for (const T& item : *array) {
      Trace(&item);
    }
  }
  template <typename T>
  void Trace(const std::list<T>* array) {
    for (const T& item : *array) {
      Trace(&item);
    }
  }
  template <typename Key, typename Value>
  void Trace(const std::unordered_map<Key, Value>* map) {
    for (const auto& pair : *map) {
      Trace(&pair.first);
      Trace(&pair.second);
    }
  }
  template <typename T>
  void Trace(const optional<T>* opt) {
    if (opt->has_value())
      Trace(&opt->value());
  }
  template <typename... Types>
  void Trace(const variant<Types...>* variant) {
    VariantHelper<0, Types...>::Trace(this, variant);
  }

  // Allow passing other types, just ignore it.  This simplifies generic
  // converter templates so they don't have to check if the type is special
  // or not.
  void Trace(const std::string*) {}
  void Trace(const bool*) {}
  template <typename T,
            typename = util::enable_if_t<util::is_number<T>::value ||
                                         std::is_enum<T>::value>>
  void Trace(const T*) {}

  void BeginPass();

  void TraceAll(const std::unordered_set<const Traceable*>& ref_alive);

  void ResetState();

 private:
  template <size_t I, typename... Types>
  struct VariantHelper {
    static void Trace(HeapTracer* tracer, const variant<Types...>* variant) {
      if (variant->index() == I)
        tracer->Trace(&get<I>(*variant));
      else
        VariantHelper<I + 1, Types...>::Trace(tracer, variant);
    }
  };
  template <typename... Types>
  struct VariantHelper<sizeof...(Types), Types...> {
    static void Trace(HeapTracer* tracer, const variant<Types...>* variant) {
      CHECK_EQ(variant->index(), sizeof...(Types) - 1);
      tracer->Trace(&get<sizeof...(Types) - 1>(*variant));
    }
  };

  Mutex mutex_;
  std::unordered_set<const Traceable*> alive_;
  std::unordered_set<const Traceable*> pending_;
};

}  // namespace memory
}  // namespace shaka

#endif  // SHAKA_EMBEDDED_MEMORY_HEAP_TRACER_H_