GPU program cache - switched to high res timings, and time report binary cache miss without the cac…

gpu/command_buffer/service/program_manager.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/program_manager.h"
 
 #include <algorithm>
 #include <set>
 #include <utility>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/string_number_conversions.h"
 #include "base/time.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
 #include "gpu/command_buffer/service/program_cache.h"
 
 using base::TimeDelta;
+using base::TimeTicks;
 
 namespace gpu {
 namespace gles2 {
 
 namespace {
 
 int ShaderTypeToIndex(GLenum shader_type) {
   switch (shader_type) {
     case GL_VERTEX_SHADER:
       return 0;
@@ skipping 341 matching lines @@
        it != bind_attrib_location_map_.end(); ++it) {
     const std::string* mapped_name = GetAttribMappedName(it->first);
     if (mapped_name && *mapped_name != it->first)
       glBindAttribLocation(service_id_, it->second, mapped_name->c_str());
   }
 }
 
 void ProgramManager::DoCompileShader(ShaderManager::ShaderInfo* info,
                                      ShaderTranslator* translator,
                                      FeatureInfo* feature_info) {
-  base::Time before = base::Time::Now();
+  TimeTicks before = TimeTicks::HighResNow();
   if (program_cache_ &&
       program_cache_->GetShaderCompilationStatus(info->source() ?
                                                  *info->source() : "") ==
           ProgramCache::COMPILATION_SUCCEEDED) {
     info->SetStatus(true, "", translator);
     info->FlagSourceAsCompiled(false);
-    UMA_HISTOGRAM_CUSTOM_COUNTS("GPU.ProgramCache.CompilationCacheHitTime",
-                                (base::Time::Now() - before).InMicroseconds(),
-                                0,
-                                TimeDelta::FromSeconds(1).InMicroseconds(),
-                                50);
+    UMA_HISTOGRAM_CUSTOM_COUNTS(
+        "GPU.ProgramCache.CompilationCacheHitTime",
+        (TimeTicks::HighResNow() - before).InMicroseconds(),
+        0,
+        TimeDelta::FromSeconds(1).InMicroseconds(),
+        50);
     return;
   }
   ForceCompileShader(info->source(), info, translator, feature_info);
-  UMA_HISTOGRAM_CUSTOM_COUNTS("GPU.ProgramCache.CompilationCacheMissTime",
-                              (base::Time::Now() - before).InMicroseconds(),
-                              0,
-                              TimeDelta::FromSeconds(1).InMicroseconds(),
-                              50);
+  UMA_HISTOGRAM_CUSTOM_COUNTS(
+      "GPU.ProgramCache.CompilationCacheMissTime",
+      (TimeTicks::HighResNow() - before).InMicroseconds(),
+      0,
+      TimeDelta::FromSeconds(1).InMicroseconds(),
+      50);
 }
 
 void ProgramManager::ForceCompileShader(const std::string* source,
                                         ShaderManager::ShaderInfo* info,
                                         ShaderTranslator* translator,
                                         FeatureInfo* feature_info) {
   info->FlagSourceAsCompiled(true);
 
   // Translate GL ES 2.0 shader to Desktop GL shader and pass that to
   // glShaderSource and then glCompileShader.
@@ skipping 61 matching lines @@
   if (!CanLink()) {
     set_log_info("missing shaders");
     return false;
   }
   if (DetectAttribLocationBindingConflicts()) {
     set_log_info("glBindAttribLocation() conflicts");
     return false;
   }
   ExecuteBindAttribLocationCalls();
 
-  base::Time before_time = base::Time::Now();
+  TimeTicks before_time = TimeTicks::HighResNow();
   bool link = true;
   ProgramCache* cache = manager_->program_cache_;
   if (cache) {
     ProgramCache::LinkedProgramStatus status = cache->GetLinkedProgramStatus(
         *attached_shaders_[0]->deferred_compilation_source(),
         *attached_shaders_[1]->deferred_compilation_source(),
         &bind_attrib_location_map_);
 
     if (status == ProgramCache::LINK_SUCCEEDED) {
       ProgramCache::ProgramLoadResult success = cache->LoadLinkedProgram(
@@ skipping 20 matching lines @@
                                        attached_shaders_[i],
                                        translator,
                                        feature_info);
           CHECK(info->IsValid());
         }
       }
     }
   }
 
   if (link) {
-    before_time = base::Time::Now();
+    before_time = TimeTicks::HighResNow();
     if (cache && gfx::g_GL_ARB_get_program_binary) {
       glProgramParameteri(service_id(),
                           PROGRAM_BINARY_RETRIEVABLE_HINT,
                           GL_TRUE);
     }
     glLinkProgram(service_id());
   }
 
   GLint success = 0;
   glGetProgramiv(service_id(), GL_LINK_STATUS, &success);
   if (success == GL_TRUE) {
     Update();
     if (cache && link) {
       cache->SaveLinkedProgram(service_id(),
                                attached_shaders_[0],
                                attached_shaders_[1],
                                &bind_attrib_location_map_);
       UMA_HISTOGRAM_CUSTOM_COUNTS(
           "GPU.ProgramCache.BinaryCacheMissTime",
-          (base::Time::Now() - before_time).InMicroseconds(),
+          (TimeTicks::HighResNow() - before_time).InMicroseconds(),
           0,
           TimeDelta::FromSeconds(10).InMicroseconds(),
           50);
-    } else if (cache) {
-      UMA_HISTOGRAM_CUSTOM_COUNTS(
-          "GPU.ProgramCache.BinaryCacheHitTime",
-          (base::Time::Now() - before_time).InMicroseconds(),
-          0,
-          TimeDelta::FromSeconds(1).InMicroseconds(),
-          50);
     }
+    UMA_HISTOGRAM_CUSTOM_COUNTS(
+        "GPU.ProgramCache.BinaryCacheHitTime",
+        (TimeTicks::HighResNow() - before_time).InMicroseconds(),
+        0,
+        TimeDelta::FromSeconds(1).InMicroseconds(),
+        50);
   } else {
     UpdateLogInfo();
   }
   return success == GL_TRUE;
 }
 
 void ProgramManager::ProgramInfo::Validate() {
   if (!IsValid()) {
     set_log_info("program not linked");
     return;
@@ skipping 577 matching lines @@
     info->ClearUniforms(&zero_);
   }
 }
 
 int32 ProgramManager::MakeFakeLocation(int32 index, int32 element) {
   return index + element * 0x10000;
 }
 
 }  // namespace gles2
 }  // namespace gpu