Implementation of the GreenWeb language extensions.

gpu/command_buffer/service/gles2_cmd_decoder.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
 #include <stdio.h>
 
 #include <algorithm>
 #include <cmath>
+#include <iostream>
 #include <list>
 #include <map>
 #include <queue>
 
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 48 matching lines @@
 #include "ui/gl/gl_surface.h"
 #include "ui/gl/gl_version_info.h"
 #include "ui/gl/gpu_timing.h"
 
 #if defined(OS_MACOSX)
 #include <IOSurface/IOSurface.h>
 // Note that this must be included after gl_bindings.h to avoid conflicts.
 #include <OpenGL/CGLIOSurface.h>
 #endif
 
+#include "content/renderer/greenweb_latency_tracking.h"
+
 namespace gpu {
 namespace gles2 {
 
 namespace {
 
 const char kOESDerivativeExtension[] = "GL_OES_standard_derivatives";
 const char kEXTFragDepthExtension[] = "GL_EXT_frag_depth";
 const char kEXTDrawBuffersExtension[] = "GL_EXT_draw_buffers";
 const char kEXTShaderTextureLodExtension[] = "GL_EXT_shader_texture_lod";
 
@@ skipping 11831 matching lines @@
       LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glShaderBinary", "unknown shader");
       return error::kNoError;
     }
     service_ids[ii] = shader->service_id();
   }
   // TODO(gman): call glShaderBinary
   return error::kNoError;
 #endif
 }
 
+void set_freq(uint32 freq)
+{
+  FILE *cpufreq = NULL;
+
+  if(!cpufreq)
+  {
+    cpufreq = fopen("/sys/devices/system/cpu/cpu0/cpufreq/scaling_setspeed", "w");
+    if(!cpufreq)
+      dbg_sched_fprintf(stdout, "[EBS] file open failed\n");
+  }
+
+  if(cpufreq)
+  {
+    int bytes = fprintf(cpufreq, "%u", freq);
+    if((bytes != 6) && (bytes != 7))
+      dbg_sched_fprintf(stdout, "[EBS] cpufreq not set\n");
+    fclose(cpufreq);
+  }
+}
+
+uint32 schedule(int64 latency, uint32 freq, int64 target) {
+  uint32 next_freq;
+  float target_f, latency_f;
+  target_f = (float)target;
+  latency_f = (float)latency;
+
+  if (latency_f > target_f * 0.9) {
+    // Under predicting
+    if (latency_f > target_f * 2)
+      next_freq = 16;
+    else {
+      if(freq == 16) next_freq = 16;
+      else if(freq == 6) next_freq = 8;
+      else next_freq = freq + 1;
+    }
+  }
+  else if (latency_f < target_f * 0.8) {
+    // Over predicting
+    if (target_f > latency_f * 2)
+      next_freq = 4;
+    else {
+      if(freq == 4) next_freq = 4;
+      else if(freq == 8) next_freq = 6;
+      else next_freq = freq - 1;
+    }
+  }
+  else {
+    // Keep last prediction
+    next_freq = freq;
+  }
+
+#ifdef EBS_DEBUG_TRACE_EVENT
+  TRACE_EVENT2("gpu", "SetFrequency",
+               "previous frame latency", latency,
+               "freq", next_freq);
+#endif
+
+  return next_freq;
+}
+
 void GLES2DecoderImpl::DoSwapBuffers() {
+  static base::TimeTicks frame_ts;
+  base::TimeTicks ts = base::TimeTicks::Now();
+  base::TimeDelta frame_latency = ts - frame_ts;
+  int64 frame_latency_in_ms = frame_latency.InMilliseconds();
+  frame_ts = ts;
+
+  dbg_ipc_cout("GPU: g_ebs_enabled " << g_ebs_enabled <<
+      ", g_qos_type " << g_qos_type <<
+      ", g_qos_target" << g_qos_target);
+  if (g_ebs_enabled && (g_qos_type == 'c')) {
+    static uint32 last_freq;
+
+    uint32 next_freq = schedule(frame_latency_in_ms,
+                                last_freq,
+                                g_qos_target);
+    set_freq(next_freq * 100000);
+    last_freq = next_freq;
+    dbg_sched_fprintf(stdout, "[EBS] set freq to %u last_latency %lld\n", next_freq, frame_latency_in_ms);
+  }
+#ifdef EBS_DEBUG_OS
+  else {
+    fprintf(stdout, "[OS] last_latency %lld\n", frame_latency_in_ms);
+  }
+#endif
+  fflush(stdout);
+
   bool is_offscreen = !!offscreen_target_frame_buffer_.get();
 
   int this_frame_number = frame_number_++;
   // TRACE_EVENT for gpu tests:
   TRACE_EVENT_INSTANT2("test_gpu", "SwapBuffersLatency",
                        TRACE_EVENT_SCOPE_THREAD,
                        "GLImpl", static_cast<int>(gfx::GetGLImplementation()),
                        "width", (is_offscreen ? offscreen_size_.width() :
                                  surface_->GetSize().width()));
   TRACE_EVENT2("gpu", "GLES2DecoderImpl::DoSwapBuffers",
@@ skipping 3486 matching lines @@
   return error::kNoError;
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu