SkBitmapHasher: use 64-bit-truncated MD5 instead of 64-bit CityHash

gm/gmmain.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 /*
  * Code for the "gm" (Golden Master) rendering comparison tool.
  *
@@ skipping 20 matching lines @@
 #include "SkImageEncoder.h"
 #include "SkOSFile.h"
 #include "SkPicture.h"
 #include "SkRefCnt.h"
 #include "SkStream.h"
 #include "SkTArray.h"
 #include "SkTDict.h"
 #include "SkTileGridPicture.h"
 #include "SamplePipeControllers.h"
 
+#define EPOGER_TEST

[epoger, 2013/04/24 17:07:07]

patchset 1 adds timing reports, and disables --writePath and --writePicturePath
options (once we switch the bots over to using checksums, we won't write out all
the generated image files anymore)

+#ifdef EPOGER_TEST
+#include "SkTime.h"
+#endif
+
 #ifdef SK_BUILD_FOR_WIN
     // json includes xlocale which generates warning 4530 because we're compiling without
     // exceptions; see https://code.google.com/p/skia/issues/detail?id=1067
     #pragma warning(push)
     #pragma warning(disable : 4530)
 #endif
 #include "json/value.h"
 #ifdef SK_BUILD_FOR_WIN
     #pragma warning(pop)
 #endif
@@ skipping 1389 matching lines @@
             }
             if (!grSuccess) {
                 errorsForThisConfig.add(kNoGpuContext_ErrorType);
             }
         }
 #endif
 
         SkBitmap comparisonBitmap;
 
         const char* writePath;
+#ifdef EPOGER_TEST
+        writePath = NULL;
+#else
         if (FLAGS_writePath.count() == 1) {
             writePath = FLAGS_writePath[0];
         } else {
             writePath = NULL;
         }
+#endif
         if (errorsForThisConfig.isEmpty()) {
             errorsForThisConfig.add(gmmain.test_drawing(gm,config, writePath, gpuTarget,
                                                         &comparisonBitmap));
         }
 
         if (FLAGS_deferred && errorsForThisConfig.isEmpty() &&
             (kGPU_Backend == config.fBackend || kRaster_Backend == config.fBackend)) {
             errorsForThisConfig.add(gmmain.test_deferred_drawing(gm, config, comparisonBitmap,
                                                                  gpuTarget));
         }
@@ skipping 43 matching lines @@
         } else {
             SkPicture* repict = gmmain.stream_to_new_picture(*pict);
             SkAutoUnref aurr(repict);
             SkBitmap bitmap;
             gmmain.generate_image_from_picture(gm, compareConfig, repict, &bitmap);
             errorsForAllModes.add(gmmain.compare_test_results_to_reference_bitmap(
                 name, renderModeDescriptor, bitmap, &comparisonBitmap));
         }
     }
 
+#ifdef EPOGER_TEST
+#else
     if ((1 == FLAGS_writePicturePath.count()) &&
         !(gmFlags & GM::kSkipPicture_Flag)) {
         const char* pictureSuffix = "skp";
         SkString path = make_filename(FLAGS_writePicturePath[0], "",
                                       gm->shortName(), pictureSuffix);
         SkFILEWStream stream(path.c_str());
         pict->serialize(&stream);
     }
+#endif
 
     if (FLAGS_rtree) {
         const char renderModeDescriptor[] = "-rtree";
         if (gmFlags & GM::kSkipPicture_Flag) {
             gmmain.RecordTestResults(kIntentionallySkipped_ErrorType, name, renderModeDescriptor);
             errorsForAllModes.add(kIntentionallySkipped_ErrorType);
         } else {
             SkPicture* pict = gmmain.generate_new_picture(
                 gm, kRTree_BbhType, SkPicture::kUsePathBoundsForClip_RecordingFlag);
             SkAutoUnref aur(pict);
@@ skipping 89 matching lines @@
     return total;
 }
 
 int tool_main(int argc, char** argv);
 int tool_main(int argc, char** argv) {
 
 #if SK_ENABLE_INST_COUNT
     gPrintInstCount = true;
 #endif
 
+#ifdef EPOGER_TEST
+    SkMSec timeStart = SkTime::GetMSecs();
+#endif
+
     SkGraphics::Init();
     // we don't need to see this during a run
     gSkSuppressFontCachePurgeSpew = true;
 
     setSystemPreferences();
     GMMain gmmain;
 
     SkTDArray<size_t> configs;
     SkTDArray<size_t> excludeConfigs;
     bool userConfig = false;
@@ skipping 147 matching lines @@
         } else {
             if (FLAGS_verbose) {
                 gm_fprintf(stdout, "reading expectations from JSON summary file %s\n", readPath);
             }
             gmmain.fExpectationsSource.reset(SkNEW_ARGS(
                 JsonExpectationsSource, (readPath)));
         }
     }
     if (FLAGS_verbose) {
         if (FLAGS_writePath.count() == 1) {
+#ifdef EPOGER_TEST
+            gm_fprintf(stdout, "EPOGER_TEST: NOT writing to %s\n", FLAGS_writePath[0]);
+#else
             gm_fprintf(stdout, "writing to %s\n", FLAGS_writePath[0]);
+#endif
         }
         if (FLAGS_writePicturePath.count() == 1) {
+#ifdef EPOGER_TEST
+            gm_fprintf(stdout, "EPOGER_TEST: NOT writing pictures to %s\n", FLAGS_writePicturePath[0]);
+#else
             gm_fprintf(stdout, "writing pictures to %s\n", FLAGS_writePicturePath[0]);
+#endif
         }
         if (FLAGS_resourcePath.count() == 1) {
             gm_fprintf(stdout, "reading resources from %s\n", FLAGS_resourcePath[0]);
         }
     }
 
     if (moduloDivisor <= 0) {
         moduloRemainder = -1;
     }
     if (moduloRemainder < 0 || moduloRemainder >= moduloDivisor) {
         moduloRemainder = -1;
     }
 
     int gmsRun = 0;
     int gmIndex = -1;
     SkString moduloStr;
 
+#ifdef EPOGER_TEST
+#else
     // If we will be writing out files, prepare subdirectories.
     if (FLAGS_writePath.count() == 1) {
         if (!sk_mkdir(FLAGS_writePath[0])) {
             return -1;
         }
         if (gmmain.fUseFileHierarchy) {
             for (int i = 0; i < configs.count(); i++) {
                 ConfigData config = gRec[configs[i]];
                 SkString subdir;
                 subdir.appendf("%s%c%s", FLAGS_writePath[0], SkPATH_SEPARATOR,
                                config.fName);
                 if (!sk_mkdir(subdir.c_str())) {
                     return -1;
                 }
             }
         }
     }
+#endif
 
     if (FLAGS_pdfJpegQuality < -1 || FLAGS_pdfJpegQuality > 100) {
         gm_fprintf(stderr, "%s\n", "pdfJpegQuality must be in [-1 .. 100] range.");
     }
 
     Iter iter;
     GM* gm;
     while ((gm = iter.next()) != NULL) {
         SkAutoTDelete<GM> adgm(gm);
         ++gmIndex;
@@ skipping 27 matching lines @@
     }
 
     SkTArray<SkString> modes;
     gmmain.GetRenderModesEncountered(modes);
     bool reportError = false;
     if (gmmain.NumSignificantErrors() > 0) {
         reportError = true;
     }
     int expectedNumberOfTests = gmsRun * (configs.count() + modes.count());
 
+#ifdef EPOGER_TEST
+    SkMSec timeBeforeSummaryOutput = SkTime::GetMSecs();
+#endif
+
     // Output summary to stdout.
     if (FLAGS_verbose) {
         gm_fprintf(stdout, "Ran %d GMs\n", gmsRun);
         gm_fprintf(stdout, "... over %2d configs [%s]\n", configs.count(),
                    list_all_config_names(configs).c_str());
         gm_fprintf(stdout, "...  and %2d modes   [%s]\n", modes.count(), list_all(modes).c_str());
         gm_fprintf(stdout, "... so there should be a total of %d tests.\n", expectedNumberOfTests);
     }
     gmmain.ListErrors(FLAGS_verbose);
 
     // TODO(epoger): Enable this check for Android, too, once we resolve
     // https://code.google.com/p/skia/issues/detail?id=1222
     // ('GM is unexpectedly skipping tests on Android')
 #ifndef SK_BUILD_FOR_ANDROID
     if (expectedNumberOfTests != gmmain.fTestsRun) {
         gm_fprintf(stderr, "expected %d tests, but ran or skipped %d tests\n",
                    expectedNumberOfTests, gmmain.fTestsRun);
         reportError = true;
     }
 #endif
 
+#ifdef EPOGER_TEST
+    Json::Value actualResults;
+    actualResults[kJsonKey_ActualResults_Failed] =
+        gmmain.fJsonActualResults_Failed;
+    actualResults[kJsonKey_ActualResults_FailureIgnored] =
+        gmmain.fJsonActualResults_FailureIgnored;
+    actualResults[kJsonKey_ActualResults_NoComparison] =
+        gmmain.fJsonActualResults_NoComparison;
+    actualResults[kJsonKey_ActualResults_Succeeded] =
+        gmmain.fJsonActualResults_Succeeded;
+    Json::Value root;
+    root[kJsonKey_ActualResults] = actualResults;
+    root[kJsonKey_ExpectedResults] = gmmain.fJsonExpectedResults;
+    std::string jsonStdString = root.toStyledString();
+    printf("%s\n", jsonStdString.c_str());
+#endif
+
     if (FLAGS_writeJsonSummaryPath.count() == 1) {
         Json::Value actualResults;
         actualResults[kJsonKey_ActualResults_Failed] =
             gmmain.fJsonActualResults_Failed;
         actualResults[kJsonKey_ActualResults_FailureIgnored] =
             gmmain.fJsonActualResults_FailureIgnored;
         actualResults[kJsonKey_ActualResults_NoComparison] =
             gmmain.fJsonActualResults_NoComparison;
         actualResults[kJsonKey_ActualResults_Succeeded] =
             gmmain.fJsonActualResults_Succeeded;
@@ skipping 17 matching lines @@
             gm_fprintf(stdout, "config: %s %x\n", config.fName, gr);
             gr->printCacheStats();
         }
     }
 #endif
 
     delete grFactory;
 #endif
     SkGraphics::Term();
 
+#ifdef EPOGER_TEST
+    SkMSec timeEnd = SkTime::GetMSecs();
+    printf("EPOGER_TEST timings: %d msecs before summary output, %d msecs total\n",
+           (timeBeforeSummaryOutput - timeStart), (timeEnd - timeStart));
+#endif
+
     return (reportError) ? -1 : 0;
 }
 
 void GMMain::installFilter(SkCanvas* canvas) {
     if (FLAGS_forceBWtext) {
         canvas->setDrawFilter(SkNEW(BWTextDrawFilter))->unref();
     }
 }
 
 #if !defined(SK_BUILD_FOR_IOS) && !defined(SK_BUILD_FOR_NACL)
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif