Change the way ImageDecodeBench supplies data

Source/web/ImageDecodeBench.cpp

 // Copyright 2015 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.
 
 #ifdef WTF
 
 Provides a minimal wrapping of the Blink image decoders. Used to perform
 a non-threaded, memory-to-memory image decode using micro second accuracy
 clocks to measure image decode time. Optionally applies color correction
 during image decoding on supported platforms (default off). Usage:
 
   % ninja -C /out/Release image_decode_bench &&
      ./out/Release/image_decode_bench file [iterations]
 
 FIXME: Consider adding md5 checksum support to WTF. Use it to compute the
 decoded image frame md5 and output that value.
 
-FIXME: Consider adding an input data packetization option. Break the input
-into network-sized packets, pump the packets into the image decoder until
-the input data is complete (allDataReceived). This to include any internal
-SharedBuffer costs, such as buffer coalescing, in the reported results.
-
 FIXME: Consider integrating this tool in Chrome telemetry for realz, using
 the image corpii used to assess Blink image decode performance. Refer to
 http://crbug.com/398235#c103 and http://crbug.com/258324#c5
 
 #endif
 
 #include "config.h"
 
 #include "platform/SharedBuffer.h"
 #include "platform/image-decoders/ImageDecoder.h"
@@ skipping 230 matching lines @@
     OwnPtr<unsigned char[]> buffer = adoptArrayPtr(new unsigned char[fileSize]);
     if (fileSize != fread(buffer.get(), 1, fileSize, fp)) {
         fprintf(stderr, "Error reading file %s\n", fileName);
         exit(2);
     }
 
     fclose(fp);
     return SharedBuffer::create(buffer.get(), fileSize);
 }
 
-bool decodeImageData(SharedBuffer* data, bool colorCorrection)
+bool decodeImageData(SharedBuffer* data, bool colorCorrection, size_t chunkSize)
 {
     OwnPtr<ImageDecoder> decoder = ImageDecoder::create(*data,
         ImageDecoder::AlphaPremultiplied, colorCorrection ?
             ImageDecoder::GammaAndColorProfileApplied : ImageDecoder::GammaAndColorProfileIgnored);
 
-    bool allDataReceived = true;
-    decoder->setData(data, allDataReceived);
+    if (!chunkSize) {
+        bool allDataReceived = true;
+        decoder->setData(data, allDataReceived);
 
-    int frameCount = decoder->frameCount();
-    for (int i = 0; i < frameCount; ++i) {
-        if (!decoder->frameBufferAtIndex(i))
-            return false;
+        int frameCount = decoder->frameCount();
+        for (int i = 0; i < frameCount; ++i) {
+            if (!decoder->frameBufferAtIndex(i))
+                return false;
+        }
+
+        return !decoder->failed();
+    }
+
+    RefPtr<SharedBuffer> incrementalData = SharedBuffer::create();

[Noel Gordon, 2015/09/02 23:29:35]

incrementalData -> packetData ?

[scroggo, 2015/09/03 22:10:26]

Done.

+    unsigned position = 0;
+    while (true) {
+        const char* segment;

[Noel Gordon, 2015/09/02 23:29:35]

segment -> packet

[scroggo, 2015/09/03 22:10:26]

Done.

+        unsigned length = data->getSomeData(segment, position);
+
+        length = std::min(static_cast<size_t>(length), chunkSize);
+        incrementalData->append(segment, length);
+        position += length;
+        bool allDataReceived = position == data->size();

[Noel Gordon, 2015/09/02 23:29:35]

Space before this line.

[scroggo, 2015/09/03 22:10:26]

Done.

+        decoder->setData(incrementalData.get(), allDataReceived);
+
+        int frameCount = decoder->frameCount();
+        for (int i = 0; i < frameCount; ++i) {
+            if (!decoder->frameBufferAtIndex(i))
+                break;
+        }
+
+        if (allDataReceived || decoder->failed())
+            break;
     }
 
     return !decoder->failed();
 }
 
 int main(int argc, char* argv[])
 {
     char* name = argv[0];
 
     // If the platform supports color correction, allow it to be controlled.
 
     bool applyColorCorrection = false;
 
 #if USE(QCMSLIB)
     if (argc >= 2 && strcmp(argv[1], "--color-correct") == 0)
         applyColorCorrection = (--argc, ++argv, true);
 
     if (argc < 2) {
-        fprintf(stderr, "Usage: %s [--color-correct] file [iterations]\n", name);
+        fprintf(stderr, "Usage: %s [--color-correct] file [iterations] [chunkSize]\n", name);
         exit(1);
     }
 #else
     if (argc < 2) {
-        fprintf(stderr, "Usage: %s file [iterations]\n", name);
+        fprintf(stderr, "Usage: %s file [iterations] [chunkSize]\n", name);
         exit(1);
     }
 #endif
 
     // Control decode bench iterations.

[Noel Gordon, 2015/09/02 23:29:35]

... iterations and chunkSize.

[scroggo, 2015/09/03 22:10:26]

Done. I've also changed "chunkSize" to "packetSize".

 
     size_t iterations = 1;
     if (argc >= 3) {
         char* end = 0;
         iterations = strtol(argv[2], &end, 10);
         if (*end != '\0' || !iterations) {
             fprintf(stderr, "Second argument should be number of iterations. "
                 "The default is 1. You supplied %s\n", argv[2]);
             exit(1);
         }
     }
 
+    size_t chunkSize = 0;
+    if (argc >= 4) {
+        char* end = 0;
+        chunkSize = strtol(argv[3], &end, 10);
+        if (*end != '\0') {
+            fprintf(stderr, "Third argument should be chunk size. Default is "
+                "0, meaning to decode the entire image in one chunk. You "
+                "supplied %s\n", argv[3]);
+            exit(1);
+        }
+    }
+
     // Create a web platform without V8.
 
     class WebPlatform : public blink::Platform {
     public:
         const unsigned char* getTraceCategoryEnabledFlag(const char*) override
         {
             return reinterpret_cast<const unsigned char *>("nope-none-nada");
         }
 
         void cryptographicallyRandomValues(unsigned char*, size_t) override
@@ skipping 16 matching lines @@
 #endif
 
     // Read entire file content to data.
 
     RefPtr<SharedBuffer> data = readFile(argv[1]);
     if (!data.get() || !data->size()) {
         fprintf(stderr, "Error reading image data from [%s]\n", argv[1]);
         exit(2);
     }
 
+    // Merge the buffers. This imitates the MemCache case, where the data is

[Noel Gordon, 2015/09/02 23:29:35]

These details about Memcache and packet chunkSize are already in the ChangeLog. 
Adding them here threw me on first reading.  The mystery is data->data() and
what it does, so I'd focus on that ... something like 

// Consolidate the SharedBuffer data() segments into one, contiguous block of
memory.

to set the scene for all that follows?

[scroggo, 2015/09/03 22:10:26]

Done.

+    // consolidated before calling the decoder. This also means that if
+    // chunkSize is not zero, each call to SharedBuffer::append will be of size
+    // chunkSize (except the last, which may be smaller).
+    data->data();
+
     // Image decode bench for iterations.
 
     double totalTime = 0.0;
 
     for (size_t i = 0; i < iterations; ++i) {
         double startTime = getCurrentTime();
-        bool decoded = decodeImageData(data.get(), applyColorCorrection);
+        bool decoded = decodeImageData(data.get(), applyColorCorrection, chunkSize);
         double elapsedTime = getCurrentTime() - startTime;
         totalTime += elapsedTime;
         if (!decoded) {
             fprintf(stderr, "Image decode failed [%s]\n", argv[1]);
             exit(3);
         }
     }
 
     // Results to stdout.
 
     double averageTime = totalTime / static_cast<double>(iterations);
     printf("%f %f\n", totalTime, averageTime);
     return 0;
 }