skia2/tests/GrUnitTests.cpp

77 lines
2.3 KiB
C++
Raw Normal View History

Automatic update of all copyright notices to reflect new license terms. I have manually examined all of these diffs and restored a few files that seem to require manual adjustment. The following files still need to be modified manually, in a separate CL: android_sample/SampleApp/AndroidManifest.xml android_sample/SampleApp/res/layout/layout.xml android_sample/SampleApp/res/menu/sample.xml android_sample/SampleApp/res/values/strings.xml android_sample/SampleApp/src/com/skia/sampleapp/SampleApp.java android_sample/SampleApp/src/com/skia/sampleapp/SampleView.java experimental/CiCarbonSampleMain.c experimental/CocoaDebugger/main.m experimental/FileReaderApp/main.m experimental/SimpleCocoaApp/main.m experimental/iOSSampleApp/Shared/SkAlertPrompt.h experimental/iOSSampleApp/Shared/SkAlertPrompt.m experimental/iOSSampleApp/SkiOSSampleApp-Base.xcconfig experimental/iOSSampleApp/SkiOSSampleApp-Debug.xcconfig experimental/iOSSampleApp/SkiOSSampleApp-Release.xcconfig gpu/src/android/GrGLDefaultInterface_android.cpp gyp/common.gypi gyp_skia include/ports/SkHarfBuzzFont.h include/views/SkOSWindow_wxwidgets.h make.bat make.py src/opts/memset.arm.S src/opts/memset16_neon.S src/opts/memset32_neon.S src/opts/opts_check_arm.cpp src/ports/SkDebug_brew.cpp src/ports/SkMemory_brew.cpp src/ports/SkOSFile_brew.cpp src/ports/SkXMLParser_empty.cpp src/utils/ios/SkImageDecoder_iOS.mm src/utils/ios/SkOSFile_iOS.mm src/utils/ios/SkStream_NSData.mm tests/FillPathTest.cpp Review URL: http://codereview.appspot.com/4816058 git-svn-id: http://skia.googlecode.com/svn/trunk@1982 2bbb7eff-a529-9590-31e7-b0007b416f81
2011-07-28 14:26:00 +00:00
/*
* Copyright 2010 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
Speed up GrResourceCache lookup by inlining GrBinHashKey comparisons The GCC compilers for Android and Ubuntu do not seem to be able to inline the memcmp operations on GrBinHashKey data. Write the comparisons manually. Also shortcut GrBinHashKey::EQ to skip comparison when hashes do not match. Speeds up grresourcecache_find test on ARM and x86_64. Speeds up grresourcecache_add on x86_64. In order to test the change, moves ad hoc Gr unit tests from src/gr_unittest.cpp to tests/GrUnitTests to be consistent with other tests and enables GrUnitTests. Fixes a regression from r2863 with where re-setting GrBinHashKey data would not set the hash correctly. This should also improve the hash function itself. The regression caused many of the hash operations be no-ops. This is caught by the unit test. Renames the comparison functions that GrHashTable needs from EQ, LT to Equals, LessThan. Renames GrTBinHashKey to GrBinHashKey. The GrTBinHashKey used to forward comparison functions to an ENTRY template class, which would extract the key and call back to the GrTBinHashKey. This would save the user from writing one comparison function when comparison was done with int ENTRY::compare(). There's no real benefit in this now. Also this was used only for one class (GrTextureStripAtlas). The other use in GrResourceKey was not actually using the provided "shortcut". The new GrBinHashKey is not templated with the entry, rather just provides == and < functions. The users of GrTHashTable provide the needed functions now. Adds explicit documentation of functions that are actually needed GrTHashTable for the Key template. Adds SK_DEBUG guards according to the contract. R=bsalomon@google.com, mtklein@google.com Author: kkinnunen@nvidia.com Review URL: https://codereview.chromium.org/88113002 git-svn-id: http://skia.googlecode.com/svn/trunk@12426 2bbb7eff-a529-9590-31e7-b0007b416f81
2013-11-28 08:24:29 +00:00
#include "Test.h"
Speed up GrResourceCache lookup by inlining GrBinHashKey comparisons The GCC compilers for Android and Ubuntu do not seem to be able to inline the memcmp operations on GrBinHashKey data. Write the comparisons manually. Also shortcut GrBinHashKey::EQ to skip comparison when hashes do not match. Speeds up grresourcecache_find test on ARM and x86_64. Speeds up grresourcecache_add on x86_64. In order to test the change, moves ad hoc Gr unit tests from src/gr_unittest.cpp to tests/GrUnitTests to be consistent with other tests and enables GrUnitTests. Fixes a regression from r2863 with where re-setting GrBinHashKey data would not set the hash correctly. This should also improve the hash function itself. The regression caused many of the hash operations be no-ops. This is caught by the unit test. Renames the comparison functions that GrHashTable needs from EQ, LT to Equals, LessThan. Renames GrTBinHashKey to GrBinHashKey. The GrTBinHashKey used to forward comparison functions to an ENTRY template class, which would extract the key and call back to the GrTBinHashKey. This would save the user from writing one comparison function when comparison was done with int ENTRY::compare(). There's no real benefit in this now. Also this was used only for one class (GrTextureStripAtlas). The other use in GrResourceKey was not actually using the provided "shortcut". The new GrBinHashKey is not templated with the entry, rather just provides == and < functions. The users of GrTHashTable provide the needed functions now. Adds explicit documentation of functions that are actually needed GrTHashTable for the Key template. Adds SK_DEBUG guards according to the contract. R=bsalomon@google.com, mtklein@google.com Author: kkinnunen@nvidia.com Review URL: https://codereview.chromium.org/88113002 git-svn-id: http://skia.googlecode.com/svn/trunk@12426 2bbb7eff-a529-9590-31e7-b0007b416f81
2013-11-28 08:24:29 +00:00
// This is a GPU-backend specific test
#if SK_SUPPORT_GPU
#include "GrBinHashKey.h"
#include "GrDrawTarget.h"
#include "SkMatrix.h"
#include "GrRedBlackTree.h"
// If we aren't inheriting these as #defines from elsewhere,
// clang demands they be declared before we #include the template
// that relies on them.
static bool LT(const int& elem, int value) {
return elem < value;
}
static bool EQ(const int& elem, int value) {
return elem == value;
}
#include "GrTBSearch.h"
Speed up GrResourceCache lookup by inlining GrBinHashKey comparisons The GCC compilers for Android and Ubuntu do not seem to be able to inline the memcmp operations on GrBinHashKey data. Write the comparisons manually. Also shortcut GrBinHashKey::EQ to skip comparison when hashes do not match. Speeds up grresourcecache_find test on ARM and x86_64. Speeds up grresourcecache_add on x86_64. In order to test the change, moves ad hoc Gr unit tests from src/gr_unittest.cpp to tests/GrUnitTests to be consistent with other tests and enables GrUnitTests. Fixes a regression from r2863 with where re-setting GrBinHashKey data would not set the hash correctly. This should also improve the hash function itself. The regression caused many of the hash operations be no-ops. This is caught by the unit test. Renames the comparison functions that GrHashTable needs from EQ, LT to Equals, LessThan. Renames GrTBinHashKey to GrBinHashKey. The GrTBinHashKey used to forward comparison functions to an ENTRY template class, which would extract the key and call back to the GrTBinHashKey. This would save the user from writing one comparison function when comparison was done with int ENTRY::compare(). There's no real benefit in this now. Also this was used only for one class (GrTextureStripAtlas). The other use in GrResourceKey was not actually using the provided "shortcut". The new GrBinHashKey is not templated with the entry, rather just provides == and < functions. The users of GrTHashTable provide the needed functions now. Adds explicit documentation of functions that are actually needed GrTHashTable for the Key template. Adds SK_DEBUG guards according to the contract. R=bsalomon@google.com, mtklein@google.com Author: kkinnunen@nvidia.com Review URL: https://codereview.chromium.org/88113002 git-svn-id: http://skia.googlecode.com/svn/trunk@12426 2bbb7eff-a529-9590-31e7-b0007b416f81
2013-11-28 08:24:29 +00:00
DEF_TEST(GrUnitTests_bsearch, reporter) {
const int array[] = {
1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44, 55, 66, 77, 88, 99
};
for (int n = 0; n < static_cast<int>(GR_ARRAY_COUNT(array)); ++n) {
for (int i = 0; i < n; i++) {
int index = GrTBSearch<int, int>(array, n, array[i]);
Speed up GrResourceCache lookup by inlining GrBinHashKey comparisons The GCC compilers for Android and Ubuntu do not seem to be able to inline the memcmp operations on GrBinHashKey data. Write the comparisons manually. Also shortcut GrBinHashKey::EQ to skip comparison when hashes do not match. Speeds up grresourcecache_find test on ARM and x86_64. Speeds up grresourcecache_add on x86_64. In order to test the change, moves ad hoc Gr unit tests from src/gr_unittest.cpp to tests/GrUnitTests to be consistent with other tests and enables GrUnitTests. Fixes a regression from r2863 with where re-setting GrBinHashKey data would not set the hash correctly. This should also improve the hash function itself. The regression caused many of the hash operations be no-ops. This is caught by the unit test. Renames the comparison functions that GrHashTable needs from EQ, LT to Equals, LessThan. Renames GrTBinHashKey to GrBinHashKey. The GrTBinHashKey used to forward comparison functions to an ENTRY template class, which would extract the key and call back to the GrTBinHashKey. This would save the user from writing one comparison function when comparison was done with int ENTRY::compare(). There's no real benefit in this now. Also this was used only for one class (GrTextureStripAtlas). The other use in GrResourceKey was not actually using the provided "shortcut". The new GrBinHashKey is not templated with the entry, rather just provides == and < functions. The users of GrTHashTable provide the needed functions now. Adds explicit documentation of functions that are actually needed GrTHashTable for the Key template. Adds SK_DEBUG guards according to the contract. R=bsalomon@google.com, mtklein@google.com Author: kkinnunen@nvidia.com Review URL: https://codereview.chromium.org/88113002 git-svn-id: http://skia.googlecode.com/svn/trunk@12426 2bbb7eff-a529-9590-31e7-b0007b416f81
2013-11-28 08:24:29 +00:00
REPORTER_ASSERT(reporter, index == (int) i);
index = GrTBSearch<int, int>(array, n, -array[i]);
Speed up GrResourceCache lookup by inlining GrBinHashKey comparisons The GCC compilers for Android and Ubuntu do not seem to be able to inline the memcmp operations on GrBinHashKey data. Write the comparisons manually. Also shortcut GrBinHashKey::EQ to skip comparison when hashes do not match. Speeds up grresourcecache_find test on ARM and x86_64. Speeds up grresourcecache_add on x86_64. In order to test the change, moves ad hoc Gr unit tests from src/gr_unittest.cpp to tests/GrUnitTests to be consistent with other tests and enables GrUnitTests. Fixes a regression from r2863 with where re-setting GrBinHashKey data would not set the hash correctly. This should also improve the hash function itself. The regression caused many of the hash operations be no-ops. This is caught by the unit test. Renames the comparison functions that GrHashTable needs from EQ, LT to Equals, LessThan. Renames GrTBinHashKey to GrBinHashKey. The GrTBinHashKey used to forward comparison functions to an ENTRY template class, which would extract the key and call back to the GrTBinHashKey. This would save the user from writing one comparison function when comparison was done with int ENTRY::compare(). There's no real benefit in this now. Also this was used only for one class (GrTextureStripAtlas). The other use in GrResourceKey was not actually using the provided "shortcut". The new GrBinHashKey is not templated with the entry, rather just provides == and < functions. The users of GrTHashTable provide the needed functions now. Adds explicit documentation of functions that are actually needed GrTHashTable for the Key template. Adds SK_DEBUG guards according to the contract. R=bsalomon@google.com, mtklein@google.com Author: kkinnunen@nvidia.com Review URL: https://codereview.chromium.org/88113002 git-svn-id: http://skia.googlecode.com/svn/trunk@12426 2bbb7eff-a529-9590-31e7-b0007b416f81
2013-11-28 08:24:29 +00:00
REPORTER_ASSERT(reporter, index < 0);
}
}
}
Speed up GrResourceCache lookup by inlining GrBinHashKey comparisons The GCC compilers for Android and Ubuntu do not seem to be able to inline the memcmp operations on GrBinHashKey data. Write the comparisons manually. Also shortcut GrBinHashKey::EQ to skip comparison when hashes do not match. Speeds up grresourcecache_find test on ARM and x86_64. Speeds up grresourcecache_add on x86_64. In order to test the change, moves ad hoc Gr unit tests from src/gr_unittest.cpp to tests/GrUnitTests to be consistent with other tests and enables GrUnitTests. Fixes a regression from r2863 with where re-setting GrBinHashKey data would not set the hash correctly. This should also improve the hash function itself. The regression caused many of the hash operations be no-ops. This is caught by the unit test. Renames the comparison functions that GrHashTable needs from EQ, LT to Equals, LessThan. Renames GrTBinHashKey to GrBinHashKey. The GrTBinHashKey used to forward comparison functions to an ENTRY template class, which would extract the key and call back to the GrTBinHashKey. This would save the user from writing one comparison function when comparison was done with int ENTRY::compare(). There's no real benefit in this now. Also this was used only for one class (GrTextureStripAtlas). The other use in GrResourceKey was not actually using the provided "shortcut". The new GrBinHashKey is not templated with the entry, rather just provides == and < functions. The users of GrTHashTable provide the needed functions now. Adds explicit documentation of functions that are actually needed GrTHashTable for the Key template. Adds SK_DEBUG guards according to the contract. R=bsalomon@google.com, mtklein@google.com Author: kkinnunen@nvidia.com Review URL: https://codereview.chromium.org/88113002 git-svn-id: http://skia.googlecode.com/svn/trunk@12426 2bbb7eff-a529-9590-31e7-b0007b416f81
2013-11-28 08:24:29 +00:00
DEF_TEST(GrUnitTests_binHashKey, reporter) {
const char* testStringA_ = "abcdABCD";
const char* testStringB_ = "abcdBBCD";
const uint32_t* testStringA = reinterpret_cast<const uint32_t*>(testStringA_);
const uint32_t* testStringB = reinterpret_cast<const uint32_t*>(testStringB_);
enum {
kDataLenUsedForKey = 8
};
Speed up GrResourceCache lookup by inlining GrBinHashKey comparisons The GCC compilers for Android and Ubuntu do not seem to be able to inline the memcmp operations on GrBinHashKey data. Write the comparisons manually. Also shortcut GrBinHashKey::EQ to skip comparison when hashes do not match. Speeds up grresourcecache_find test on ARM and x86_64. Speeds up grresourcecache_add on x86_64. In order to test the change, moves ad hoc Gr unit tests from src/gr_unittest.cpp to tests/GrUnitTests to be consistent with other tests and enables GrUnitTests. Fixes a regression from r2863 with where re-setting GrBinHashKey data would not set the hash correctly. This should also improve the hash function itself. The regression caused many of the hash operations be no-ops. This is caught by the unit test. Renames the comparison functions that GrHashTable needs from EQ, LT to Equals, LessThan. Renames GrTBinHashKey to GrBinHashKey. The GrTBinHashKey used to forward comparison functions to an ENTRY template class, which would extract the key and call back to the GrTBinHashKey. This would save the user from writing one comparison function when comparison was done with int ENTRY::compare(). There's no real benefit in this now. Also this was used only for one class (GrTextureStripAtlas). The other use in GrResourceKey was not actually using the provided "shortcut". The new GrBinHashKey is not templated with the entry, rather just provides == and < functions. The users of GrTHashTable provide the needed functions now. Adds explicit documentation of functions that are actually needed GrTHashTable for the Key template. Adds SK_DEBUG guards according to the contract. R=bsalomon@google.com, mtklein@google.com Author: kkinnunen@nvidia.com Review URL: https://codereview.chromium.org/88113002 git-svn-id: http://skia.googlecode.com/svn/trunk@12426 2bbb7eff-a529-9590-31e7-b0007b416f81
2013-11-28 08:24:29 +00:00
GrBinHashKey<kDataLenUsedForKey> keyA;
keyA.setKeyData(testStringA);
// test copy constructor and comparison
Speed up GrResourceCache lookup by inlining GrBinHashKey comparisons The GCC compilers for Android and Ubuntu do not seem to be able to inline the memcmp operations on GrBinHashKey data. Write the comparisons manually. Also shortcut GrBinHashKey::EQ to skip comparison when hashes do not match. Speeds up grresourcecache_find test on ARM and x86_64. Speeds up grresourcecache_add on x86_64. In order to test the change, moves ad hoc Gr unit tests from src/gr_unittest.cpp to tests/GrUnitTests to be consistent with other tests and enables GrUnitTests. Fixes a regression from r2863 with where re-setting GrBinHashKey data would not set the hash correctly. This should also improve the hash function itself. The regression caused many of the hash operations be no-ops. This is caught by the unit test. Renames the comparison functions that GrHashTable needs from EQ, LT to Equals, LessThan. Renames GrTBinHashKey to GrBinHashKey. The GrTBinHashKey used to forward comparison functions to an ENTRY template class, which would extract the key and call back to the GrTBinHashKey. This would save the user from writing one comparison function when comparison was done with int ENTRY::compare(). There's no real benefit in this now. Also this was used only for one class (GrTextureStripAtlas). The other use in GrResourceKey was not actually using the provided "shortcut". The new GrBinHashKey is not templated with the entry, rather just provides == and < functions. The users of GrTHashTable provide the needed functions now. Adds explicit documentation of functions that are actually needed GrTHashTable for the Key template. Adds SK_DEBUG guards according to the contract. R=bsalomon@google.com, mtklein@google.com Author: kkinnunen@nvidia.com Review URL: https://codereview.chromium.org/88113002 git-svn-id: http://skia.googlecode.com/svn/trunk@12426 2bbb7eff-a529-9590-31e7-b0007b416f81
2013-11-28 08:24:29 +00:00
GrBinHashKey<kDataLenUsedForKey> keyA2(keyA);
REPORTER_ASSERT(reporter, keyA == keyA2);
REPORTER_ASSERT(reporter, keyA.getHash() == keyA2.getHash());
// test re-init
keyA2.setKeyData(testStringA);
Speed up GrResourceCache lookup by inlining GrBinHashKey comparisons The GCC compilers for Android and Ubuntu do not seem to be able to inline the memcmp operations on GrBinHashKey data. Write the comparisons manually. Also shortcut GrBinHashKey::EQ to skip comparison when hashes do not match. Speeds up grresourcecache_find test on ARM and x86_64. Speeds up grresourcecache_add on x86_64. In order to test the change, moves ad hoc Gr unit tests from src/gr_unittest.cpp to tests/GrUnitTests to be consistent with other tests and enables GrUnitTests. Fixes a regression from r2863 with where re-setting GrBinHashKey data would not set the hash correctly. This should also improve the hash function itself. The regression caused many of the hash operations be no-ops. This is caught by the unit test. Renames the comparison functions that GrHashTable needs from EQ, LT to Equals, LessThan. Renames GrTBinHashKey to GrBinHashKey. The GrTBinHashKey used to forward comparison functions to an ENTRY template class, which would extract the key and call back to the GrTBinHashKey. This would save the user from writing one comparison function when comparison was done with int ENTRY::compare(). There's no real benefit in this now. Also this was used only for one class (GrTextureStripAtlas). The other use in GrResourceKey was not actually using the provided "shortcut". The new GrBinHashKey is not templated with the entry, rather just provides == and < functions. The users of GrTHashTable provide the needed functions now. Adds explicit documentation of functions that are actually needed GrTHashTable for the Key template. Adds SK_DEBUG guards according to the contract. R=bsalomon@google.com, mtklein@google.com Author: kkinnunen@nvidia.com Review URL: https://codereview.chromium.org/88113002 git-svn-id: http://skia.googlecode.com/svn/trunk@12426 2bbb7eff-a529-9590-31e7-b0007b416f81
2013-11-28 08:24:29 +00:00
REPORTER_ASSERT(reporter, keyA == keyA2);
REPORTER_ASSERT(reporter, keyA.getHash() == keyA2.getHash());
// test sorting
Speed up GrResourceCache lookup by inlining GrBinHashKey comparisons The GCC compilers for Android and Ubuntu do not seem to be able to inline the memcmp operations on GrBinHashKey data. Write the comparisons manually. Also shortcut GrBinHashKey::EQ to skip comparison when hashes do not match. Speeds up grresourcecache_find test on ARM and x86_64. Speeds up grresourcecache_add on x86_64. In order to test the change, moves ad hoc Gr unit tests from src/gr_unittest.cpp to tests/GrUnitTests to be consistent with other tests and enables GrUnitTests. Fixes a regression from r2863 with where re-setting GrBinHashKey data would not set the hash correctly. This should also improve the hash function itself. The regression caused many of the hash operations be no-ops. This is caught by the unit test. Renames the comparison functions that GrHashTable needs from EQ, LT to Equals, LessThan. Renames GrTBinHashKey to GrBinHashKey. The GrTBinHashKey used to forward comparison functions to an ENTRY template class, which would extract the key and call back to the GrTBinHashKey. This would save the user from writing one comparison function when comparison was done with int ENTRY::compare(). There's no real benefit in this now. Also this was used only for one class (GrTextureStripAtlas). The other use in GrResourceKey was not actually using the provided "shortcut". The new GrBinHashKey is not templated with the entry, rather just provides == and < functions. The users of GrTHashTable provide the needed functions now. Adds explicit documentation of functions that are actually needed GrTHashTable for the Key template. Adds SK_DEBUG guards according to the contract. R=bsalomon@google.com, mtklein@google.com Author: kkinnunen@nvidia.com Review URL: https://codereview.chromium.org/88113002 git-svn-id: http://skia.googlecode.com/svn/trunk@12426 2bbb7eff-a529-9590-31e7-b0007b416f81
2013-11-28 08:24:29 +00:00
GrBinHashKey<kDataLenUsedForKey> keyB;
keyB.setKeyData(testStringB);
Speed up GrResourceCache lookup by inlining GrBinHashKey comparisons The GCC compilers for Android and Ubuntu do not seem to be able to inline the memcmp operations on GrBinHashKey data. Write the comparisons manually. Also shortcut GrBinHashKey::EQ to skip comparison when hashes do not match. Speeds up grresourcecache_find test on ARM and x86_64. Speeds up grresourcecache_add on x86_64. In order to test the change, moves ad hoc Gr unit tests from src/gr_unittest.cpp to tests/GrUnitTests to be consistent with other tests and enables GrUnitTests. Fixes a regression from r2863 with where re-setting GrBinHashKey data would not set the hash correctly. This should also improve the hash function itself. The regression caused many of the hash operations be no-ops. This is caught by the unit test. Renames the comparison functions that GrHashTable needs from EQ, LT to Equals, LessThan. Renames GrTBinHashKey to GrBinHashKey. The GrTBinHashKey used to forward comparison functions to an ENTRY template class, which would extract the key and call back to the GrTBinHashKey. This would save the user from writing one comparison function when comparison was done with int ENTRY::compare(). There's no real benefit in this now. Also this was used only for one class (GrTextureStripAtlas). The other use in GrResourceKey was not actually using the provided "shortcut". The new GrBinHashKey is not templated with the entry, rather just provides == and < functions. The users of GrTHashTable provide the needed functions now. Adds explicit documentation of functions that are actually needed GrTHashTable for the Key template. Adds SK_DEBUG guards according to the contract. R=bsalomon@google.com, mtklein@google.com Author: kkinnunen@nvidia.com Review URL: https://codereview.chromium.org/88113002 git-svn-id: http://skia.googlecode.com/svn/trunk@12426 2bbb7eff-a529-9590-31e7-b0007b416f81
2013-11-28 08:24:29 +00:00
REPORTER_ASSERT(reporter, keyA < keyB);
REPORTER_ASSERT(reporter, keyA.getHash() != keyB.getHash());
}
Speed up GrResourceCache lookup by inlining GrBinHashKey comparisons The GCC compilers for Android and Ubuntu do not seem to be able to inline the memcmp operations on GrBinHashKey data. Write the comparisons manually. Also shortcut GrBinHashKey::EQ to skip comparison when hashes do not match. Speeds up grresourcecache_find test on ARM and x86_64. Speeds up grresourcecache_add on x86_64. In order to test the change, moves ad hoc Gr unit tests from src/gr_unittest.cpp to tests/GrUnitTests to be consistent with other tests and enables GrUnitTests. Fixes a regression from r2863 with where re-setting GrBinHashKey data would not set the hash correctly. This should also improve the hash function itself. The regression caused many of the hash operations be no-ops. This is caught by the unit test. Renames the comparison functions that GrHashTable needs from EQ, LT to Equals, LessThan. Renames GrTBinHashKey to GrBinHashKey. The GrTBinHashKey used to forward comparison functions to an ENTRY template class, which would extract the key and call back to the GrTBinHashKey. This would save the user from writing one comparison function when comparison was done with int ENTRY::compare(). There's no real benefit in this now. Also this was used only for one class (GrTextureStripAtlas). The other use in GrResourceKey was not actually using the provided "shortcut". The new GrBinHashKey is not templated with the entry, rather just provides == and < functions. The users of GrTHashTable provide the needed functions now. Adds explicit documentation of functions that are actually needed GrTHashTable for the Key template. Adds SK_DEBUG guards according to the contract. R=bsalomon@google.com, mtklein@google.com Author: kkinnunen@nvidia.com Review URL: https://codereview.chromium.org/88113002 git-svn-id: http://skia.googlecode.com/svn/trunk@12426 2bbb7eff-a529-9590-31e7-b0007b416f81
2013-11-28 08:24:29 +00:00
DEF_TEST(GrUnitTests_redBlackTree, reporter) {
// TODO(mtklein): unwrap this and use reporter.
GrRedBlackTree<int>::UnitTest();
}
Speed up GrResourceCache lookup by inlining GrBinHashKey comparisons The GCC compilers for Android and Ubuntu do not seem to be able to inline the memcmp operations on GrBinHashKey data. Write the comparisons manually. Also shortcut GrBinHashKey::EQ to skip comparison when hashes do not match. Speeds up grresourcecache_find test on ARM and x86_64. Speeds up grresourcecache_add on x86_64. In order to test the change, moves ad hoc Gr unit tests from src/gr_unittest.cpp to tests/GrUnitTests to be consistent with other tests and enables GrUnitTests. Fixes a regression from r2863 with where re-setting GrBinHashKey data would not set the hash correctly. This should also improve the hash function itself. The regression caused many of the hash operations be no-ops. This is caught by the unit test. Renames the comparison functions that GrHashTable needs from EQ, LT to Equals, LessThan. Renames GrTBinHashKey to GrBinHashKey. The GrTBinHashKey used to forward comparison functions to an ENTRY template class, which would extract the key and call back to the GrTBinHashKey. This would save the user from writing one comparison function when comparison was done with int ENTRY::compare(). There's no real benefit in this now. Also this was used only for one class (GrTextureStripAtlas). The other use in GrResourceKey was not actually using the provided "shortcut". The new GrBinHashKey is not templated with the entry, rather just provides == and < functions. The users of GrTHashTable provide the needed functions now. Adds explicit documentation of functions that are actually needed GrTHashTable for the Key template. Adds SK_DEBUG guards according to the contract. R=bsalomon@google.com, mtklein@google.com Author: kkinnunen@nvidia.com Review URL: https://codereview.chromium.org/88113002 git-svn-id: http://skia.googlecode.com/svn/trunk@12426 2bbb7eff-a529-9590-31e7-b0007b416f81
2013-11-28 08:24:29 +00:00
#endif