QualityService.cpp

#include "Rendering/IContext.h"
#include "Rendering/IGraphicsDevice.h"
#include "Rendering/Statistics.h"
 
#include "Foundation/Logging/Logger.h"
 
#include "Context.h"
#include "Services/Variables.h"
 
#include "QualityService.h"
 
namespace {
  using namespace Cogs::Core;
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("QualityService");
 
  struct Setting {
    Cogs::StringView name;
    float defaultValue;
  };
 
  const Cogs::StringView qualityVariableName = "quality.setting";
  const Cogs::StringView qualityFrameTimeAlphaName = "quality.frameTime.alpha";    // smoothing in (0,1], higher value discards values faster.
  const Cogs::StringView qualityFrameTimeTargetName = "quality.frameTimeTarget";
  const Cogs::StringView GPUMemTargetMBName = "quality.GPUMemTargetMB";
 
  const Setting qualityScalingSpeed = { "quality.scaling.speed", 5e-2f };  // How fast to adjust scaling
 
  const Setting qualityAssetSystemToleranceScaleCoarse =   { "quality.assetSystem.toleranceScale.coarse",   10.f };   // 1 <= value
  const Setting qualityAssetSystemToleranceScaleDetailed = { "quality.assetSystem.toleranceScale.detailed", 0.25f };  // value <= 1
 
  const Setting qualityPotreeSystemToleranceScaleCoarse    = { "quality.potreeSystem.toleranceScale.coarse",    3.f };    // 1 <= value
  const Setting qualityPotreeSystemToleranceScaleDetailed  = { "quality.potreeSystem.toleranceScale.detailed",  0.25f };  // value <= 1
  const Setting qualityPotreeSystemChunkCountScaleCoarse   = { "quality.potreeSystem.chunkCountScale.coarse",   1e-3f };  // value <= 1
  const Setting qualityPotreeSystemChunkCountScaleDetailed = { "quality.potreeSystem.chunkCountScale.detailed", 2.f };    // 1 <= value
 
  const Setting qualityOGC3DTilesSystemToleranceScaleCoarse =   { "quality.ogc3DTilesSystem.toleranceScale.coarse",   3.f };    // 1 <= value
  const Setting qualityOGC3DTilesSystemToleranceScaleDetailed = { "quality.ogc3DTilesSystem.toleranceScale.detailed", 0.25f };  // value <= 1
  const Setting qualityOGC3DTilesSystemCacheControlCoarse =     { "quality.ogc3DTilesSystem.cacheControl.coarse",     1e-3f };  // value <= 1
  const Setting qualityOGC3DTilesSystemCacheControlDetailed =   { "quality.ogc3DTilesSystem.cacheControl.detailed",   2.f };    // 1 <= value
 
  float mapDecreasing(Context* context, const Setting& coarseSetting, const Setting& detailedSetting, float quality)
  {
    Variable* coarseVar = context->variables->get(coarseSetting.name);
    if (coarseVar->isEmpty()) {
      coarseVar->setFloat(coarseSetting.defaultValue);
    }
 
    Variable* detailedVar = context->variables->get(detailedSetting.name);
    if (detailedVar->isEmpty()) {
      detailedVar->setFloat(detailedSetting.defaultValue);
    }
 
    float coarse = std::max(1.f, coarseVar->getFloat());
    float detailed = std::min(1.f, std::max(detailedVar->getFloat(), std::numeric_limits<float>::min()));
 
    // Use average slope at x=1, value=1.
    // Clamp slope to ensure a monotonically decreasing function over [0,2]
    float a = coarse - 1.f;
    float b = 1.f - detailed;
    float c = glm::min(0.5f * (a + b), glm::min(a, b));
 
    // One quadratic Bezier below 1 and one above.
    float rv;
    if (quality <= 1.f) {
      const float x = quality;
      rv = coarse * (1.f - x) * (1.f - x) + 2.f * (1.f + c) * (1.f - x) * x + x * x;
    }
    else {
      const float x = quality - 1.f;
      rv = (1.f - x) * (1.f - x) + 2.f * (1.f - c) * (1.f - x) * x + detailed * x * x;
    }
    return std::isfinite(rv) ? rv : 1.f;
  }
 
  float mapIncreasing(Context* context, const Setting& coarseSetting, const Setting& detailedSetting, float quality)
  {
    Variable* coarseVar = context->variables->get(coarseSetting.name);
    if (coarseVar->isEmpty()) {
      coarseVar->setFloat(coarseSetting.defaultValue);
    }
 
    Variable* detailedVar = context->variables->get(detailedSetting.name);
    if (detailedVar->isEmpty()) {
      detailedVar->setFloat(detailedSetting.defaultValue);
    }
 
    float coarse = std::min(1.f, std::max(coarseVar->getFloat(), std::numeric_limits<float>::min()));
    float detailed = std::max(1.f, detailedVar->getFloat());
 
    // Use average slope at x=1, value=1.
    // Clamp slope to ensure a monotonically decreasing function over [0,2]
    float a = coarse - 1.f;
    float b = 1.f - detailed;
    float c = glm::max(0.5f * (a + b), glm::min(a, b));
 
    // One quadratic Bezier below 1 and one above.
    float rv;
    if (quality <= 1.f) {
      const float x = quality;
      rv = coarse * (1.f - x) * (1.f - x) + 2.f * (1.f + c) * (1.f - x) * x + x * x;
    }
    else {
      const float x = quality - 1.f;
      rv = (1.f - x) * (1.f - x) + 2.f * (1.f - c) * (1.f - x) * x + detailed * x * x;
    }
    return std::isfinite(rv) ? rv : 1.f;
  }
}
 
Cogs::Core::QualityService::QualityService(class Context* context)
  : context(context)
{
 
  for(size_t i=0; i<(size_t)MetricType::MetricTypeCount; i++){
    for(size_t j=0; j<TIMES_COUNT; j++){
      times[j][i] = 0.0f;
    }
  }
}
 
void Cogs::Core::QualityService::beginFrame()
{
  if(hasOneFrame){
    end(MetricType::Idle);
    times_idx = (times_idx+1)%TIMES_COUNT;
  }
  else{
    hasOneFrame = true;
  }
  for(size_t i=0; i<(size_t)MetricType::MetricTypeCount; i++){
    time[i] = {};
  }
  for(size_t i=0; i<(size_t)MetricType::MetricTypeCount; i++){
    times[times_idx][i] = 0.0f;
  }
 
  {
    Cogs::UploadStatistics upload_stats = context->device->getImmediateContext()->getLastUploadStatistics();
    bufferUploadSize[times_idx] = upload_stats.bufferUploadSize;
    textureUploadSize[times_idx] = upload_stats.textureUploadSize;
  }
 
  assert(stack_idx == 0);
  begin(MetricType::Frame);
 
  if (Variable* var = context->variables->get(qualityVariableName); !var->isEmpty()) {
    qualitySetting = var->getFloat(qualitySetting);
    if (qualitySetting < 0.0f) { qualitySetting = 0.f; }
    if (200.f < qualitySetting || !std::isfinite(qualitySetting)) { qualitySetting = 200.f; }
    var->setFloat(qualitySetting);
  }
  else {
    context->variables->set(qualityVariableName, qualitySetting);
  }
 
  if (Variable* var = context->variables->get(qualityFrameTimeTargetName); !var->isEmpty()) {
    frameTimeTarget = std::max(0.f, var->getFloat());
  }
  else {
    context->variables->set(qualityFrameTimeTargetName, frameTimeTarget);
  }
 
  if (Variable* var = context->variables->get(GPUMemTargetMBName); !var->isEmpty()) {
    gpuMemTargetMB = static_cast<uint32_t>(std::max(0, var->getInt()));
  }
  else {
    context->variables->set(GPUMemTargetMBName, static_cast<int>(gpuMemTargetMB));
  }
 
  float maxQuality = 1e-2f * qualitySetting;
  if ((0.f < frameTimeTarget) || (0 < gpuMemTargetMB)) {
    float speed = qualityScalingSpeed.defaultValue;
    if (Variable* var = context->variables->get(qualityScalingSpeed.name); !var->isEmpty()) {
      speed = std::max(std::numeric_limits<float>::min(), var->getFloat());
    }
    else {
      context->variables->set(qualityScalingSpeed.name, speed);
    }
 
    speed = speed * 1e-3f * avgFrameTime;
    if (rapidBackoff) {
      currentQuality = glm::clamp(currentQuality - 10.f * speed, 0.f, maxQuality);
      resetFrameTime = true;
    }
    else if (throttleDown) {
      currentQuality = glm::clamp(currentQuality - speed, 0.f, maxQuality);
    }
    else if (hasSlack) {
      currentQuality = std::min(currentQuality + speed, maxQuality);
    }
    else {
      currentQuality = std::min(currentQuality, maxQuality);
    }
  }
  else {
    currentQuality = maxQuality;
  }
 
  {
    Variable* coarse = context->variables->get(qualityAssetSystemToleranceScaleCoarse.name);
    if (coarse->isEmpty()) {
      coarse->setFloat(qualityAssetSystemToleranceScaleCoarse.defaultValue);
    }
 
    Variable* detailed = context->variables->get(qualityAssetSystemToleranceScaleDetailed.name);
    if (detailed->isEmpty()) {
      detailed->setFloat(qualityAssetSystemToleranceScaleDetailed.defaultValue);
    }
  }
 
  assetSystemToleranceScale = mapDecreasing(context,
                                            qualityAssetSystemToleranceScaleCoarse,
                                            qualityAssetSystemToleranceScaleDetailed,
                                            currentQuality);
 
  potreeSystemToleranceScale = mapDecreasing(context,
                                             qualityPotreeSystemToleranceScaleCoarse,
                                             qualityPotreeSystemToleranceScaleDetailed,
                                             currentQuality);
 
  potreeSystemChunkCountScale = mapIncreasing(context,
                                              qualityPotreeSystemChunkCountScaleCoarse,
                                              qualityPotreeSystemChunkCountScaleDetailed,
                                              currentQuality);
 
  ogc3DTilesSystemToleranceScale = mapDecreasing(context,
                                                 qualityOGC3DTilesSystemToleranceScaleCoarse,
                                                 qualityOGC3DTilesSystemToleranceScaleDetailed,
                                                 currentQuality);
 
  ogc3DTilesSystemCacheControl = mapIncreasing(context,
                                              qualityOGC3DTilesSystemCacheControlCoarse,
                                              qualityOGC3DTilesSystemCacheControlDetailed,
                                              currentQuality);
  rapidBackoff = false;
  throttleDown = false;
  hasSlack = true;
}
 
void Cogs::Core::QualityService::endFrame()
{
  end(MetricType::Frame);
 
  float frameTime = times[times_idx][(size_t)MetricType::Frame];
  if (avgFrameTime == 0.f || resetFrameTime) {
    resetFrameTime = false;
    avgFrameTime = frameTime;
  }
  else {
    float alpha = 1e-2f;
    if (Variable* var = context->variables->get(qualityFrameTimeAlphaName); !var->isEmpty()) {
      alpha = glm::clamp(var->getFloat(), std::numeric_limits<float>::min(), 1.f);
    }
    else {
      context->variables->set(qualityFrameTimeAlphaName, alpha);
    }
    avgFrameTime = (1.f - alpha) * avgFrameTime + alpha * frameTime;
  }
 
  bool hasSlack = true; // TODO This is suspicus, hides class member
  bool hasLimits = false;
  if (0 < gpuMemTargetMB) {
    const Cogs::ResourceStatistics resourceStats = context->device->getResourceStatistics();
 
    float gpuMemTarget = float(gpuMemTargetMB);
    float gpuMemValue = float(resourceStats.memoryConsumption()) / float(1024 * 1024);
 
    if (1.5f * gpuMemTarget < gpuMemValue) {
      requestQualityChange(QualityRequest::RapidBackoff);
      return;
    }
 
    if (gpuMemTarget < gpuMemValue) {
      requestQualityChange(QualityRequest::ThrottleDown);
      return;
    }
 
    if (0.8f * gpuMemTarget < gpuMemValue) {
      hasSlack = false;
    }
    hasLimits = true;
  }
 
  if (0.f < frameTimeTarget) {
    if (1.5f * frameTimeTarget < avgFrameTime) {
      requestQualityChange(QualityRequest::RapidBackoff);
      return;
    }
 
    if (frameTimeTarget < avgFrameTime) {
      requestQualityChange(QualityRequest::ThrottleDown);
      return;
    }
 
    if (0.8f * frameTimeTarget < avgFrameTime) {
      hasSlack = false;
    }
    hasLimits = true;
  }
 
  if (hasLimits && !hasSlack) {
    requestQualityChange(QualityRequest::AtTarget);
    return;
  }
 
  requestQualityChange(QualityRequest::HasSlack);
 
  begin(MetricType::Idle);
}
 
void Cogs::Core::QualityService::requestQualityChange(QualityRequest request)
{
  switch (request) {
  case QualityRequest::AtTarget:
    hasSlack = false;
    break;
  case QualityRequest::HasSlack:
    break;
  case QualityRequest::ThrottleDown:
    throttleDown = true;
    break;
  case QualityRequest::RapidBackoff:
    rapidBackoff = true;
    break;
  default:
    assert(false && "Illegal enum value");
    break;
  }
}
 
void QualityService::begin(MetricType metric)
{
  time[(size_t)metric] = Cogs::perfTime();
  stack_idx++;
}
 
void QualityService::end(MetricType metric)
{
  times[times_idx][(size_t)metric] += (float)(perfTimeToSeconds(Cogs::perfTime()-time[(size_t)metric]));
  stack_idx--;
}
 
QualityService::FrameTimings QualityService::getFrameTimings() const
{
  size_t idx = (times_idx+TIMES_COUNT-1)%TIMES_COUNT;
  float frameTime = times[idx][(size_t)MetricType::Frame];
  float idleTime = times[idx][(size_t)MetricType::Idle];
  float presentTime = times[idx][(size_t)MetricType::Present];
  return {
    .frameTime = frameTime + idleTime,
    .cogsTime = frameTime,
    .cpuTime = frameTime - presentTime,
    .presentTime = presentTime,
    .idleTime = idleTime
  };
}
 
float QualityService::getMetric(MetricType metric)
{
  size_t idx = (times_idx+TIMES_COUNT-1)%TIMES_COUNT;
  return times[idx][(size_t)metric];
}