blob: 176463e07d7d65579d2a9494bbf6ca06704a9abe [file] [log] [blame]
/*
* Copyright 2017 Google Inc. All Rights Reserved.
*
* 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 "cobalt/browser/memory_settings/constrainer.h"
#include <algorithm>
#include <iterator>
#include <vector>
#include "base/logging.h"
#include "cobalt/browser/memory_settings/memory_settings.h"
#include "cobalt/browser/memory_settings/pretty_print.h"
#include "starboard/configuration.h"
namespace cobalt {
namespace browser {
namespace memory_settings {
namespace {
// Any memory setting that matches the MemoryType and is an AutoSet type is
// passed to the output.
std::vector<MemorySetting*> FilterSettings(
MemorySetting::MemoryType memory_type,
const std::vector<MemorySetting*>& settings) {
std::vector<MemorySetting*> output;
for (size_t i = 0; i < settings.size(); ++i) {
MemorySetting* setting = settings[i];
if (setting->memory_type() == memory_type) {
output.push_back(setting);
}
}
return output;
}
// Sums the memory consumption at the given global_constraining_value. The
// settings variable is read buy not modified (despite the non-const
// declaration). If constrained_values_out is non-null, then the computed
// constraining values are stored in this vector.
// Returns: The amount of memory in bytes that the memory settings vector will
// consume at the given global_constraining_factor.
int64_t SumMemoryConsumption(
double global_constraining_factor,
const std::vector<MemorySetting*>& memory_settings,
std::vector<double>* constrained_values_out) {
if (constrained_values_out) {
constrained_values_out->clear();
}
int64_t sum = 0;
// Iterates through the MemorySettings and determines the total memory
// consumption at the current global_constraining_value.
for (size_t i = 0; i < memory_settings.size(); ++i) {
const MemorySetting* setting = memory_settings[i];
const int64_t requested_consumption = setting->MemoryConsumption();
double local_constraining_value = 1.0;
if (setting->source_type() == MemorySetting::kAutoSet) {
local_constraining_value =
setting->ComputeAbsoluteMemoryScale(global_constraining_factor);
}
const int64_t new_consumption_value =
static_cast<int64_t>(local_constraining_value * requested_consumption);
if (constrained_values_out) {
constrained_values_out->push_back(local_constraining_value);
}
sum += new_consumption_value;
}
return sum;
}
void CheckMemoryChange(const std::string& setting_name,
int64_t old_memory_consumption,
int64_t new_memory_consumption,
double constraining_value) {
if (old_memory_consumption == 0) {
// If the system is already using no memory, then it can't use any less.
return;
}
// Represents 1% allowed difference.
static const double kErrorThreshold = 0.01;
const double actual_constraining_value =
static_cast<double>(new_memory_consumption) /
static_cast<double>(old_memory_consumption);
double diff = constraining_value - actual_constraining_value;
if (diff < 0.0) {
diff = -diff;
}
DCHECK_LE(diff, kErrorThreshold)
<< "MemorySetting " << setting_name << " did not change it's memory by "
<< "the expected value.\n"
<< " Expected Change: " << (constraining_value * 100) << "%\n"
<< " Actual Change: " << (diff * 100) << "%\n"
<< " Original memory consumption (bytes): " << old_memory_consumption
<< " New memory consumption (bytes): " << new_memory_consumption
<< "\n";
}
void ConstrainToMemoryLimit(int64_t memory_limit,
std::vector<MemorySetting*>* memory_settings) {
if (memory_settings->empty()) {
return;
}
// If the memory consumed is already under the memory limit then no further
// work needs to be done.
if (SumMemoryConsumption(1.0, *memory_settings, NULL) <= memory_limit) {
return;
}
// Iterate by small steps the constraining value from 1.0 (100%) toward
// 0.0.
static const double kStep = 0.0001; // .01% change per iteration.
std::vector<double> constrained_sizes;
// 1-1 mapping.
constrained_sizes.resize(memory_settings->size());
for (double global_constraining_factor = 1.0;
global_constraining_factor >= 0.0;
global_constraining_factor -= kStep) {
global_constraining_factor = std::max(0.0, global_constraining_factor);
const int64_t new_global_memory_consumption =
SumMemoryConsumption(global_constraining_factor, *memory_settings,
&constrained_sizes);
const bool finished =
(global_constraining_factor == 0.0) ||
(new_global_memory_consumption <= memory_limit);
if (finished) {
break;
}
}
DCHECK_EQ(memory_settings->size(), constrained_sizes.size());
for (size_t i = 0; i < memory_settings->size(); ++i) {
const double local_constraining_factor = constrained_sizes[i];
MemorySetting* setting = memory_settings->at(i);
if (local_constraining_factor != 1.0) {
const int64_t old_memory_consumption = setting->MemoryConsumption();
DCHECK_EQ(setting->source_type(), MemorySetting::kAutoSet);
setting->ScaleMemory(local_constraining_factor);
const int64_t new_memory_consumption = setting->MemoryConsumption();
// If the memory doesn't actually change as predicted by the constraining
// value then this check will catch it here.
CheckMemoryChange(setting->name(),
old_memory_consumption, new_memory_consumption,
local_constraining_factor);
}
}
}
void ConstrainMemoryType(MemorySetting::MemoryType memory_type,
int64_t max_memory,
std::vector<MemorySetting*>* memory_settings,
std::vector<std::string>* error_msgs) {
if (max_memory == 0) {
return;
}
DCHECK_NE(MemorySetting::kNotApplicable, memory_type);
const char* memory_type_str = "UNKNOWN";
switch (memory_type) {
case MemorySetting::kCPU: { memory_type_str = "CPU"; break; }
case MemorySetting::kGPU: { memory_type_str = "GPU"; break; }
case MemorySetting::kNotApplicable: { memory_type_str = "ERROR"; break; }
}
std::vector<MemorySetting*> filtered_settings =
FilterSettings(memory_type, *memory_settings);
const int64_t current_consumption =
SumMemoryConsumption(memory_type, *memory_settings);
if (current_consumption < max_memory) {
return;
}
ConstrainToMemoryLimit(max_memory, &filtered_settings);
const int64_t new_memory_size = SumMemoryConsumption(memory_type,
*memory_settings);
if (new_memory_size > max_memory) {
std::stringstream ss;
ss << "WARNING - ATTEMPTED TO CONSTRAIN " << memory_type_str
<< " MEMORY FROM " << ToMegabyteString(current_consumption, 2)
<< " TO " << ToMegabyteString(max_memory, 2) << ".\nBUT STOPPED"
<< " AT " << ToMegabyteString(new_memory_size, 2) << " because"
<< " there was nothing left to\n"
<< "constrain (settings refused to reduce any more memory). Try\n"
<< "setting more memory setting(s) to -1 to allow autoset.\n"
<< "Example: --image_cache_size_in_bytes=-1";
error_msgs->push_back(ss.str());
}
}
} // namespace.
void ConstrainToMemoryLimits(int64_t max_cpu_memory,
int64_t max_gpu_memory,
std::vector<MemorySetting*>* memory_settings,
std::vector<std::string>* error_msgs) {
// Constrain cpu memory.
ConstrainMemoryType(MemorySetting::kCPU, max_cpu_memory,
memory_settings, error_msgs);
// Constrain gpu memory.
ConstrainMemoryType(MemorySetting::kGPU, max_gpu_memory,
memory_settings, error_msgs);
}
} // namespace memory_settings
} // namespace browser
} // namespace cobalt