revert 4478

git-svn-id: http://skia.googlecode.com/svn/trunk@4479 2bbb7eff-a529-9590-31e7-b0007b416f81

bench/ChecksumBench.cpp

@@ -7,41 +7,97 @@
 #include "SkBenchmark.h"
 #include "SkCanvas.h"
 #include "SkChecksum.h"
-#include "SkRandom.h"
+#include "SkString.h"
 
 class ComputeChecksumBench : public SkBenchmark {
+public:
+    ComputeChecksumBench(void* param, const char name[]) : INHERITED(param) {
+        fName.printf("compute_checksum_%s", name);
+    }
+
     enum {
-        U32COUNT  = 256,
+        DATA_SIZE = 1024,
-        SIZE      = U32COUNT * 4,
         N         = SkBENCHLOOP(100000),
     };
-    uint32_t    fData[U32COUNT];
-
-public:
-    ComputeChecksumBench(void* param) : INHERITED(param) {
-        SkRandom rand;
-        for (int i = 0; i < U32COUNT; ++i) {
-            fData[i] = rand.nextU();
-        }
-    }
-
 protected:
     virtual const char* onGetName() {
-        return "compute_checksum";
+        return fName.c_str();
     }
 
     virtual void onDraw(SkCanvas* canvas) {
-        for (int i = 0; i < N; i++) {
+        uint64_t data[DATA_SIZE / sizeof(uint64_t)];
-            volatile uint32_t result = SkChecksum::Compute(fData, sizeof(fData));
+        computeChecksum(data, DATA_SIZE);
-        }
     }
 
+    virtual void computeChecksum(const uint64_t*, size_t) = 0;
+
+    SkString fName;
 private:
     typedef SkBenchmark INHERITED;
 };
 
+/*
+ *  Use SkComputeChecksum32 to compute a checksum on a datablock
+ */
+class ComputeChecksum32Bench : public ComputeChecksumBench {
+public:
+    ComputeChecksum32Bench(void* param)
+        : INHERITED(param, "32") { }
+
+protected:
+    virtual void computeChecksum(const uint64_t* data, size_t len) {
+        for (int i = 0; i < N; i++) {
+            volatile uint32_t result = SkComputeChecksum32(reinterpret_cast<const uint32_t*>(data), len);
+        }
+    }
+
+private:
+    typedef ComputeChecksumBench INHERITED;
+};
+
+/*
+ *  Use SkComputeChecksum64 to compute a checksum on a datablock
+ */
+class ComputeChecksum64Bench : public ComputeChecksumBench {
+public:
+    ComputeChecksum64Bench(void* param)
+    : INHERITED(param, "64") { }
+    
+protected:
+    virtual void computeChecksum(const uint64_t* data, size_t len) {
+        for (int i = 0; i < N; i++) {
+            volatile uint64_t result = SkComputeChecksum64(data, len);
+        }
+    }
+    
+private:
+    typedef ComputeChecksumBench INHERITED;
+};
+
+/*
+ *  Use SkComputeChecksum64 to compute a checksum on a datablock
+ */
+class ComputeChecksumXXBench : public ComputeChecksumBench {
+public:
+    ComputeChecksumXXBench(void* param) : INHERITED(param, "XX") { }
+    
+protected:
+    virtual void computeChecksum(const uint64_t* data, size_t len) {
+        for (int i = 0; i < N; i++) {
+            volatile uint32_t result = SkChecksum::Compute(reinterpret_cast<const uint32_t*>(data), len);
+        }
+    }
+    
+private:
+    typedef ComputeChecksumBench INHERITED;
+};
+
 ///////////////////////////////////////////////////////////////////////////////
 
-static SkBenchmark* Fact0(void* p) { return new ComputeChecksumBench(p); }
+static SkBenchmark* Fact0(void* p) { return new ComputeChecksum32Bench(p); }
+static SkBenchmark* Fact1(void* p) { return new ComputeChecksum64Bench(p); }
+static SkBenchmark* Fact2(void* p) { return new ComputeChecksumXXBench(p); }
 
 static BenchRegistry gReg0(Fact0);
+static BenchRegistry gReg1(Fact1);
+static BenchRegistry gReg2(Fact2);

include/core/SkChecksum.h

@@ -10,6 +10,64 @@
 
 #include "SkTypes.h"
 
+#if !defined(SK_PREFER_32BIT_CHECKSUM)
+#define SK_PREFER_32BIT_CHECKSUM 0
+#endif
+
+enum {
+    ChecksumRotateBits = 17
+};
+
+#define SkCHECKSUM_MASH(CHECKSUM, NEW_CHUNK) \
+    CHECKSUM = (((CHECKSUM) >> (sizeof(CHECKSUM)*8 - ChecksumRotateBits)) + \
+        ((CHECKSUM) << ChecksumRotateBits)) ^ (NEW_CHUNK);
+
+
+/**
+ *  Compute a 64-bit checksum for a given data block
+ *
+ *  @param data Memory address of the data block to be processed. Must be
+ *      32-bit aligned
+ *  @param size Size of the data block in bytes. Must be a multiple of 8.
+ *  @return checksum result
+ */
+inline uint64_t SkComputeChecksum64(const uint64_t* ptr, size_t size) {
+    SkASSERT(SkIsAlign8(size));
+    // Strict 8-byte alignment is not required on ptr. On current
+    // CPUs there is no measurable performance difference between 32-bit
+    // and 64-bit aligned access to uint64_t data
+    SkASSERT(SkIsAlign4((intptr_t)ptr));
+
+    const uint64_t* stop = ptr + (size >> 3);
+    uint64_t result = 0;
+    while (ptr < stop) {
+        SkCHECKSUM_MASH(result, *ptr);
+        ptr++;
+    }
+    return result;
+}
+
+/**
+ *  Compute a 32-bit checksum for a given data block
+ *
+ *  @param data Memory address of the data block to be processed. Must be
+ *      32-bit aligned.
+ *  @param size Size of the data block in bytes. Must be a multiple of 4.
+ *  @return checksum result
+ */
+inline uint32_t SkComputeChecksum32(const uint32_t* ptr, size_t size) {
+    SkASSERT(SkIsAlign4(size));
+    SkASSERT(SkIsAlign4((intptr_t)ptr));
+
+    const uint32_t* stop = ptr + (size >> 2);
+    uint32_t result = 0;
+    while (ptr < stop) {
+        SkCHECKSUM_MASH(result, *ptr);
+        ptr++;
+    }
+    return result;
+}
+
 class SkChecksum : SkNoncopyable {
 private:
     /*

include/core/SkDescriptor.h

@@ -15,29 +15,34 @@
 
 class SkDescriptor : SkNoncopyable {
 public:
-    static size_t ComputeOverhead(int entryCount) {
+    static size_t ComputeOverhead(int entryCount)
+    {
         SkASSERT(entryCount >= 0);
         return sizeof(SkDescriptor) + entryCount * sizeof(Entry);
     }
 
-    static SkDescriptor* Alloc(size_t length) {
+    static SkDescriptor* Alloc(size_t length)
+    {
         SkASSERT(SkAlign4(length) == length);
         SkDescriptor* desc = (SkDescriptor*)sk_malloc_throw(length);
         return desc;
     }
 
-    static void Free(SkDescriptor* desc) {
+    static void Free(SkDescriptor* desc)
+    {
         sk_free(desc);
     }
 
-    void init() {
+    void init()
+    {
         fLength = sizeof(SkDescriptor);
         fCount  = 0;
     }
 
     uint32_t getLength() const { return fLength; }
 
-    void* addEntry(uint32_t tag, uint32_t length, const void* data = NULL) {
+    void* addEntry(uint32_t tag, uint32_t length, const void* data = NULL)
+    {
         SkASSERT(tag);
         SkASSERT(SkAlign4(length) == length);
         SkASSERT(this->findEntry(tag, NULL) == NULL);
@@ -45,34 +50,37 @@ public:
         Entry*  entry = (Entry*)((char*)this + fLength);
         entry->fTag = tag;
         entry->fLen = length;
-        if (data) {
+        if (data)
             memcpy(entry + 1, data, length);
-        }
 
         fCount += 1;
         fLength += sizeof(Entry) + length;
         return (entry + 1); // return its data
     }
 
-    void computeChecksum() {
+    void computeChecksum()
+    {
         fChecksum = SkDescriptor::ComputeChecksum(this);
     }
 
 #ifdef SK_DEBUG
-    void assertChecksum() const {
+    void assertChecksum() const
-        SkASSERT(SkDescriptor::ComputeChecksum(this) == fChecksum);
+    {
+        SkASSERT(fChecksum == SkDescriptor::ComputeChecksum(this));
     }
 #endif
 
-    const void* findEntry(uint32_t tag, uint32_t* length) const {
+    const void* findEntry(uint32_t tag, uint32_t* length) const
+    {
         const Entry* entry = (const Entry*)(this + 1);
         int          count = fCount;
 
-        while (--count >= 0) {
+        while (--count >= 0)
-            if (entry->fTag == tag) {
+        {
-                if (length) {
+            if (entry->fTag == tag)
+            {
+                if (length)
                     *length = entry->fLen;
-                }
                 return entry + 1;
             }
             entry = (const Entry*)((const char*)(entry + 1) + entry->fLen);
@@ -80,13 +88,15 @@ public:
         return NULL;
     }
 
-    SkDescriptor* copy() const {
+    SkDescriptor* copy() const
+    {
         SkDescriptor* desc = SkDescriptor::Alloc(fLength);
         memcpy(desc, this, fLength);
         return desc;
     }
 
-    bool equals(const SkDescriptor& other) const {
+    bool equals(const SkDescriptor& other) const
+    {
         // probe to see if we have a good checksum algo
 //        SkASSERT(a.fChecksum != b.fChecksum || memcmp(&a, &b, a.fLength) == 0);
 
@@ -120,10 +130,11 @@ private:
     uint32_t fLength;    // must be second
     uint32_t fCount;
 
-    static uint32_t ComputeChecksum(const SkDescriptor* desc) {
+    static uint32_t ComputeChecksum(const SkDescriptor* desc)
+    {
         const uint32_t* ptr = (const uint32_t*)desc + 1; // skip the checksum field
-        size_t len = desc->fLength - sizeof(uint32_t);
+        const size_t len = desc->fLength-sizeof(uint32_t);
-        return SkChecksum::Compute(ptr, len);
+        return SkComputeChecksum32(ptr, len);
     }
     
     // private so no one can create one except our factories
@@ -134,20 +145,18 @@ private:
 
 class SkAutoDescriptor : SkNoncopyable {
 public:
-    SkAutoDescriptor(size_t size) {
+    SkAutoDescriptor(size_t size)
-        if (size <= sizeof(fStorage)) {
+    {
+        if (size <= sizeof(fStorage))
             fDesc = (SkDescriptor*)(void*)fStorage;
-        } else {
+        else
             fDesc = SkDescriptor::Alloc(size);
     }
-    }
+    ~SkAutoDescriptor()
-
+    {
-    ~SkAutoDescriptor() {
+        if (fDesc != (SkDescriptor*)(void*)fStorage)
-        if (fDesc != (SkDescriptor*)(void*)fStorage) {
             SkDescriptor::Free(fDesc);
     }
-    }
-
     SkDescriptor* getDesc() const { return fDesc; }
 private:
     enum {

src/core/SkPictureFlat.cpp

@@ -80,6 +80,12 @@ SkFlatData* SkFlatData::Create(SkChunkAlloc* heap, const void* obj,
     flattenProc(buffer, obj);
     uint32_t size = buffer.size();
 
+
+#if !SK_PREFER_32BIT_CHECKSUM
+    uint32_t unpaddedSize = size;
+    size = SkAlign8(size);
+#endif
+
     // allocate enough memory to hold both SkFlatData and the serialized
     // contents
     SkFlatData* result = (SkFlatData*) heap->allocThrow(size + sizeof(SkFlatData));
@@ -88,7 +94,18 @@ SkFlatData* SkFlatData::Create(SkChunkAlloc* heap, const void* obj,
 
     // put the serialized contents into the data section of the new allocation
     buffer.flatten(result->data());
-    result->fChecksum = SkChecksum::Compute(result->data32(), size);
+#if SK_PREFER_32BIT_CHECKSUM
+    result->fChecksum =
+        SkComputeChecksum32(reinterpret_cast<uint32_t*>(result->data()), size);
+#else
+    if (size != unpaddedSize) {
+        // Flat data is padded: put zeros in the last 32 bits.
+        SkASSERT(size - 4 == unpaddedSize);
+        *((uint32_t*)((char*)result->data() + unpaddedSize)) = 0;
+    }
+    result->fChecksum =
+        SkComputeChecksum64(reinterpret_cast<uint64_t*>(result->data()), size);
+#endif
     return result;
 }
 

src/core/SkPictureFlat.h

@@ -156,11 +156,16 @@ public:
 
     static int Compare(const SkFlatData* a, const SkFlatData* b) {
         size_t bytesToCompare = sizeof(a->fChecksum) + a->fAllocSize;
+#if SK_PREFER_32BIT_CHECKSUM
+        typedef uint32_t CompareType;
         SkASSERT(SkIsAlign4(bytesToCompare));
-
+#else
-        const uint32_t* a_ptr = &(a->fChecksum);
+        typedef uint64_t CompareType;
-        const uint32_t* b_ptr = &(b->fChecksum);
+        SkASSERT(SkIsAlign8(bytesToCompare));
-        const uint32_t* stop = a_ptr + bytesToCompare / sizeof(uint32_t);
+#endif
+        const CompareType* a_ptr = &(a->fChecksum);
+        const CompareType* b_ptr = &(b->fChecksum);
+        const CompareType* stop = a_ptr + bytesToCompare / sizeof(CompareType);
         while(a_ptr < stop) {
             if (*a_ptr != *b_ptr) {
                 return (*a_ptr < *b_ptr) ? -1 : 1;
@@ -173,8 +178,6 @@ public:
     
     int index() const { return fIndex; }
     void* data() const { return (char*)this + sizeof(*this); }
-    // We guarantee that our data is 32bit aligned
-    uint32_t* data32() const { return (uint32_t*)this->data(); }
     
 #ifdef SK_DEBUG_SIZE
     size_t size() const { return sizeof(SkFlatData) + fAllocSize; }
@@ -196,7 +199,11 @@ private:
     int fIndex;
     int32_t fAllocSize;
     // fChecksum must be defined last in order to be contiguous with data()
+#if SK_PREFER_32BIT_CHECKSUM
     uint32_t fChecksum;
+#else
+    uint64_t fChecksum;
+#endif
 };
 
 template <class T>