Merge 129796 - Rewrite multithreaded filter job dispatching

Source/WebCore/platform/graphics/filters/FEGaussianBlur.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2004, 2005 Rob Buis <buis@kde.org>
  * Copyright (C) 2005 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2009 Dirk Schulze <krit@webkit.org>
  * Copyright (C) 2010 Igalia, S.L.
  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 153 matching lines @@
 {
     int scanline = 4 * paintSize.width();
     int extraHeight = 3 * kernelSizeY * 0.5f;
     int optimalThreadNumber = (paintSize.width() * paintSize.height()) / (s_minimalRectDimension + extraHeight * paintSize.width());
 
     if (optimalThreadNumber > 1) {
         WTF::ParallelJobs<PlatformApplyParameters> parallelJobs(&platformApplyWorker, optimalThreadNumber);
 
         int jobs = parallelJobs.numberOfJobs();
         if (jobs > 1) {
-            int blockHeight = paintSize.height() / jobs;
-            --jobs;
-            for (int job = jobs; job >= 0; --job) {
+            // Split the job into "blockHeight"-sized jobs but there a few jobs that need to be slightly larger since
+            // blockHeight * jobs < total size. These extras are handled by the remainder "jobsWithExtra".
+            const int blockHeight = paintSize.height() / jobs;
+            const int jobsWithExtra = paintSize.height() % jobs;
+
+            int currentY = 0;
+            for (int job = 0; job < jobs; job++) {
                 PlatformApplyParameters& params = parallelJobs.parameter(job);
                 params.filter = this;
 
-                int startY;
-                int endY;
+                int startY = !job ? 0 : currentY - extraHeight;
+                currentY += job < jobsWithExtra ? blockHeight + 1 : blockHeight;
+                int endY = job == jobs - 1 ? currentY : currentY + extraHeight;
+
+                int blockSize = (endY - startY) * scanline;
                 if (!job) {
-                    startY = 0;
-                    endY = blockHeight + extraHeight;
                     params.srcPixelArray = srcPixelArray;
                     params.dstPixelArray = tmpPixelArray;
                 } else {
-                    if (job == jobs) {
-                        startY = job * blockHeight - extraHeight;
-                        endY = paintSize.height();
-                    } else {
-                        startY = job * blockHeight - extraHeight;
-                        endY = (job + 1) * blockHeight + extraHeight;
-                    }
-
-                    int blockSize = (endY - startY) * scanline;
                     params.srcPixelArray = Uint8ClampedArray::createUninitialized(blockSize);
                     params.dstPixelArray = Uint8ClampedArray::createUninitialized(blockSize);
                     memcpy(params.srcPixelArray->data(), srcPixelArray->data() + startY * scanline, blockSize);
                 }
 
                 params.width = paintSize.width();
                 params.height = endY - startY;
                 params.kernelSizeX = kernelSizeX;
                 params.kernelSizeY = kernelSizeY;
             }
 
             parallelJobs.execute();
 
             // Copy together the parts of the image.
-            for (int job = jobs; job >= 1; --job) {
+            currentY = 0;
+            for (int job = 1; job < jobs; job++) {
                 PlatformApplyParameters& params = parallelJobs.parameter(job);
                 int sourceOffset;
                 int destinationOffset;
                 int size;
-                if (job == jobs) {
-                    sourceOffset = extraHeight * scanline;
-                    destinationOffset = job * blockHeight * scanline;
-                    size = (paintSize.height() - job * blockHeight) * scanline;
-                } else {
-                    sourceOffset = extraHeight * scanline;
-                    destinationOffset = job * blockHeight * scanline;
-                    size = blockHeight * scanline;
-                }
+                int adjustedBlockHeight = job < jobsWithExtra ? blockHeight + 1 : blockHeight;
+
+                currentY += adjustedBlockHeight;
+                sourceOffset = extraHeight * scanline;
+                destinationOffset = currentY * scanline;
+                size = adjustedBlockHeight * scanline;
+
                 memcpy(srcPixelArray->data() + destinationOffset, params.srcPixelArray->data() + sourceOffset, size);
             }
             return;
         }
         // Fallback to single threaded mode.
     }
 
     // The selection here eventually should happen dynamically on some platforms.
     platformApplyGeneric(srcPixelArray, tmpPixelArray, kernelSizeX, kernelSizeY, paintSize);
 }
@@ skipping 86 matching lines @@
 
 float FEGaussianBlur::calculateStdDeviation(float radius)
 {
     // Blur radius represents 2/3 times the kernel size, the dest pixel is half of the radius applied 3 times
     return max((radius * 2 / 3.f - 0.5f) / gaussianKernelFactor(), 0.f);
 }
 
 } // namespace WebCore
 
 #endif // ENABLE(FILTERS)