103693 2012-11-29 17:32:25 -0800 Remove conversion to/from float and float division from ImageFrame::setRGBA 2012-12-11 21:36:06 -0800 1 1 1 Unclassified WebKit Images 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED Performance P2 Normal --- 1 ostap73 ostap73 bfulgham webkit.review.bot oldest_to_newest 779650 0 176859 ostap73 2012-11-29 17:32:25 -0800 Created attachment 176859 setRGBA benchmark with different variants of this function. Floats is slow and shouldn't be used in this case. 779652 1 176860 ostap73 2012-11-29 17:35:11 -0800 Created attachment 176860 Benchmark run results on Intel Core I7 and ARM CPUs 779667 2 176859 ostap73 2012-11-29 17:46:14 -0800 Comment on attachment 176859 setRGBA benchmark with different variants of this function. #include <memory.h> #include <stdio.h> #include <stdlib.h> #include <time.h> typedef unsigned PixelData; bool m_premultiplyAlpha = true; inline void setRGBA_orig(PixelData* dest, unsigned r, unsigned g, unsigned b, unsigned a) { if (m_premultiplyAlpha && a < 255) { if (!a) { *dest = 0; return; } float alphaPercent = a / 255.0f; r = static_cast<unsigned>(r * alphaPercent); g = static_cast<unsigned>(g * alphaPercent); b = static_cast<unsigned>(b * alphaPercent); } *dest = (a << 24 | r << 16 | g << 8 | b); } const int fixPointShift = 24; const unsigned fixPointMult = unsigned(1.0 / 255.0 * (1 << fixPointShift)) + 1; inline void setRGBA_fixPointMult(PixelData* dest, unsigned r, unsigned g, unsigned b, unsigned a) { if (m_premultiplyAlpha && a < 255) { if (!a) { *dest = 0; return; } unsigned alphaMult = a * fixPointMult; r = (r * alphaMult) >> fixPointShift; g = (g * alphaMult) >> fixPointShift; b = (b * alphaMult) >> fixPointShift; } *dest = (a << 24 | r << 16 | g << 8 | b); } inline void setRGBA_integerDiv(PixelData* dest, unsigned r, unsigned g, unsigned b, unsigned a) { if (m_premultiplyAlpha && a < 255) { if (!a) { *dest = 0; return; } r = r * a / 255; g = g * a / 255; b = b * a / 255; } *dest = (a << 24 | r << 16 | g << 8 | b); } inline unsigned fastDiv255(unsigned a) { return (a + (a >> 8) + 1) >> 8; } inline void setRGBA_fastDiv255(PixelData* dest, unsigned r, unsigned g, unsigned b, unsigned a) { if (m_premultiplyAlpha && a < 255) { if (!a) { *dest = 0; return; } r = fastDiv255(r * a); g = fastDiv255(g * a); b = fastDiv255(b * a); } *dest = (a << 24 | r << 16 | g << 8 | b); } const unsigned bufferSize = 256 * 1024 * 1024; // Something bigger than all cpu caches PixelData source[bufferSize]; PixelData dest[bufferSize]; inline unsigned char* castUChar(void* p) { return static_cast<unsigned char *>(p); } void runTests() { unsigned i, tmp; unsigned char *bytesEnd = castUChar(&(source[bufferSize])); PixelData* destPosition; unsigned char *bytes; clock_t start; clock_t end; start = clock(); for(bytes = castUChar(&(source[0])), destPosition = &dest[0]; bytes < bytesEnd; bytes += 4, destPosition++) { setRGBA_integerDiv(destPosition, bytes[0], bytes[1], bytes[2], bytes[3]); } end = clock(); printf("1: %lu\t", end - start); start = clock(); for(bytes = castUChar(&(source[0])), destPosition = &dest[0]; bytes < bytesEnd; bytes += 4, destPosition++) { setRGBA_fastDiv255(destPosition, bytes[0], bytes[1], bytes[2], bytes[3]); } end = clock(); printf("2: %lu\t", end - start); start = clock(); for(bytes = castUChar(&(source[0])), destPosition = &dest[0]; bytes < bytesEnd; bytes += 4, destPosition++) { setRGBA_fixPointMult(destPosition, bytes[0], bytes[1], bytes[2], bytes[3]); } end = clock(); printf("3: %lu\t", end - start); start = clock(); for(bytes = castUChar(&(source[0])), destPosition = &dest[0]; bytes < bytesEnd; bytes += 4, destPosition++) { setRGBA_orig(destPosition, bytes[0], bytes[1], bytes[2], bytes[3]); } end = clock(); printf("4: %lu\n", end - start); } int main(int argc, char *argv[]) { unsigned i, j; unsigned diffValues = 0; // Fastdiv and fixedpoint mult precision check for(i = 0; i < 256; i++) { for(j = 0; j < 256; j++) { unsigned a = fastDiv255(i * j); unsigned alphaMult = i * fixPointMult; unsigned b = (j * alphaMult) >> fixPointShift; unsigned c = j * i / 255; float alphaPercent = i / 255.0f; unsigned d = static_cast<unsigned>(j * alphaPercent); if (a != d || b != d || c != d) { printf("Alpha; %u,\t color: %u,\t a: %u,\t b: %u,\t c: %u,\t d: %u\n", i, j, a, b, c, d); diffValues++; } } } printf("Different %u values\n", diffValues); memset(&dest[0], 0, sizeof(dest)); do { // Run benchmarks with both values of m_premultiplyAlpha to make sure it is not optimized out printf("Premultiply Alpha: %d\n",m_premultiplyAlpha); printf("All 0 buffer:\n"); memset(&source[0], 0, sizeof(source)); runTests(); printf("All 255 buffer:\n"); memset(&source[0], 255, sizeof(source)); runTests(); printf("Pseudo random buffer:\n"); // Fill buffer with 25% 0 alpha, 25% 255 alpha and other random values for(i = 0; i < bufferSize; i += 4) { source[i] = PixelData(rand()) & 0xFFFFFF; source[i] = PixelData(rand()); source[i] = PixelData(rand()) | 0xFF000000; source[i] = PixelData(rand()); } runTests(); m_premultiplyAlpha = 1 - m_premultiplyAlpha; } while(m_premultiplyAlpha == false); } 779681 3 ostap73 2012-11-29 17:58:17 -0800 Benchmark was compiled like this: gcc -O3 setRGBPerf.cpp -o setRGBPerf Close to real life and slowest case of benchmark when tests run on pseudo random source buffer and m_premultiplyAlpha is true. Pseudo random buffer is generated so, that approx 25% of pixels have 0 alpha, 25% have 255 alpha, other values are random. Macbook Pro Ivy Bridge I7 2.7GHz, 256M elements Pseudo random buffer: 1: 580000 2: 560000 3: 500000 4: 3290000 Samsung Galaxy Note II, 32M elements Pseudo random buffer: 1: 380000 2: 360000 3: 360000 4: 1480000 1. Float conversion/division replace with simple integer division. 2. "Fast division" used instead of x/255 like x/256 + x/256^2 = (x + x / 256) / 256 . 1 is added to compensate for rounding error. 3. Fixed point pre-calculated constant is used as 1/255 multiplier. 4. Original function body. There is simple test at the beginning of main function to make sure that all 4 methods produce identical results. Obviously, that original function is significantly slower and fixed point multipler is the fastest, but ordinary integer division also works well. 788118 4 178738 ostap73 2012-12-11 00:26:16 -0800 Created attachment 178738 Patch 788121 5 ostap73 2012-12-11 00:30:07 -0800 Run of ImageDecoder benchmark (attached to bug 88424) on Intel i7 930 : Without patch: time ./ImageDecoderPerf img_with_alpha.png Done real 1m11.751s user 1m10.628s sys 0m0.160s With patch: time ./ImageDecoderPerf img_with_alpha.png Done real 1m9.862s user 1m8.464s sys 0m0.200s 788802 6 bfulgham 2012-12-11 14:26:26 -0800 (In reply to comment #5) > Run of ImageDecoder benchmark (attached to bug 88424) on Intel i7 930 : > > Without patch: > user 1m10.628s > > With patch: > user 1m8.464s This looks like a nearly 3% improvement in speed. Is this significant enough that the (perhaps small) complexity of the fixed-point math implementation is worth it? Will this work as written under 64-bit architectures? 788816 7 178738 bfulgham 2012-12-11 14:40:24 -0800 Comment on attachment 178738 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=178738&action=review > Source/WebCore/ChangeLog:8 > + Replace floating point operations used for alpha premultiply with fixed point arifmetics *arithmetic* > Source/WebCore/platform/image-decoders/ImageDecoder.h:173 > + static const unsigned fixPointMult = unsigned(1.0 / 255.0 * (1 << fixPointShift)) + 1; This should be a c++ style cast. static_cast<unsigned>(1.0 / 255.0 * ...) > Source/WebCore/platform/image-decoders/ImageDecoder.h:177 > + b = (b * alphaMult) >> fixPointShift; What if we made the fixedpoint operation an template or inline function: (Pseudocode): static unsigned alphaMult<fixPointShift>(unsigned component, unsigned alphaMult) { return (component * alphaMult) >> fixPointShift; } r = alphaMult (r, alphaMult); g = alphaMult (g, alphaMult); ... etc ... In fact, you might be able to use SSE here since we are doing the same operation on all three values. I wonder what kind of improvement that would be... 789083 8 178738 ostap73 2012-12-11 18:18:17 -0800 Comment on attachment 178738 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=178738&action=review >> Source/WebCore/platform/image-decoders/ImageDecoder.h:177 >> + b = (b * alphaMult) >> fixPointShift; > > What if we made the fixedpoint operation an template or inline function: > > (Pseudocode): > static unsigned alphaMult<fixPointShift>(unsigned component, unsigned alphaMult) { > return (component * alphaMult) >> fixPointShift; > } > > r = alphaMult (r, alphaMult); > g = alphaMult (g, alphaMult); > ... etc ... > > In fact, you might be able to use SSE here since we are doing the same operation on all three values. I wonder what kind of improvement that would be... Actually, compiler is doing sse instructions for floats here, but in this case conversions to/from int make it slow. If the operation would be more complex, it might be faster. But in this case simple integer math works better. 789110 9 178946 ostap73 2012-12-11 18:59:45 -0800 Created attachment 178946 Patch 789139 10 178946 bfulgham 2012-12-11 20:18:34 -0800 Comment on attachment 178946 Patch Looks great! Thanks. r = me. 789141 11 ostap73 2012-12-11 20:32:31 -0800 (In reply to comment #6) > (In reply to comment #5) > > Run of ImageDecoder benchmark (attached to bug 88424) on Intel i7 930 : > > > > Without patch: > > user 1m10.628s > > > > With patch: > > user 1m8.464s > > This looks like a nearly 3% improvement in speed. Is this significant enough that the (perhaps small) complexity of the fixed-point math implementation is worth it? The PNG decoder is pretty slow itself, but there is no single point where it can give bigger improvement. Another option would be just to use integer division. It is about function itself would become about 15% slower than with use of fixed point precalculated multiplier, but it is still would be 5-6 times faster than original code with float/int conversions. > Will this work as written under 64-bit architectures? Why not? It uses only lower 32 bits and I don't see any reason why it would fail. BTW, it is actually tested on 64-bit ubuntu, but unsigned is 32 bit on 64 bit linuxes. May be it is really better just to use integer division to avoid all confusions. 789178 12 178946 webkit.review.bot 2012-12-11 21:36:02 -0800 Comment on attachment 178946 Patch Clearing flags on attachment: 178946 Committed r137413: <http://trac.webkit.org/changeset/137413> 789179 13 webkit.review.bot 2012-12-11 21:36:06 -0800 All reviewed patches have been landed. Closing bug. 176859 2012-11-29 17:32:25 -0800 2012-11-29 17:46:14 -0800 setRGBA benchmark with different variants of this function. setRGBPerf.cpp text/x-c++src 875 ostap73 I2luY2x1ZGUgInd0Zi9QbGF0Zm9ybS5oIgojaW5jbHVkZSAid3RmL0V4cG9ydE1hY3Jvcy5oIgoj aW5jbHVkZSAid3RmL093blB0ci5oIgojaW5jbHVkZSAid3RmL1Bhc3NPd25QdHIuaCIKI2luY2x1 ZGUgIkltYWdlRGVjb2Rlci5oIgoKI2luY2x1ZGUgPHN0ZGlvLmg+CiNpbmNsdWRlIDxzeXMvc3Rh dC5oPgoKdXNpbmcgbmFtZXNwYWNlIFdlYkNvcmU7CgppbnQgbWFpbihpbnQgYXJnYywgY2hhciAq YXJndltdKQp7CiAgICBpZiAoYXJnYyA8IDIpIHsKICAgICAgICBwcmludGYoIk5lZWQganBlZyBm aWxlbmFtZS5cbiIpOwogICAgICAgIHJldHVybiAwOwogICAgfQoKICAgIFNoYXJlZEJ1ZmZlciog YnVmZmVyID0gU2hhcmVkQnVmZmVyOjpjcmVhdGVXaXRoQ29udGVudHNPZkZpbGUoU3RyaW5nKGFy Z3ZbMV0pKS5sZWFrUmVmKCk7CiAgICAKCiAgICBib29sIG9wdGltaXphdGlvbnNCcmVha2VyID0g MDsKICAgIGZvciAoaW50IGkgPSAwOyBpIDwgMTAwMDsgaSArKykgewogICAgICAgIE93blB0cjxJ bWFnZURlY29kZXI+IGRlY29kZXIgPSBXVEY6OmFkb3B0UHRyKEltYWdlRGVjb2Rlcjo6Y3JlYXRl KCpidWZmZXIsIEltYWdlU291cmNlOjpBbHBoYVByZW11bHRpcGxpZWQsIEltYWdlU291cmNlOjpH YW1tYUFuZENvbG9yUHJvZmlsZUFwcGxpZWQpKTsKICAgICAgICBkZWNvZGVyLT5zZXREYXRhKGJ1 ZmZlciwgdHJ1ZSk7CiAgICAgICAgSW1hZ2VGcmFtZSogZnJhbWUgPSBkZWNvZGVyLT5mcmFtZUJ1 ZmZlckF0SW5kZXgoMCk7CiAgICAgICAgb3B0aW1pemF0aW9uc0JyZWFrZXIgJj0gZnJhbWUtPmhh c0FscGhhKCk7CiAgICB9CgogICAgcHJpbnRmKCJEb25lXG4iLCBvcHRpbWl6YXRpb25zQnJlYWtl cik7CiAgICByZXR1cm4gMDsKfQo= 176860 2012-11-29 17:35:11 -0800 2012-11-29 17:35:11 -0800 Benchmark run results on Intel Core I7 and ARM CPUs perf_runs.txt text/plain 903 ostap73 TWFjYm9vayBQcm8gSXZ5IEJyaWRnZSBJNyAyLjdHSHosIDI1Nk0gZWxlbWVudHMKCkRpZmZlcmVu dCAwIHZhbHVlcwpQcmVtdWx0aXBseSBBbHBoYTogMQpBbGwgMCBidWZmZXI6CjE6IDI5MDAwMAky OiAyNzAwMDAJMzogMjcwMDAwCTQ6IDI3MDAwMApBbGwgMjU1IGJ1ZmZlcjoKMTogMzgwMDAwCTI6 IDM2MDAwMAkzOiAzNjAwMDAJNDogMzcwMDAwClBzZXVkbyByYW5kb20gYnVmZmVyOgoxOiA1ODAw MDAJMjogNTYwMDAwCTM6IDUwMDAwMAk0OiAzMjkwMDAwClByZW11bHRpcGx5IEFscGhhOiAwCkFs bCAwIGJ1ZmZlcjoKMTogMzQwMDAwCTI6IDM0MDAwMAkzOiAzNDAwMDAJNDogMzQwMDAwCkFsbCAy NTUgYnVmZmVyOgoxOiAzNDAwMDAJMjogMzUwMDAwCTM6IDM0MDAwMAk0OiAzNDAwMDAKUHNldWRv IHJhbmRvbSBidWZmZXI6CjE6IDM1MDAwMAkyOiAzNTAwMDAJMzogMzUwMDAwCTQ6IDM1MDAwMAoK CgoKU2Ftc3VuZyBHYWxheHkgTm90ZSBJSSwgMzJNIGVsZW1lbnRzCgpEaWZmZXJlbnQgMCB2YWx1 ZXMKUHJlbXVsdGlwbHkgQWxwaGE6IDEKQWxsIDAgYnVmZmVyOgoxOiAyNTAwMDAJMjogMjQwMDAw CTM6IDI2MDAwMAk0OiAyMjAwMDAKQWxsIDI1NSBidWZmZXI6CjE6IDMwMDAwMAkyOiAzMDAwMDAJ MzogMjkwMDAwCTQ6IDMwMDAwMApQc2V1ZG8gcmFuZG9tIGJ1ZmZlcjoKMTogMzgwMDAwCTI6IDM2 MDAwMAkzOiAzNjAwMDAJNDogMTQ4MDAwMApQcmVtdWx0aXBseSBBbHBoYTogMApBbGwgMCBidWZm ZXI6CjE6IDIzMDAwMAkyOiAyMjAwMDAJMzogMjMwMDAwCTQ6IDIyMDAwMApBbGwgMjU1IGJ1ZmZl cjoKMTogMjkwMDAwCTI6IDI1MDAwMAkzOiAyMjAwMDAJNDogMjMwMDAwClBzZXVkbyByYW5kb20g YnVmZmVyOgoxOiAyNDAwMDAJMjogMjIwMDAwCTM6IDIzMDAwMAk0OiAyMjAwMDAK 178738 2012-12-11 00:26:16 -0800 2012-12-11 18:59:43 -0800 Patch bug-103693-20121211032656.patch text/plain 2351 ostap73 U3VidmVyc2lvbiBSZXZpc2lvbjogMTM2ODgzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYTNiZGVkNDBhMzg5N2Yw MGIyODU3NzIwMjVlZjc0MTkwZmZhNjlhMC4uN2U2ODRmNWIyZThjNDZiOTEyNjg5OGYxZGM4ODI2 MzhhMWQ0MWNjOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE5IEBACisyMDEyLTEyLTExICBWaWF0 Y2hlc2xhdiBPc3RhcGVua28gIDx2Lm9zdGFwZW5rb0BzYW1zdW5nLmNvbT4KKworICAgICAgICBS ZW1vdmUgY29udmVyc2lvbiB0by9mcm9tIGZsb2F0IGFuZCBmbG9hdCBkaXZpc2lvbiBmcm9tIElt YWdlRnJhbWU6OnNldFJHQkEKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTEwMzY5MworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgIFJlcGxhY2UgZmxvYXRpbmcgcG9pbnQgb3BlcmF0aW9ucyB1c2VkIGZvciBhbHBo YSBwcmVtdWx0aXBseSB3aXRoIGZpeGVkIHBvaW50IGFyaWZtZXRpY3MKKyAgICAgICAgd2hpY2gg aXMgYmFzaWNhbGx5IGludGVnZXIgb3BlcmF0aW9ucy4gQWxsb3dzIHRvIHNoYXZlIGV4dHJhIGNv dXBsZSBwZXJjZW50IGZyb20gZGVjb2RpbmcKKyAgICAgICAgaW1hZ2VzIHdpdGggdHJhbnNwYXJl bmN5LgorCisgICAgICAgIENvdmVyZWQgYnkgZXhpc3RpbmcgdGVzdHMuCisKKyAgICAgICAgKiBw bGF0Zm9ybS9pbWFnZS1kZWNvZGVycy9JbWFnZURlY29kZXIuaDoKKyAgICAgICAgKFdlYkNvcmU6 OkltYWdlRnJhbWU6OnNldFJHQkEpOgorCiAyMDEyLTEyLTA2ICBTaGVyaWZmIEJvdCAgPHdlYmtp dC5yZXZpZXcuYm90QGdtYWlsLmNvbT4KIAogICAgICAgICBVbnJldmlld2VkLCByb2xsaW5nIG91 dCByMTM2ODcxLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vaW1hZ2UtZGVj b2RlcnMvSW1hZ2VEZWNvZGVyLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9pbWFnZS1kZWNv ZGVycy9JbWFnZURlY29kZXIuaAppbmRleCAzZWQwMjVmYWE0ZmYzNzcyZTdiY2EwOWYyM2YyYjRi MzQ4OGIzNjQyLi5lM2UyMGViZGNiZGM5ZjM3YWQ1Y2EwY2I3YjllMWQ0NTMzNWExN2ZmIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9pbWFnZS1kZWNvZGVycy9JbWFnZURlY29k ZXIuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9pbWFnZS1kZWNvZGVycy9JbWFnZURl Y29kZXIuaApAQCAtMTY3LDEwICsxNjcsMTQgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAg ICAgICAgICAgICAgICByZXR1cm47CiAgICAgICAgICAgICAgICAgfQogCi0gICAgICAgICAgICAg ICAgZmxvYXQgYWxwaGFQZXJjZW50ID0gYSAvIDI1NS4wZjsKLSAgICAgICAgICAgICAgICByID0g c3RhdGljX2Nhc3Q8dW5zaWduZWQ+KHIgKiBhbHBoYVBlcmNlbnQpOwotICAgICAgICAgICAgICAg IGcgPSBzdGF0aWNfY2FzdDx1bnNpZ25lZD4oZyAqIGFscGhhUGVyY2VudCk7Ci0gICAgICAgICAg ICAgICAgYiA9IHN0YXRpY19jYXN0PHVuc2lnbmVkPihiICogYWxwaGFQZXJjZW50KTsKKyAgICAg ICAgICAgICAgICAvLyBVc2UgZml4IHBvaW50IG11bHRpcGxpZXIgaW5zdGVhZCBvZiBpbnRlZ2Vy IGRpdmlzaW9uIG9yIGZsb2F0aW5nIHBvaW50IG1hdGguCisgICAgICAgICAgICAgICAgLy8gVGhp cyBtdWx0aXBsZXIgcHJvZHVjZXMgZXhhY3RseSB0aGUgc2FtZSByZXN1bHQgZm9yIGFsbCB2YWx1 ZXMgaW4gcmFuZ2UgMCAtIDI1NS4KKyAgICAgICAgICAgICAgICBzdGF0aWMgY29uc3QgdW5zaWdu ZWQgZml4UG9pbnRTaGlmdCA9IDI0OworICAgICAgICAgICAgICAgIHN0YXRpYyBjb25zdCB1bnNp Z25lZCBmaXhQb2ludE11bHQgPSB1bnNpZ25lZCgxLjAgLyAyNTUuMCAqICgxIDw8IGZpeFBvaW50 U2hpZnQpKSArIDE7CisgICAgICAgICAgICAgICAgdW5zaWduZWQgYWxwaGFNdWx0ID0gYSAqIGZp eFBvaW50TXVsdDsKKyAgICAgICAgICAgICAgICByID0gKHIgKiBhbHBoYU11bHQpID4+IGZpeFBv aW50U2hpZnQ7CisgICAgICAgICAgICAgICAgZyA9IChnICogYWxwaGFNdWx0KSA+PiBmaXhQb2lu dFNoaWZ0OworICAgICAgICAgICAgICAgIGIgPSAoYiAqIGFscGhhTXVsdCkgPj4gZml4UG9pbnRT aGlmdDsKICAgICAgICAgICAgIH0KICNpZiBVU0UoU0tJQSkKICAgICAgICAgICAgIC8vIENhbGwg dGhlICJOb0NoZWNrIiB2ZXJzaW9uIHNpbmNlIHdlIG1heSBkZWxpYmVyYXRlbHkgcGFzcyBub24t cHJlbXVsdGlwbGllZAo= 178946 2012-12-11 18:59:45 -0800 2012-12-11 21:36:02 -0800 Patch bug-103693-20121211220429.patch text/plain 2888 ostap73 U3VidmVyc2lvbiBSZXZpc2lvbjogMTM2ODgzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYTNiZGVkNDBhMzg5N2Yw MGIyODU3NzIwMjVlZjc0MTkwZmZhNjlhMC4uNmRkOTAyNTc0NGEyNjJhY2Q4YzBmMmMxYzA1ZTMy NTc3NzFjZjdjOCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIxIEBACisyMDEyLTEyLTExICBWaWF0 Y2hlc2xhdiBPc3RhcGVua28gIDx2Lm9zdGFwZW5rb0BzYW1zdW5nLmNvbT4KKworICAgICAgICBS ZW1vdmUgY29udmVyc2lvbiB0by9mcm9tIGZsb2F0IGFuZCBmbG9hdCBkaXZpc2lvbiBmcm9tIElt YWdlRnJhbWU6OnNldFJHQkEKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTEwMzY5MworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgIFJlcGxhY2UgZmxvYXRpbmcgcG9pbnQgb3BlcmF0aW9ucyB1c2VkIGZvciBhbHBo YSBwcmVtdWx0aXBseSB3aXRoIGZpeGVkIHBvaW50IGFyaXRobWV0aWMKKyAgICAgICAgd2hpY2gg aXMgYmFzaWNhbGx5IGludGVnZXIgb3BlcmF0aW9ucy4gQWxsb3dzIHRvIHNoYXZlIGV4dHJhIGNv dXBsZSBwZXJjZW50IGZyb20gZGVjb2RpbmcKKyAgICAgICAgaW1hZ2VzIHdpdGggdHJhbnNwYXJl bmN5LgorCisgICAgICAgIENvdmVyZWQgYnkgZXhpc3RpbmcgdGVzdHMuCisKKyAgICAgICAgKiBw bGF0Zm9ybS9pbWFnZS1kZWNvZGVycy9JbWFnZURlY29kZXIuaDoKKyAgICAgICAgKEltYWdlRnJh bWUpOgorICAgICAgICAoV2ViQ29yZTo6SW1hZ2VGcmFtZTo6Zml4UG9pbnRVbnNpZ25lZE11bHRp cGx5KToKKyAgICAgICAgKFdlYkNvcmU6OkltYWdlRnJhbWU6OnNldFJHQkEpOgorCiAyMDEyLTEy LTA2ICBTaGVyaWZmIEJvdCAgPHdlYmtpdC5yZXZpZXcuYm90QGdtYWlsLmNvbT4KIAogICAgICAg ICBVbnJldmlld2VkLCByb2xsaW5nIG91dCByMTM2ODcxLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vaW1hZ2UtZGVjb2RlcnMvSW1hZ2VEZWNvZGVyLmggYi9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9pbWFnZS1kZWNvZGVycy9JbWFnZURlY29kZXIuaAppbmRleCAzZWQwMjVm YWE0ZmYzNzcyZTdiY2EwOWYyM2YyYjRiMzQ4OGIzNjQyLi40YzFjM2RlZDE3NTllNDg1MzIyMmE1 ZWMzZGE4MTJhMzYxZWUxNmQ3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9p bWFnZS1kZWNvZGVycy9JbWFnZURlY29kZXIuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9pbWFnZS1kZWNvZGVycy9JbWFnZURlY29kZXIuaApAQCAtMTU5LDYgKzE1OSwxNiBAQCBuYW1l c3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIH0KICNlbmRpZgogCisgICAgICAgIC8vIFVzZSBmaXgg cG9pbnQgbXVsdGlwbGllciBpbnN0ZWFkIG9mIGludGVnZXIgZGl2aXNpb24gb3IgZmxvYXRpbmcg cG9pbnQgbWF0aC4KKyAgICAgICAgLy8gVGhpcyBtdWx0aXBsZXIgcHJvZHVjZXMgZXhhY3RseSB0 aGUgc2FtZSByZXN1bHQgZm9yIGFsbCB2YWx1ZXMgaW4gcmFuZ2UgMCAtIDI1NS4KKyAgICAgICAg c3RhdGljIGNvbnN0IHVuc2lnbmVkIGZpeFBvaW50U2hpZnQgPSAyNDsKKyAgICAgICAgc3RhdGlj IGNvbnN0IHVuc2lnbmVkIGZpeFBvaW50TXVsdCA9IHN0YXRpY19jYXN0PHVuc2lnbmVkPigxLjAg LyAyNTUuMCAqICgxIDw8IGZpeFBvaW50U2hpZnQpKSArIDE7CisgICAgICAgIC8vIE11bHRpcGxp ZXMgdW5zaWduZWQgdmFsdWUgYnkgZml4cG9pbnQgdmFsdWUgYW5kIGNvbnZlcnRzIGJhY2sgdG8g dW5zaWduZWQuCisgICAgICAgIHN0YXRpYyB1bnNpZ25lZCBmaXhQb2ludFVuc2lnbmVkTXVsdGlw bHkodW5zaWduZWQgZml4ZWQsIHVuc2lnbmVkIHYpCisgICAgICAgIHsKKyAgICAgICAgICAgIHJl dHVybiAgKGZpeGVkICogdikgPj4gZml4UG9pbnRTaGlmdDsKKyAgICAgICAgfQorCiAgICAgICAg IGlubGluZSB2b2lkIHNldFJHQkEoUGl4ZWxEYXRhKiBkZXN0LCB1bnNpZ25lZCByLCB1bnNpZ25l ZCBnLCB1bnNpZ25lZCBiLCB1bnNpZ25lZCBhKQogICAgICAgICB7CiAgICAgICAgICAgICBpZiAo bV9wcmVtdWx0aXBseUFscGhhICYmIGEgPCAyNTUpIHsKQEAgLTE2NywxMCArMTc3LDEwIEBAIG5h bWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgICAgICAgICAgICAgcmV0dXJuOwogICAgICAgICAg ICAgICAgIH0KIAotICAgICAgICAgICAgICAgIGZsb2F0IGFscGhhUGVyY2VudCA9IGEgLyAyNTUu MGY7Ci0gICAgICAgICAgICAgICAgciA9IHN0YXRpY19jYXN0PHVuc2lnbmVkPihyICogYWxwaGFQ ZXJjZW50KTsKLSAgICAgICAgICAgICAgICBnID0gc3RhdGljX2Nhc3Q8dW5zaWduZWQ+KGcgKiBh bHBoYVBlcmNlbnQpOwotICAgICAgICAgICAgICAgIGIgPSBzdGF0aWNfY2FzdDx1bnNpZ25lZD4o YiAqIGFscGhhUGVyY2VudCk7CisgICAgICAgICAgICAgICAgdW5zaWduZWQgYWxwaGFNdWx0ID0g YSAqIGZpeFBvaW50TXVsdDsKKyAgICAgICAgICAgICAgICByID0gZml4UG9pbnRVbnNpZ25lZE11 bHRpcGx5KHIsIGFscGhhTXVsdCk7CisgICAgICAgICAgICAgICAgZyA9IGZpeFBvaW50VW5zaWdu ZWRNdWx0aXBseShnLCBhbHBoYU11bHQpOworICAgICAgICAgICAgICAgIGIgPSBmaXhQb2ludFVu c2lnbmVkTXVsdGlwbHkoYiwgYWxwaGFNdWx0KTsKICAgICAgICAgICAgIH0KICNpZiBVU0UoU0tJ QSkKICAgICAgICAgICAgIC8vIENhbGwgdGhlICJOb0NoZWNrIiB2ZXJzaW9uIHNpbmNlIHdlIG1h eSBkZWxpYmVyYXRlbHkgcGFzcyBub24tcHJlbXVsdGlwbGllZAo=