azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[K/N] Add cms related targets and compiler option

Browse Source
This commit is contained in:
Pavel Kunyavskiy
2021-11-23 11:55:06 +03:00
committed by Space
parent 03299023f1
commit df4b367296
8 changed files with 119 additions and 56 deletions
Download Patch File Download Diff File Expand all files Collapse all files
kotlin-native/backend.native/cli.bc/src/org/jetbrains/kotlin/cli/bc/K2Native.kt
+4
View File
@@ -315,6 +315,10 @@ class K2Native : CLICompiler<K2NativeCompilerArguments>() {
assertGcSupported()
GC.SAME_THREAD_MARK_AND_SWEEP
}
"cms" -> {
assertGcSupported()
GC.CONCURRENT_MARK_AND_SWEEP
}
else -> {
configuration.report(ERROR, "Unsupported GC ${arguments.gc}")
GC.SAME_THREAD_MARK_AND_SWEEP
kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/GC.kt
+1
View File
@@ -8,4 +8,5 @@ package org.jetbrains.kotlin.backend.konan
enum class GC {
NOOP,
SAME_THREAD_MARK_AND_SWEEP,
CONCURRENT_MARK_AND_SWEEP
}
kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/KonanConfig.kt
+5
View File
@@ -235,6 +235,11 @@ class KonanConfig(val project: Project, val configuration: CompilerConfiguration
add("experimental_memory_manager_noop.bc")
add("noop_gc.bc")
}
GC.CONCURRENT_MARK_AND_SWEEP -> {
add("common_gc_cms.bc")
add("experimental_memory_manager_cms.bc")
add("concurrent_ms_gc.bc")
}
}
}
}
kotlin-native/runtime/build.gradle.kts
+53
View File
@@ -60,9 +60,12 @@ bitcode {
"${target}LegacyMemoryManager",
"${target}ExperimentalMemoryManagerNoop",
"${target}ExperimentalMemoryManagerStms",
"${target}ExperimentalMemoryManagerCms",
"${target}CommonGcNoop",
"${target}CommonGcStms",
"${target}CommonGcCms",
"${target}SameThreadMsGc",
"${target}ConcurrentMsGc",
"${target}NoopGc"
)
includeRuntime()
@@ -182,6 +185,11 @@ bitcode {
includeRuntime()
}
create("experimental_memory_manager_cms", file("src/mm")) {
headersDirs += files("src/gc/cms/cpp", "src/gc/common/cpp")
includeRuntime()
}
create("common_gc_noop", file("src/gc/common")) {
headersDirs += files("src/gc/noop/cpp", "src/mm/cpp")
includeRuntime()
@@ -192,6 +200,11 @@ bitcode {
includeRuntime()
}
create("common_gc_cms", file("src/gc/common")) {
headersDirs += files("src/gc/cms/cpp", "src/mm/cpp")
includeRuntime()
}
create("noop_gc", file("src/gc/noop")) {
headersDirs += files("src/gc/noop/cpp", "src/gc/common/cpp", "src/mm/cpp")
includeRuntime()
@@ -201,6 +214,11 @@ bitcode {
headersDirs += files("src/gc/stms/cpp", "src/gc/common/cpp", "src/mm/cpp")
includeRuntime()
}
create("concurrent_ms_gc", file("src/gc/cms")) {
headersDirs += files("src/gc/cms/cpp", "src/gc/common/cpp", "src/mm/cpp")
includeRuntime()
}
}
targetList.forEach { targetName ->
@@ -272,6 +290,41 @@ targetList.forEach { targetName ->
includeRuntime()
})
allTests.addAll(createTestTasks(
project,
targetName,
"${targetName}ExperimentalMMCmsMimallocRuntimeTests",
listOf(
"${targetName}Runtime",
"${targetName}ExperimentalMemoryManagerCms",
"${targetName}CommonGcCms",
"${targetName}ConcurrentMsGc",
"${targetName}Mimalloc",
"${targetName}OptAlloc",
"${targetName}Objc"
)
) {
headersDirs += files("src/gc/cms/cpp", "src/gc/common/cpp", "src/mm/cpp")
includeRuntime()
})
allTests.addAll(createTestTasks(
project,
targetName,
"${targetName}ExperimentalMMCmsStdAllocRuntimeTests",
listOf(
"${targetName}Runtime",
"${targetName}ExperimentalMemoryManagerCms",
"${targetName}CommonGcCms",
"${targetName}ConcurrentMsGc",
"${targetName}StdAlloc",
"${targetName}Objc"
)
) {
headersDirs += files("src/gc/cms/cpp", "src/gc/common/cpp", "src/mm/cpp")
includeRuntime()
})
allTests.addAll(createTestTasks(
project,
targetName,
kotlin-native/runtime/src/gc/cms/cpp/ConcurrentMarkAndSweep.cpp
+23 -23
View File
@@ -3,7 +3,7 @@
* that can be found in the LICENSE file.
*/
#include "SameThreadMarkAndSweep.hpp"
#include "ConcurrentMarkAndSweep.hpp"
#include <cinttypes>
@@ -24,55 +24,55 @@ namespace {
struct MarkTraits {
static bool IsMarked(ObjHeader* object) noexcept {
auto& objectData = mm::ObjectFactory<gc::SameThreadMarkAndSweep>::NodeRef::From(object).GCObjectData();
return objectData.color() == gc::SameThreadMarkAndSweep::ObjectData::Color::kBlack;
auto& objectData = mm::ObjectFactory<gc::ConcurrentMarkAndSweep>::NodeRef::From(object).GCObjectData();
return objectData.color() == gc::ConcurrentMarkAndSweep::ObjectData::Color::kBlack;
}
static bool TryMark(ObjHeader* object) noexcept {
auto& objectData = mm::ObjectFactory<gc::SameThreadMarkAndSweep>::NodeRef::From(object).GCObjectData();
if (objectData.color() == gc::SameThreadMarkAndSweep::ObjectData::Color::kBlack) return false;
objectData.setColor(gc::SameThreadMarkAndSweep::ObjectData::Color::kBlack);
auto& objectData = mm::ObjectFactory<gc::ConcurrentMarkAndSweep>::NodeRef::From(object).GCObjectData();
if (objectData.color() == gc::ConcurrentMarkAndSweep::ObjectData::Color::kBlack) return false;
objectData.setColor(gc::ConcurrentMarkAndSweep::ObjectData::Color::kBlack);
return true;
};
};
struct SweepTraits {
using ObjectFactory = mm::ObjectFactory<gc::SameThreadMarkAndSweep>;
using ObjectFactory = mm::ObjectFactory<gc::ConcurrentMarkAndSweep>;
using ExtraObjectsFactory = mm::ExtraObjectDataFactory;
static bool IsMarkedByExtraObject(mm::ExtraObjectData &object) noexcept {
auto *baseObject = object.GetBaseObject();
if (!baseObject->heap()) return true;
auto& objectData = mm::ObjectFactory<gc::SameThreadMarkAndSweep>::NodeRef::From(baseObject).GCObjectData();
return objectData.color() == gc::SameThreadMarkAndSweep::ObjectData::Color::kBlack;
auto& objectData = mm::ObjectFactory<gc::ConcurrentMarkAndSweep>::NodeRef::From(baseObject).GCObjectData();
return objectData.color() == gc::ConcurrentMarkAndSweep::ObjectData::Color::kBlack;
}
static bool TryResetMark(ObjectFactory::NodeRef node) noexcept {
auto& objectData = node.GCObjectData();
if (objectData.color() == gc::SameThreadMarkAndSweep::ObjectData::Color::kWhite) return false;
objectData.setColor(gc::SameThreadMarkAndSweep::ObjectData::Color::kWhite);
if (objectData.color() == gc::ConcurrentMarkAndSweep::ObjectData::Color::kWhite) return false;
objectData.setColor(gc::ConcurrentMarkAndSweep::ObjectData::Color::kWhite);
return true;
}
};
struct FinalizeTraits {
using ObjectFactory = mm::ObjectFactory<gc::SameThreadMarkAndSweep>;
using ObjectFactory = mm::ObjectFactory<gc::ConcurrentMarkAndSweep>;
};
// Global, because it's accessed on a hot path: avoid memory load from `this`.
std::atomic<gc::SameThreadMarkAndSweep::SafepointFlag> gSafepointFlag = gc::SameThreadMarkAndSweep::SafepointFlag::kNone;
std::atomic<gc::ConcurrentMarkAndSweep::SafepointFlag> gSafepointFlag = gc::ConcurrentMarkAndSweep::SafepointFlag::kNone;
} // namespace
ALWAYS_INLINE void gc::SameThreadMarkAndSweep::ThreadData::SafePointFunctionPrologue() noexcept {
ALWAYS_INLINE void gc::ConcurrentMarkAndSweep::ThreadData::SafePointFunctionPrologue() noexcept {
SafePointRegular(GCSchedulerThreadData::kFunctionPrologueWeight);
}
ALWAYS_INLINE void gc::SameThreadMarkAndSweep::ThreadData::SafePointLoopBody() noexcept {
ALWAYS_INLINE void gc::ConcurrentMarkAndSweep::ThreadData::SafePointLoopBody() noexcept {
SafePointRegular(GCSchedulerThreadData::kLoopBodyWeight);
}
void gc::SameThreadMarkAndSweep::ThreadData::SafePointAllocation(size_t size) noexcept {
void gc::ConcurrentMarkAndSweep::ThreadData::SafePointAllocation(size_t size) noexcept {
threadData_.gcScheduler().OnSafePointAllocation(size);
SafepointFlag flag = gSafepointFlag.load();
if (flag != SafepointFlag::kNone) {
@@ -80,7 +80,7 @@ void gc::SameThreadMarkAndSweep::ThreadData::SafePointAllocation(size_t size) no
}
}
void gc::SameThreadMarkAndSweep::ThreadData::PerformFullGC() noexcept {
void gc::ConcurrentMarkAndSweep::ThreadData::PerformFullGC() noexcept {
auto didGC = gc_.PerformFullGC();
if (!didGC) {
@@ -89,12 +89,12 @@ void gc::SameThreadMarkAndSweep::ThreadData::PerformFullGC() noexcept {
}
}
void gc::SameThreadMarkAndSweep::ThreadData::OnOOM(size_t size) noexcept {
void gc::ConcurrentMarkAndSweep::ThreadData::OnOOM(size_t size) noexcept {
RuntimeLogDebug({kTagGC}, "Attempt to GC on OOM at size=%zu", size);
PerformFullGC();
}
ALWAYS_INLINE void gc::SameThreadMarkAndSweep::ThreadData::SafePointRegular(size_t weight) noexcept {
ALWAYS_INLINE void gc::ConcurrentMarkAndSweep::ThreadData::SafePointRegular(size_t weight) noexcept {
threadData_.gcScheduler().OnSafePointRegular(weight);
SafepointFlag flag = gSafepointFlag.load();
if (flag != SafepointFlag::kNone) {
@@ -102,7 +102,7 @@ ALWAYS_INLINE void gc::SameThreadMarkAndSweep::ThreadData::SafePointRegular(size
}
}
NO_INLINE void gc::SameThreadMarkAndSweep::ThreadData::SafePointSlowPath(SafepointFlag flag) noexcept {
NO_INLINE void gc::ConcurrentMarkAndSweep::ThreadData::SafePointSlowPath(SafepointFlag flag) noexcept {
RuntimeAssert(flag != SafepointFlag::kNone, "Must've been handled by the caller");
// No need to check for kNeedsSuspend, because `suspendIfRequested` checks for its own atomic.
threadData_.suspensionData().suspendIfRequested();
@@ -112,14 +112,14 @@ NO_INLINE void gc::SameThreadMarkAndSweep::ThreadData::SafePointSlowPath(Safepoi
}
}
gc::SameThreadMarkAndSweep::SameThreadMarkAndSweep() noexcept {
gc::ConcurrentMarkAndSweep::ConcurrentMarkAndSweep() noexcept {
mm::GlobalData::Instance().gcScheduler().SetScheduleGC([]() {
RuntimeLogDebug({kTagGC}, "Scheduling GC by thread %d", konan::currentThreadId());
gSafepointFlag = SafepointFlag::kNeedsGC;
});
}
bool gc::SameThreadMarkAndSweep::PerformFullGC() noexcept {
bool gc::ConcurrentMarkAndSweep::PerformFullGC() noexcept {
RuntimeLogDebug({kTagGC}, "Attempt to suspend threads by thread %d", konan::currentThreadId());
auto timeStartUs = konan::getTimeMicros();
bool didSuspend = mm::RequestThreadsSuspension();
@@ -132,7 +132,7 @@ bool gc::SameThreadMarkAndSweep::PerformFullGC() noexcept {
RuntimeLogDebug({kTagGC}, "Requested thread suspension by thread %d", konan::currentThreadId());
gSafepointFlag = SafepointFlag::kNeedsSuspend;
mm::ObjectFactory<gc::SameThreadMarkAndSweep>::FinalizerQueue finalizerQueue;
mm::ObjectFactory<gc::ConcurrentMarkAndSweep>::FinalizerQueue finalizerQueue;
{
// Switch state to native to simulate this thread being a GC thread.
ThreadStateGuard guard(ThreadState::kNative);
kotlin-native/runtime/src/gc/cms/cpp/ConcurrentMarkAndSweep.hpp
+6 -6
View File
@@ -22,7 +22,7 @@ class ThreadData;
namespace gc {
// Stop-the-world Mark-and-Sweep that runs on mutator threads. Can support targets that do not have threads.
class SameThreadMarkAndSweep : private Pinned {
class ConcurrentMarkAndSweep : private Pinned {
public:
enum class SafepointFlag {
kNone,
@@ -47,10 +47,10 @@ public:
class ThreadData : private Pinned {
public:
using ObjectData = SameThreadMarkAndSweep::ObjectData;
using ObjectData = ConcurrentMarkAndSweep::ObjectData;
using Allocator = AllocatorWithGC<AlignedAllocator, ThreadData>;
explicit ThreadData(SameThreadMarkAndSweep& gc, mm::ThreadData& threadData) noexcept : gc_(gc), threadData_(threadData) {}
explicit ThreadData(ConcurrentMarkAndSweep& gc, mm::ThreadData& threadData) noexcept : gc_(gc), threadData_(threadData) {}
~ThreadData() = default;
void SafePointFunctionPrologue() noexcept;
@@ -68,14 +68,14 @@ public:
void SafePointRegular(size_t weight) noexcept;
void SafePointSlowPath(SafepointFlag flag) noexcept;
SameThreadMarkAndSweep& gc_;
ConcurrentMarkAndSweep& gc_;
mm::ThreadData& threadData_;
};
using Allocator = ThreadData::Allocator;
SameThreadMarkAndSweep() noexcept;
~SameThreadMarkAndSweep() = default;
ConcurrentMarkAndSweep() noexcept;
~ConcurrentMarkAndSweep() = default;
private:
// Returns `true` if GC has happened, and `false` if not (because someone else has suspended the threads).
kotlin-native/runtime/src/gc/cms/cpp/ConcurrentMarkAndSweepTest.cpp
+25 -25
View File
@@ -3,7 +3,7 @@
* that can be found in the LICENSE file.
*/
#include "SameThreadMarkAndSweep.hpp"
#include "ConcurrentMarkAndSweep.hpp"
#include <condition_variable>
#include <future>
@@ -23,7 +23,7 @@
using namespace kotlin;
// These tests can only work if `GC` is `SameThreadMarkAndSweep`.
// These tests can only work if `GC` is `ConcurrentMarkAndSweep`.
// TODO: Extracting GC into a separate module will help with this.
namespace {
@@ -197,10 +197,10 @@ KStdVector<ObjHeader*> Alive(mm::ThreadData& threadData) {
return objects;
}
using Color = gc::SameThreadMarkAndSweep::ObjectData::Color;
using Color = gc::ConcurrentMarkAndSweep::ObjectData::Color;
Color GetColor(ObjHeader* objHeader) {
auto nodeRef = mm::ObjectFactory<gc::SameThreadMarkAndSweep>::NodeRef::From(objHeader);
auto nodeRef = mm::ObjectFactory<gc::ConcurrentMarkAndSweep>::NodeRef::From(objHeader);
return nodeRef.GCObjectData().color();
}
@@ -214,7 +214,7 @@ WeakCounter& InstallWeakCounter(mm::ThreadData& threadData, ObjHeader* objHeader
return weakCounter;
}
class SameThreadMarkAndSweepTest : public testing::Test {
class ConcurrentMarkAndSweepTest : public testing::Test {
public:
~ConcurrentMarkAndSweepTest() {
@@ -231,7 +231,7 @@ private:
} // namespace
TEST_F(SameThreadMarkAndSweepTest, RootSet) {
TEST_F(ConcurrentMarkAndSweepTest, RootSet) {
RunInNewThread([](mm::ThreadData& threadData) {
GlobalObjectHolder global1{threadData};
GlobalObjectArrayHolder global2{threadData};
@@ -266,7 +266,7 @@ TEST_F(SameThreadMarkAndSweepTest, RootSet) {
});
}
TEST_F(SameThreadMarkAndSweepTest, InterconnectedRootSet) {
TEST_F(ConcurrentMarkAndSweepTest, InterconnectedRootSet) {
RunInNewThread([](mm::ThreadData& threadData) {
GlobalObjectHolder global1{threadData};
GlobalObjectArrayHolder global2{threadData};
@@ -312,7 +312,7 @@ TEST_F(SameThreadMarkAndSweepTest, InterconnectedRootSet) {
});
}
TEST_F(SameThreadMarkAndSweepTest, FreeObjects) {
TEST_F(ConcurrentMarkAndSweepTest, FreeObjects) {
RunInNewThread([](mm::ThreadData& threadData) {
auto& object1 = AllocateObject(threadData);
auto& object2 = AllocateObject(threadData);
@@ -327,7 +327,7 @@ TEST_F(SameThreadMarkAndSweepTest, FreeObjects) {
});
}
TEST_F(SameThreadMarkAndSweepTest, FreeObjectsWithFinalizers) {
TEST_F(ConcurrentMarkAndSweepTest, FreeObjectsWithFinalizers) {
RunInNewThread([this](mm::ThreadData& threadData) {
auto& object1 = AllocateObjectWithFinalizer(threadData);
auto& object2 = AllocateObjectWithFinalizer(threadData);
@@ -344,7 +344,7 @@ TEST_F(SameThreadMarkAndSweepTest, FreeObjectsWithFinalizers) {
});
}
TEST_F(SameThreadMarkAndSweepTest, FreeObjectWithFreeWeak) {
TEST_F(ConcurrentMarkAndSweepTest, FreeObjectWithFreeWeak) {
RunInNewThread([](mm::ThreadData& threadData) {
auto& object1 = AllocateObject(threadData);
auto& weak1 = ([&threadData, &object1]() -> WeakCounter& {
@@ -363,7 +363,7 @@ TEST_F(SameThreadMarkAndSweepTest, FreeObjectWithFreeWeak) {
});
}
TEST_F(SameThreadMarkAndSweepTest, FreeObjectWithHoldedWeak) {
TEST_F(ConcurrentMarkAndSweepTest, FreeObjectWithHoldedWeak) {
RunInNewThread([](mm::ThreadData& threadData) {
auto& object1 = AllocateObject(threadData);
StackObjectHolder stack{threadData};
@@ -382,7 +382,7 @@ TEST_F(SameThreadMarkAndSweepTest, FreeObjectWithHoldedWeak) {
});
}
TEST_F(SameThreadMarkAndSweepTest, ObjectReferencedFromRootSet) {
TEST_F(ConcurrentMarkAndSweepTest, ObjectReferencedFromRootSet) {
RunInNewThread([](mm::ThreadData& threadData) {
GlobalObjectHolder global{threadData};
StackObjectHolder stack{threadData};
@@ -422,7 +422,7 @@ TEST_F(SameThreadMarkAndSweepTest, ObjectReferencedFromRootSet) {
});
}
TEST_F(SameThreadMarkAndSweepTest, ObjectsWithCycles) {
TEST_F(ConcurrentMarkAndSweepTest, ObjectsWithCycles) {
RunInNewThread([](mm::ThreadData& threadData) {
GlobalObjectHolder global{threadData};
StackObjectHolder stack{threadData};
@@ -471,7 +471,7 @@ TEST_F(SameThreadMarkAndSweepTest, ObjectsWithCycles) {
});
}
TEST_F(SameThreadMarkAndSweepTest, ObjectsWithCyclesAndFinalizers) {
TEST_F(ConcurrentMarkAndSweepTest, ObjectsWithCyclesAndFinalizers) {
RunInNewThread([this](mm::ThreadData& threadData) {
GlobalObjectHolder global{threadData};
StackObjectHolder stack{threadData};
@@ -522,7 +522,7 @@ TEST_F(SameThreadMarkAndSweepTest, ObjectsWithCyclesAndFinalizers) {
});
}
TEST_F(SameThreadMarkAndSweepTest, ObjectsWithCyclesIntoRootSet) {
TEST_F(ConcurrentMarkAndSweepTest, ObjectsWithCyclesIntoRootSet) {
RunInNewThread([](mm::ThreadData& threadData) {
GlobalObjectHolder global{threadData};
StackObjectHolder stack{threadData};
@@ -550,7 +550,7 @@ TEST_F(SameThreadMarkAndSweepTest, ObjectsWithCyclesIntoRootSet) {
});
}
TEST_F(SameThreadMarkAndSweepTest, RunGCTwice) {
TEST_F(ConcurrentMarkAndSweepTest, RunGCTwice) {
RunInNewThread([](mm::ThreadData& threadData) {
GlobalObjectHolder global{threadData};
StackObjectHolder stack{threadData};
@@ -600,7 +600,7 @@ TEST_F(SameThreadMarkAndSweepTest, RunGCTwice) {
});
}
TEST_F(SameThreadMarkAndSweepTest, PermanentObjects) {
TEST_F(ConcurrentMarkAndSweepTest, PermanentObjects) {
RunInNewThread([](mm::ThreadData& threadData) {
GlobalPermanentObjectHolder global1{threadData};
GlobalObjectHolder global2{threadData};
@@ -622,7 +622,7 @@ TEST_F(SameThreadMarkAndSweepTest, PermanentObjects) {
});
}
TEST_F(SameThreadMarkAndSweepTest, SameObjectInRootSet) {
TEST_F(ConcurrentMarkAndSweepTest, SameObjectInRootSet) {
RunInNewThread([](mm::ThreadData& threadData) {
GlobalObjectHolder global{threadData};
StackObjectHolder stack(*global);
@@ -746,7 +746,7 @@ private:
} // namespace
TEST_F(SameThreadMarkAndSweepTest, MultipleMutatorsCollect) {
TEST_F(ConcurrentMarkAndSweepTest, MultipleMutatorsCollect) {
KStdVector<Mutator> mutators(kDefaultThreadCount);
KStdVector<ObjHeader*> globals(kDefaultThreadCount);
KStdVector<ObjHeader*> locals(kDefaultThreadCount);
@@ -802,7 +802,7 @@ TEST_F(SameThreadMarkAndSweepTest, MultipleMutatorsCollect) {
}
}
TEST_F(SameThreadMarkAndSweepTest, MultipleMutatorsAllCollect) {
TEST_F(ConcurrentMarkAndSweepTest, MultipleMutatorsAllCollect) {
KStdVector<Mutator> mutators(kDefaultThreadCount);
KStdVector<ObjHeader*> globals(kDefaultThreadCount);
KStdVector<ObjHeader*> locals(kDefaultThreadCount);
@@ -852,7 +852,7 @@ TEST_F(SameThreadMarkAndSweepTest, MultipleMutatorsAllCollect) {
}
}
TEST_F(SameThreadMarkAndSweepTest, MultipleMutatorsAddToRootSetAfterCollectionRequested) {
TEST_F(ConcurrentMarkAndSweepTest, MultipleMutatorsAddToRootSetAfterCollectionRequested) {
KStdVector<Mutator> mutators(kDefaultThreadCount);
KStdVector<ObjHeader*> globals(kDefaultThreadCount);
KStdVector<ObjHeader*> locals(kDefaultThreadCount);
@@ -924,7 +924,7 @@ TEST_F(SameThreadMarkAndSweepTest, MultipleMutatorsAddToRootSetAfterCollectionRe
}
}
TEST_F(SameThreadMarkAndSweepTest, CrossThreadReference) {
TEST_F(ConcurrentMarkAndSweepTest, CrossThreadReference) {
KStdVector<Mutator> mutators(kDefaultThreadCount);
KStdVector<ObjHeader*> globals(kDefaultThreadCount);
KStdVector<ObjHeader*> locals(kDefaultThreadCount);
@@ -990,7 +990,7 @@ TEST_F(SameThreadMarkAndSweepTest, CrossThreadReference) {
}
}
TEST_F(SameThreadMarkAndSweepTest, MultipleMutatorsWeaks) {
TEST_F(ConcurrentMarkAndSweepTest, MultipleMutatorsWeaks) {
KStdVector<Mutator> mutators(kDefaultThreadCount);
ObjHeader* globalRoot = nullptr;
WeakCounter* weak = nullptr;
@@ -1042,7 +1042,7 @@ TEST_F(SameThreadMarkAndSweepTest, MultipleMutatorsWeaks) {
}
}
TEST_F(SameThreadMarkAndSweepTest, NewThreadsWhileRequestingCollection) {
TEST_F(ConcurrentMarkAndSweepTest, NewThreadsWhileRequestingCollection) {
KStdVector<Mutator> mutators(kDefaultThreadCount);
KStdVector<ObjHeader*> globals(2 * kDefaultThreadCount);
KStdVector<ObjHeader*> locals(2 * kDefaultThreadCount);
@@ -1124,7 +1124,7 @@ TEST_F(SameThreadMarkAndSweepTest, NewThreadsWhileRequestingCollection) {
}
TEST_F(SameThreadMarkAndSweepTest, FreeObjectWithFreeWeakReversedOrder) {
TEST_F(ConcurrentMarkAndSweepTest, FreeObjectWithFreeWeakReversedOrder) {
KStdVector<Mutator> mutators(2);
std::atomic<test_support::Object<Payload>*> object1 = nullptr;
std::atomic<WeakCounter*> weak = nullptr;
kotlin-native/runtime/src/gc/cms/cpp/GC.hpp
+2 -2
View File
@@ -5,12 +5,12 @@
#pragma once
#include "SameThreadMarkAndSweep.hpp"
#include "ConcurrentMarkAndSweep.hpp"
namespace kotlin {
namespace gc {
using GC = kotlin::gc::SameThreadMarkAndSweep;
using GC = kotlin::gc::ConcurrentMarkAndSweep;
inline constexpr bool kSupportsMultipleMutators = true;