00b621cfc0
This should be a drop-in replacement for most for-loops to make them run in parallel:
for (int i = 0; i < N; i++) { code... }
~~~>
sk_parallel_for(N, [&](int i) { code... });
This is just syntax sugar over SkTaskGroup to make this use case really easy to write.
There's no more overhead that we weren't already forced to add using an interface like batch(),
and no extra heap allocations.
I've replaced 3 uses of SkTaskGroup with sk_parallel_for:
1) My unit tests for SkOnce.
2) Cary's path fuzzer.
3) SkMultiPictureDraw.
Performance should be the same. Please compare left and right for readability. :)
BUG=skia:
No public API changes.
TBR=reed@google.com
Review URL: https://codereview.chromium.org/1184373003
430 lines
16 KiB
C++
430 lines
16 KiB
C++
/*
|
|
* Copyright 2013 Google Inc.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
* found in the LICENSE file.
|
|
*/
|
|
|
|
#include "SkBitmap.h"
|
|
#include "SkImageDecoder.h"
|
|
#include "SkOSFile.h"
|
|
#include "SkRunnable.h"
|
|
#include "SkSize.h"
|
|
#include "SkStream.h"
|
|
#include "SkTDict.h"
|
|
#include "SkTaskGroup.h"
|
|
|
|
// from the tools directory for replace_char(...)
|
|
#include "picture_utils.h"
|
|
|
|
#include "SkDiffContext.h"
|
|
#include "SkImageDiffer.h"
|
|
#include "skpdiff_util.h"
|
|
|
|
SkDiffContext::SkDiffContext() {
|
|
fDiffers = NULL;
|
|
fDifferCount = 0;
|
|
}
|
|
|
|
SkDiffContext::~SkDiffContext() {
|
|
if (fDiffers) {
|
|
SkDELETE_ARRAY(fDiffers);
|
|
}
|
|
}
|
|
|
|
void SkDiffContext::setAlphaMaskDir(const SkString& path) {
|
|
if (!path.isEmpty() && sk_mkdir(path.c_str())) {
|
|
fAlphaMaskDir = path;
|
|
}
|
|
}
|
|
|
|
void SkDiffContext::setRgbDiffDir(const SkString& path) {
|
|
if (!path.isEmpty() && sk_mkdir(path.c_str())) {
|
|
fRgbDiffDir = path;
|
|
}
|
|
}
|
|
|
|
void SkDiffContext::setWhiteDiffDir(const SkString& path) {
|
|
if (!path.isEmpty() && sk_mkdir(path.c_str())) {
|
|
fWhiteDiffDir = path;
|
|
}
|
|
}
|
|
|
|
void SkDiffContext::setLongNames(const bool useLongNames) {
|
|
longNames = useLongNames;
|
|
}
|
|
|
|
void SkDiffContext::setDiffers(const SkTDArray<SkImageDiffer*>& differs) {
|
|
// Delete whatever the last array of differs was
|
|
if (fDiffers) {
|
|
SkDELETE_ARRAY(fDiffers);
|
|
fDiffers = NULL;
|
|
fDifferCount = 0;
|
|
}
|
|
|
|
// Copy over the new differs
|
|
fDifferCount = differs.count();
|
|
fDiffers = SkNEW_ARRAY(SkImageDiffer*, fDifferCount);
|
|
differs.copy(fDiffers);
|
|
}
|
|
|
|
static SkString get_common_prefix(const SkString& a, const SkString& b) {
|
|
const size_t maxPrefixLength = SkTMin(a.size(), b.size());
|
|
SkASSERT(maxPrefixLength > 0);
|
|
for (size_t x = 0; x < maxPrefixLength; ++x) {
|
|
if (a[x] != b[x]) {
|
|
SkString result;
|
|
result.set(a.c_str(), x);
|
|
return result;
|
|
}
|
|
}
|
|
if (a.size() > b.size()) {
|
|
return b;
|
|
} else {
|
|
return a;
|
|
}
|
|
}
|
|
|
|
static SkString get_combined_name(const SkString& a, const SkString& b) {
|
|
// Note (stephana): We must keep this function in sync with
|
|
// getImageDiffRelativeUrl() in static/loader.js (under rebaseline_server).
|
|
SkString result = a;
|
|
result.append("-vs-");
|
|
result.append(b);
|
|
sk_tools::replace_char(&result, '.', '_');
|
|
return result;
|
|
}
|
|
|
|
void SkDiffContext::addDiff(const char* baselinePath, const char* testPath) {
|
|
// Load the images at the paths
|
|
SkBitmap baselineBitmap;
|
|
SkBitmap testBitmap;
|
|
if (!SkImageDecoder::DecodeFile(baselinePath, &baselineBitmap)) {
|
|
SkDebugf("Failed to load bitmap \"%s\"\n", baselinePath);
|
|
return;
|
|
}
|
|
if (!SkImageDecoder::DecodeFile(testPath, &testBitmap)) {
|
|
SkDebugf("Failed to load bitmap \"%s\"\n", testPath);
|
|
return;
|
|
}
|
|
|
|
// Setup a record for this diff
|
|
fRecordMutex.acquire();
|
|
DiffRecord* newRecord = fRecords.addToHead(DiffRecord());
|
|
fRecordMutex.release();
|
|
|
|
// compute the common name
|
|
SkString baseName = SkOSPath::Basename(baselinePath);
|
|
SkString testName = SkOSPath::Basename(testPath);
|
|
|
|
if (longNames) {
|
|
newRecord->fCommonName = get_combined_name(baseName, testName);
|
|
} else {
|
|
newRecord->fCommonName = get_common_prefix(baseName, testName);
|
|
}
|
|
newRecord->fCommonName.append(".png");
|
|
|
|
newRecord->fBaselinePath = baselinePath;
|
|
newRecord->fTestPath = testPath;
|
|
newRecord->fSize = SkISize::Make(baselineBitmap.width(), baselineBitmap.height());
|
|
|
|
// only generate diff images if we have a place to store them
|
|
SkImageDiffer::BitmapsToCreate bitmapsToCreate;
|
|
bitmapsToCreate.alphaMask = !fAlphaMaskDir.isEmpty();
|
|
bitmapsToCreate.rgbDiff = !fRgbDiffDir.isEmpty();
|
|
bitmapsToCreate.whiteDiff = !fWhiteDiffDir.isEmpty();
|
|
|
|
// Perform each diff
|
|
for (int differIndex = 0; differIndex < fDifferCount; differIndex++) {
|
|
SkImageDiffer* differ = fDiffers[differIndex];
|
|
|
|
// Copy the results into data for this record
|
|
DiffData& diffData = newRecord->fDiffs.push_back();
|
|
diffData.fDiffName = differ->getName();
|
|
|
|
if (!differ->diff(&baselineBitmap, &testBitmap, bitmapsToCreate, &diffData.fResult)) {
|
|
// if the diff failed, record -1 as the result
|
|
// TODO(djsollen): Record more detailed information about exactly what failed.
|
|
// (Image dimension mismatch? etc.) See http://skbug.com/2710 ('make skpdiff
|
|
// report more detail when it fails to compare two images')
|
|
diffData.fResult.result = -1;
|
|
continue;
|
|
}
|
|
|
|
if (bitmapsToCreate.alphaMask
|
|
&& SkImageDiffer::RESULT_CORRECT != diffData.fResult.result
|
|
&& !diffData.fResult.poiAlphaMask.empty()
|
|
&& !newRecord->fCommonName.isEmpty()) {
|
|
|
|
newRecord->fAlphaMaskPath = SkOSPath::Join(fAlphaMaskDir.c_str(),
|
|
newRecord->fCommonName.c_str());
|
|
|
|
// compute the image diff and output it
|
|
SkBitmap copy;
|
|
diffData.fResult.poiAlphaMask.copyTo(©, kN32_SkColorType);
|
|
SkImageEncoder::EncodeFile(newRecord->fAlphaMaskPath.c_str(), copy,
|
|
SkImageEncoder::kPNG_Type, 100);
|
|
|
|
// cleanup the existing bitmap to free up resources;
|
|
diffData.fResult.poiAlphaMask.reset();
|
|
|
|
bitmapsToCreate.alphaMask = false;
|
|
}
|
|
|
|
if (bitmapsToCreate.rgbDiff
|
|
&& SkImageDiffer::RESULT_CORRECT != diffData.fResult.result
|
|
&& !diffData.fResult.rgbDiffBitmap.empty()
|
|
&& !newRecord->fCommonName.isEmpty()) {
|
|
// TODO(djsollen): Rather than taking the max r/g/b diffs that come back from
|
|
// a particular differ and storing them as toplevel fields within
|
|
// newRecord, we should extend outputRecords() to report optional
|
|
// fields for each differ (not just "result" and "pointsOfInterest").
|
|
// See http://skbug.com/2712 ('allow skpdiff to report different sets
|
|
// of result fields for different comparison algorithms')
|
|
newRecord->fMaxRedDiff = diffData.fResult.maxRedDiff;
|
|
newRecord->fMaxGreenDiff = diffData.fResult.maxGreenDiff;
|
|
newRecord->fMaxBlueDiff = diffData.fResult.maxBlueDiff;
|
|
|
|
newRecord->fRgbDiffPath = SkOSPath::Join(fRgbDiffDir.c_str(),
|
|
newRecord->fCommonName.c_str());
|
|
SkImageEncoder::EncodeFile(newRecord->fRgbDiffPath.c_str(),
|
|
diffData.fResult.rgbDiffBitmap,
|
|
SkImageEncoder::kPNG_Type, 100);
|
|
diffData.fResult.rgbDiffBitmap.reset();
|
|
bitmapsToCreate.rgbDiff = false;
|
|
}
|
|
|
|
if (bitmapsToCreate.whiteDiff
|
|
&& SkImageDiffer::RESULT_CORRECT != diffData.fResult.result
|
|
&& !diffData.fResult.whiteDiffBitmap.empty()
|
|
&& !newRecord->fCommonName.isEmpty()) {
|
|
newRecord->fWhiteDiffPath = SkOSPath::Join(fWhiteDiffDir.c_str(),
|
|
newRecord->fCommonName.c_str());
|
|
SkImageEncoder::EncodeFile(newRecord->fWhiteDiffPath.c_str(),
|
|
diffData.fResult.whiteDiffBitmap,
|
|
SkImageEncoder::kPNG_Type, 100);
|
|
diffData.fResult.whiteDiffBitmap.reset();
|
|
bitmapsToCreate.whiteDiff = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
void SkDiffContext::diffDirectories(const char baselinePath[], const char testPath[]) {
|
|
// Get the files in the baseline, we will then look for those inside the test path
|
|
SkTArray<SkString> baselineEntries;
|
|
if (!get_directory(baselinePath, &baselineEntries)) {
|
|
SkDebugf("Unable to open path \"%s\"\n", baselinePath);
|
|
return;
|
|
}
|
|
|
|
sk_parallel_for(baselineEntries.count(), [&](int i) {
|
|
const char* baseFilename = baselineEntries[i].c_str();
|
|
|
|
// Find the real location of each file to compare
|
|
SkString baselineFile = SkOSPath::Join(baselinePath, baseFilename);
|
|
SkString testFile = SkOSPath::Join(testPath, baseFilename);
|
|
|
|
// Check that the test file exists and is a file
|
|
if (sk_exists(testFile.c_str()) && !sk_isdir(testFile.c_str())) {
|
|
this->addDiff(baselineFile.c_str(), testFile.c_str());
|
|
} else {
|
|
SkDebugf("Baseline file \"%s\" has no corresponding test file\n", baselineFile.c_str());
|
|
}
|
|
});
|
|
}
|
|
|
|
|
|
void SkDiffContext::diffPatterns(const char baselinePattern[], const char testPattern[]) {
|
|
// Get the files in the baseline and test patterns. Because they are in sorted order, it's easy
|
|
// to find corresponding images by matching entry indices.
|
|
|
|
SkTArray<SkString> baselineEntries;
|
|
if (!glob_files(baselinePattern, &baselineEntries)) {
|
|
SkDebugf("Unable to get pattern \"%s\"\n", baselinePattern);
|
|
return;
|
|
}
|
|
|
|
SkTArray<SkString> testEntries;
|
|
if (!glob_files(testPattern, &testEntries)) {
|
|
SkDebugf("Unable to get pattern \"%s\"\n", testPattern);
|
|
return;
|
|
}
|
|
|
|
if (baselineEntries.count() != testEntries.count()) {
|
|
SkDebugf("Baseline and test patterns do not yield corresponding number of files\n");
|
|
return;
|
|
}
|
|
|
|
sk_parallel_for(baselineEntries.count(), [&](int i) {
|
|
this->addDiff(baselineEntries[i].c_str(), testEntries[i].c_str());
|
|
});
|
|
}
|
|
|
|
void SkDiffContext::outputRecords(SkWStream& stream, bool useJSONP) {
|
|
SkTLList<DiffRecord>::Iter iter(fRecords, SkTLList<DiffRecord>::Iter::kHead_IterStart);
|
|
DiffRecord* currentRecord = iter.get();
|
|
|
|
if (useJSONP) {
|
|
stream.writeText("var SkPDiffRecords = {\n");
|
|
} else {
|
|
stream.writeText("{\n");
|
|
}
|
|
|
|
// TODO(djsollen): Would it be better to use the jsoncpp library to write out the JSON?
|
|
// This manual approach is probably more efficient, but it sure is ugly.
|
|
// See http://skbug.com/2713 ('make skpdiff use jsoncpp library to write out
|
|
// JSON output, instead of manual writeText() calls?')
|
|
stream.writeText(" \"records\": [\n");
|
|
while (currentRecord) {
|
|
stream.writeText(" {\n");
|
|
|
|
SkString baselineAbsPath = get_absolute_path(currentRecord->fBaselinePath);
|
|
SkString testAbsPath = get_absolute_path(currentRecord->fTestPath);
|
|
|
|
stream.writeText(" \"commonName\": \"");
|
|
stream.writeText(currentRecord->fCommonName.c_str());
|
|
stream.writeText("\",\n");
|
|
|
|
stream.writeText(" \"differencePath\": \"");
|
|
stream.writeText(get_absolute_path(currentRecord->fAlphaMaskPath).c_str());
|
|
stream.writeText("\",\n");
|
|
|
|
stream.writeText(" \"rgbDiffPath\": \"");
|
|
stream.writeText(get_absolute_path(currentRecord->fRgbDiffPath).c_str());
|
|
stream.writeText("\",\n");
|
|
|
|
stream.writeText(" \"whiteDiffPath\": \"");
|
|
stream.writeText(get_absolute_path(currentRecord->fWhiteDiffPath).c_str());
|
|
stream.writeText("\",\n");
|
|
|
|
stream.writeText(" \"baselinePath\": \"");
|
|
stream.writeText(baselineAbsPath.c_str());
|
|
stream.writeText("\",\n");
|
|
|
|
stream.writeText(" \"testPath\": \"");
|
|
stream.writeText(testAbsPath.c_str());
|
|
stream.writeText("\",\n");
|
|
|
|
stream.writeText(" \"width\": ");
|
|
stream.writeDecAsText(currentRecord->fSize.width());
|
|
stream.writeText(",\n");
|
|
stream.writeText(" \"height\": ");
|
|
stream.writeDecAsText(currentRecord->fSize.height());
|
|
stream.writeText(",\n");
|
|
|
|
stream.writeText(" \"maxRedDiff\": ");
|
|
stream.writeDecAsText(currentRecord->fMaxRedDiff);
|
|
stream.writeText(",\n");
|
|
stream.writeText(" \"maxGreenDiff\": ");
|
|
stream.writeDecAsText(currentRecord->fMaxGreenDiff);
|
|
stream.writeText(",\n");
|
|
stream.writeText(" \"maxBlueDiff\": ");
|
|
stream.writeDecAsText(currentRecord->fMaxBlueDiff);
|
|
stream.writeText(",\n");
|
|
|
|
stream.writeText(" \"diffs\": [\n");
|
|
for (int diffIndex = 0; diffIndex < currentRecord->fDiffs.count(); diffIndex++) {
|
|
DiffData& data = currentRecord->fDiffs[diffIndex];
|
|
stream.writeText(" {\n");
|
|
|
|
stream.writeText(" \"differName\": \"");
|
|
stream.writeText(data.fDiffName);
|
|
stream.writeText("\",\n");
|
|
|
|
stream.writeText(" \"result\": ");
|
|
stream.writeScalarAsText((SkScalar)data.fResult.result);
|
|
stream.writeText(",\n");
|
|
|
|
stream.writeText(" \"pointsOfInterest\": ");
|
|
stream.writeDecAsText(data.fResult.poiCount);
|
|
stream.writeText("\n");
|
|
|
|
stream.writeText(" }");
|
|
|
|
// JSON does not allow trailing commas
|
|
if (diffIndex + 1 < currentRecord->fDiffs.count()) {
|
|
stream.writeText(",");
|
|
}
|
|
stream.writeText(" \n");
|
|
}
|
|
stream.writeText(" ]\n");
|
|
|
|
stream.writeText(" }");
|
|
|
|
currentRecord = iter.next();
|
|
|
|
// JSON does not allow trailing commas
|
|
if (currentRecord) {
|
|
stream.writeText(",");
|
|
}
|
|
stream.writeText("\n");
|
|
}
|
|
stream.writeText(" ]\n");
|
|
if (useJSONP) {
|
|
stream.writeText("};\n");
|
|
} else {
|
|
stream.writeText("}\n");
|
|
}
|
|
}
|
|
|
|
void SkDiffContext::outputCsv(SkWStream& stream) {
|
|
SkTDict<int> columns(2);
|
|
int cntColumns = 0;
|
|
|
|
stream.writeText("key");
|
|
|
|
SkTLList<DiffRecord>::Iter iter(fRecords, SkTLList<DiffRecord>::Iter::kHead_IterStart);
|
|
DiffRecord* currentRecord = iter.get();
|
|
|
|
// Write CSV header and create a dictionary of all columns.
|
|
while (currentRecord) {
|
|
for (int diffIndex = 0; diffIndex < currentRecord->fDiffs.count(); diffIndex++) {
|
|
DiffData& data = currentRecord->fDiffs[diffIndex];
|
|
if (!columns.find(data.fDiffName)) {
|
|
columns.set(data.fDiffName, cntColumns);
|
|
stream.writeText(", ");
|
|
stream.writeText(data.fDiffName);
|
|
cntColumns++;
|
|
}
|
|
}
|
|
currentRecord = iter.next();
|
|
}
|
|
stream.writeText("\n");
|
|
|
|
double values[100];
|
|
SkASSERT(cntColumns < 100); // Make the array larger, if we ever have so many diff types.
|
|
|
|
SkTLList<DiffRecord>::Iter iter2(fRecords, SkTLList<DiffRecord>::Iter::kHead_IterStart);
|
|
currentRecord = iter2.get();
|
|
while (currentRecord) {
|
|
for (int i = 0; i < cntColumns; i++) {
|
|
values[i] = -1;
|
|
}
|
|
|
|
for (int diffIndex = 0; diffIndex < currentRecord->fDiffs.count(); diffIndex++) {
|
|
DiffData& data = currentRecord->fDiffs[diffIndex];
|
|
int index = -1;
|
|
SkAssertResult(columns.find(data.fDiffName, &index));
|
|
SkASSERT(index >= 0 && index < cntColumns);
|
|
values[index] = data.fResult.result;
|
|
}
|
|
|
|
const char* filename = currentRecord->fBaselinePath.c_str() +
|
|
strlen(currentRecord->fBaselinePath.c_str()) - 1;
|
|
while (filename > currentRecord->fBaselinePath.c_str() && *(filename - 1) != '/') {
|
|
filename--;
|
|
}
|
|
|
|
stream.writeText(filename);
|
|
|
|
for (int i = 0; i < cntColumns; i++) {
|
|
SkString str;
|
|
str.printf(", %f", values[i]);
|
|
stream.writeText(str.c_str());
|
|
}
|
|
stream.writeText("\n");
|
|
|
|
currentRecord = iter2.next();
|
|
}
|
|
}
|