blob: 5261fe49237de485d77f250495171a655187e742 [file] [log] [blame]
/*
* Copyright (C) 2021 The Android Open Source Project
*
* 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.
*/
#ifndef ART_ODREFRESH_ODR_CONFIG_H_
#define ART_ODREFRESH_ODR_CONFIG_H_
#include <algorithm>
#include <optional>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include "android-base/file.h"
#include "android-base/no_destructor.h"
#include "android-base/strings.h"
#include "arch/instruction_set.h"
#include "base/file_utils.h"
#include "base/globals.h"
#include "log/log.h"
#include "odr_common.h"
#include "odrefresh/odrefresh.h"
namespace art {
namespace odrefresh {
// The prefixes of system properties that odrefresh keeps track of. Odrefresh will recompile
// everything if any property matching a prefix changes.
constexpr const char* kCheckedSystemPropertyPrefixes[]{"dalvik.vm.", "ro.dalvik.vm."};
// The list of system properties that odrefresh ignores. They don't affect compilation results.
const std::unordered_set<std::string> kIgnoredSystemProperties{
"dalvik.vm.dex2oat-cpu-set",
"dalvik.vm.dex2oat-threads",
"dalvik.vm.boot-dex2oat-cpu-set",
"dalvik.vm.boot-dex2oat-threads",
"dalvik.vm.restore-dex2oat-cpu-set",
"dalvik.vm.restore-dex2oat-threads",
"dalvik.vm.background-dex2oat-cpu-set",
"dalvik.vm.background-dex2oat-threads"};
struct SystemPropertyConfig {
const char* name;
const char* default_value;
};
// The system properties that odrefresh keeps track of, in addition to the ones matching the
// prefixes in `kCheckedSystemPropertyPrefixes`. Odrefresh will recompile everything if any property
// changes.
// All phenotype flags under the `runtime_native_boot` namespace that affects the compiler's
// behavior must be explicitly listed below. We cannot use a prefix to match all phenotype flags
// because a default value is required for each flag. Changing the flag value from empty to the
// default value should not trigger re-compilation. This is to comply with the phenotype flag
// requirement (go/platform-experiments-flags#pre-requisites).
const android::base::NoDestructor<std::vector<SystemPropertyConfig>> kSystemProperties{
{SystemPropertyConfig{.name = "persist.device_config.runtime_native_boot.enable_uffd_gc",
.default_value = "false"},
SystemPropertyConfig{.name = kPhDisableCompactDex, .default_value = "false"}}};
// An enumeration of the possible zygote configurations on Android.
enum class ZygoteKind : uint8_t {
// 32-bit primary zygote, no secondary zygote.
kZygote32 = 0,
// 32-bit primary zygote, 64-bit secondary zygote.
kZygote32_64 = 1,
// 64-bit primary zygote, 32-bit secondary zygote.
kZygote64_32 = 2,
// 64-bit primary zygote, no secondary zygote.
kZygote64 = 3
};
// Configuration class for odrefresh. Exists to enable abstracting environment variables and
// system properties into a configuration class for development and testing purposes.
class OdrConfig final {
private:
std::string apex_info_list_file_;
std::string art_bin_dir_;
std::string dex2oat_;
std::string dex2oat_boot_classpath_;
bool dry_run_;
std::optional<bool> refresh_;
std::optional<bool> partial_compilation_;
InstructionSet isa_;
std::string program_name_;
std::string system_server_classpath_;
std::string boot_image_compiler_filter_;
std::string system_server_compiler_filter_;
ZygoteKind zygote_kind_;
std::string boot_classpath_;
std::string artifact_dir_;
std::string standalone_system_server_jars_;
bool compilation_os_mode_ = false;
bool minimal_ = false;
// The current values of system properties listed in `kSystemProperties`.
std::unordered_map<std::string, std::string> system_properties_;
// Staging directory for artifacts. The directory must exist and will be automatically removed
// after compilation. If empty, use the default directory.
std::string staging_dir_;
public:
explicit OdrConfig(const char* program_name)
: dry_run_(false),
isa_(InstructionSet::kNone),
program_name_(android::base::Basename(program_name)),
artifact_dir_(GetApexDataDalvikCacheDirectory(InstructionSet::kNone)) {
}
const std::string& GetApexInfoListFile() const { return apex_info_list_file_; }
std::vector<InstructionSet> GetBootClasspathIsas() const {
const auto [isa32, isa64] = GetPotentialInstructionSets();
switch (zygote_kind_) {
case ZygoteKind::kZygote32:
return {isa32};
case ZygoteKind::kZygote32_64:
case ZygoteKind::kZygote64_32:
return {isa32, isa64};
case ZygoteKind::kZygote64:
return {isa64};
}
}
InstructionSet GetSystemServerIsa() const {
const auto [isa32, isa64] = GetPotentialInstructionSets();
switch (zygote_kind_) {
case ZygoteKind::kZygote32:
case ZygoteKind::kZygote32_64:
return isa32;
case ZygoteKind::kZygote64_32:
case ZygoteKind::kZygote64:
return isa64;
}
}
const std::string& GetDex2oatBootClasspath() const { return dex2oat_boot_classpath_; }
const std::string& GetArtifactDirectory() const { return artifact_dir_; }
std::string GetDex2Oat() const {
const char* prefix = UseDebugBinaries() ? "dex2oatd" : "dex2oat";
const char* suffix = "";
if (kIsTargetBuild) {
switch (zygote_kind_) {
case ZygoteKind::kZygote32:
suffix = "32";
break;
case ZygoteKind::kZygote32_64:
case ZygoteKind::kZygote64_32:
case ZygoteKind::kZygote64:
suffix = "64";
break;
}
}
return art_bin_dir_ + '/' + prefix + suffix;
}
bool GetDryRun() const { return dry_run_; }
bool HasPartialCompilation() const {
return partial_compilation_.has_value();
}
bool GetPartialCompilation() const {
return partial_compilation_.value_or(true);
}
bool GetRefresh() const {
return refresh_.value_or(true);
}
const std::string& GetSystemServerClasspath() const {
return system_server_classpath_;
}
const std::string& GetBootImageCompilerFilter() const {
return boot_image_compiler_filter_;
}
const std::string& GetSystemServerCompilerFilter() const {
return system_server_compiler_filter_;
}
const std::string& GetStagingDir() const {
return staging_dir_;
}
bool GetCompilationOsMode() const { return compilation_os_mode_; }
bool GetMinimal() const { return minimal_; }
const std::unordered_map<std::string, std::string>& GetSystemProperties() const {
return system_properties_;
}
void SetApexInfoListFile(const std::string& file_path) { apex_info_list_file_ = file_path; }
void SetArtBinDir(const std::string& art_bin_dir) { art_bin_dir_ = art_bin_dir; }
void SetDex2oatBootclasspath(const std::string& classpath) {
dex2oat_boot_classpath_ = classpath;
}
void SetArtifactDirectory(const std::string& artifact_dir) {
artifact_dir_ = artifact_dir;
}
void SetDryRun() { dry_run_ = true; }
void SetPartialCompilation(bool value) {
partial_compilation_ = value;
}
void SetRefresh(bool value) {
refresh_ = value;
}
void SetIsa(const InstructionSet isa) { isa_ = isa; }
void SetSystemServerClasspath(const std::string& classpath) {
system_server_classpath_ = classpath;
}
void SetBootImageCompilerFilter(const std::string& filter) {
boot_image_compiler_filter_ = filter;
}
void SetSystemServerCompilerFilter(const std::string& filter) {
system_server_compiler_filter_ = filter;
}
void SetZygoteKind(ZygoteKind zygote_kind) { zygote_kind_ = zygote_kind; }
const std::string& GetBootClasspath() const { return boot_classpath_; }
void SetBootClasspath(const std::string& classpath) { boot_classpath_ = classpath; }
void SetStagingDir(const std::string& staging_dir) {
staging_dir_ = staging_dir;
}
const std::string& GetStandaloneSystemServerJars() const {
return standalone_system_server_jars_;
}
void SetStandaloneSystemServerJars(const std::string& jars) {
standalone_system_server_jars_ = jars;
}
void SetCompilationOsMode(bool value) { compilation_os_mode_ = value; }
void SetMinimal(bool value) { minimal_ = value; }
std::unordered_map<std::string, std::string>* MutableSystemProperties() {
return &system_properties_;
}
private:
// Returns a pair for the possible instruction sets for the configured instruction set
// architecture. The first item is the 32-bit architecture and the second item is the 64-bit
// architecture. The current `isa` is based on `kRuntimeISA` on target, odrefresh is compiled
// 32-bit by default so this method returns all options which are finessed based on the
// `ro.zygote` property.
std::pair<InstructionSet, InstructionSet> GetPotentialInstructionSets() const {
switch (isa_) {
case art::InstructionSet::kArm:
case art::InstructionSet::kArm64:
return std::make_pair(art::InstructionSet::kArm, art::InstructionSet::kArm64);
case art::InstructionSet::kX86:
case art::InstructionSet::kX86_64:
return std::make_pair(art::InstructionSet::kX86, art::InstructionSet::kX86_64);
case art::InstructionSet::kRiscv64:
case art::InstructionSet::kThumb2:
case art::InstructionSet::kNone:
LOG(FATAL) << "Invalid instruction set " << isa_;
return std::make_pair(art::InstructionSet::kNone, art::InstructionSet::kNone);
}
}
bool UseDebugBinaries() const { return program_name_ == "odrefreshd"; }
OdrConfig() = delete;
OdrConfig(const OdrConfig&) = delete;
OdrConfig& operator=(const OdrConfig&) = delete;
};
} // namespace odrefresh
} // namespace art
#endif // ART_ODREFRESH_ODR_CONFIG_H_