801d5a056d
- Take HeapHandle& parameter to allow a use case of free() on an already dead object during sweeping. - Change free() from T* to T& which forces an object and allows the caller to place the nullptr check before retrieving a heap handle. Bug: chromium:1056170 Change-Id: I80689d27d3abe410d177cd8c86b31ff2fe579a77 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2874461 Commit-Queue: Michael Lippautz <mlippautz@chromium.org> Reviewed-by: Omer Katz <omerkatz@chromium.org> Cr-Commit-Position: refs/heads/master@{#74387}
127 lines
3.8 KiB
C++
127 lines
3.8 KiB
C++
// Copyright 2020 the V8 project authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
#ifndef V8_UNITTESTS_HEAP_CPPGC_TESTS_H_
|
|
#define V8_UNITTESTS_HEAP_CPPGC_TESTS_H_
|
|
|
|
#include "include/cppgc/heap-consistency.h"
|
|
#include "include/cppgc/heap.h"
|
|
#include "include/cppgc/platform.h"
|
|
#include "src/heap/cppgc/heap.h"
|
|
#include "src/heap/cppgc/trace-event.h"
|
|
#include "test/unittests/heap/cppgc/test-platform.h"
|
|
#include "testing/gtest/include/gtest/gtest.h"
|
|
|
|
namespace cppgc {
|
|
namespace internal {
|
|
namespace testing {
|
|
class DelegatingTracingController : public TracingController {
|
|
public:
|
|
#if !defined(V8_USE_PERFETTO)
|
|
const uint8_t* GetCategoryGroupEnabled(const char* name) override {
|
|
static uint8_t yes = 1;
|
|
return &yes;
|
|
}
|
|
|
|
uint64_t AddTraceEvent(
|
|
char phase, const uint8_t* category_enabled_flag, const char* name,
|
|
const char* scope, uint64_t id, uint64_t bind_id, int32_t num_args,
|
|
const char** arg_names, const uint8_t* arg_types,
|
|
const uint64_t* arg_values,
|
|
std::unique_ptr<ConvertableToTraceFormat>* arg_convertables,
|
|
unsigned int flags) override {
|
|
return tracing_controller_->AddTraceEvent(
|
|
phase, category_enabled_flag, name, scope, id, bind_id, num_args,
|
|
arg_names, arg_types, arg_values, arg_convertables, flags);
|
|
}
|
|
#endif // !defined(V8_USE_PERFETTO)
|
|
|
|
void SetTracingController(
|
|
std::unique_ptr<TracingController> tracing_controller_impl) {
|
|
tracing_controller_ = std::move(tracing_controller_impl);
|
|
}
|
|
|
|
private:
|
|
std::unique_ptr<TracingController> tracing_controller_ =
|
|
std::make_unique<TracingController>();
|
|
};
|
|
|
|
class TestWithPlatform : public ::testing::Test {
|
|
protected:
|
|
static void SetUpTestSuite();
|
|
static void TearDownTestSuite();
|
|
|
|
TestPlatform& GetPlatform() const { return *platform_; }
|
|
|
|
std::shared_ptr<TestPlatform> GetPlatformHandle() const { return platform_; }
|
|
|
|
void SetTracingController(
|
|
std::unique_ptr<TracingController> tracing_controller_impl) {
|
|
static_cast<DelegatingTracingController*>(platform_->GetTracingController())
|
|
->SetTracingController(std::move(tracing_controller_impl));
|
|
}
|
|
|
|
protected:
|
|
static std::shared_ptr<TestPlatform> platform_;
|
|
};
|
|
|
|
class TestWithHeap : public TestWithPlatform {
|
|
protected:
|
|
TestWithHeap();
|
|
|
|
void PreciseGC() {
|
|
heap_->ForceGarbageCollectionSlow(
|
|
::testing::UnitTest::GetInstance()->current_test_info()->name(),
|
|
"Testing", cppgc::Heap::StackState::kNoHeapPointers);
|
|
}
|
|
|
|
void ConservativeGC() {
|
|
heap_->ForceGarbageCollectionSlow(
|
|
::testing::UnitTest::GetInstance()->current_test_info()->name(),
|
|
"Testing", cppgc::Heap::StackState::kMayContainHeapPointers);
|
|
}
|
|
|
|
cppgc::Heap* GetHeap() const { return heap_.get(); }
|
|
|
|
cppgc::AllocationHandle& GetAllocationHandle() const {
|
|
return allocation_handle_;
|
|
}
|
|
|
|
cppgc::HeapHandle& GetHeapHandle() const {
|
|
return GetHeap()->GetHeapHandle();
|
|
}
|
|
|
|
std::unique_ptr<MarkerBase>& GetMarkerRef() {
|
|
return Heap::From(GetHeap())->marker_;
|
|
}
|
|
|
|
const std::unique_ptr<MarkerBase>& GetMarkerRef() const {
|
|
return Heap::From(GetHeap())->marker_;
|
|
}
|
|
|
|
void ResetLinearAllocationBuffers();
|
|
|
|
private:
|
|
std::unique_ptr<cppgc::Heap> heap_;
|
|
cppgc::AllocationHandle& allocation_handle_;
|
|
};
|
|
|
|
// Restrictive test fixture that supports allocation but will make sure no
|
|
// garbage collection is triggered. This is useful for writing idiomatic
|
|
// tests where object are allocated on the managed heap while still avoiding
|
|
// far reaching test consequences of full garbage collection calls.
|
|
class TestSupportingAllocationOnly : public TestWithHeap {
|
|
protected:
|
|
TestSupportingAllocationOnly();
|
|
|
|
private:
|
|
subtle::NoGarbageCollectionScope no_gc_scope_;
|
|
};
|
|
|
|
} // namespace testing
|
|
} // namespace internal
|
|
} // namespace cppgc
|
|
|
|
#endif // V8_UNITTESTS_HEAP_CPPGC_TESTS_H_
|