nb/analytics/memory_tracker_test.cc

/*
 * Copyright 2016 Google Inc. All Rights Reserved.
 *
 * 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
 *
 *     http://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.
 */

#include "nb/analytics/memory_tracker.h"
#include "nb/analytics/memory_tracker_helpers.h"
#include "nb/memory_scope.h"
#include "nb/scoped_ptr.h"
#include "starboard/memory.h"
#include "starboard/memory_reporter.h"
#include "starboard/thread.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace nb {
namespace analytics {
namespace {

MemoryTracker* s_memory_tracker_ = NULL;

struct NoMemTracking {
  bool prev_val;
  NoMemTracking() : prev_val(false) {
    if (s_memory_tracker_) {
      prev_val = s_memory_tracker_->IsMemoryTrackingEnabled();
      s_memory_tracker_->SetMemoryTrackingEnabled(false);
    }
  }
  ~NoMemTracking() {
    if (s_memory_tracker_) {
      s_memory_tracker_->SetMemoryTrackingEnabled(prev_val);
    }
  }
};

// EXPECT_XXX and ASSERT_XXX allocate memory, a big no-no when
// for unit testing allocations. These overrides disable memory
// tracking for the duration of the EXPECT and ASSERT operations.
#define EXPECT_EQ_NO_TRACKING(A, B)                 \
  {                                                 \
    NoMemTracking no_memory_tracking_in_this_scope; \
    EXPECT_EQ(A, B);                                \
  }

#define EXPECT_TRUE_NO_TRACKING(A)                  \
  {                                                 \
    NoMemTracking no_memory_tracking_in_this_scope; \
    EXPECT_TRUE(A);                                 \
  }

#define EXPECT_FALSE_NO_TRACKING(A)                 \
  {                                                 \
    NoMemTracking no_memory_tracking_in_this_scope; \
    EXPECT_FALSE(A);                                \
  }

#define ASSERT_TRUE_NO_TRACKING(A)                  \
  {                                                 \
    NoMemTracking no_memory_tracking_in_this_scope; \
    ASSERT_TRUE(A);                                 \
  }

///////////////////////////////////////////////////////////////////////////////
// Framework which initializes the MemoryTracker once and installs it
// for the first test and the removes the MemoryTracker after the
// the last test finishes.
class MemoryTrackerTest : public ::testing::Test {
 public:
  MemoryTrackerTest() {}

  MemoryTracker* memory_tracker() { return s_memory_tracker_; }

  bool GetAllocRecord(void* alloc_memory, AllocationRecord* output) {
    return memory_tracker()->GetMemoryTracking(alloc_memory, output);
  }

  int64_t TotalNumberOfAllocations() {
    return memory_tracker()->GetTotalNumberOfAllocations();
  }

  int64_t TotalAllocationBytes() {
    return memory_tracker()->GetTotalAllocationBytes();
  }

  bool MemoryTrackerEnabled() const { return s_memory_tracker_enabled_; }

 protected:
  static void SetUpTestCase() {
    s_memory_tracker_ = MemoryTracker::Get();
    s_memory_tracker_enabled_ = s_memory_tracker_->InstallGlobalTrackingHooks();
  }
  static void TearDownTestCase() {
    s_memory_tracker_->RemoveGlobalTrackingHooks();
    // Give time for all threads to sync up to the fact that the memory tracker
    // has been removed.
    SbThreadSleep(50 * kSbTimeMillisecond);
  }
  static bool s_memory_tracker_enabled_;
};
bool MemoryTrackerTest::s_memory_tracker_enabled_ = false;

///////////////////////////////////////////////////////////////////////////////
class FindAllocationVisitor : public AllocationVisitor {
 public:
  FindAllocationVisitor() : found_(false), memory_to_find_(NULL) {}

  bool found() const { return found_; }
  void set_found(bool val) { found_ = val; }
  void set_memory_to_find(const void* memory) {
    memory_to_find_ = memory;
    found_ = false;
  }

  virtual bool Visit(const void* memory, const AllocationRecord& alloc_record) {
    if (memory_to_find_ == memory) {
      found_ = true;
      return false;
    }
    return true;
  }

 private:
  bool found_;
  const void* memory_to_find_;
};

///////////////////////////////////////////////////////////////////////////////
TEST_F(MemoryTrackerTest, MacrosScopedObject) {
  // Memory tracker is not enabled for this build.
  if (!MemoryTrackerEnabled()) {
    return;
  }

  scoped_ptr<int> alloc_a, alloc_b;
  {
    TRACK_MEMORY_SCOPE("MemoryTrackerTest-ScopeA");
    alloc_a.reset(new int());
    {
      TRACK_MEMORY_SCOPE("MemoryTrackerTest-ScopeB");
      alloc_b.reset(new int());
    }
  }

  // Now test that the allocations now exist in the memory tracker.
  AllocationRecord alloc_record_a, alloc_record_b;
  // Expect that the allocations exist and that the AllocRecords are written
  // with the allocation information.
  EXPECT_TRUE_NO_TRACKING(
      memory_tracker()->GetMemoryTracking(alloc_a.get(), &alloc_record_a));
  EXPECT_TRUE_NO_TRACKING(
      memory_tracker()->GetMemoryTracking(alloc_b.get(), &alloc_record_b));

  // Sanity test that the allocations are non-null.

  const AllocationGroup* group_a = alloc_record_a.allocation_group;
  const AllocationGroup* group_b = alloc_record_b.allocation_group;
  ASSERT_TRUE_NO_TRACKING(group_a);
  ASSERT_TRUE_NO_TRACKING(group_b);

  EXPECT_EQ_NO_TRACKING(group_a->name(),
                        std::string("MemoryTrackerTest-ScopeA"));
  EXPECT_EQ_NO_TRACKING(group_b->name(),
                        std::string("MemoryTrackerTest-ScopeB"));

  // When the allocation is returned to the free store then it's expected that
  // the memory tracker will indicate that the allocation no longer exists.
  alloc_a.reset();
  alloc_b.reset();

  EXPECT_FALSE_NO_TRACKING(
      memory_tracker()->GetMemoryTracking(alloc_a.get(), &alloc_record_a));
  EXPECT_FALSE_NO_TRACKING(
      memory_tracker()->GetMemoryTracking(alloc_b.get(), &alloc_record_b));

  int32_t num_allocations = -1;
  int64_t allocation_bytes = -1;

  group_a->GetAggregateStats(&num_allocations, &allocation_bytes);
  EXPECT_EQ_NO_TRACKING(0, num_allocations);
  EXPECT_EQ_NO_TRACKING(0, allocation_bytes);

  group_b->GetAggregateStats(&num_allocations, &allocation_bytes);
  EXPECT_EQ_NO_TRACKING(0, num_allocations);
  EXPECT_EQ_NO_TRACKING(0, allocation_bytes);
}

///////////////////////////////////////////////////////////////////////////////
TEST_F(MemoryTrackerTest, Visitor) {
  // Memory tracker is not enabled for this build.
  if (!MemoryTrackerEnabled()) {
    return;
  }

  FindAllocationVisitor visitor;

  scoped_ptr<int> alloc_a;
  {
    TRACK_MEMORY_SCOPE("MemoryTrackerTest-ScopeA");

    alloc_a.reset(new int());
    visitor.set_memory_to_find(alloc_a.get());
    memory_tracker()->Accept(&visitor);
    EXPECT_TRUE_NO_TRACKING(visitor.found());

    alloc_a.reset(NULL);
    visitor.set_found(false);
    memory_tracker()->Accept(&visitor);
    EXPECT_FALSE_NO_TRACKING(visitor.found());
  }
}

}  // namespace
}  // namespace analytics
}  // namespace nb