Update bench pictures to time image decode & upload costs

tools/PictureBenchmark.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBenchLogger.h"
 #include "BenchTimer.h"
 #include "PictureBenchmark.h"
 #include "SkCanvas.h"
 #include "SkPicture.h"
 #include "SkString.h"
 #include "picture_utils.h"
 
 namespace sk_tools {
 
 PictureBenchmark::PictureBenchmark()
 : fRepeats(1)
 , fLogger(NULL)
 , fRenderer(NULL)
 , fTimerResult(TimerData::kAvg_Result)
 , fTimerTypes(0)
 , fTimeIndividualTiles(false)
+, fPurgeDecodedTex(false)
 {}
 
 PictureBenchmark::~PictureBenchmark() {
     SkSafeUnref(fRenderer);
 }
 
 void PictureBenchmark::setTimersToShow(bool wall,
                                        bool truncatedWall,
                                        bool cpu,
                                        bool truncatedCpu,
@@ skipping 37 matching lines @@
         return;
     }
 
     fRenderer->init(pict);
 
     // We throw this away to remove first time effects (such as paging in this program)
     fRenderer->setup();
     fRenderer->render(NULL);
     fRenderer->resetState(true);
 
+    if (fPurgeDecodedTex) {
+        fRenderer->purgeTextures();
+    }
+
     bool usingGpu = false;
 #if SK_SUPPORT_GPU
     usingGpu = fRenderer->isUsingGpuDevice();
 #endif
 
     uint32_t timerTypes = fTimerTypes;
     if (!usingGpu) {
         timerTypes &= ~TimerData::kGpu_Flag;
     }
 
@@ skipping 41 matching lines @@
             SkAutoTDelete<BenchTimer> perTileTimer(this->setupTimer(false));
             TimerData perTileTimerData(fRepeats);
             longRunningTimer->start();
             for (int i = 0; i < fRepeats; ++i) {
                 perTileTimer->start();
                 tiledRenderer->drawCurrentTile();
                 perTileTimer->truncatedEnd();
                 tiledRenderer->resetState(false);
                 perTileTimer->end();
                 SkAssertResult(perTileTimerData.appendTimes(perTileTimer.get()));
+
+                if (fPurgeDecodedTex) {
+                    fRenderer->purgeTextures();
+                }
             }
             longRunningTimer->truncatedEnd();
             tiledRenderer->resetState(true);
             longRunningTimer->end();
             SkAssertResult(longRunningTimerData.appendTimes(longRunningTimer.get()));
 
             SkString configName = tiledRenderer->getConfigName();
             configName.appendf(": tile [%i,%i] out of [%i,%i]", x, y, xTiles, yTiles);
 
             SkString result = perTileTimerData.getResult(timeFormat.c_str(), fTimerResult,
                                                          configName.c_str(), timerTypes);
             result.append("\n");
 
 // TODO(borenet): Turn off per-iteration tile time reporting for now.  Avoiding logging the time
 // for every iteration for each tile cuts down on data file size by a significant amount. Re-enable
 // this once we're loading the bench data directly into a data store and are no longer generating
 // SVG graphs.
 #if 0
             this->logProgress(result.c_str());
 #endif
-
+            if (fPurgeDecodedTex) {
+                configName.append(" <withPurging>");
+            }
             configName.append(" <averaged>");
             SkString longRunningResult = longRunningTimerData.getResult(
                 tiledRenderer->getNormalTimeFormat().c_str(),
                 TimerData::kAvg_Result,
                 configName.c_str(), timerTypes, fRepeats);
             longRunningResult.append("\n");
             this->logProgress(longRunningResult.c_str());
         }
     } else {
         SkAutoTDelete<BenchTimer> longRunningTimer(this->setupTimer());
         TimerData longRunningTimerData(1);
         SkAutoTDelete<BenchTimer> perRunTimer(this->setupTimer(false));
         TimerData perRunTimerData(fRepeats);
 
         longRunningTimer->start();
         for (int i = 0; i < fRepeats; ++i) {
             fRenderer->setup();
 
             perRunTimer->start();
             fRenderer->render(NULL);
             perRunTimer->truncatedEnd();
             fRenderer->resetState(false);
             perRunTimer->end();
 
             SkAssertResult(perRunTimerData.appendTimes(perRunTimer.get()));
+
+            if (fPurgeDecodedTex) {
+                fRenderer->purgeTextures();
+            }
         }
         longRunningTimer->truncatedEnd();
         fRenderer->resetState(true);
         longRunningTimer->end();
         SkAssertResult(longRunningTimerData.appendTimes(longRunningTimer.get()));
 
         SkString configName = fRenderer->getConfigName();
+        if (fPurgeDecodedTex) {
+            configName.append(" <withPurging>");
+        }
 
         // Beware - since the per-run-timer doesn't ever include a glFinish it can
         // report a lower time then the long-running-timer
 #if 0
         SkString result = perRunTimerData.getResult(timeFormat.c_str(),
                                                     fTimerResult,
                                                     configName.c_str(),
                                                     timerTypes);
         result.append("\n");
 
         this->logProgress(result.c_str());
 #else
         SkString result = longRunningTimerData.getResult(timeFormat.c_str(), 
                                                          fTimerResult, 
                                                          configName.c_str(), 
                                                          timerTypes, 
                                                          fRepeats);
         result.append("\n");
         this->logProgress(result.c_str());
 #endif
     }
 
     fRenderer->end();
 }
 
 }