commit c90a8c72af601bbeef3816a64fc1e59f97b75880
author Mike Klein <mtklein@google.com> Thu Feb 06 13:41:57 2020 -0600
committer Skia Commit-Bot <skia-commit-bot@chromium.org> Thu Feb 06 20:27:53 2020 +0000
tree 44060d32bd8f81ea26d79f91eda114fa1c31c086
parent ed9b1f1c1ede0b9b35a723d67435ab190d661b3d

calculate program hash in bulk

Now that Builder::Instructions are dense, it's easier to just calculate
Builder::hash() all at once when requested rather than as we go along.

(I'm planning to move the other use of Builder::Instruction hashing to
optimize() later too.)

Change-Id: I3124da5a3905291a907d08a12f62e794ed88e92d
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/269184
Commit-Queue: Mike Klein <mtklein@google.com>
Reviewed-by: Herb Derby <herb@google.com>

src/core/SkVM.cpp

diff --git a/src/core/SkVM.cpp b/src/core/SkVM.cpp
index 81498e0..6d354e2 100644
--- a/src/core/SkVM.cpp
+++ b/src/core/SkVM.cpp
@@ -455,6 +455,12 @@
         return {this->optimize(), fStrides, debug_name};
     }
 
+    uint64_t Builder::hash() const {
+        uint32_t lo = SkOpts::hash(fProgram.data(), fProgram.size() * sizeof(Instruction), 0),
+                 hi = SkOpts::hash(fProgram.data(), fProgram.size() * sizeof(Instruction), 1);
+        return (uint64_t)lo | (uint64_t)hi << 32;
+    }
+
     static bool operator==(const Builder::Instruction& a, const Builder::Instruction& b) {
         return a.op   == b.op
             && a.x    == b.x
@@ -468,19 +474,12 @@
         return SkOpts::hash(&inst, sizeof(inst), seed);
     }
 
-    uint64_t Builder::hash() const { return (uint64_t)fHashLo | (uint64_t)fHashHi << 32; }
 
     // Most instructions produce a value and return it by ID,
     // the value-producing instruction's own index in the program vector.
     Val Builder::push(Op op, Val x, Val y, Val z, int immy, int immz) {
         Instruction inst{op, x, y, z, immy, immz};
 
-        // This first InstructionHash{}() call should be free given we're about to use fIndex below.
-        fHashLo ^= InstructionHash{}(inst, 0);    // Two hash streams with different seeds.
-        fHashHi ^= InstructionHash{}(inst, 1);
-        fHashLo = SkChecksum::CheapMix(fHashLo);  // Mix to make sure instruction order matters.
-        fHashHi = SkChecksum::CheapMix(fHashHi);
-
         // Basic common subexpression elimination:
         // if we've already seen this exact Instruction, use it instead of creating a new one.
         if (Val* id = fIndex.find(inst)) {

src/core/SkVM.h

diff --git a/src/core/SkVM.h b/src/core/SkVM.h
index e5d34cf..fc6cf52 100644
--- a/src/core/SkVM.h
+++ b/src/core/SkVM.h
@@ -575,8 +575,6 @@
         SkTHashMap<Instruction, Val, InstructionHash> fIndex;
         std::vector<Instruction>                      fProgram;
         std::vector<int>                              fStrides;
-        uint32_t                                      fHashLo{0},
-                                                      fHashHi{0};
     };
 
     // Helper to streamline allocating and working with uniforms.