blob: 0c8dda88052d27af13dc8c8fc37affca4331965f [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.
*/
#include <odr_compilation_log.h>
#include <errno.h>
#include <fstream>
#include <ios>
#include <iosfwd>
#include <istream>
#include <ostream>
#include <streambuf>
#include <string>
#include <vector>
#include "android-base/logging.h"
#include "base/os.h"
#include "odrefresh/odrefresh.h"
#include "odr_metrics.h"
namespace art {
namespace odrefresh {
std::istream& operator>>(std::istream& is, OdrCompilationLogEntry& entry) {
// Block I/O related exceptions
auto saved_exceptions = is.exceptions();
is.exceptions(std::ios_base::iostate {});
// Write log entry. NB update OdrCompilationLog::kLogVersion if changing the format here.
is >> entry.apex_version >> std::ws;
is >> entry.last_update_millis >> std::ws;
is >> entry.trigger >> std::ws;
is >> entry.when >> std::ws;
is >> entry.exit_code >> std::ws;
// Restore I/O related exceptions
is.exceptions(saved_exceptions);
return is;
}
std::ostream& operator<<(std::ostream& os, const OdrCompilationLogEntry& entry) {
static const char kSpace = ' ';
// Block I/O related exceptions
auto saved_exceptions = os.exceptions();
os.exceptions(std::ios_base::iostate {});
os << entry.apex_version << kSpace;
os << entry.last_update_millis << kSpace;
os << entry.trigger << kSpace;
os << entry.when << kSpace;
os << entry.exit_code << std::endl;
// Restore I/O related exceptions
os.exceptions(saved_exceptions);
return os;
}
bool operator==(const OdrCompilationLogEntry& lhs, const OdrCompilationLogEntry& rhs) {
return lhs.apex_version == rhs.apex_version && lhs.last_update_millis == rhs.last_update_millis &&
lhs.trigger == rhs.trigger && lhs.when == rhs.when && lhs.exit_code == rhs.exit_code;
}
bool operator!=(const OdrCompilationLogEntry& lhs, const OdrCompilationLogEntry& rhs) {
return !(lhs == rhs);
}
OdrCompilationLog::OdrCompilationLog(const char* compilation_log_path)
: log_path_(compilation_log_path) {
if (log_path_ != nullptr && OS::FileExists(log_path_)) {
if (!Read()) {
PLOG(ERROR) << "Failed to read compilation log: " << log_path_;
}
}
}
OdrCompilationLog::~OdrCompilationLog() {
if (log_path_ != nullptr && !Write()) {
PLOG(ERROR) << "Failed to write compilation log: " << log_path_;
}
}
bool OdrCompilationLog::Read() {
std::ifstream ifs(log_path_);
if (!ifs.good()) {
return false;
}
std::string log_version;
ifs >> log_version >> std::ws;
if (log_version != kLogVersion) {
return false;
}
while (!ifs.eof()) {
OdrCompilationLogEntry entry;
ifs >> entry;
if (ifs.fail()) {
entries_.clear();
return false;
}
entries_.push_back(entry);
}
return true;
}
bool OdrCompilationLog::Write() const {
std::ofstream ofs(log_path_, std::ofstream::trunc);
if (!ofs.good()) {
return false;
}
ofs << kLogVersion << std::endl;
for (const auto& entry : entries_) {
ofs << entry;
if (ofs.fail()) {
return false;
}
}
return true;
}
void OdrCompilationLog::Truncate() {
if (entries_.size() < kMaxLoggedEntries) {
return;
}
size_t excess = entries_.size() - kMaxLoggedEntries;
entries_.erase(entries_.begin(), entries_.begin() + excess);
}
size_t OdrCompilationLog::NumberOfEntries() const {
return entries_.size();
}
const OdrCompilationLogEntry* OdrCompilationLog::Peek(size_t index) const {
if (index >= entries_.size()) {
return nullptr;
}
return &entries_[index];
}
void OdrCompilationLog::Log(int64_t apex_version,
int64_t last_update_millis,
OdrMetrics::Trigger trigger,
ExitCode compilation_result) {
time_t now;
time(&now);
Log(apex_version, last_update_millis, trigger, now, compilation_result);
}
void OdrCompilationLog::Log(int64_t apex_version,
int64_t last_update_millis,
OdrMetrics::Trigger trigger,
time_t when,
ExitCode compilation_result) {
entries_.push_back(OdrCompilationLogEntry{apex_version,
last_update_millis,
static_cast<int32_t>(trigger),
when,
static_cast<int32_t>(compilation_result)});
Truncate();
}
bool OdrCompilationLog::ShouldAttemptCompile(OdrMetrics::Trigger trigger, time_t now) const {
if (entries_.size() == 0) {
// We have no history, try to compile.
return true;
}
// The backoff time is for avoiding too many failed attempts. It should not be applied if the last
// compilation was successful.
if (entries_.back().exit_code == ExitCode::kCompilationSuccess) {
return true;
}
if (trigger == OdrMetrics::Trigger::kApexVersionMismatch ||
trigger == OdrMetrics::Trigger::kDexFilesChanged) {
// Things have changed since the last run.
return true;
}
// Compute the backoff time based on the number of consecutive failures.
//
// Wait 12 hrs * pow(2, consecutive_failures) since the last compilation attempt.
static const int kSecondsPerDay = 86'400;
time_t backoff = kSecondsPerDay / 2;
for (auto it = entries_.crbegin(); it != entries_.crend(); ++it, backoff *= 2) {
if (it->exit_code == ExitCode::kCompilationSuccess) {
break;
}
}
if (now == 0) {
time(&now);
}
const time_t last_attempt = entries_.back().when;
const time_t threshold = last_attempt + backoff;
return now >= threshold;
}
} // namespace odrefresh
} // namespace art