Improve deterministic boot image compilation with CC collector.
Allow deterministic compilation with the read barrier configuration.
Test: Compare boot.art produced by different builds of the same tree.
Bug: 37442966
Change-Id: I6cc0d0d7fdfe4f954765764d9f7f3778b7307028
diff --git a/build/art.go b/build/art.go
index 053968d..61a9759 100644
--- a/build/art.go
+++ b/build/art.go
@@ -59,8 +59,8 @@
}
if !envFalse(ctx, "ART_USE_READ_BARRIER") && ctx.AConfig().ArtUseReadBarrier() {
- // Used to change the read barrier type. Valid values are BAKER, BROOKS, TABLELOOKUP.
- // The default is BAKER.
+ // Used to change the read barrier type. Valid values are BAKER, BROOKS,
+ // TABLELOOKUP. The default is BAKER.
barrierType := envDefault(ctx, "ART_READ_BARRIER_TYPE", "BAKER")
cflags = append(cflags,
"-DART_USE_READ_BARRIER=1",
diff --git a/dex2oat/dex2oat.cc b/dex2oat/dex2oat.cc
index a9108e0e..5090c11 100644
--- a/dex2oat/dex2oat.cc
+++ b/dex2oat/dex2oat.cc
@@ -382,8 +382,6 @@
"input dex file.");
UsageError("");
UsageError(" --force-determinism: force the compiler to emit a deterministic output.");
- UsageError(" This option is incompatible with read barriers (e.g., if dex2oat has been");
- UsageError(" built with the environment variable `ART_USE_READ_BARRIER` set to `true`).");
UsageError("");
UsageError(" --classpath-dir=<directory-path>: directory used to resolve relative class paths.");
UsageError("");
@@ -915,9 +913,10 @@
// Fill some values into the key-value store for the oat header.
key_value_store_.reset(new SafeMap<std::string, std::string>());
- // Automatically force determinism for the boot image in a host build if the default GC is CMS
- // or MS and read barriers are not enabled, as the former switches the GC to a non-concurrent
- // one by passing the option `-Xgc:nonconcurrent` (see below).
+ // Automatically force determinism for the boot image in a host build if read barriers
+ // are enabled, or if the default GC is CMS or MS. When the default GC is CMS
+ // (Concurrent Mark-Sweep), the GC is switched to a non-concurrent one by passing the
+ // option `-Xgc:nonconcurrent` (see below).
if (!kIsTargetBuild && IsBootImage()) {
if (SupportsDeterministicCompilation()) {
force_determinism_ = true;
@@ -939,9 +938,9 @@
}
static bool SupportsDeterministicCompilation() {
- return (gc::kCollectorTypeDefault == gc::kCollectorTypeCMS ||
- gc::kCollectorTypeDefault == gc::kCollectorTypeMS) &&
- !kEmitCompilerReadBarrier;
+ return (kUseReadBarrier ||
+ gc::kCollectorTypeDefault == gc::kCollectorTypeCMS ||
+ gc::kCollectorTypeDefault == gc::kCollectorTypeMS);
}
void ExpandOatAndImageFilenames() {
@@ -1233,7 +1232,7 @@
no_inline_from_string_ = option.substr(strlen("--no-inline-from=")).data();
} else if (option == "--force-determinism") {
if (!SupportsDeterministicCompilation()) {
- Usage("Cannot use --force-determinism with read barriers or non-CMS garbage collector");
+ Usage("Option --force-determinism requires read barriers or a CMS/MS garbage collector");
}
force_determinism_ = true;
} else if (option.starts_with("--classpath-dir=")) {
@@ -2421,15 +2420,25 @@
// foreground collector by default for dex2oat.
raw_options.push_back(std::make_pair("-XX:DisableHSpaceCompactForOOM", nullptr));
- // If we're asked to be deterministic, ensure non-concurrent GC for determinism. Also
- // force the free-list implementation for large objects.
if (compiler_options_->IsForceDeterminism()) {
+ // If we're asked to be deterministic, ensure non-concurrent GC for determinism.
+ //
+ // Note that with read barriers, this option is ignored, because Runtime::Init
+ // overrides the foreground GC to be gc::kCollectorTypeCC when instantiating
+ // gc::Heap. This is fine, as concurrent GC requests are not honored in dex2oat,
+ // which uses an unstarted runtime.
raw_options.push_back(std::make_pair("-Xgc:nonconcurrent", nullptr));
+
+ // Also force the free-list implementation for large objects.
raw_options.push_back(std::make_pair("-XX:LargeObjectSpace=freelist", nullptr));
// We also need to turn off the nonmoving space. For that, we need to disable HSpace
// compaction (done above) and ensure that neither foreground nor background collectors
// are concurrent.
+ //
+ // Likewise, this option is ignored with read barriers because Runtime::Init
+ // overrides the background GC to be gc::kCollectorTypeCCBackground, but that's
+ // fine too, for the same reason (see above).
raw_options.push_back(std::make_pair("-XX:BackgroundGC=nonconcurrent", nullptr));
// To make identity hashcode deterministic, set a known seed.
diff --git a/runtime/gc/heap-inl.h b/runtime/gc/heap-inl.h
index 394e541..f40d3c8 100644
--- a/runtime/gc/heap-inl.h
+++ b/runtime/gc/heap-inl.h
@@ -57,8 +57,8 @@
HandleWrapperObjPtr<mirror::Class> h = hs.NewHandleWrapper(&klass);
self->PoisonObjectPointers();
}
- // Need to check that we arent the large object allocator since the large object allocation code
- // path this function. If we didn't check we would have an infinite loop.
+ // Need to check that we aren't the large object allocator since the large object allocation code
+ // path includes this function. If we didn't check we would have an infinite loop.
ObjPtr<mirror::Object> obj;
if (kCheckLargeObject && UNLIKELY(ShouldAllocLargeObject(klass, byte_count))) {
obj = AllocLargeObject<kInstrumented, PreFenceVisitor>(self, &klass, byte_count,
@@ -199,7 +199,7 @@
} else {
DCHECK(!gc_stress_mode_);
}
- // IsConcurrentGc() isn't known at compile time so we can optimize by not checking it for
+ // IsGcConcurrent() isn't known at compile time so we can optimize by not checking it for
// the BumpPointer or TLAB allocators. This is nice since it allows the entire if statement to be
// optimized out. And for the other allocators, AllocatorMayHaveConcurrentGC is a constant since
// the allocator_type should be constant propagated.
diff --git a/runtime/gc/heap.cc b/runtime/gc/heap.cc
index 4a25610..94af2ef 100644
--- a/runtime/gc/heap.cc
+++ b/runtime/gc/heap.cc
@@ -3727,8 +3727,8 @@
if (!Runtime::Current()->IsShuttingDown(self)) {
// Wait for any GCs currently running to finish.
if (WaitForGcToComplete(cause, self) == collector::kGcTypeNone) {
- // If the we can't run the GC type we wanted to run, find the next appropriate one and try that
- // instead. E.g. can't do partial, so do full instead.
+ // If the we can't run the GC type we wanted to run, find the next appropriate one and try
+ // that instead. E.g. can't do partial, so do full instead.
collector::GcType next_gc_type = next_gc_type_;
// If forcing full and next gc type is sticky, override with a non-sticky type.
if (force_full && next_gc_type == collector::kGcTypeSticky) {