diff options
Diffstat (limited to 'src/main/java/org/linaro/benchmarks')
68 files changed, 14067 insertions, 60 deletions
diff --git a/src/main/java/org/linaro/benchmarks/algorithm/AccessFannkuch.java b/src/main/java/org/linaro/benchmarks/algorithm/AccessFannkuch.java new file mode 100644 index 0000000..c999216 --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/algorithm/AccessFannkuch.java @@ -0,0 +1,113 @@ +/* + * Copyright (C) 2015 Linaro Limited. Ported to Java from: + * https://github.com/WebKit/webkit/blob/master/PerformanceTests/SunSpider/tests/sunspider-1.0.2/access-fannkuch.js + * + * Description: Algorithm that performs array permutations. + * Main Focus: Array operations. + * + */ + +/* The Great Computer Language Shootout + http://shootout.alioth.debian.org/ + contributed by Isaac Gouy */ + +// http://benchmarksgame.alioth.debian.org/license.html (BSD 3-clause license) +// See NOTICE file for the license + +package org.linaro.benchmarks.algorithm; + +import java.lang.Integer; +import java.lang.System; +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + +public class AccessFannkuch { + private static final int ACCESS_FANNKUCH_EXPECTED = 22; + + private int fannkuch(int n) { + int check = 0; + int[] perm = new int[n]; + int[] perm1 = new int[n]; + int[] count = new int[n]; + int[] maxPerm = new int[n]; + int maxFlipsCount = 0; + final int m = n - 1; + + for (int i = 0; i < n; i++) { + perm1[i] = i; + } + int r = n; + + while (true) { + // Write-out the first 30 permutations. + if (check < 30) { + String s = ""; + for (int i = 0; i < n; i++) { + s += Integer.toString((perm1[i] + 1)); + } + check++; + } + + while (r != 1) { + count[r - 1] = r; + r--; + } + + if (!(perm1[0] == 0 || perm1[m] == m)) { + for (int i = 0; i < n; i++) { + perm[i] = perm1[i]; + } + + int flipsCount = 0; + int k; + + while (!((k = perm[0]) == 0)) { + int k2 = ( k + 1) >> 1; + for (int i = 0; i < k2; i++) { + int temp = perm[i]; + perm[i] = perm[k - i]; + perm[k - i] = temp; + } + flipsCount++; + } + + if (flipsCount > maxFlipsCount) { + maxFlipsCount = flipsCount; + for (int i = 0; i < n; i++) { + maxPerm[i] = perm1[i]; + } + } + } + + while (true) { + if (r == n) { + return maxFlipsCount; + } + int perm0 = perm1[0]; + int i = 0; + while (i < r) { + int j = i + 1; + perm1[i] = perm1[j]; + i = j; + } + perm1[r] = perm0; + + count[r] = count[r] - 1; + if (count[r] > 0) { + break; + } + r++; + } + } + } + + @Benchmark + public void jmhTimeAccessFannkuch() { + fannkuch(8); + } +} + diff --git a/src/main/java/org/linaro/benchmarks/algorithm/BitopsNSieve.java b/src/main/java/org/linaro/benchmarks/algorithm/BitopsNSieve.java new file mode 100644 index 0000000..8904fe7 --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/algorithm/BitopsNSieve.java @@ -0,0 +1,75 @@ +/* + * Copyright (C) 2015 Linaro Limited. Ported to Java from: + * https://github.com/WebKit/webkit/blob/master/PerformanceTests/SunSpider/tests/sunspider-1.0.2/bitops-nsieve-bits.js + * + * Description: Bitops prime number sieve, used for finding prime numbers. + * Main Focus: Bitwise operations. + * + */ + +// The Great Computer Language Shootout +// http://shootout.alioth.debian.org/ +// +// Contributed by Ian Osgood + +// http://benchmarksgame.alioth.debian.org/license.html (BSD 3-clause license) +// See NOTICE file for the license + +package org.linaro.benchmarks.algorithm; + +import java.lang.Integer; +import java.lang.System; +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + +public class BitopsNSieve { + private static final int BITOPS_NSIEVE_EXPECTED = -1431657430; + + // As per the original, this function is not used. + private String pad(int n, int width) { + String s = Integer.toString(n); + while (s.length() < width) { + s = ' ' + s; + } + return s; + } + + private void primes(int[] isPrime, int n) { + // As per the original, this variable can be optimised out. + int count = 0; + final int m = 10000 << n; + final int size = m + 31 >> 5; + + for (int i = 0; i < size; i++) { + isPrime[i] = 0xffffffff; + } + + for (int i = 2; i < m; i++) { + if ((isPrime[i >> 5] & 1 << (i & 31)) != 0) { + for (int j = i + 1; j < m; j += i) { + isPrime[j >> 5] &= ~ (1 << (j & 31)); + } + count++; + } + } + } + + private int[] sieve() { + int[] isPrime = null; + // As per the original, this loop will have just one iteration. + for (int i = 4; i <= 4; i++) { + isPrime = new int[(10000 << i) + 31 >> 5]; + primes(isPrime, i); + } + return isPrime; + } + + @Benchmark + public void jmhTimeBitopsNSieve() { + sieve(); + } +} diff --git a/src/main/java/org/linaro/benchmarks/algorithm/CryptoMD5.java b/src/main/java/org/linaro/benchmarks/algorithm/CryptoMD5.java new file mode 100644 index 0000000..4641b01 --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/algorithm/CryptoMD5.java @@ -0,0 +1,271 @@ +/* + * Copyright (C) 2015 Linaro Limited. Ported to Java from: + * https://github.com/WebKit/webkit/blob/master/PerformanceTests/SunSpider/tests/sunspider-1.0.2/crypto-md5.js + * + * Description: Encrypts a text fragment using the MD5 message-digest + * algorithm, producing a 128-bit hash value. + * Main Focus: Bit operations. + */ + +/* + * A JavaScript implementation of the RSA Data Security, Inc. MD5 Message + * Digest Algorithm, as defined in RFC 1321. + * Version 2.1 Copyright (C) Paul Johnston 1999 - 2002. + * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet + * Distributed under the BSD License + * See http://pajhome.org.uk/crypt/md5 for more info. + */ +/* + * Copyright (c) 1998 - 2009, Paul Johnston & Contributors + * All rights reserved. + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * Neither the name of the author nor the names of its contributors may be used + * to endorse or promote products derived from this software without specific + * prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +package org.linaro.benchmarks.algorithm; + +import java.lang.System; +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + +public class CryptoMD5 { + private static String TEXT; + private static final String TEXT_FRAGMENT = + "Rebellious subjects, enemies to peace,\n" + + "Profaners of this neighbour-stained steel,--\n" + + "Will they not hear? What, ho! you men, you beasts,\n" + + "That quench the fire of your pernicious rage\n" + + "With purple fountains issuing from your veins,\n" + + "On pain of torture, from those bloody hands\n" + + "Throw your mistemper'd weapons to the ground,\n" + + "And hear the sentence of your moved prince.\n" + + "Three civil brawls, bred of an airy word,\n" + + "By thee, old Capulet, and Montague,\n" + + "Have thrice disturb'd the quiet of our streets,\n" + + "And made Verona's ancient citizens\n" + + "Cast by their grave beseeming ornaments,\n" + + "To wield old partisans, in hands as old,\n" + + "Canker'd with peace, to part your canker'd hate:\n" + + "If ever you disturb our streets again,\n" + + "Your lives shall pay the forfeit of the peace.\n" + + "For this time, all the rest depart away:\n" + + "You Capulet; shall go along with me:\n" + + "And, Montague, come you this afternoon,\n" + + "To know our further pleasure in this case,\n" + + "To old Free-town, our common judgment-place.\n" + + "Once more, on pain of death, all men depart."; + + private static final String MD5_EXPECTED = + "a831e91e0f70eddcb70dc61c6f82f6cd"; + + // bits per input character. 8 - ASCII; 16 - Unicode + private static final int CHRSZ = 8; + private static final int MASK = (1 << CHRSZ) - 1; + + // to convert binary values into a hex string digest + private static final boolean HEX_UPPER_CASE = false; + private static final String HEX_CHARS = + HEX_UPPER_CASE ? "0123456789ABCDEF" : "0123456789abcdef"; + + static { + TEXT = TEXT_FRAGMENT; + + for (int i = 0; i < 4; ++i) { + TEXT += TEXT; + } + } + + /* Bitwise rotate a 32-bit number to the left. */ + private int bitRotateLeft(int num, int cnt) { + return (num << cnt) | (num >>> (32 - cnt)); + } + + /* + * Convert a string to an array of little-endian words + * If CHRSZ is ASCII, characters >255 have their hi-byte silently ignored. + */ + private int[] str2binl(String str, int padding) { + final int len = str.length() / 4; + int paddedLen = len; + final int rem = paddedLen % padding; + + if (padding != 0 && rem != 0) { + paddedLen += padding - rem; + } + + int[] bin = new int[paddedLen]; + + for (int i = 0; i < str.length() * CHRSZ; i += CHRSZ) { + bin[i >> 5] |= (str.charAt(i / CHRSZ) & MASK) << (i % 32); + } + + return bin; + } + + /* Default padding of 16 as in the original Javascript implementation. */ + private int[] str2binl(String str) { + return str2binl(str, 16); + } + + /* Convert an array of little-endian words to a hex string. */ + private String binl2hex(int[] bin) { + String str = ""; + + for (int i = 0; i < bin.length * 4; i++) { + str += HEX_CHARS.charAt((bin[i >> 2] >> ((i % 4) * 8 + 4)) & 0xF); + str += HEX_CHARS.charAt((bin[i >> 2] >> ((i % 4) * 8)) & 0xF); + } + + return str; + } + + private int md5Common(int q, int a, int b, int x, int s, int t) { + return bitRotateLeft(a + q + x + t, s) + b; + } + + private int md5FF(int a, int b, int c, int d, int x, int s, int t) { + return md5Common((b & c) | ((~b) & d), a, b, x, s, t); + } + + private int md5GG(int a, int b, int c, int d, int x, int s, int t) { + return md5Common((b & d) | (c & (~d)), a, b, x, s, t); + } + + private int md5HH(int a, int b, int c, int d, int x, int s, int t) { + return md5Common(b ^ c ^ d, a, b, x, s, t); + } + + private int md5II(int a, int b, int c, int d, int x, int s, int t) { + return md5Common(c ^ (b | (~d)), a, b, x, s, t); + } + + private int[] coreMD5(int[] x, int len) { + /* append padding */ + x[len >> 5] |= 0x80 << ((len) % 32); + x[(((len + 64) >>> 9) << 4) + 14] = len; + + int a = 1732584193; + int b = -271733879; + int c = -1732584194; + int d = 271733878; + + for (int i = 0; i < x.length; i += 16) { + final int olda = a; + final int oldb = b; + final int oldc = c; + final int oldd = d; + + a = md5FF(a, b, c, d, x[i + 0], 7 , -680876936); + d = md5FF(d, a, b, c, x[i + 1], 12, -389564586); + c = md5FF(c, d, a, b, x[i + 2], 17, 606105819); + b = md5FF(b, c, d, a, x[i + 3], 22, -1044525330); + a = md5FF(a, b, c, d, x[i + 4], 7 , -176418897); + d = md5FF(d, a, b, c, x[i + 5], 12, 1200080426); + c = md5FF(c, d, a, b, x[i + 6], 17, -1473231341); + b = md5FF(b, c, d, a, x[i + 7], 22, -45705983); + a = md5FF(a, b, c, d, x[i + 8], 7 , 1770035416); + d = md5FF(d, a, b, c, x[i + 9], 12, -1958414417); + c = md5FF(c, d, a, b, x[i + 10], 17, -42063); + b = md5FF(b, c, d, a, x[i + 11], 22, -1990404162); + a = md5FF(a, b, c, d, x[i + 12], 7 , 1804603682); + d = md5FF(d, a, b, c, x[i + 13], 12, -40341101); + c = md5FF(c, d, a, b, x[i + 14], 17, -1502002290); + b = md5FF(b, c, d, a, x[i + 15], 22, 1236535329); + + a = md5GG(a, b, c, d, x[i + 1], 5 , -165796510); + d = md5GG(d, a, b, c, x[i + 6], 9 , -1069501632); + c = md5GG(c, d, a, b, x[i + 11], 14, 643717713); + b = md5GG(b, c, d, a, x[i + 0], 20, -373897302); + a = md5GG(a, b, c, d, x[i + 5], 5 , -701558691); + d = md5GG(d, a, b, c, x[i + 10], 9 , 38016083); + c = md5GG(c, d, a, b, x[i + 15], 14, -660478335); + b = md5GG(b, c, d, a, x[i + 4], 20, -405537848); + a = md5GG(a, b, c, d, x[i + 9], 5 , 568446438); + d = md5GG(d, a, b, c, x[i + 14], 9 , -1019803690); + c = md5GG(c, d, a, b, x[i + 3], 14, -187363961); + b = md5GG(b, c, d, a, x[i + 8], 20, 1163531501); + a = md5GG(a, b, c, d, x[i + 13], 5 , -1444681467); + d = md5GG(d, a, b, c, x[i + 2], 9 , -51403784); + c = md5GG(c, d, a, b, x[i + 7], 14, 1735328473); + b = md5GG(b, c, d, a, x[i + 12], 20, -1926607734); + + a = md5HH(a, b, c, d, x[i + 5], 4 , -378558); + d = md5HH(d, a, b, c, x[i + 8], 11, -2022574463); + c = md5HH(c, d, a, b, x[i + 11], 16, 1839030562); + b = md5HH(b, c, d, a, x[i + 14], 23, -35309556); + a = md5HH(a, b, c, d, x[i + 1], 4 , -1530992060); + d = md5HH(d, a, b, c, x[i + 4], 11, 1272893353); + c = md5HH(c, d, a, b, x[i + 7], 16, -155497632); + b = md5HH(b, c, d, a, x[i + 10], 23, -1094730640); + a = md5HH(a, b, c, d, x[i + 13], 4 , 681279174); + d = md5HH(d, a, b, c, x[i + 0], 11, -358537222); + c = md5HH(c, d, a, b, x[i + 3], 16, -722521979); + b = md5HH(b, c, d, a, x[i + 6], 23, 76029189); + a = md5HH(a, b, c, d, x[i + 9], 4 , -640364487); + d = md5HH(d, a, b, c, x[i + 12], 11, -421815835); + c = md5HH(c, d, a, b, x[i + 15], 16, 530742520); + b = md5HH(b, c, d, a, x[i + 2], 23, -995338651); + + a = md5II(a, b, c, d, x[i + 0], 6 , -198630844); + d = md5II(d, a, b, c, x[i + 7], 10, 1126891415); + c = md5II(c, d, a, b, x[i + 14], 15, -1416354905); + b = md5II(b, c, d, a, x[i + 5], 21, -57434055); + a = md5II(a, b, c, d, x[i + 12], 6 , 1700485571); + d = md5II(d, a, b, c, x[i + 3], 10, -1894986606); + c = md5II(c, d, a, b, x[i + 10], 15, -1051523); + b = md5II(b, c, d, a, x[i + 1], 21, -2054922799); + a = md5II(a, b, c, d, x[i + 8], 6 , 1873313359); + d = md5II(d, a, b, c, x[i + 15], 10, -30611744); + c = md5II(c, d, a, b, x[i + 6], 15, -1560198380); + b = md5II(b, c, d, a, x[i + 13], 21, 1309151649); + a = md5II(a, b, c, d, x[i + 4], 6 , -145523070); + d = md5II(d, a, b, c, x[i + 11], 10, -1120210379); + c = md5II(c, d, a, b, x[i + 2], 15, 718787259); + b = md5II(b, c, d, a, x[i + 9], 21, -343485551); + + a = a + olda; + b = b + oldb; + c = c + oldc; + d = d + oldd; + } + return new int[] {a, b, c, d}; + } + + public String hexMD5(String stringData) { + int[] bin = str2binl(stringData); + int[] md5 = coreMD5(bin, stringData.length() * CHRSZ); + String hex = binl2hex(md5); + return hex; + } + + @Benchmark + public void jmhTimeHexMD5() { + hexMD5(TEXT); + } +} diff --git a/src/main/java/org/linaro/benchmarks/algorithm/CryptoSHA1.java b/src/main/java/org/linaro/benchmarks/algorithm/CryptoSHA1.java new file mode 100644 index 0000000..846d7e3 --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/algorithm/CryptoSHA1.java @@ -0,0 +1,220 @@ +/* + * Copyright (C) 2015 Linaro Limited. Ported to Java from: + * https://github.com/WebKit/webkit/blob/master/PerformanceTests/SunSpider/tests/sunspider-1.0.2/crypto-sha1.js + * + * Description: Encrypts a text fragment using the SHA1 Secure Hash + * Algorithm, producing a 160-bit hash value. + * Main Focus: Bit operations. + * + */ + +/* + * A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined + * in FIPS PUB 180-1 + * Version 2.1a Copyright Paul Johnston 2000 - 2002. + * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet + * Distributed under the BSD License + * See http://pajhome.org.uk/crypt/md5 for details. + */ +/* + * Copyright (c) 1998 - 2009, Paul Johnston & Contributors + * All rights reserved. + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * Neither the name of the author nor the names of its contributors may be used + * to endorse or promote products derived from this software without specific + * prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +package org.linaro.benchmarks.algorithm; + +import java.lang.System; +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + +public class CryptoSHA1 { + private static String TEXT; + private static final String TEXT_FRAGMENT = + "Two households, both alike in dignity,\n" + + "In fair Verona, where we lay our scene,\n" + + "From ancient grudge break to new mutiny,\n" + + "Where civil blood makes civil hands unclean.\n" + + "From forth the fatal loins of these two foes\n" + + "A pair of star-cross'd lovers take their life;\n" + + "Whole misadventured piteous overthrows\n" + + "Do with their death bury their parents' strife.\n" + + "The fearful passage of their death-mark'd love,\n" + + "And the continuance of their parents' rage,\n" + + "Which, but their children's end, nought could remove,\n" + + "Is now the two hours' traffic of our stage;\n" + + "The which if you with patient ears attend,\n" + + "What here shall miss, our toil shall strive to mend."; + + private static final String SHA1_EXPECTED = + "2524d264def74cce2498bf112bedf00e6c0b796d"; + + // bits per input character. 8 - ASCII; 16 - Unicode + private static final int CHRSZ = 8; + private static final int MASK = (1 << CHRSZ) - 1; + + // to convert binary values into a hex string digest + private static final boolean HEX_UPPER_CASE = false; + private static final String HEX_CHARS = + HEX_UPPER_CASE ? "0123456789ABCDEF" : "0123456789abcdef"; + + static { + TEXT = TEXT_FRAGMENT; + + for (int i = 0; i < 4; ++i) { + TEXT += TEXT; + } + } + + /* + * Convert a string to an array of little-endian words + * If CHRSZ is ASCII, characters >255 have their hi-byte silently ignored. + */ + private int[] str2binb(String str, int padding) { + final int len = str.length() / 4; + int paddedLen = len; + final int rem = paddedLen % padding; + + if (padding != 0 && rem != 0) { + paddedLen += padding - rem; + } + + int[] bin = new int[paddedLen]; + + for (int i = 0; i < str.length() * CHRSZ; i += CHRSZ) { + bin[i >> 5] |= (str.charAt(i / CHRSZ) & MASK) << (32 - CHRSZ - i % 32); + } + + return bin; + } + + /* Default padding of 16 as in the original Javascript implementation. */ + private int[] str2binb(String str) { + return str2binb(str, 16); + } + + /* Convert an array of little-endian words to a hex string. */ + private String binb2hex(int[] bin) { + String str = ""; + + for (int i = 0; i < bin.length * 4; i++) { + str += HEX_CHARS.charAt((bin[i >> 2] >> ((3 - i % 4) * 8 + 4)) & 0xF); + str += HEX_CHARS.charAt((bin[i >> 2] >> ((3 - i % 4) * 8)) & 0xF); + } + + return str; + } + + /* + * Bitwise rotate a 32-bit number to the left + * TODO: Name + */ + private int bitRotateLeft(int num, int cnt) { + return (num << cnt) | (num >>> (32 - cnt)); + } + + /* + * Perform the appropriate triplet combination function for the current + * iteration + */ + private int sha1FT(int t, int b, int c, int d) { + if (t < 20) { + return (b & c) | ((~b) & d); + } else if (t < 40) { + return b ^ c ^ d; + } else if (t < 60) { + return (b & c) | (b & d) | (c & d); + } else { + return b ^ c ^ d; + } + } + + /* + * Determine the appropriate additive constant for the current iteration + */ + private int sha1KT(int t) { + return (t < 20) ? 1518500249 : ((t < 40) ? 1859775393 : + ((t < 60) ? -1894007588 : -899497514)); + } + + private int[] coreSHA1(int[] x, int len) { + /* append padding */ + x[len >> 5] |= 0x80 << (24 - len % 32); + x[(((len + 64) >> 9) << 4) + 15] = len; + + int[] w = new int[80]; + int a = 1732584193; + int b = -271733879; + int c = -1732584194; + int d = 271733878; + int e = -1009589776; + + for (int i = 0; i < x.length; i += 16) { + final int olda = a; + final int oldb = b; + final int oldc = c; + final int oldd = d; + final int olde = e; + + for (int j = 0; j < 80; j++) { + if (j < 16) { + w[j] = x[i + j]; + } else { + w[j] = bitRotateLeft(w[j - 3] ^ w[j - 8] ^ w[j - 14] ^ w[j - 16], 1); + } + int t = bitRotateLeft(a, 5) + sha1FT(j, b, c, d) + e + w[j] + sha1KT(j); + + e = d; + d = c; + c = bitRotateLeft(b, 30); + b = a; + a = t; + } + a = a + olda; + b = b + oldb; + c = c + oldc; + d = d + oldd; + e = e + olde; + } + return new int[] {a, b, c, d, e}; + } + + public String hexSHA1(String stringData) { + int[] bin = str2binb(stringData); + int[] sha1 = coreSHA1(bin, stringData.length() * CHRSZ); + String hex = binb2hex(sha1); + return hex; + } + + @Benchmark + public void jmhTimeHexSHA1() { + hexSHA1(TEXT); + } +} diff --git a/src/main/java/org/linaro/benchmarks/algorithm/Dhrystone.java b/src/main/java/org/linaro/benchmarks/algorithm/Dhrystone.java new file mode 100644 index 0000000..c0986f0 --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/algorithm/Dhrystone.java @@ -0,0 +1,390 @@ +/* + * Copyright (C) 2016 Linaro Limited. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.linaro.benchmarks.algorithm; + +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +class Record { + Record ptrComp; + int discr; + int enumComp; + int intComp; + StringBuilder strComp; + int enumComp2; + char ch1Comp; + char ch2Comp; +} + +class Pointer<T> { + T ref; +} + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + +public class Dhrystone { + Record ptrGlob; + Record nextPtrGlob; + int intGlob; + boolean boolGlob; + char ch1Glob; + char ch2Glob; + int []arr1Glob; + int [][]arr2Glob; + int numOfRuns; + + public static final int Ident_1 = 0; + public static final int Ident_2 = 1; + public static final int Ident_3 = 2; + public static final int Ident_4 = 3; + public static final int Ident_5 = 4; + private static final int loop_size = 500000; + + public Dhrystone() { + ptrGlob = new Record(); + nextPtrGlob = new Record(); + + ptrGlob.ptrComp = nextPtrGlob; + ptrGlob.discr = Ident_1; + ptrGlob.enumComp = Ident_3; + ptrGlob.intComp = 40; + ptrGlob.strComp = new StringBuilder(30); + + nextPtrGlob.strComp = new StringBuilder(30); + + arr1Glob = new int[50]; + arr2Glob = new int[50][50]; + arr2Glob[8][7] = 10; + } + + + + @Benchmark + public void jmhTimeDhrystone() { + old_main(); + } + + public void old_main() { + int runIndex; + int int1Loc; + int int2Loc; + int int3Loc = 0; + Pointer<Integer> intRef = new Pointer<Integer>(); + String str1Loc = "DHRYSTONE PROGRAM, 1'ST STRING"; + StringBuilder str2Loc = new StringBuilder(30); + + int enumLoc = 0; + char chIndex; + + /* We should re-init the parameters on every test */ + ptrGlob.ptrComp = nextPtrGlob; + ptrGlob.discr = Ident_1; + ptrGlob.enumComp = Ident_3; + ptrGlob.intComp = 40; + ptrGlob.strComp.setLength(0); + ptrGlob.strComp.append("DHRYSTONE PROGRAM, SOME STRING"); + arr2Glob[8][7] = 10; + numOfRuns = loop_size; + + for (runIndex = 1; runIndex <= loop_size; runIndex++) { + proc5(); + proc4(); + + int1Loc = 2; + int2Loc = 3; + str2Loc.setLength(0); + str2Loc.append("DHRYSTONE PROGRAM, 2'ND STRING"); + enumLoc = Ident_2; + + /* boolGlob == 1 */ + boolGlob = !func2(str1Loc, str2Loc.toString()); + + while (int1Loc < int2Loc) { /* loop body executed once */ + /* int3Loc == 7 */ + int3Loc = 5 * int1Loc - int2Loc; + + /* int3Loc == 7 */ + intRef.ref = int3Loc; + proc7(int1Loc, int2Loc, intRef); + int3Loc = intRef.ref; + + int1Loc += 1; + } + + /* int1Loc == 3, int2Loc == 3, int3Loc == 7 */ + proc8(arr1Glob, arr2Glob, int1Loc, int3Loc); + + /* intGlob == 5 */ + proc1(ptrGlob); + + for (chIndex = 'A'; chIndex <= ch2Glob; ++chIndex) { + /* loop body executed twice */ + if (enumLoc == func1(chIndex, 'C')) { + /* then, not executed */ + intRef.ref = enumLoc; + proc6(Ident_1, intRef); + enumLoc = intRef.ref; + + str2Loc.setLength(0); + str2Loc.append("DHRYSTONE PROGRAM, 3'RD STRING"); + int2Loc = runIndex; + intGlob = runIndex; + } + } + + /* int1Loc == 3, int2Loc == 3, int3Loc == 7 */ + int2Loc = int2Loc * int1Loc; + int1Loc = int2Loc / int3Loc; + int2Loc = 7 * (int2Loc - int3Loc) - int1Loc; + /* int1Loc == 1, int2Loc == 13, int3Loc == 7 */ + + intRef.ref = int1Loc; + proc2(intRef); + int1Loc = intRef.ref; + + /* int1Loc == 5 */ + } + } + + /* executed once */ + public void proc1(Record ptrValPar) { + /* == ptrGlob_Next */ + /* Local variable, initialized with ptrValPar->ptrComp, */ + /* corresponds to "rename" in Ada, "with" in Pascal */ + Record nextRecord = ptrValPar.ptrComp; + + ptrValPar.ptrComp.ptrComp = ptrGlob.ptrComp; + ptrValPar.ptrComp.discr = ptrGlob.discr; + ptrValPar.ptrComp.enumComp = ptrGlob.enumComp; + ptrValPar.ptrComp.intComp = ptrGlob.intComp; + ptrValPar.ptrComp.strComp.setLength(0); + ptrValPar.ptrComp.strComp.append(ptrGlob.strComp.toString()); + ptrValPar.ptrComp.enumComp2 = ptrGlob.enumComp2; + ptrValPar.ptrComp.ch1Comp = ptrGlob.ch1Comp; + ptrValPar.ptrComp.ch2Comp = ptrGlob.ch2Comp; + ptrValPar.intComp = 5; + + nextRecord.intComp = ptrValPar.intComp; + nextRecord.ptrComp = ptrValPar.ptrComp; + + proc3(nextRecord.ptrComp); + + if (nextRecord.discr == Ident_1) { + /* then, executed */ + nextRecord.intComp = 6; + + Pointer<Integer> intRef = new Pointer<Integer>(); + + intRef.ref = nextRecord.enumComp; + proc6(ptrValPar.enumComp, intRef); + nextRecord.enumComp = intRef.ref; + + nextRecord.ptrComp = ptrGlob.ptrComp; + + intRef.ref = nextRecord.intComp; + proc7(nextRecord.intComp, 10, intRef); + nextRecord.intComp = intRef.ref; + } + else { /* not executed */ + ptrValPar = ptrValPar.ptrComp; + } + } + + /* executed once */ + /* intParRef == 1, becomes 4 */ + public void proc2(Pointer<Integer> intParRef) { + int intLoc; + int enumLoc = 0; + + intLoc = intParRef.ref + 10; + do { /* executed once */ + if (ch1Glob == 'A') { + /* then, executed */ + intLoc -= 1; + intParRef.ref = intLoc - intGlob; + enumLoc = Ident_1; + } + } + while (enumLoc != Ident_1); + } + + /* executed once */ + /* ptrRefPar becomes ptrGlob */ + public void proc3(Record ptrRefPar) { + if (ptrGlob != null) { + /* then, executed */ + ptrRefPar = ptrGlob.ptrComp; + } + + Pointer<Integer> intRef = new Pointer<Integer>(); + intRef.ref = ptrGlob.intComp; + proc7(10, intGlob, intRef); + ptrGlob.intComp = intRef.ref; + } + + public void proc4() { + Boolean boolLoc; + boolLoc = ch1Glob == 'A'; + boolGlob = boolLoc | boolGlob; + ch2Glob = 'B'; + } + + public void proc5() { + ch1Glob = 'A'; + boolGlob = false; + } + + /* executed once */ + /* enumValPar == Ident_3, enumRefPar becomes Ident_2 */ + public void proc6(int enumValPar, Pointer<Integer> enumRefPar) { + enumRefPar.ref = enumValPar; + if (!func3(enumValPar)) { + /* then, not executed */ + enumRefPar.ref = Ident_4; + } + + switch (enumValPar) { + case Ident_1: + enumRefPar.ref = Ident_1; + break; + case Ident_2: + if (intGlob > 100) { + /* then */ + enumRefPar.ref = Ident_1; + } + else { + enumRefPar.ref = Ident_4; + } + break; + case Ident_3: /* executed */ + enumRefPar.ref = Ident_2; + break; + case Ident_4: + break; + case Ident_5: + enumRefPar.ref = Ident_3; + break; + default: + break; + } + } + + /* executed three times */ + /* first call: int1ParVal == 2, int2ParVal == 3, */ + /* intParRef becomes 7 */ + /* second call: int1ParVal == 10, int2ParVal == 5, */ + /* intParRef becomes 17 */ + /* third call: int1ParVal == 6, int2ParVal == 10, */ + /* intParRef becomes 18 */ + public void proc7(int int1ParVal, int int2ParVal, Pointer<Integer> intParRef) { + int intLoc; + + intLoc = int1ParVal + 2; + intParRef.ref = int2ParVal + intLoc; + } + + /* executed once */ + /* Int_Par_Val_1 == 3 */ + /* Int_Par_Val_2 == 7 */ + public void proc8(int []arr1ParRef, int [][]arr2ParRef, int int1ParVal, int int2ParVal) { + int intIndex; + int intLoc; + + intLoc = int1ParVal + 5; + arr1ParRef[intLoc] = int2ParVal; + arr1ParRef[intLoc + 1] = arr1ParRef[intLoc]; + arr1ParRef[intLoc + 30] = intLoc; + + for (intIndex = intLoc; intIndex <= intLoc + 1; ++intIndex) { + arr2ParRef[intLoc][intIndex] = intLoc; + } + + arr2ParRef[intLoc][intLoc - 1] += 1; + arr2ParRef[intLoc + 20][intLoc] = arr1ParRef[intLoc]; + intGlob = 5; + } + + public int func1(char ch1ParVal, char ch2ParVal) { + char ch1Loc; + char ch2Loc; + + ch1Loc = ch1ParVal; + ch2Loc = ch1Loc; + if (ch2Loc != ch2ParVal) { + /* then, executed */ + return Ident_1; + } + else { /* not executed */ + ch1Glob = ch1Loc; + return Ident_2; + } + } + + /* executed once */ + /* str1ParRef == "DHRYSTONE PROGRAM, 1'ST STRING" */ + /* str2ParRef == "DHRYSTONE PROGRAM, 2'ND STRING" */ + public boolean func2(String str1ParRef, String str2ParRef) { + int intLoc; + char chLoc = 0; + + intLoc = 2; + while (intLoc <= 2) /* loop body executed once */ + if (func1(str1ParRef.charAt(intLoc), str2ParRef.charAt(intLoc + 1)) == Ident_1) { + /* then, executed */ + chLoc = 'A'; + intLoc += 1; + } + + if (chLoc >= 'W' && chLoc < 'Z') { + /* then, not executed */ + intLoc = 7; + } + + if (chLoc == 'R') { + /* then, not executed */ + return true; + } + else { /* executed */ + if (str1ParRef.compareTo(str2ParRef) > 0) { + /* then, not executed */ + intLoc += 7; + intGlob = intLoc; + return true; + } + else { /* executed */ + return false; + } + } + } + + /* executed once */ + /* enumParVal == Ident_3 */ + public boolean func3(int enumParVal) { + int enumLoc; + + enumLoc = enumParVal; + if (enumLoc == Ident_3) { + /* then, executed */ + return true; + } + else { /* not executed */ + return false; + } + } +} diff --git a/src/main/java/org/linaro/benchmarks/algorithm/Linpack.java b/src/main/java/org/linaro/benchmarks/algorithm/Linpack.java new file mode 100644 index 0000000..d0d4119 --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/algorithm/Linpack.java @@ -0,0 +1,671 @@ +/* + +Modified 3/23/2016 by Tim Zhang tim.zhang@linaro.org +Modifications performed: + - Added runLinpack() method for running the linpack without computing the float rate. + - Added timeLinpack() method for running with different iterations. + - Updated main() method. + +Modified 3/3/97 by David M. Doolin (dmd) doolin@cs.utk.edu +Fixed error in matgen() method. Added some comments. + +Modified 1/22/97 by Paul McMahan mcmahan@cs.utk.edu +Added more MacOS options to form. + +Optimized by Jonathan Hardwick (jch@cs.cmu.edu), 3/28/96 +Compare to Linkpack.java. +Optimizations performed: + - added "final" modifier to performance-critical methods. + - changed lines of the form "a[i] = a[i] + x" to "a[i] += x". + - minimized array references using common subexpression elimination. + - eliminated unused variables. + - undid an unrolled loop. + - added temporary 1D arrays to hold frequently-used columns of 2D arrays. + - wrote my own abs() method +See http://www.cs.cmu.edu/~jch/java/linpack.html for more details. + + +Ported to Java by Reed Wade (wade@cs.utk.edu) 2/96 +built using JDK 1.0 on solaris +using "javac -O Linpack.java" + + +Translated to C by Bonnie Toy 5/88 + (modified on 2/25/94 to fix a problem with daxpy for + unequal increments or equal increments not equal to 1. + Jack Dongarra) + +*/ + +// CHECKSTYLE.OFF: .* +package org.linaro.benchmarks.algorithm; + +import java.net.*; +import java.io.*; +import java.util.*; +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + + +public class Linpack { + + public static void main_(String[] args) + { + Linpack l = new Linpack(); + l.run_benchmark(); + } + + final double abs (double d) { + return (d >= 0) ? d : -d; + } + + double second_orig = -1; + + double second() + { + if (second_orig==-1) { + second_orig = System.currentTimeMillis(); + } + return (System.currentTimeMillis() - second_orig)/1000; + } + + public void run_benchmark() + { + double mflops_result = 0.0; + double residn_result = 0.0; + double time_result = 0.0; + double eps_result = 0.0; + + double a[][] = new double[200][201]; + double b[] = new double[200]; + double x[] = new double[200]; + double cray,ops,total,norma,normx; + double resid,time; + double kf; + int n,i,ntimes,info,lda,ldaa,kflops; + int ipvt[] = new int[200]; + + //double mflops_result; + //double residn_result; + //double time_result; + //double eps_result; + + lda = 201; + ldaa = 200; + cray = .056; + n = 100; + + ops = (2.0e0*(n*n*n))/3.0 + 2.0*(n*n); + + norma = matgen(a,lda,n,b); + time = second(); + info = dgefa(a,lda,n,ipvt); + dgesl(a,lda,n,ipvt,b,0); + total = second() - time; + + for (i = 0; i < n; i++) { + x[i] = b[i]; + } + norma = matgen(a,lda,n,b); + for (i = 0; i < n; i++) { + b[i] = -b[i]; + } + dmxpy(n,b,n,lda,x,a); + resid = 0.0; + normx = 0.0; + for (i = 0; i < n; i++) { + resid = (resid > abs(b[i])) ? resid : abs(b[i]); + normx = (normx > abs(x[i])) ? normx : abs(x[i]); + } + + eps_result = epslon((double)1.0); +/* + + residn_result = resid/( n*norma*normx*eps_result ); + time_result = total; + mflops_result = ops/(1.0e6*total); + + return ("Mflops/s: " + mflops_result + + " Time: " + time_result + " secs" + + " Norm Res: " + residn_result + + " Precision: " + eps_result); +*/ + residn_result = resid/( n*norma*normx*eps_result ); + residn_result += 0.005; // for rounding + residn_result = (int)(residn_result*100); + residn_result /= 100; + + time_result = total; + time_result += 0.005; // for rounding + time_result = (int)(time_result*100); + time_result /= 100; + + mflops_result = ops/(1.0e6*total); + mflops_result += 0.0005; // for rounding + mflops_result = (int)(mflops_result*1000); + mflops_result /= 1000; + + System.out.println("Mflops/s: " + mflops_result + + " Time: " + time_result + " secs" + + " Norm Res: " + residn_result + + " Precision: " + eps_result); + } + + + + final double matgen (double a[][], int lda, int n, double b[]) + { + double norma; + int init, i, j; + + init = 1325; + norma = 0.0; +/* Next two for() statements switched. Solver wants +matrix in column order. --dmd 3/3/97 +*/ + for (i = 0; i < n; i++) { + for (j = 0; j < n; j++) { + init = 3125*init % 65536; + a[j][i] = (init - 32768.0)/16384.0; + norma = (a[j][i] > norma) ? a[j][i] : norma; + } + } + for (i = 0; i < n; i++) { + b[i] = 0.0; + } + for (j = 0; j < n; j++) { + for (i = 0; i < n; i++) { + b[i] += a[j][i]; + } + } + + return norma; + } + + + + /* + dgefa factors a double precision matrix by gaussian elimination. + + dgefa is usually called by dgeco, but it can be called + directly with a saving in time if rcond is not needed. + (time for dgeco) = (1 + 9/n)*(time for dgefa) . + + on entry + + a double precision[n][lda] + the matrix to be factored. + + lda integer + the leading dimension of the array a . + + n integer + the order of the matrix a . + + on return + + a an upper triangular matrix and the multipliers + which were used to obtain it. + the factorization can be written a = l*u where + l is a product of permutation and unit lower + triangular matrices and u is upper triangular. + + ipvt integer[n] + an integer vector of pivot indices. + + info integer + = 0 normal value. + = k if u[k][k] .eq. 0.0 . this is not an error + condition for this subroutine, but it does + indicate that dgesl or dgedi will divide by zero + if called. use rcond in dgeco for a reliable + indication of singularity. + + linpack. this version dated 08/14/78. + cleve moler, university of new mexico, argonne national lab. + + functions + + blas daxpy,dscal,idamax + */ + final int dgefa( double a[][], int lda, int n, int ipvt[]) + { + double[] col_k, col_j; + double t; + int j,k,kp1,l,nm1; + int info; + + // gaussian elimination with partial pivoting + + info = 0; + nm1 = n - 1; + if (nm1 >= 0) { + for (k = 0; k < nm1; k++) { + col_k = a[k]; + kp1 = k + 1; + + // find l = pivot index + + l = idamax(n-k,col_k,k,1) + k; + ipvt[k] = l; + + // zero pivot implies this column already triangularized + + if (col_k[l] != 0) { + + // interchange if necessary + + if (l != k) { + t = col_k[l]; + col_k[l] = col_k[k]; + col_k[k] = t; + } + + // compute multipliers + + t = -1.0/col_k[k]; + dscal(n-(kp1),t,col_k,kp1,1); + + // row elimination with column indexing + + for (j = kp1; j < n; j++) { + col_j = a[j]; + t = col_j[l]; + if (l != k) { + col_j[l] = col_j[k]; + col_j[k] = t; + } + daxpy(n-(kp1),t,col_k,kp1,1, + col_j,kp1,1); + } + } + else { + info = k; + } + } + } + ipvt[n-1] = n-1; + if (a[(n-1)][(n-1)] == 0) info = n-1; + + return info; + } + + + + /* + dgesl solves the double precision system + a * x = b or trans(a) * x = b + using the factors computed by dgeco or dgefa. + + on entry + + a double precision[n][lda] + the output from dgeco or dgefa. + + lda integer + the leading dimension of the array a . + + n integer + the order of the matrix a . + + ipvt integer[n] + the pivot vector from dgeco or dgefa. + + b double precision[n] + the right hand side vector. + + job integer + = 0 to solve a*x = b , + = nonzero to solve trans(a)*x = b where + trans(a) is the transpose. + + on return + + b the solution vector x . + + error condition + + a division by zero will occur if the input factor contains a + zero on the diagonal. technically this indicates singularity + but it is often caused by improper arguments or improper + setting of lda . it will not occur if the subroutines are + called correctly and if dgeco has set rcond .gt. 0.0 + or dgefa has set info .eq. 0 . + + to compute inverse(a) * c where c is a matrix + with p columns + dgeco(a,lda,n,ipvt,rcond,z) + if (!rcond is too small){ + for (j=0,j<p,j++) + dgesl(a,lda,n,ipvt,c[j][0],0); + } + + linpack. this version dated 08/14/78 . + cleve moler, university of new mexico, argonne national lab. + + functions + + blas daxpy,ddot + */ + final void dgesl( double a[][], int lda, int n, int ipvt[], double b[], int job) + { + double t; + int k,kb,l,nm1,kp1; + + nm1 = n - 1; + if (job == 0) { + + // job = 0 , solve a * x = b. first solve l*y = b + + if (nm1 >= 1) { + for (k = 0; k < nm1; k++) { + l = ipvt[k]; + t = b[l]; + if (l != k){ + b[l] = b[k]; + b[k] = t; + } + kp1 = k + 1; + daxpy(n-(kp1),t,a[k],kp1,1,b,kp1,1); + } + } + + // now solve u*x = y + + for (kb = 0; kb < n; kb++) { + k = n - (kb + 1); + b[k] /= a[k][k]; + t = -b[k]; + daxpy(k,t,a[k],0,1,b,0,1); + } + } + else { + + // job = nonzero, solve trans(a) * x = b. first solve trans(u)*y = b + + for (k = 0; k < n; k++) { + t = ddot(k,a[k],0,1,b,0,1); + b[k] = (b[k] - t)/a[k][k]; + } + + // now solve trans(l)*x = y + + if (nm1 >= 1) { + for (kb = 1; kb < nm1; kb++) { + k = n - (kb+1); + kp1 = k + 1; + b[k] += ddot(n-(kp1),a[k],kp1,1,b,kp1,1); + l = ipvt[k]; + if (l != k) { + t = b[l]; + b[l] = b[k]; + b[k] = t; + } + } + } + } + } + + + + /* + constant times a vector plus a vector. + jack dongarra, linpack, 3/11/78. + */ + final void daxpy( int n, double da, double dx[], int dx_off, int incx, + double dy[], int dy_off, int incy) + { + int i,ix,iy; + + if ((n > 0) && (da != 0)) { + if (incx != 1 || incy != 1) { + + // code for unequal increments or equal increments not equal to 1 + + ix = 0; + iy = 0; + if (incx < 0) ix = (-n+1)*incx; + if (incy < 0) iy = (-n+1)*incy; + for (i = 0;i < n; i++) { + dy[iy +dy_off] += da*dx[ix +dx_off]; + ix += incx; + iy += incy; + } + return; + } else { + + // code for both increments equal to 1 + + for (i=0; i < n; i++) + dy[i +dy_off] += da*dx[i +dx_off]; + } + } + } + + + + /* + forms the dot product of two vectors. + jack dongarra, linpack, 3/11/78. + */ + final double ddot( int n, double dx[], int dx_off, int incx, double dy[], + int dy_off, int incy) + { + double dtemp; + int i,ix,iy; + + dtemp = 0; + + if (n > 0) { + + if (incx != 1 || incy != 1) { + + // code for unequal increments or equal increments not equal to 1 + + ix = 0; + iy = 0; + if (incx < 0) ix = (-n+1)*incx; + if (incy < 0) iy = (-n+1)*incy; + for (i = 0;i < n; i++) { + dtemp += dx[ix +dx_off]*dy[iy +dy_off]; + ix += incx; + iy += incy; + } + } else { + + // code for both increments equal to 1 + + for (i=0;i < n; i++) + dtemp += dx[i +dx_off]*dy[i +dy_off]; + } + } + return(dtemp); + } + + + + /* + scales a vector by a constant. + jack dongarra, linpack, 3/11/78. + */ + final void dscal( int n, double da, double dx[], int dx_off, int incx) + { + int i,nincx; + + if (n > 0) { + if (incx != 1) { + + // code for increment not equal to 1 + + nincx = n*incx; + for (i = 0; i < nincx; i += incx) + dx[i +dx_off] *= da; + } else { + + // code for increment equal to 1 + + for (i = 0; i < n; i++) + dx[i +dx_off] *= da; + } + } + } + + + + /* + finds the index of element having max. absolute value. + jack dongarra, linpack, 3/11/78. + */ + final int idamax( int n, double dx[], int dx_off, int incx) + { + double dmax, dtemp; + int i, ix, itemp=0; + + if (n < 1) { + itemp = -1; + } else if (n ==1) { + itemp = 0; + } else if (incx != 1) { + + // code for increment not equal to 1 + + dmax = abs(dx[0 +dx_off]); + ix = 1 + incx; + for (i = 1; i < n; i++) { + dtemp = abs(dx[ix + dx_off]); + if (dtemp > dmax) { + itemp = i; + dmax = dtemp; + } + ix += incx; + } + } else { + + // code for increment equal to 1 + + itemp = 0; + dmax = abs(dx[0 +dx_off]); + for (i = 1; i < n; i++) { + dtemp = abs(dx[i + dx_off]); + if (dtemp > dmax) { + itemp = i; + dmax = dtemp; + } + } + } + return (itemp); + } + + + + /* + estimate unit roundoff in quantities of size x. + + this program should function properly on all systems + satisfying the following two assumptions, + 1. the base used in representing dfloating point + numbers is not a power of three. + 2. the quantity a in statement 10 is represented to + the accuracy used in dfloating point variables + that are stored in memory. + the statement number 10 and the go to 10 are intended to + force optimizing compilers to generate code satisfying + assumption 2. + under these assumptions, it should be true that, + a is not exactly equal to four-thirds, + b has a zero for its last bit or digit, + c is not exactly equal to one, + eps measures the separation of 1.0 from + the next larger dfloating point number. + the developers of eispack would appreciate being informed + about any systems where these assumptions do not hold. + + ***************************************************************** + this routine is one of the auxiliary routines used by eispack iii + to avoid machine dependencies. + ***************************************************************** + + this version dated 4/6/83. + */ + final double epslon (double x) + { + double a,b,c,eps; + + a = 4.0e0/3.0e0; + eps = 0; + while (eps == 0) { + b = a - 1.0; + c = b + b + b; + eps = abs(c-1.0); + } + return(eps*abs(x)); + } + + + + /* + purpose: + multiply matrix m times vector x and add the result to vector y. + + parameters: + + n1 integer, number of elements in vector y, and number of rows in + matrix m + + y double [n1], vector of length n1 to which is added + the product m*x + + n2 integer, number of elements in vector x, and number of columns + in matrix m + + ldm integer, leading dimension of array m + + x double [n2], vector of length n2 + + m double [ldm][n2], matrix of n1 rows and n2 columns + */ + final void dmxpy ( int n1, double y[], int n2, int ldm, double x[], double m[][]) + { + int j,i; + + // cleanup odd vector + for (j = 0; j < n2; j++) { + for (i = 0; i < n1; i++) { + y[i] += x[j]*m[j][i]; + } + } + } + + // CHECKSTYLE.ON: .* + /* + This function derived from run_benchmark() function in the original file. + Modifications: + - Keep the code that is used to timing. + - Ignore the computing of Linpack result in Mflops/s. + */ + public void runLinpack() { + double [][]a = new double[200][201]; + double []b = new double[200]; + double norma; + int n; + int info; + int lda; + int []ipvt = new int[200]; + + lda = 201; + n = 100; + + norma = matgen(a,lda,n,b); + info = dgefa(a,lda,n,ipvt); + dgesl(a,lda,n,ipvt,b,0); + } + + @Benchmark + public void jmhTimeLinpack() { + runLinpack(); + } +} diff --git a/src/main/java/org/linaro/benchmarks/algorithm/NSieve.java b/src/main/java/org/linaro/benchmarks/algorithm/NSieve.java new file mode 100644 index 0000000..08a3fee --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/algorithm/NSieve.java @@ -0,0 +1,67 @@ +/* + * Copyright (C) 2015 Linaro Limited. Ported to Java from: + * https://github.com/WebKit/webkit/blob/master/PerformanceTests/SunSpider/tests/sunspider-1.0.2/access-nsieve.js + * + */ + +// The Great Computer Language Shootout +// http://shootout.alioth.debian.org/ +// +// modified by Isaac Gouy + +// http://benchmarksgame.alioth.debian.org/license.html (BSD 3-clause license) +// See NOTICE file for license. + +package org.linaro.benchmarks.algorithm; + +import java.lang.System; +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + + +public class NSieve { + /* Expected result for the standard benchmark setup */ + private static final int EXPECTED = 14302; + /* Number of repeats (internal, not benchmark iterations) */ + private static final int NUM_SIEVES = 4; + /* Array of flags - big enough for all standard test scenarios */ + private static boolean[] flags = new boolean[80001]; + private static int[] results = new int[NUM_SIEVES]; + + private int nsieve(int m) { + for (int i = 2; i <= m; i++) { + flags[i] = true; + } + + int count = 0; + for (int i = 2; i <= m; i++) { + if (flags[i]) { + for (int k = i + i; k <= m; k += i) { + flags[k] = false; + } + count++; + } + } + return count; + } + + /** + * Find prime numbers in three sizes of pool, four times over + * Repeat over number of iterations set by framework + **/ + @Benchmark + public void jmhTimeNSieveAccess() { + for (int i = 0; i < NUM_SIEVES; i++) { + int sum = 0; + for (int o = 1; o <= 3; o++) { + int m = (1 << o) * 10000; + sum += nsieve(m); + } + results[i] = sum; + } + } +} diff --git a/src/main/java/org/linaro/benchmarks/algorithm/Richards.java b/src/main/java/org/linaro/benchmarks/algorithm/Richards.java new file mode 100644 index 0000000..eee1a43 --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/algorithm/Richards.java @@ -0,0 +1,648 @@ +/* + * Copyright 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ + +/* + * The original file is available at: + * https://gwt.googlesource.com/gwt-benchmarks/+/master/benchmarks/src/main/ + * java/com/google/gwt/benchmark/benchmarks/octane/client/richards/gwt/ + * + * Modifications: + * (1) Squashed java files into a single java file. + * (2) Added timeRichards() method for running with different iterations. + * (3) Changed arrays from using GWT library classes (JavaScriptArray, + * CollectionFactory, etc) into standard java arrays. + */ + +package org.linaro.benchmarks.algorithm; + +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +// CHECKSTYLE.OFF: .* +class DeviceTask implements Task { + + private Scheduler scheduler; + private Packet v1; + /** + * A task that suspends itself after each time it has been run to simulate + * waiting for data from an external device. + * @param {Scheduler} scheduler the scheduler that manages this task + * @constructor + */ + @SuppressWarnings("javadoc") + public DeviceTask(Scheduler scheduler) { + this.scheduler = scheduler; + this.v1 = null; + } + + @Override + public TaskControlBlock run(Packet packet) { + if (packet == null) { + if (this.v1 == null) return this.scheduler.suspendCurrent(); + Packet v = this.v1; + this.v1 = null; + return this.scheduler.queue(v); + } else { + this.v1 = packet; + return this.scheduler.holdCurrent(); + } + } + + @Override + public String toString() { + return "DeviceTask"; + } +} + +class HandlerTask implements Task{ + + private Scheduler scheduler; + private Packet v1; + private Packet v2; + + /** + * A task that manipulates work packets and then suspends itself. + * @param {Scheduler} scheduler the scheduler that manages this task + * @constructor + */ + @SuppressWarnings("javadoc") + public HandlerTask(Scheduler scheduler) { + this.scheduler = scheduler; + this.v1 = null; + this.v2 = null; + } + + @Override + public TaskControlBlock run(Packet packet) { + if (packet != null) { + if (packet.kind == Scheduler.KIND_WORK) { + this.v1 = packet.addTo(this.v1); + } else { + this.v2 = packet.addTo(this.v2); + } + } + if (this.v1 != null) { + int count = this.v1.a1; + Packet v; + if (count < Packet.DATA_SIZE) { + if (this.v2 != null) { + v = this.v2; + this.v2 = this.v2.link; + v.a1 = this.v1.a2[count]; + this.v1.a1 = count + 1; + return this.scheduler.queue(v); + } + } else { + v = this.v1; + this.v1 = this.v1.link; + return this.scheduler.queue(v); + } + } + return this.scheduler.suspendCurrent(); + } + + @Override + public String toString() { + return "HandlerTask"; + } +} + +class IdleTask implements Task { + + private Scheduler scheduler; + private int v1; + private int count; + /** + * An idle task doesn't do any work itself but cycles control between the two + * device tasks. + * @param {Scheduler} scheduler the scheduler that manages this task + * @param {int} v1 a seed value that controls how the device tasks are scheduled + * @param {int} count the number of times this task should be scheduled + * @constructor + */ + @SuppressWarnings("javadoc") + public IdleTask(Scheduler scheduler, int v1, int count) { + this.scheduler = scheduler; + this.v1 = v1; + this.count = count; + } + + @Override + public TaskControlBlock run(Packet packet) { + this.count--; + if (this.count == 0) return this.scheduler.holdCurrent(); + if ((this.v1 & 1) == 0) { + this.v1 = this.v1 >> 1; + return this.scheduler.release(Scheduler.ID_DEVICE_A); + } else { + this.v1 = (this.v1 >> 1) ^ 0xD008; + return this.scheduler.release(Scheduler.ID_DEVICE_B); + } + } + + @Override + public String toString() { + return "IdleTask"; + } +} + +class Packet { + + public static final int DATA_SIZE = 4; + + public Packet link; + + public int id; + + public int a1; + + public int[] a2; + + public int kind; + + /** + * A simple package org.linaro.benchmarks.algorithm; + * carried by a packet is not importaint, and neither is the nature of the work performed on + * packets by the tasks. + * + * Besides carrying data, packets form linked lists and are hence used both as data and + * worklists. + * + * @param {Packet} link the tail of the linked list of packets + * @param {int} id an ID for this packet + * @param {int} kind the type of this packet + * @constructor + */ + @SuppressWarnings("javadoc") + public Packet(Packet link, int id, int kind) { + this.link = link; + this.id = id; + this.kind = kind; + this.a1 = 0; + this.a2 = new int[DATA_SIZE]; + } + + /** + * Add this packet to the end of a worklist, and return the worklist. + * + * @param {Packet} queue the worklist to add this packet to + */ + @SuppressWarnings("javadoc") + public Packet addTo(Packet queue) { + this.link = null; + if (queue == null) + return this; + Packet peek; + Packet next = queue; + while ((peek = next.link) != null) + next = peek; + next.link = this; + return queue; + } + + @Override + public String toString() { + return "Packet"; + } + +} + +/** + * A scheduler can be used to schedule a set of tasks based on their relative priorities. Scheduling + * is done by maintaining a list of task control blocks which holds tasks and the data queue they + * are processing. + * + * @constructor + */ +class Scheduler { + + public static final int ID_IDLE = 0; + public static final int ID_WORKER = 1; + public static final int ID_HANDLER_A = 2; + public static final int ID_HANDLER_B = 3; + public static final int ID_DEVICE_A = 4; + public static final int ID_DEVICE_B = 5; + public static final int NUMBER_OF_IDS = 6; + + public static final int KIND_DEVICE = 0; + public static final int KIND_WORK = 1; + + public int queueCount; + public int holdCount; + private TaskControlBlock list; + private TaskControlBlock currentTcb; + private int currentId; + private TaskControlBlock[] blocks; + + public Scheduler() { + this.queueCount = 0; + this.holdCount = 0; + this.blocks = new TaskControlBlock[NUMBER_OF_IDS]; + this.list = null; + this.currentTcb = null; + this.currentId = -1; + } + + /** + * Add an idle task to this scheduler. + * @param {int} id the identity of the task + * @param {int} priority the task's priority + * @param {Packet} queue the queue of work to be processed by the task + * @param {int} count the number of times to schedule the task + */ + @SuppressWarnings("javadoc") + public void addIdleTask(int id, int priority, Packet queue, int count) { + this.addRunningTask(id, priority, queue, new IdleTask(this, 1, count)); + } + + /** + * Add a work task to this scheduler. + * @param {int} id the identity of the task + * @param {int} priority the task's priority + * @param {Packet} queue the queue of work to be processed by the task + */ + @SuppressWarnings("javadoc") + public void addWorkerTask(int id, int priority, Packet queue) { + this.addTask(id, priority, queue, new WorkerTask(this, ID_HANDLER_A, 0)); + } + + /** + * Add a handler task to this scheduler. + * @param {int} id the identity of the task + * @param {int} priority the task's priority + * @param {Packet} queue the queue of work to be processed by the task + */ + @SuppressWarnings("javadoc") + public void addHandlerTask(int id, int priority, Packet queue) { + this.addTask(id, priority, queue, new HandlerTask(this)); + } + + /** + * Add a handler task to this scheduler. + * @param {int} id the identity of the task + * @param {int} priority the task's priority + * @param {Packet} queue the queue of work to be processed by the task + */ + @SuppressWarnings("javadoc") + public void addDeviceTask(int id, int priority, Packet queue) { + this.addTask(id, priority, queue, new DeviceTask(this)); + } + + /** + * Add the specified task and mark it as running. + * @param {int} id the identity of the task + * @param {int} priority the task's priority + * @param {Packet} queue the queue of work to be processed by the task + * @param {Task} task the task to add + */ + @SuppressWarnings("javadoc") + public void addRunningTask(int id, int priority, Packet queue, Task task) { + this.addTask(id, priority, queue, task); + this.currentTcb.setRunning(); + } + + /** + * Add the specified task to this scheduler. + * @param {int} id the identity of the task + * @param {int} priority the task's priority + * @param {Packet} queue the queue of work to be processed by the task + * @param {Task} task the task to add + */ + @SuppressWarnings("javadoc") + private void addTask(int id, int priority, Packet queue, Task task) { + this.currentTcb = new TaskControlBlock(this.list, id, priority, queue, task); + this.list = this.currentTcb; + this.blocks[id] = this.currentTcb; + } + + /** + * Execute the tasks managed by this scheduler. + */ + public void schedule() { + this.currentTcb = this.list; + while (this.currentTcb != null) { + if (this.currentTcb.isHeldOrSuspended()) { + this.currentTcb = this.currentTcb.link; + } else { + this.currentId = this.currentTcb.id; + this.currentTcb = this.currentTcb.run(); + } + } + } + + /** + * Release a task that is currently blocked and return the next block to run. + * @param {int} id the id of the task to suspend + */ + @SuppressWarnings("javadoc") + public TaskControlBlock release(int id) { + TaskControlBlock tcb = this.blocks[id]; + if (tcb == null) return tcb; + tcb.markAsNotHeld(); + if (tcb.priority > this.currentTcb.priority) { + return tcb; + } else { + return this.currentTcb; + } + } + + /** + * Block the currently executing task and return the next task control block + * to run. The blocked task will not be made runnable until it is explicitly + * released, even if new work is added to it. + */ + public TaskControlBlock holdCurrent() { + this.holdCount++; + this.currentTcb.markAsHeld(); + return this.currentTcb.link; + } + + /** + * Suspend the currently executing task and return the next task control block + * to run. If new work is added to the suspended task it will be made runnable. + */ + public TaskControlBlock suspendCurrent() { + this.currentTcb.markAsSuspended(); + return this.currentTcb; + } + + /** + * Add the specified packet to the end of the worklist used by the task + * associated with the packet and make the task runnable if it is currently + * suspended. + * @param {Packet} packet the packet to add + */ + @SuppressWarnings("javadoc") + public TaskControlBlock queue(Packet packet) { + TaskControlBlock t = this.blocks[packet.id]; + if (t == null) return t; + this.queueCount++; + packet.link = null; + packet.id = this.currentId; + return t.checkPriorityAdd(this.currentTcb, packet); + } + +} + +class TaskControlBlock implements Task { + + public TaskControlBlock link; + + public int id; + + public int priority; + + private Packet queue; + + private Task task; + + private int state; + + /** + * A task control block manages a task and the queue of work packages associated + * with it. + * @param {TaskControlBlock} link the preceding block in the linked block list + * @param {int} id the id of this block + * @param {int} priority the priority of this block + * @param {Packet} queue the queue of packages to be processed by the task + * @param {Task} task the task + * @constructor + */ + @SuppressWarnings("javadoc") + public TaskControlBlock(TaskControlBlock link, int id, int priority, Packet queue, Task task) { + this.link = link; + this.id = id; + this.priority = priority; + this.queue = queue; + this.task = task; + if (queue == null) { + this.state = STATE_SUSPENDED; + } else { + this.state = STATE_SUSPENDED_RUNNABLE; + } + } + + /** + * The task is running and is currently scheduled. + */ + public static final int STATE_RUNNING = 0; + + /** + * The task has packets left to process. + */ + public static final int STATE_RUNNABLE = 1; + + /** + * The task is not currently running. The task is not blocked as such and may + * be started by the scheduler. + */ + public static final int STATE_SUSPENDED = 2; + + /** + * The task is blocked and cannot be run until it is explicitly released. + */ + public static final int STATE_HELD = 4; + + public static final int STATE_SUSPENDED_RUNNABLE = STATE_SUSPENDED | STATE_RUNNABLE; + public static final int STATE_NOT_HELD = ~STATE_HELD; + + public void setRunning() { + this.state = STATE_RUNNING; + } + + public void markAsNotHeld () { + this.state = this.state & STATE_NOT_HELD; + } + + public void markAsHeld() { + this.state = this.state | STATE_HELD; + } + + public boolean isHeldOrSuspended() { + return (this.state & STATE_HELD) != 0 || (this.state == STATE_SUSPENDED); + } + + public void markAsSuspended() { + this.state = this.state | STATE_SUSPENDED; + } + + public void markAsRunnable() { + this.state = this.state | STATE_RUNNABLE; + } + + /** + * Runs this task, if it is ready to be run, and returns the next task to run. + */ + public TaskControlBlock run() { + Packet packet; + if (this.state == STATE_SUSPENDED_RUNNABLE) { + packet = this.queue; + this.queue = packet.link; + if (this.queue == null) { + this.state = STATE_RUNNING; + } else { + this.state = STATE_RUNNABLE; + } + } else { + packet = null; + } + return this.task.run(packet); + } + + /** + * Adds a packet to the worklist of this block's task, marks this as runnable if + * necessary, and returns the next runnable object to run (the one + * with the highest priority). + */ + public TaskControlBlock checkPriorityAdd(TaskControlBlock task, Packet packet) { + if (this.queue == null) { + this.queue = packet; + this.markAsRunnable(); + if (this.priority > task.priority) return this; + } else { + this.queue = packet.addTo(this.queue); + } + return task; + } + + @Override + public String toString() { + return "tcb { " + this.task + "@" + this.state + " }"; + } + + @Override + public TaskControlBlock run(Packet packet) { + return run(); + } +} + +interface Task { + TaskControlBlock run(Packet packet); +} + +class WorkerTask implements Task { + + private Scheduler scheduler; + private int v1; + private int v2; + /** + * A task that manipulates work packets. + * @param {Scheduler} scheduler the scheduler that manages this task + * @param {int} v1 a seed used to specify how work packets are manipulated + * @param {int} v2 another seed used to specify how work packets are manipulated + * @constructor + */ + @SuppressWarnings("javadoc") + public WorkerTask(Scheduler scheduler, int v1, int v2) { + this.scheduler = scheduler; + this.v1 = v1; + this.v2 = v2; + } + + @Override + public TaskControlBlock run(Packet packet) { + if (packet == null) { + return this.scheduler.suspendCurrent(); + } else { + if (this.v1 == Scheduler.ID_HANDLER_A) { + this.v1 = Scheduler.ID_HANDLER_B; + } else { + this.v1 = Scheduler.ID_HANDLER_A; + } + packet.id = this.v1; + packet.a1 = 0; + for (int i = 0; i < Packet.DATA_SIZE; i++) { + this.v2++; + if (this.v2 > 26) this.v2 = 1; + packet.a2[i] = this.v2; + } + return this.scheduler.queue(packet); + } + } + + @Override + public String toString() { + return "WorkerTask"; + } +} + +/** + * This is the Java port of the JavaScript implementation of Richards benchmark from + * http://www.cl.cam.ac.uk/~mr10/Bench.html + * + * This benchmark (written in JavaScript) is part of the V8 benchmark suite. + */ +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + +public class Richards { + /** + * The Richards benchmark simulates the task dispatcher of an + * operating system. + **/ + public boolean runRichards() { + Scheduler scheduler = new Scheduler(); + scheduler.addIdleTask(Scheduler.ID_IDLE, 0, null, COUNT); + + Packet queue = new Packet(null, Scheduler.ID_WORKER, Scheduler.KIND_WORK); + queue = new Packet(queue, Scheduler.ID_WORKER, Scheduler.KIND_WORK); + scheduler.addWorkerTask(Scheduler.ID_WORKER, 1000, queue); + + queue = new Packet(null, Scheduler.ID_DEVICE_A, Scheduler.KIND_DEVICE); + queue = new Packet(queue, Scheduler.ID_DEVICE_A, Scheduler.KIND_DEVICE); + queue = new Packet(queue, Scheduler.ID_DEVICE_A, Scheduler.KIND_DEVICE); + scheduler.addHandlerTask(Scheduler.ID_HANDLER_A, 2000, queue); + + queue = new Packet(null, Scheduler.ID_DEVICE_B, Scheduler.KIND_DEVICE); + queue = new Packet(queue, Scheduler.ID_DEVICE_B, Scheduler.KIND_DEVICE); + queue = new Packet(queue, Scheduler.ID_DEVICE_B, Scheduler.KIND_DEVICE); + scheduler.addHandlerTask(Scheduler.ID_HANDLER_B, 3000, queue); + + scheduler.addDeviceTask(Scheduler.ID_DEVICE_A, 4000, null); + + scheduler.addDeviceTask(Scheduler.ID_DEVICE_B, 5000, null); + + scheduler.schedule(); + + if (scheduler.queueCount != EXPECTED_QUEUE_COUNT || + scheduler.holdCount != EXPECTED_HOLD_COUNT) { + String msg = + "Error during execution: queueCount = " + scheduler.queueCount + + ", holdCount = " + scheduler.holdCount + "."; + System.out.println(msg); + return false; + } + return true; + } + + public static final int COUNT = 1000; + /** + * These two constants specify how many times a packet is queued and + * how many times a task is put on hold in a correct run of richards. + * They don't have any meaning a such but are characteristic of a + * correct run so if the actual queue or hold count is different from + * the expected there must be a bug in the implementation. + **/ + public static final int EXPECTED_QUEUE_COUNT = 2322; + public static final int EXPECTED_HOLD_COUNT = 928; + + + @Benchmark // CHECKSTYLE.ON: .* + public void jmhTimeRichards() { + runRichards(); + } +} diff --git a/src/main/java/org/linaro/benchmarks/algorithm/Sort.java b/src/main/java/org/linaro/benchmarks/algorithm/Sort.java new file mode 100644 index 0000000..10f003a --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/algorithm/Sort.java @@ -0,0 +1,469 @@ +/* + * Copyright 2015 ARM Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +/* + * Description: Implementation of various sort algorithms. + * + * Main Focus: array accesses, array copies, branching. + * + * TODO: Add more sorting algorithms. + */ + +package org.linaro.benchmarks.algorithm; + +import java.lang.System; +import java.util.ArrayList; +import java.util.Arrays; +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + +public class Sort { + private final int ITERS = 10; + + public ArrayList<int[]> systemSortArraysToVerify = new ArrayList<int[]>(); + public ArrayList<int[]> bubbleSortArraysToVerify = new ArrayList<int[]>(); + public ArrayList<int[]> insertionSortArraysToVerify = new ArrayList<int[]>(); + public ArrayList<int[]> mergeSortArraysToVerify = new ArrayList<int[]>(); + + public static int[] array_16 = new int[16]; + public static int[] array_128 = new int[128]; + public static int[] array_2048 = new int[2048]; + public static final int SMALL=16; + public static final int MEDIUM=128; + public static final int LARGE=2048; + public static int[] array_scratch_small = new int[SMALL]; + public static int[] array_scratch_medium = new int[MEDIUM]; + public static int[] array_scratch_large = new int[LARGE]; + + void initArray(int[] array) { + int copyBase; + int copySize; + for (copyBase = 0; copyBase < array.length; copyBase += copySize) { + copySize = Math.min(referenceInputArray.length, array.length - copyBase); + System.arraycopy(referenceInputArray, 0, array, copyBase, copySize); + } + } + + boolean arraysEqual(int[] array_1, int[] array_2) { + int length = Math.min(array_1.length, array_2.length); + for (int i = 0; i < length; i++) { + if (array_1[i] != array_2[i]) { + System.out.println("ERROR: Arrays differ at index " + i + ": " + + array_1[i] + " != " + array_2[i]); + return false; + } + } + if (array_1.length != array_2.length) { + System.out.println("ERROR: Arrays have different lengths: " + + array_1.length + " != " + array_2.length); + return false; + } + return true; + } + + boolean isArraySorted(int[] array) { + for (int i = 0; i < array.length - 1; ++i) { + if (array[i] > array[i + 1]) { + System.out.println("ERROR: The array is not sorted at index " + i + ": " + + array[i] + " > " + array[i + 1]); + return false; + } + } + return true; + } + + /* Bubble sort */ + + void bubbleSort(int[] array) { + for (int i = 0; i < array.length; ++i) { + for (int j = 0; j < array.length - i - 1; ++j) { + if (array[j] > array[j + 1]) { + int temp = array[j]; + array[j] = array[j + 1]; + array[j + 1] = temp; + } + } + } + } + + public void benchBubbleSort(int []array, int iterations) { + bubbleSortArraysToVerify.add(array); + for (int iter = 0; iter < iterations; ++iter) { + initArray(array); // This will include lots of uncertain noise. + bubbleSort(array); + } + } + + public boolean verifyBubbleSort() { + for (int[] array : bubbleSortArraysToVerify) { + int[] ref = new int[array.length]; + initArray(ref); + Arrays.sort(ref); + if (!isArraySorted(array) || !arraysEqual(ref, array)) { + return false; + } + } + bubbleSortArraysToVerify.clear(); + return true; + } + + + /* Insertion sort */ + + void insertionSort(int[] array) { + for (int k = 1; k < array.length; ++k) { + int i; + int key = array[k]; + for (i = k; i > 0 && array[i - 1] > key; --i) { + array[i] = array[i - 1]; + } + array[i] = key; + } + } + + public void benchInsertionSort(int []array, int iterations) { + // insertionSortArraysToVerify.add(array); + for (int iter = 0; iter < iterations; ++iter) { + initArray(array); + insertionSort(array); + } + } + + public boolean verifyInsertionSort() { + for (int[] array : insertionSortArraysToVerify) { + int[] ref = new int[array.length]; + initArray(ref); + Arrays.sort(ref); + if (!isArraySorted(array) || !arraysEqual(ref, array)) { + return false; + } + } + insertionSortArraysToVerify.clear(); + return true; + } + + + /* Merge sort */ + + void mergeSort(int[] array, int[] scratch) { + mergeSort(array, 0, array.length, scratch); + } + + void mergeSort(int[] array, int index, int size, int[] scratch) { + if (size <= 1) { + return; + } + + int index_1 = index; + int size_1 = size / 2; + int index_2 = index + size_1; + int size_2 = size - size_1; + mergeSort(array, index_1, size_1, scratch); + mergeSort(array, index_2, size_2, scratch); + mergeArrays(array, index_1, size_1, index_2, size_2, scratch); + } + + void mergeArrays(int[] array, + int index_1, int size_1, + int index_2, int size_2, + int[] scratch) { + int end_1 = index_1 + size_1; + int end_2 = index_2 + size_2; + int i1 = index_1; + int i2 = index_2; + int j = 0; + + while (i1 != end_1 && i2 != end_2) { + if (array[i1] < array[i2]) { + scratch[j] = array[i1]; + ++i1; + } else { + scratch[j] = array[i2]; + ++i2; + } + ++j; + } + + if (i1 != end_1) { + System.arraycopy(array, i1, scratch, j, end_1 - i1); + } + + if (i2 != end_2) { + System.arraycopy(array, i2, scratch, j, end_2 - i2); + } + + System.arraycopy(scratch, 0, array, index_1, size_1 + size_2); + } + + public void benchMergeSort(int[] array, int iterations) { + int [] scratch; + if (array.length <= SMALL) { + scratch = array_scratch_small; + } else if (array.length > SMALL && array.length <= MEDIUM) { + scratch = array_scratch_medium; + } else { + scratch = array_scratch_large; + } + // mergeSortArraysToVerify.add(array); + for (int iter = 0; iter < iterations; ++iter) { + initArray(array); // This will bring noise. + mergeSort(array, scratch); + } + } + + public boolean verifyMergeSort() { + for (int[] array : mergeSortArraysToVerify) { + int[] ref = new int[array.length]; + initArray(ref); + Arrays.sort(ref); + if (!isArraySorted(array) || !arraysEqual(ref, array)) { + return false; + } + } + mergeSortArraysToVerify.clear(); + return true; + } + + + /* System sort */ + + void systemSort(int[] array) { + // This is wrapped in a helper to match the implementation for other sort + // algorithms. + Arrays.sort(array); + } + + void benchSystemSort(int [] array, int iterations) { + // systemSortArraysToVerify.add(array); + for (int iter = 0; iter < iterations; ++iter) { + initArray(array); // This will bring noise. + systemSort(array); + } + } + + public boolean verifySystemSort() { + for (int[] array : systemSortArraysToVerify) { + int[] ref = new int[array.length]; + System.arraycopy(array, 0, ref, 0, array.length); + Arrays.sort(ref); + if (!isArraySorted(array) || !arraysEqual(ref, array)) { + return false; + } + } + systemSortArraysToVerify.clear(); + return true; + } + + + // CHECKSTYLE.OFF: LeftCurly + // CHECKSTYLE.OFF: RightCurly + // CHECKSTYLE.OFF: EmptyLineSeparator + @Benchmark + public void timeBubbleSort____16() { benchBubbleSort(array_16, ITERS*100); } + @Benchmark + public void timeBubbleSort___128() { benchBubbleSort(array_128, ITERS*10); } + @Benchmark + public void timeBubbleSort__2048() { benchBubbleSort(array_2048, ITERS); } + @Benchmark + public void timeInsertionSort____16() { benchInsertionSort(array_16, ITERS*100); } + @Benchmark + public void timeInsertionSort___128() { benchInsertionSort(array_128, ITERS*10); } + @Benchmark + public void timeInsertionSort__2048() { benchInsertionSort(array_2048, ITERS); } + @Benchmark + public void timeMergeSort____16() { benchMergeSort(array_16, ITERS*100); } + @Benchmark + public void timeMergeSort___128() { benchMergeSort(array_128, ITERS*10); } + @Benchmark + public void timeMergeSort__2048() { benchMergeSort(array_2048, ITERS); } + @Benchmark + public void timeSystemSort____16() { benchSystemSort(array_16, ITERS*100); } + @Benchmark + public void timeSystemSort___128() { benchSystemSort(array_128, ITERS*10); } + @Benchmark + public void timeSystemSort__2048() { benchSystemSort(array_2048, ITERS); } + // CHECKSTYLE.ON: EmptyLineSeparator + // CHECKSTYLE.ON: RightCurly + // CHECKSTYLE.ON: LeftCurly + + // Array of 2048 integers between 0 and 4096. + public int[] referenceInputArray = { + 2334, 3368, 316, 762, 3183, 3200, 1037, 814, 238, 1882, 3382, 3682, 4034, + 2655, 119, 1820, 1287, 896, 1871, 939, 1478, 3882, 327, 3368, 1764, 3712, + 2363, 2823, 878, 3094, 1961, 3351, 1518, 2658, 2627, 3537, 4096, 1917, 1403, + 183, 61, 1753, 2223, 3080, 2952, 1514, 1291, 1588, 4037, 960, 721, 3470, + 574, 3277, 3068, 3190, 3257, 481, 2698, 2817, 1863, 3671, 2677, 3969, 1403, + 3408, 3829, 2487, 136, 3810, 2247, 1402, 2680, 2255, 1532, 723, 1274, 655, + 2389, 1820, 59, 10, 3981, 3605, 2735, 3959, 1914, 808, 3485, 507, 1345, 545, + 1673, 1056, 4074, 1257, 1165, 1625, 3505, 1686, 3927, 3842, 3216, 276, 1930, + 1578, 2915, 2400, 3401, 1150, 987, 3350, 2338, 2333, 1489, 3395, 2157, 3475, + 2861, 4067, 2135, 2893, 1518, 3298, 1954, 3512, 2219, 576, 3776, 19, 3784, + 3922, 1769, 1000, 2440, 3949, 1725, 55, 2194, 3764, 1178, 615, 1722, 152, + 476, 2947, 2700, 2076, 1985, 1631, 1823, 1300, 62, 1389, 1821, 3313, 1350, + 15, 3015, 3639, 2281, 4039, 2284, 3560, 4044, 764, 163, 3989, 152, 1347, + 3069, 3801, 3256, 301, 71, 1419, 1781, 2832, 2671, 1977, 450, 472, 1834, + 2478, 2735, 1940, 996, 1954, 269, 408, 246, 1995, 2937, 273, 766, 3012, + 1215, 2538, 2222, 480, 157, 60, 3107, 33, 2551, 246, 482, 4000, 700, 90, + 540, 3359, 1436, 344, 3751, 2657, 3406, 2072, 2245, 2896, 127, 2157, 249, + 2185, 813, 336, 2757, 1456, 1, 2565, 3178, 2235, 2069, 759, 1932, 570, 1386, + 2236, 3192, 3138, 2720, 3819, 1111, 3340, 360, 2998, 3344, 2350, 781, 3474, + 1870, 2608, 2456, 3740, 1845, 2802, 1109, 2042, 1671, 1794, 3774, 3073, + 2339, 3191, 374, 668, 1243, 3421, 1541, 3376, 2986, 2209, 167, 1652, 1908, + 3567, 233, 2703, 3753, 3548, 3642, 3703, 3792, 16, 3612, 867, 2130, 1271, + 318, 440, 1097, 350, 2211, 163, 1226, 3265, 3882, 3513, 3651, 316, 523, + 1757, 1691, 718, 3637, 3634, 2677, 3938, 1781, 2890, 683, 2605, 1631, 2673, + 2347, 274, 1726, 1084, 539, 1368, 1448, 225, 3042, 345, 310, 698, 2257, + 3208, 2427, 330, 4091, 463, 2033, 107, 331, 1968, 1339, 3495, 2764, 3114, + 1095, 2693, 3699, 963, 2466, 1517, 1088, 672, 1658, 1345, 2455, 2454, 223, + 469, 3347, 2699, 1937, 2029, 2467, 1735, 2244, 3866, 1214, 1907, 2717, 47, + 2301, 2051, 1156, 2391, 3241, 2644, 912, 2535, 1911, 1350, 854, 2909, 2001, + 4063, 983, 2565, 3495, 1875, 1187, 4025, 1613, 3390, 1376, 3970, 2297, 1511, + 305, 3331, 2630, 1867, 2989, 1718, 2037, 3504, 3628, 1133, 2705, 864, 3325, + 1106, 2662, 2093, 2283, 753, 494, 3, 2892, 2687, 2244, 4044, 2087, 3200, + 1712, 1879, 1197, 2820, 1473, 2045, 3757, 16, 421, 435, 2504, 1236, 1415, + 3889, 1336, 1754, 2679, 2196, 3680, 3431, 385, 744, 3835, 1959, 3117, 2690, + 2990, 3598, 2355, 1242, 2711, 2032, 2145, 3509, 2963, 567, 1549, 772, 1554, + 249, 184, 228, 1631, 361, 1605, 2984, 2287, 571, 2158, 3658, 1401, 383, + 2495, 777, 869, 3625, 952, 3691, 1831, 1350, 1856, 3872, 1960, 2243, 2234, + 2970, 3468, 1180, 3416, 1551, 4088, 4043, 2043, 3889, 539, 1200, 2145, 2346, + 1641, 1303, 2022, 1924, 1342, 3348, 723, 1766, 1170, 2377, 2732, 2995, 1649, + 3766, 1760, 2390, 1193, 451, 2134, 2568, 486, 987, 548, 3733, 2687, 2357, + 4060, 556, 586, 3663, 1410, 1502, 1637, 2670, 874, 2465, 3958, 3091, 1433, + 471, 1251, 2567, 3695, 1768, 2569, 2546, 585, 1767, 1098, 962, 1900, 1943, + 3367, 3878, 3247, 2893, 3627, 3429, 3668, 3800, 369, 4004, 3444, 2820, 1642, + 2090, 1880, 3611, 1964, 1689, 1369, 679, 2033, 2832, 596, 2040, 3932, 856, + 994, 2678, 2486, 737, 1402, 3979, 3183, 2082, 1323, 3093, 1853, 1704, 3546, + 2967, 659, 2559, 400, 668, 3881, 1090, 3153, 1287, 1183, 2884, 2753, 1757, + 2133, 2618, 1581, 2308, 2742, 3596, 3592, 3789, 2704, 2035, 1098, 494, 1896, + 1581, 2384, 2679, 101, 401, 3097, 69, 3251, 1574, 3695, 1287, 3663, 2378, + 1706, 2136, 2847, 2361, 1416, 1556, 2448, 2072, 3539, 1726, 75, 1927, 3933, + 583, 2838, 1993, 2715, 1825, 2538, 3867, 3039, 3757, 1726, 2808, 141, 1378, + 3750, 849, 1592, 342, 288, 97, 1647, 3110, 540, 1231, 3832, 2012, 3065, 393, + 1695, 626, 2258, 2285, 3782, 1227, 3432, 2595, 1980, 225, 403, 912, 1871, + 3255, 3456, 964, 1053, 1006, 1263, 792, 1377, 1573, 176, 2474, 34, 1257, + 409, 717, 1901, 1119, 873, 3322, 2880, 3092, 2199, 797, 1574, 2379, 2541, + 1689, 427, 2586, 2384, 945, 179, 1001, 2777, 2855, 1207, 3187, 210, 2436, + 1862, 3120, 491, 1030, 1890, 3212, 3658, 2933, 2914, 681, 3592, 93, 2709, + 3270, 112, 3239, 2541, 28, 2323, 3735, 39, 364, 86, 1055, 947, 3367, 3778, + 636, 1269, 3045, 116, 296, 3843, 3650, 338, 3408, 145, 1020, 3632, 435, + 4056, 554, 1456, 3931, 3549, 1028, 2169, 2176, 2798, 344, 3291, 3183, 2904, + 2959, 1293, 3176, 557, 1705, 3583, 3297, 2395, 2157, 976, 399, 803, 228, + 3382, 4035, 3951, 3188, 3822, 1158, 3386, 1849, 3777, 1398, 3793, 2749, + 1691, 247, 278, 493, 3061, 3826, 153, 879, 1070, 2355, 1502, 3198, 999, + 2047, 1762, 1753, 2470, 1331, 2190, 1708, 997, 2280, 1863, 1931, 2690, 4074, + 3585, 2030, 3792, 958, 1425, 1707, 506, 2363, 1847, 2721, 3630, 362, 626, + 1012, 784, 2069, 3268, 3060, 2717, 489, 1421, 1287, 3552, 540, 1486, 1306, + 1736, 3397, 2930, 1499, 3337, 57, 2044, 718, 3081, 2252, 3348, 2806, 2335, + 3172, 2126, 3998, 1304, 2460, 2553, 3548, 3457, 1967, 1844, 2973, 2288, 118, + 810, 2469, 1371, 1522, 279, 1963, 1659, 57, 1260, 2275, 3243, 389, 3952, + 465, 1557, 3294, 2064, 382, 1182, 484, 1698, 1170, 572, 4029, 1395, 3521, + 1009, 3313, 4062, 2595, 2559, 2172, 72, 3685, 3803, 1498, 224, 3731, 2441, + 3514, 2479, 1831, 96, 2615, 878, 2216, 352, 1741, 503, 1701, 327, 2966, 916, + 3139, 2295, 3377, 1137, 1714, 3449, 722, 2728, 3608, 1427, 1876, 971, 3573, + 1661, 1008, 2130, 2689, 821, 2946, 1070, 1511, 2574, 3153, 3913, 1552, 3496, + 2448, 1220, 457, 2640, 118, 3010, 3361, 3749, 2266, 3770, 1788, 524, 1802, + 3054, 2271, 3887, 3728, 1749, 2525, 1498, 3421, 35, 3185, 1150, 1452, 3468, + 1289, 2541, 608, 2601, 269, 2097, 1466, 2073, 1542, 1544, 236, 1082, 2626, + 1117, 1462, 2959, 3254, 1435, 1584, 2672, 1452, 1384, 814, 3983, 2447, 859, + 2087, 3211, 2873, 1842, 2524, 4021, 2025, 1824, 342, 3795, 2637, 2490, 1376, + 1647, 3405, 1709, 2148, 861, 305, 3486, 3263, 690, 1410, 341, 1405, 2148, + 439, 3895, 3074, 425, 1108, 1518, 3874, 854, 797, 2417, 840, 3603, 1178, + 3640, 3018, 2911, 675, 578, 657, 2937, 2478, 2216, 1596, 2886, 1540, 1016, + 4, 1331, 2519, 1255, 1134, 2685, 2129, 3927, 3993, 1793, 3279, 817, 3844, + 1372, 3043, 472, 1522, 3667, 3724, 1115, 104, 1084, 1218, 3029, 3767, 2870, + 3170, 3925, 3452, 973, 3400, 928, 751, 2177, 2972, 62, 3708, 3216, 4081, + 2573, 232, 532, 3128, 1400, 1855, 2601, 3443, 1938, 490, 2985, 8, 1906, + 1517, 1040, 14, 817, 2736, 3031, 240, 546, 3833, 3585, 3193, 990, 1687, + 3489, 3669, 1278, 1746, 3673, 3694, 2077, 743, 3534, 880, 2814, 3330, 3714, + 4038, 3426, 2433, 3181, 2441, 2797, 3547, 274, 940, 1937, 2487, 1964, 1565, + 2240, 2976, 784, 1994, 15, 3599, 2234, 2374, 2175, 3704, 301, 95, 3955, + 2064, 896, 1528, 578, 220, 1574, 1072, 2192, 3048, 2556, 2502, 2240, 1915, + 3715, 3794, 3072, 3282, 2572, 3300, 2035, 3078, 2902, 3887, 1721, 3263, + 1009, 1915, 1247, 3648, 350, 3348, 1651, 1276, 3180, 2334, 2578, 3269, 1203, + 1088, 436, 1827, 3548, 2587, 3299, 3949, 2846, 1692, 3043, 2627, 1653, 4062, + 2388, 680, 3926, 166, 639, 1142, 2405, 1421, 3214, 2027, 1428, 2361, 3456, + 2250, 3648, 2972, 533, 3470, 2157, 1847, 1317, 1708, 3781, 785, 2228, 250, + 2563, 906, 1771, 1688, 1587, 3149, 1748, 2180, 3331, 3389, 2294, 423, 1041, + 190, 982, 1994, 755, 2149, 3773, 1922, 3293, 3233, 300, 3402, 846, 1316, + 2397, 2408, 2425, 2857, 3848, 1097, 3559, 3113, 52, 3200, 964, 815, 3382, + 1242, 4034, 2382, 2853, 743, 3592, 3375, 685, 688, 933, 3038, 3825, 446, + 2557, 3657, 2696, 3087, 1866, 4059, 1593, 1171, 164, 1016, 2375, 2373, 3580, + 3586, 208, 2648, 2261, 1487, 1720, 559, 1116, 1666, 3735, 3944, 3875, 422, + 3886, 1370, 3677, 3071, 1797, 2133, 2522, 804, 3164, 1138, 3442, 3937, 2909, + 1765, 3507, 1010, 3145, 1803, 2101, 3072, 2252, 2533, 1617, 3981, 3593, + 1446, 1508, 3070, 754, 3477, 2722, 2573, 2528, 110, 766, 1593, 3906, 1958, + 3712, 2160, 3184, 2577, 821, 3929, 888, 2165, 322, 2508, 516, 4033, 3297, + 3008, 3297, 2073, 757, 2210, 3969, 2033, 481, 3138, 3901, 3578, 1020, 2160, + 237, 3190, 1360, 3553, 3310, 3969, 851, 1804, 1243, 1712, 2506, 3500, 3469, + 720, 3664, 3137, 2173, 186, 2323, 2198, 2382, 3037, 2661, 3213, 664, 1068, + 3244, 2435, 211, 3897, 1976, 1595, 619, 1676, 13, 3431, 2809, 2512, 518, + 2794, 2701, 484, 916, 1572, 970, 786, 1077, 1854, 3864, 1771, 80, 587, 3045, + 2171, 1159, 4085, 511, 370, 3259, 9, 1977, 3555, 961, 3788, 3926, 450, 135, + 277, 515, 2208, 2922, 4063, 1879, 2394, 824, 1827, 824, 405, 1783, 483, + 1718, 1169, 3737, 3441, 2808, 3326, 3481, 3182, 626, 1129, 3495, 3466, 3935, + 83, 401, 3369, 336, 2954, 2355, 3485, 1562, 370, 413, 567, 2818, 3581, 859, + 209, 3382, 2722, 2060, 1476, 855, 601, 3819, 3928, 2099, 3158, 538, 485, + 837, 840, 3176, 3231, 1056, 1528, 3667, 3623, 2400, 790, 2658, 749, 3115, + 254, 1333, 2409, 1334, 2894, 3703, 1644, 1779, 3676, 847, 3745, 1362, 255, + 191, 3153, 2421, 1775, 2068, 2016, 1827, 3279, 852, 2295, 3979, 4038, 2588, + 2132, 606, 496, 3576, 508, 1915, 1261, 1592, 970, 3458, 3183, 3879, 1933, + 2426, 2477, 259, 1953, 2393, 4040, 1130, 2807, 2397, 326, 4044, 61, 2638, + 332, 3219, 2094, 1448, 1416, 2597, 2607, 2340, 3921, 3573, 3556, 3557, 3603, + 264, 1189, 2079, 995, 2188, 1437, 810, 3105, 1828, 498, 3495, 1253, 1165, + 82, 1455, 1916, 2976, 99, 3774, 1784, 1471, 2874, 2121, 3058, 1307, 71, + 1012, 3399, 582, 1713, 918, 1509, 3076, 3313, 1307, 3051, 3074, 2073, 1243, + 825, 3574, 829, 3028, 3849, 2561, 1365, 461, 50, 100, 2088, 607, 651, 1400, + 3572, 1565, 569, 270, 1392, 340, 3706, 2992, 450, 2113, 679, 1381, 3876, + 243, 4013, 366, 1733, 1010, 1445, 1042, 789, 1600, 2786, 1595, 796, 3670, + 987, 3824, 593, 3069, 4014, 2248, 866, 2830, 3896, 354, 2185, 2455, 2467, + 2320, 2107, 1534, 2670, 1978, 2632, 1679, 38, 2260, 1374, 2619, 2966, 1638, + 2447, 2289, 667, 361, 2647, 704, 2704, 3679, 2808, 1940, 1873, 1580, 1259, + 2237, 723, 2154, 2284, 1848, 3076, 2250, 2498, 3334, 361, 3172, 3369, 3468, + 539, 2594, 2385, 1715, 1254, 881, 3530, 2686, 3063, 2654, 145, 2218, 3711, + 3392, 2429, 1275, 3471, 314, 1024, 3971, 1371, 1355, 3974, 3318, 1819, 2714, + 1814, 2031, 555, 2791, 896, 380, 1662, 1377, 3602, 3447, 2729, 684, 2374, + 391, 2868, 2601, 1545, 2449, 1651, 198, 1140, 302, 3546, 2249, 115, 755, + 3324, 1374, 3705, 3587, 3735, 1642, 2067, 452, 3342, 3069, 1232, 698, 2784, + 540, 570, 2657, 511, 1497, 992, 959, 1301, 1707, 2992, 2306, 4019, 1358, + 809, 1967, 1468, 1531, 1919, 1330, 1197, 404, 1364, 1142, 3059, 3067, 1536, + 2546, 1358, 1653, 71, 3120, 2224, 2437, 2927, 2440, 2138, 1114, 824, 2324, + 1726, 3246, 1541, 2062, 3733, 2749, 3844, 1678, 3838, 1938, 2393, 2321, + 3419, 3709, 3162, 1033, 2216, 1799, 2512, 2171, 2826, 2962, 3531, 1548, 911, + 1386, 3111, 265, 3387, 4046, 3869, 899, 1453, 1559, 1177, 1665, 3498, 811, + 3273, 1545, 403, 1785, 263, 2975, 932, 3279, 2709, 1807, 1895, 3470, 3771, + 3649, 766, 265, 3105, 2402, 3065, 3489, 3392, 3325, 1219, 1362, 272, 449, + 89, 1814, 1424, 1929, 3234, 3643, 3773, 862, 3938, 2957, 3773, 415, 1770, + 2999, 3167, 3992, 3640, 405, 2616, 2046, 919, 1019, 324, 2104, 3851, 3795, + 1571, 2779, 2360, 1915, 2773, 1359, 2850, 1891, 480, 589, 2772, 2449, 977, + 2106, 2539, 1262, 1129, 2383, 3092, 4023, 50, 2228, 367, 3644, 1100, 2055, + 2203, 3067, 3062, 42, 313, 3685, 3606, 1462, 3324, 2052, 2355, 2586, 3762, + 2879, 3653, 38, 783, 1262, 1540, 3002, 1466, 1639, 3472, 1801, 3830, 3801, + 2620, 514, 1183, 2361, 3002, 2043, 2020, 3798, 1198, 3151, 942, 4016, 2957, + 4018, 2874, 4095, 1358, 2796, 2728, 3034, 2927, 1224, 1178, 24, 2396, 3422, + 124, 3164, 635, 170, 4083, 3085, 2528, 1685, 3959, 2319, 3832, 3223, 65, + 3899, 48, 3629, 2633, 3241, 2127, 2291, 2725, 1067, 3772, 2948, 2816, 3493, + 3732, 578, 3219, 4026, 635, 2807, 417, 2868, 929, 3072, 3312, 238, 1584, 92, + 807, 2235, 794, 1233, 3815, 4074, 1105, 141, 1315, 1517, 2346, 1132, 3899, + 3904, 3063, 3085, 1630, 1880, 743, 1825, 1793, 2441, 709, 2477, 3382, 348, + 2626 + }; +} + diff --git a/src/main/java/org/linaro/benchmarks/benchmarksgame/LICENSE b/src/main/java/org/linaro/benchmarks/benchmarksgame/LICENSE new file mode 100644 index 0000000..330d9e7 --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/benchmarksgame/LICENSE @@ -0,0 +1,34 @@ +Revised BSD license + +This is a specific instance of the Open Source Initiative (OSI) BSD license +template http://www.opensource.org/licenses/bsd-license.php + + +Copyright © 2004-2008 Brent Fulgham, 2005-2015 Isaac Gouy +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + + Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + Neither the name of "The Computer Language Benchmarks Game" nor the name of + of "The Computer Language Shootout Benchmarks" nor the names of its + contributors may be used to endorse or promote products derived from this + software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/src/main/java/org/linaro/benchmarks/benchmarksgame/binarytrees.java b/src/main/java/org/linaro/benchmarks/benchmarksgame/binarytrees.java new file mode 100644 index 0000000..8ce6f1c --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/benchmarksgame/binarytrees.java @@ -0,0 +1,102 @@ +/* + * This benchmark has been ported from "The Computer Language Benchmarks Game" suite and slightly + * modified to fit the benchmarking framework. + * + * The original file is `binarytrees/binarytrees.java-2.java` from the archive + * available at + * http://benchmarksgame.alioth.debian.org/download/benchmarksgame-sourcecode.zip. + * See LICENSE file in the same folder (BSD 3-clause) + * + * The Computer Language Benchmarks Game + * http://benchmarksgame.alioth.debian.org/ + * + * contributed by Jarkko Miettinen + */ + +/* + * Description: Allocate and deallocate many many binary trees. + * Main Focus: TODO + * + */ + +package org.linaro.benchmarks.benchmarksgame; + +import java.util.ArrayList; +import java.util.Date; +import java.util.SortedSet; +import java.util.TreeSet; +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + +// CHECKSTYLE.OFF: .* +public class binarytrees { + + private static final int PREDEFINED_DEPTH = 10; + private final static int minDepth = 4; + + public int old_main(){ + int n = 0; + int maxDepth = (minDepth + 2 > PREDEFINED_DEPTH) ? minDepth + 2 : PREDEFINED_DEPTH; + int stretchDepth = maxDepth + 1; + + int check = (TreeNode.bottomUpTree(0,stretchDepth)).itemCheck(); + + TreeNode longLivedTree = TreeNode.bottomUpTree(0,maxDepth); + + for (int depth=minDepth; depth<=maxDepth; depth+=2){ + int iterations = 1 << (maxDepth - depth + minDepth); + check = 0; + + for (int i=1; i<=iterations; i++){ + check += (TreeNode.bottomUpTree(i,depth)).itemCheck(); + check += (TreeNode.bottomUpTree(-i,depth)).itemCheck(); + } + } + return check; + } + + + private static class TreeNode + { + private TreeNode left, right; + private int item; + + TreeNode(int item){ + this.item = item; + } + + private static TreeNode bottomUpTree(int item, int depth){ + if (depth>0){ + return new TreeNode( + bottomUpTree(2*item-1, depth-1) + , bottomUpTree(2*item, depth-1) + , item + ); + } + else { + return new TreeNode(item); + } + } + + TreeNode(TreeNode left, TreeNode right, int item){ + this.left = left; + this.right = right; + this.item = item; + } + + private int itemCheck(){ + // if necessary deallocate here + if (left==null) return item; + else return item + left.itemCheck() - right.itemCheck(); + } + } + // CHECKSTYLE.ON: .* + @Benchmark + public void jmhTimeBinaryTrees() { + old_main(); + } +} diff --git a/src/main/java/org/linaro/benchmarks/benchmarksgame/chameneosredux.java b/src/main/java/org/linaro/benchmarks/benchmarksgame/chameneosredux.java new file mode 100644 index 0000000..6733d6b --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/benchmarksgame/chameneosredux.java @@ -0,0 +1,253 @@ +/* + * This benchmark has been ported from "The Computer Language Benchmarks Game" suite and slightly + * modified to fit the benchmarking framework. + * + * The original file is `chameneosredux/chameneosredux.java` from the archive + * available at + * http://benchmarksgame.alioth.debian.org/download/benchmarksgame-sourcecode.zip. + * See LICENSE file in the same folder (BSD 3-clause) + * + * The Computer Language Benchmarks Game + * http://benchmarksgame.alioth.debian.org/ + * + * contributed by Michael Barker + */ + +/* + * Description: Symmetrical thread rendezvous requests. + * Main Focus: TODO + * + */ + +package org.linaro.benchmarks.benchmarksgame; + +import java.util.concurrent.ArrayBlockingQueue; +import java.util.concurrent.BlockingQueue; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.concurrent.atomic.AtomicReference; +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + + +/** + * This implementation uses the java.util.concurrent.atomic library + * i.e. (compare and set) to avoid locking. Real threads are used, but + * are set up as a thread pool and meeting requests are pushed onto a + * queue that feeds the thread pool. + */ +// CHECKSTYLE.OFF: .* +public class chameneosredux { + + enum Colour { + blue, + red, + yellow + } + + private static Colour doCompliment(final Colour c1, final Colour c2) { + switch (c1) { + case blue: + switch (c2) { + case blue: + return Colour.blue; + case red: + return Colour.yellow; + case yellow: + return Colour.red; + } + case red: + switch (c2) { + case blue: + return Colour.yellow; + case red: + return Colour.red; + case yellow: + return Colour.blue; + } + case yellow: + switch (c2) { + case blue: + return Colour.red; + case red: + return Colour.blue; + case yellow: + return Colour.yellow; + } + } + + throw new RuntimeException("Error"); + } + + static final class MeetingPlace { + + private final AtomicInteger meetingsLeft; + private final AtomicReference<Creature> creatureRef = new AtomicReference<Creature>(); + + public MeetingPlace(final int meetings) { + meetingsLeft = new AtomicInteger(meetings); + } + + public void meet(final Creature incoming) { + Colour newColour = null; + Creature first = null; + Creature next = null; + do { + first = creatureRef.get(); + next = incoming; + if (first != null) { + newColour = doCompliment(incoming.colour, first.colour); + next = null; + } + } while (!creatureRef.compareAndSet(first, next)); + + if (first != null) { + final int meetings = meetingsLeft.decrementAndGet(); + if (meetings >= 0) { + first.setColour(incoming.id, newColour); + incoming.setColour(first.id, newColour); + } else { + first.complete(); + incoming.complete(); + } + } + } + } + + static final class Dispatcher implements Runnable { + private final BlockingQueue<Creature> q; + + public Dispatcher(final BlockingQueue<Creature> q) { + this.q = q; + } + + public void run() { + try { + while (true) { + q.take().run(); + } + } catch (final InterruptedException e) { + } + } + } + + static final class Creature { + + private final int id; + private final MeetingPlace place; + private final BlockingQueue<Creature> q; + private final CountDownLatch latch; + private int count = 0; + private int sameCount = 0; + private Colour colour; + + public Creature(final MeetingPlace place, final Colour colour, + final BlockingQueue<Creature> q, final CountDownLatch latch) { + this.id = System.identityHashCode(this); + this.place = place; + this.latch = latch; + this.colour = colour; + this.q = q; + } + + public void complete() { + latch.countDown(); + } + + public void setColour(final int id, final Colour newColour) { + this.colour = newColour; + count++; + sameCount += 1 ^ Integer.signum(abs(this.id - id)); + q.add(this); + } + + private int abs(final int x) { + final int y = x >> 31; + return (x ^ y) - y; + } + + public void run() { + place.meet(this); + } + + public int getCount() { + return count; + } + + @Override + public String toString() { + return String.valueOf(count) + getNumber(sameCount); + } + } + + private int run(final int n, final Colour...colours) { + final int len = colours.length; + final MeetingPlace place = new MeetingPlace(n); + final Creature[] creatures = new Creature[len]; + final BlockingQueue<Creature> q = new ArrayBlockingQueue<Creature>(len); + final CountDownLatch latch = new CountDownLatch(len - 1); + + for (int i = 0; i < len; i++) { + creatures[i] = new Creature(place, colours[i], q, latch); + } + + final Thread[] ts = new Thread[len]; + for (int i = 0, h = ts.length; i < h; i++) { + ts[i] = new Thread(new Dispatcher(q)); + ts[i].setDaemon(true); + ts[i].start(); + } + + for (final Creature creature : creatures) { + q.add(creature); + } + + try { + latch.await(); + for (final Thread t : ts) { + t.interrupt(); + } + for (final Thread t : ts) { + t.join(); + } + } catch (final InterruptedException e1) { + System.err.println("Existing with error: " + e1); + } + + int total = 0; + for (final Creature creature : creatures) { + total += creature.getCount(); + } + return total; + } + + private static final String[] NUMBERS = { + "zero", "one", "two", "three", "four", "five", + "six", "seven", "eight", "nine" + }; + + private static String getNumber(final int n) { + final StringBuilder sb = new StringBuilder(); + final String nStr = String.valueOf(n); + for (int i = 0; i < nStr.length(); i++) { + sb.append(" "); + sb.append(NUMBERS[Character.getNumericValue(nStr.charAt(i))]); + } + + return sb.toString(); + } + // CHECKSTYLE.ON: .* + + private static final int PREDEFINED_N = 600; + + @Benchmark + public void jmhTimeChameneosRedux() { + run(PREDEFINED_N, Colour.blue, Colour.red, Colour.yellow); + run(PREDEFINED_N, Colour.blue, Colour.red, Colour.yellow, Colour.red, Colour.yellow, + Colour.blue, Colour.red, Colour.yellow, Colour.red, Colour.blue); + } +} diff --git a/src/main/java/org/linaro/benchmarks/benchmarksgame/fannkuchredux.java b/src/main/java/org/linaro/benchmarks/benchmarksgame/fannkuchredux.java new file mode 100644 index 0000000..6a644c1 --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/benchmarksgame/fannkuchredux.java @@ -0,0 +1,94 @@ +/* + * This benchmark has been ported from "The Computer Language Benchmarks Game" suite and slightly + * modified to fit the benchmarking framework. + * + * The original file is `fannkuchredux/fannkuchredux.java-2.java` from the + * archive available at + * http://benchmarksgame.alioth.debian.org/download/benchmarksgame-sourcecode.zip. + * See LICENSE file in the same folder (BSD 3-clause). + * + * The Computer Language Benchmarks Game + * http://benchmarksgame.alioth.debian.org/ + * + * contributed by Isaac Gouy + * converted to Java by Oleg Mazurov + */ + +/* + * Description: Indexed-access to tiny integer-sequence. + * Main Focus: TODO + * + */ + +package org.linaro.benchmarks.benchmarksgame; +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + + // CHECKSTYLE.OFF: .* +public class fannkuchredux +{ + public int fannkuch(int n) { + int[] perm = new int[n]; + int[] perm1 = new int[n]; + int[] count = new int[n]; + int maxFlipsCount = 0; + int permCount = 0; + int checksum = 0; + + for(int i=0; i<n; i++) perm1[i] = i; + int r = n; + + while (true) { + + while (r != 1){ count[r-1] = r; r--; } + + for(int i=0; i<n; i++) perm[i] = perm1[i]; + int flipsCount = 0; + int k; + + while ( !((k=perm[0]) == 0) ) { + int k2 = (k+1) >> 1; + for(int i=0; i<k2; i++) { + int temp = perm[i]; perm[i] = perm[k-i]; perm[k-i] = temp; + } + flipsCount++; + } + + maxFlipsCount = Math.max(maxFlipsCount, flipsCount); + checksum += permCount%2 == 0 ? flipsCount : -flipsCount; + + // Use incremental change to generate another permutation + while (true) { + if (r == n) { + return maxFlipsCount; + } + int perm0 = perm1[0]; + int i = 0; + while (i < r) { + int j = i + 1; + perm1[i] = perm1[j]; + i = j; + } + perm1[r] = perm0; + + count[r] = count[r] - 1; + if (count[r] > 0) break; + r++; + } + + permCount++; + } + } + // CHECKSTYLE.ON: .* + + private static final int PREDEFINED_N_PANCAKES = 7; + + @Benchmark + public void jmhTimeFannkuchRedux() { + fannkuch(PREDEFINED_N_PANCAKES); + } +} diff --git a/src/main/java/org/linaro/benchmarks/benchmarksgame/fasta.java b/src/main/java/org/linaro/benchmarks/benchmarksgame/fasta.java new file mode 100644 index 0000000..f662bd3 --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/benchmarksgame/fasta.java @@ -0,0 +1,173 @@ +/* + * This benchmark has been ported from "The Computer Language Benchmarks Game" suite and modified + * to fit the benchmarking framework. + * The original benchmarks printed long strings to the stdout. This print was removed to fit the + * framework. These action can cause difference in behaviour of the original and changed benchmarks; + * it hasn't been estimated yet. + * + * The original file is `fasta/fasta.java-2.java` from the archive available at + * http://benchmarksgame.alioth.debian.org/download/benchmarksgame-sourcecode.zip. + * See LICENSE file in the same folder (BSD 3-clause). + * + * The Computer Language Benchmarks Game + * http://benchmarksgame.alioth.debian.org/ + * + * modified by Mehmet D. AKIN + * + */ + +/* + * Description: Generate and write random DNA sequences. + * Main Focus: TODO + * + */ + +package org.linaro.benchmarks.benchmarksgame; +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + +// CHECKSTYLE.OFF: .* +public class fasta { + public static final int IM = 139968; + public static final int IA = 3877; + public static final int IC = 29573; + public static int last = 42; + + public static final int LINE_LENGTH = 60; + + // pseudo-random number generator + public static final double random(double max) { + last = (last * IA + IC) % IM; + return max * last / IM; + } + + // Weighted selection from alphabet + public static String ALU = + "GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG" + + "GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA" + + "CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT" + + "ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA" + + "GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG" + + "AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC" + + "AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA"; + public static byte[] ALUB = ALU.getBytes(); + + public static final frequency[] IUB = new frequency[] { + new frequency('a', 0.27), + new frequency('c', 0.12), + new frequency('g', 0.12), + new frequency('t', 0.27), + + new frequency('B', 0.02), + new frequency('D', 0.02), + new frequency('H', 0.02), + new frequency('K', 0.02), + new frequency('M', 0.02), + new frequency('N', 0.02), + new frequency('R', 0.02), + new frequency('S', 0.02), + new frequency('V', 0.02), + new frequency('W', 0.02), + new frequency('Y', 0.02) }; + + public static final frequency[] HomoSapiens = new frequency[] { + new frequency('a', 0.3029549426680d), + new frequency('c', 0.1979883004921d), + new frequency('g', 0.1975473066391d), + new frequency('t', 0.3015094502008d)}; + + public static void makeCumulative(frequency[] a) { + double cp = 0.0; + for (int i = 0; i < a.length; i++) { + cp += a[i].p; + a[i].p = cp; + } + } + + // naive + public final static byte selectRandom(frequency[] a) { + int len = a.length; + double r = random(1.0); + for (int i = 0; i < len; i++) + if (r < a[i].p) + return a[i].c; + return a[len - 1].c; + } + + static int BUFFER_SIZE = 1024; + static int index = 0; + static byte[] bbuffer = new byte[BUFFER_SIZE]; + final void makeRandomFasta(String id, String desc,frequency[] a, int n) + { + index = 0; + int m = 0; + String descStr = ">" + id + " " + desc + '\n'; + while (n > 0) { + if (n < LINE_LENGTH) m = n; else m = LINE_LENGTH; + if(BUFFER_SIZE - index < m){ + index = 0; + } + for (int i = 0; i < m; i++) { + bbuffer[index++] = selectRandom(a); + } + bbuffer[index++] = '\n'; + n -= LINE_LENGTH; + } + } + + final void makeRepeatFasta(String id, String desc, String alu, int n) + { + index = 0; + int m = 0; + int k = 0; + int kn = ALUB.length; + String descStr = ">" + id + " " + desc + '\n'; + while (n > 0) { + if (n < LINE_LENGTH) m = n; else m = LINE_LENGTH; + if(BUFFER_SIZE - index < m){ + index = 0; + } + for (int i = 0; i < m; i++) { + if (k == kn) k = 0; + bbuffer[index++] = ALUB[k]; + k++; + } + bbuffer[index++] = '\n'; + n -= LINE_LENGTH; + } + } + + public static class frequency { + public byte c; + public double p; + + public frequency(char c, double p) { + this.c = (byte)c; + this.p = p; + } + } + + public void old_main() { + int n = 1000; + + makeRepeatFasta("ONE", "Homo sapiens alu", ALU, n * 2); + makeRandomFasta("TWO", "IUB ambiguity codes", IUB, n * 3); + makeRandomFasta("THREE", "Homo sapiens frequency", HomoSapiens, n * 5); + } + // CHECKSTYLE.ON: .* + + @Setup + public void setup() { + makeCumulative(HomoSapiens); + makeCumulative(IUB); + } + + @Benchmark + public void jmhTimeFasta() { + old_main(); + } +} diff --git a/src/main/java/org/linaro/benchmarks/benchmarksgame/fastaredux.java b/src/main/java/org/linaro/benchmarks/benchmarksgame/fastaredux.java new file mode 100644 index 0000000..a0a86dd --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/benchmarksgame/fastaredux.java @@ -0,0 +1,204 @@ +/* + * This benchmark has been ported from "The Computer Language Benchmarks Game" suite and modified + * to fit the benchmarking framework. + * The original benchmarks printed long strings to the stdout. This print was overrided to do + * nothing to fit the framework. These action can cause difference in behaviour of the original and + * changed benchmarks; it hasn't been estimated yet. + * + * The original file is `fastaredux/fastaredux.java-3.java` from the archive + * available at + * http://benchmarksgame.alioth.debian.org/download/benchmarksgame-sourcecode.zip. + * See LICENSE file in the same folder (BSD 3-clause). + * + * The Computer Language Benchmarks Game + * http://benchmarksgame.alioth.debian.org/ + * + * modified by Enotus + * + */ + +/* + * Description: Generate and write random DNA sequences. + * Main Focus: TODO + * + */ + +package org.linaro.benchmarks.benchmarksgame; + +import java.io.*; +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + +// CHECKSTYLE.OFF: .* +public class fastaredux { + + static final int LINE_LENGTH = 60; + static final int OUT_BUFFER_SIZE = 256*1024; + static final int LOOKUP_SIZE = 4*1024; + static final double LOOKUP_SCALE = LOOKUP_SIZE - 1; + + static final class Freq { + byte c; + double p; + Freq(char cc, double pp) {c = (byte) cc;p = pp;} + } + + static final String ALU = + "GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG" + + "GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA" + + "CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT" + + "ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA" + + "GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG" + + "AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC" + + "AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA"; + static final Freq[] IUB = { + new Freq('a', 0.27), + new Freq('c', 0.12), + new Freq('g', 0.12), + new Freq('t', 0.27), + new Freq('B', 0.02), + new Freq('D', 0.02), + new Freq('H', 0.02), + new Freq('K', 0.02), + new Freq('M', 0.02), + new Freq('N', 0.02), + new Freq('R', 0.02), + new Freq('S', 0.02), + new Freq('V', 0.02), + new Freq('W', 0.02), + new Freq('Y', 0.02)}; + static final Freq[] HomoSapiens = { + new Freq('a', 0.3029549426680), + new Freq('c', 0.1979883004921), + new Freq('g', 0.1975473066391), + new Freq('t', 0.3015094502008)}; + + static void sumAndScale(Freq[] a) { + double p = 0; + for (int i = 0; i < a.length; i++) + a[i].p = (p += a[i].p) * LOOKUP_SCALE; + a[a.length - 1].p = LOOKUP_SCALE; + } + + static final class Random { + + static final int IM = 139968; + static final int IA = 3877; + static final int IC = 29573; + static final double SCALE = LOOKUP_SCALE / IM; + static int last = 42; + + static double next() { + return SCALE * (last = (last * IA + IC) % IM); + } + } + + static final class Out { + + static byte buf[] = new byte[OUT_BUFFER_SIZE]; + static final int lim = OUT_BUFFER_SIZE - 2*LINE_LENGTH - 1; + static int ct = 0; + static OutputStream stream; + + static void checkFlush() throws IOException { + if (ct >= lim) { stream.write(buf, 0, ct); ct = 0;} + } + + static void close() throws IOException { + stream.write(buf, 0, ct);ct = 0; + stream.close(); + } + } + + static final class RandomFasta { + + static final Freq[] lookup=new Freq[LOOKUP_SIZE]; + + static void makeLookup(Freq[] a) { + for (int i = 0, j = 0; i < LOOKUP_SIZE; i++) { + while (a[j].p < i) j++; + lookup[i] = a[j]; + } + } + + static void addLine(int bytes) throws IOException{ + Out.checkFlush(); + int lct=Out.ct; + while(lct<Out.ct+bytes){ + double r = Random.next(); // Problematic for AOT! See fastaredux_revised.java. + int ai = (int) r; while (lookup[ai].p < r) ai++; + Out.buf[lct++] = lookup[ai].c; + } + Out.buf[lct++] = (byte)'\n'; + Out.ct=lct; + } + + static void make(String desc, Freq[] a, int n) throws IOException { + makeLookup(a); + + System.arraycopy(desc.getBytes(), 0, Out.buf, Out.ct, desc.length()); + Out.ct+=desc.length(); + + while (n > 0) { + int bytes = Math.min(LINE_LENGTH, n); + addLine(bytes); + n -= bytes; + } + } + } + + static final class RepeatFasta { + + static void make(String desc, byte[] alu, int n) throws IOException { + System.arraycopy(desc.getBytes(), 0, Out.buf, Out.ct, desc.length()); + Out.ct+=desc.length(); + + byte buf[] = new byte[alu.length + LINE_LENGTH]; + for (int i = 0; i < buf.length; i += alu.length) + System.arraycopy(alu, 0, buf, i, Math.min(alu.length, buf.length - i)); + + int pos = 0; + while (n > 0) { + int bytes = Math.min(LINE_LENGTH, n); + Out.checkFlush(); + System.arraycopy(buf, pos, Out.buf, Out.ct, bytes); Out.ct+=bytes; + Out.buf[Out.ct++] = (byte)'\n'; + pos = (pos + bytes) % alu.length; + n -= bytes; + } + } + } + + private void old_main() throws IOException { + int n = 1000; + + RepeatFasta.make(">ONE Homo sapiens alu\n", ALU.getBytes(), n * 2); + RandomFasta.make(">TWO IUB ambiguity codes\n", IUB, n * 3); + RandomFasta.make(">THREE Homo sapiens frequency\n", HomoSapiens, n * 5); + } + // CHECKSTYLE.ON: .* + + /** Writes to nowhere */ + public class NullOutputStream extends OutputStream { + @Override + public void write(int b) throws IOException { + } + } + + @Setup + public void setup() { + sumAndScale(IUB); + sumAndScale(HomoSapiens); + + Out.stream = new NullOutputStream(); + } + + @Benchmark + public void jmhTimeFastaRedux() throws IOException { + old_main(); + } +} diff --git a/src/main/java/org/linaro/benchmarks/benchmarksgame/knucleotide.java b/src/main/java/org/linaro/benchmarks/benchmarksgame/knucleotide.java new file mode 100644 index 0000000..b14ef8a --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/benchmarksgame/knucleotide.java @@ -0,0 +1,1312 @@ +/* + * This benchmark has been ported from "The Computer Language Benchmarks Game" suite and slightly + * modified to fit the benchmarking framework. + * + * The original file is `knucleotide/knucleotide.java-4.java` from the archive + * available at + * http://benchmarksgame.alioth.debian.org/download/benchmarksgame-sourcecode.zip. + * See LICENSE file in the same folder (BSD 3-clause). + * + * The Computer Language Benchmarks Game + * http://benchmarksgame.alioth.debian.org/ + * + * contributed by Daryl Griffith + */ + +/* + * Description: Hashtable update and k-nucleotide strings. + * Main Focus: TODO + * + */ + +package org.linaro.benchmarks.benchmarksgame; + +import java.io.ByteArrayInputStream; +import java.io.Closeable; +import java.io.IOException; +import java.io.InputStream; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.Collections; +import java.util.Comparator; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + +// CHECKSTYLE.OFF: .* +public class knucleotide { + + private byte[] temp = null; + private byte[] buffer = null; + private byte[] species = null; + private ByteArrayInputStream stream = null; + private LineInputStream in; + + static Map<Key, Value> MAP; + static final int[] SEQUENCES1 = {2, 1}; + static final int[] SEQUENCES2 = {18, 12, 6, 4, 3}; + static final String[] SPICIFIC_SEQUENCES = new String[]{"GGT", "GGTA", "GGTATT", "GGTATTTTAATT", "GGTATTTTAATTTATAGT"}; + static final int LINE_LENGTH = 60; + static final int EOF = -1; + static byte[] nucleotides; + + public void old_main() { + { + int n; + int i; + + try { +outer: + for (;;) { + n = in.readLine(temp); + if (n == EOF) { + return; + } + if (n != LINE_LENGTH) { + for (i = 0; i < species.length; i++) { + if (temp[i] != species[i]) { + continue outer; + } + } + break; + } + } + i = 0; + for (;;) { + n = in.readLine(temp); + if (n == EOF) { + break; + } + for (int j = 0; j < n; i++, j++) { + buffer[i] = translate(temp[j]); + } + } + if (i == buffer.length) { + nucleotides = buffer; + } else { + nucleotides = new byte[i]; + System.arraycopy(buffer, 0, nucleotides, 0, i); + } + } catch (IOException e) { + + } + } + countSequences(SEQUENCES1); + { + List<Entry<Key, Value>> sequence1 = new ArrayList<Entry<Key, Value>>(); + List<Entry<Key, Value>> sequence2 = new ArrayList<Entry<Key, Value>>(); + + for (Entry<Key, Value> entry : MAP.entrySet()) { + switch (Long.numberOfLeadingZeros(entry.getKey().key)) { + case 61: + sequence1.add(entry); + break; + case 59: + sequence2.add(entry); + } + } + printSequence(sequence1); + printSequence(sequence2); + } + countSequences(SEQUENCES2); + { + Key key = new Key(); + } + } + + static byte translate(byte b) { + return (byte) ((b >> 1) & 3); + } + + static void countSequences(int[] sequences) { + for (int sequence : sequences) { + updateHashtable(sequence); + } + } + + static void updateHashtable(int sequence) { + int sequenceTop = nucleotides.length - sequence + 1; + Key key = new Key(); + Value value; + + for (int i = 0; i < sequenceTop; i++) { + key.setHash(i, sequence); + value = MAP.get(key); + if (value == null) { + value = new Value(); + value.count = 1; + MAP.put(key, value); + key = new Key(); + } else { + value.count++; + } + } + } + + static void printSequence(List<Entry<Key, Value>> sequence) { + int sum = 0; + + Collections.sort(sequence, new Comparator<Entry<Key, Value>>() { + + @Override + public int compare(Entry<Key, Value> entry1, Entry<Key, Value> entry2) { + if (entry2.getValue().count != entry1.getValue().count) { + return entry2.getValue().count - entry1.getValue().count; + } + return entry1.getKey().toString().compareTo(entry2.getKey().toString()); + } + }); + for (Entry<Key, Value> entry : sequence) { + sum += entry.getValue().count; + } + } + + static class LineInputStream implements Closeable { + + private static final int LF = 10; + private final ByteBuffer buffer = ByteBuffer.allocate(8192); + private final InputStream in; + + public LineInputStream(InputStream in) { + this.in = in; + buffer.limit(buffer.position()); + } + + public int readLine(byte[] b) throws IOException { + for (int end = buffer.position(); end < buffer.limit(); end++) { + if (buffer.get(end) == LF) { + if (end - buffer.position() == LINE_LENGTH) { + buffer.get(b); + buffer.position(buffer.position() + 1); + return LINE_LENGTH; + } else { + int size = end - buffer.position(); + + buffer.get(b, 0, size); + buffer.position(buffer.position() + 1); + return size; + } + } + } + buffer.compact(); + int n = in.read(buffer.array(), buffer.position(), buffer.remaining()); + + if (n == EOF) { + buffer.flip(); + if (buffer.hasRemaining()) { + int size = buffer.remaining(); + + buffer.get(b, 0, size); + return size; + } else { + return EOF; + } + } else { + buffer.position(buffer.position() + n); + buffer.flip(); + } + for (int end = buffer.position(); end < buffer.limit(); end++) { + if (buffer.get(end) == LF) { + if (end - buffer.position() == LINE_LENGTH) { + buffer.get(b); + buffer.position(buffer.position() + 1); + return LINE_LENGTH; + } else { + int size = end - buffer.position(); + + buffer.get(b, 0, size); + buffer.position(buffer.position() + 1); + return size; + } + } + } + return EOF; + } + + @Override + public void close() throws IOException { + in.close(); + } + } + + static class Key { + + long key; + + void setHash(int offset, int length) { + key = 1; + for (int i = offset + length - 1; i >= offset; i--) { + key = (key << 2) | nucleotides[i]; + } + } + + void setHash(String species) { + key = 1; + for (int i = species.length() - 1; i >= 0; i--) { + key = (key << 2) | translate((byte) species.charAt(i)); + } + } + + @Override + public int hashCode() { + return (int) key; + } + + @Override + public boolean equals(Object obj) { + final Key other = (Key) obj; + + return key == other.key; + } + + @Override + public String toString() { + char[] name = new char[(63 - Long.numberOfLeadingZeros(key)) / 2]; + long temp = key; + + for (int i = 0; temp > 1; temp >>= 2, i++) { + name[i] = (char) (((temp & 3) << 1) | 'A'); + if (name[i] == 'E') { + name[i] = 'T'; + } + } + return new String(name); + } + } + + static class Value { + + int count; + } + // CHECKSTYLE.ON: .* + + public void reinitBuffers() { + MAP = new HashMap<Key, Value>(); + species = ">TH".getBytes(); + } + + public knucleotide() { + temp = new byte[LINE_LENGTH]; + buffer = new byte[125000000]; + stream = new ByteArrayInputStream(fastaStr.getBytes()); + in = new LineInputStream(stream); + } + + @Benchmark + public void jmhTimeKnucleotide() { + reinitBuffers(); + old_main(); + stream.reset(); + } + + private static final String fastaStr = ">ONE Homo sapiens alu\n" + + "GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA\n" + + "TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT\n" + + "AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG\n" + + "GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG\n" + + "CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT\n" + + "GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA\n" + + "GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA\n" + + "TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG\n" + + "AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA\n" + + "GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT\n" + + "AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC\n" + + "AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG\n" + + "GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC\n" + + "CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG\n" + + "AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT\n" + + "TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA\n" + + "TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT\n" + + "GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG\n" + + "TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT\n" + + "CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG\n" + + "CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG\n" + + "TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA\n" + + "CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG\n" + + "AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG\n" + + "GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC\n" + + "TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA\n" + + "TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA\n" + + "GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT\n" + + "GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC\n" + + "ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT\n" + + "TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC\n" + + "CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG\n" + + "CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG\n" + + "GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC\n" + + "CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT\n" + + "GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC\n" + + "GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA\n" + + "GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA\n" + + "GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA\n" + + "GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG\n" + + "AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT\n" + + "CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA\n" + + "GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA\n" + + "AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC\n" + + "GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT\n" + + "ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG\n" + + "GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC\n" + + "GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC\n" + + "GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG\n" + + "TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA\n" + + "AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG\n" + + "GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT\n" + + "CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC\n" + + "TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG\n" + + "ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC\n" + + "GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA\n" + + "ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA\n" + + "CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA\n" + + "CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA\n" + + "ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG\n" + + "CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG\n" + + "AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC\n" + + "CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG\n" + + "AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC\n" + + "CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG\n" + + "CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG\n" + + "CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG\n" + + "CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC\n" + + "ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA\n" + + "AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC\n" + + "TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC\n" + + "ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG\n" + + "CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG\n" + + "AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT\n" + + "AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA\n" + + "TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC\n" + + "CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA\n" + + "TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG\n" + + "CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT\n" + + "GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG\n" + + "GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG\n" + + "CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG\n" + + "GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG\n" + + "GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT\n" + + "AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT\n" + + "GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT\n" + + "CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG\n" + + "GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC\n" + + "TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT\n" + + "CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG\n" + + "ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG\n" + + "CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG\n" + + "AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA\n" + + "CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG\n" + + "CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC\n" + + "ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC\n" + + "GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC\n" + + "GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG\n" + + "GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT\n" + + "TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG\n" + + "CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA\n" + + "GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG\n" + + "CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC\n" + + "GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG\n" + + "CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA\n" + + "CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG\n" + + "CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA\n" + + "ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC\n" + + "CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT\n" + + "GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA\n" + + "AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG\n" + + "ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC\n" + + "TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA\n" + + "GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC\n" + + "GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG\n" + + "TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC\n" + + "AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA\n" + + "ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA\n" + + "GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC\n" + + "AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG\n" + + "TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC\n" + + "CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT\n" + + "GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC\n" + + "CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA\n" + + "GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT\n" + + "TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC\n" + + "ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC\n" + + "TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG\n" + + "GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG\n" + + "TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG\n" + + "GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC\n" + + "GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT\n" + + "ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC\n" + + "GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC\n" + + "GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC\n" + + "CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA\n" + + "ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG\n" + + "AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC\n" + + "TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT\n" + + "CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG\n" + + "TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG\n" + + "CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC\n" + + "GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT\n" + + "GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC\n" + + "CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC\n" + + "TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG\n" + + "CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG\n" + + "AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG\n" + + "AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG\n" + + "AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT\n" + + "GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA\n" + + "TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC\n" + + "AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA\n" + + "AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG\n" + + "CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC\n" + + "TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG\n" + + "GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT\n" + + "CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG\n" + + "CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG\n" + + "GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA\n" + + "AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA\n" + + "GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC\n" + + "TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC\n" + + "CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA\n" + + "GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG\n" + + "CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG\n" + + "AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG\n" + + "ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC\n" + + "ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC\n" + + "AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC\n" + + "GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG\n" + + "GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT\n" + + "CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC\n" + + "GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC\n" + + "CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA\n" + + "GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA\n" + + "GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG\n" + + "GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT\n" + + "CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA\n" + + "AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG\n" + + "CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC\n" + + "CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG\n" + + "GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG\n" + + "GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT\n" + + "TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA\n" + + "ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG\n" + + "CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA\n" + + "ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA\n" + + "GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG\n" + + "TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC\n" + + "GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA\n" + + "GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT\n" + + "GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT\n" + + "GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG\n" + + "TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT\n" + + "TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC\n" + + "TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC\n" + + "GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT\n" + + "CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC\n" + + "TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA\n" + + ">TWO IUB ambiguity codes\n" + + "cttBtatcatatgctaKggNcataaaSatgtaaaDcDRtBggDtctttataattcBgtcg\n" + + "tactDtDagcctatttSVHtHttKtgtHMaSattgWaHKHttttagacatWatgtRgaaa\n" + + "NtactMcSMtYtcMgRtacttctWBacgaaatatagScDtttgaagacacatagtVgYgt\n" + + "cattHWtMMWcStgttaggKtSgaYaaccWStcgBttgcgaMttBYatcWtgacaYcaga\n" + + "gtaBDtRacttttcWatMttDBcatWtatcttactaBgaYtcttgttttttttYaaScYa\n" + + "HgtgttNtSatcMtcVaaaStccRcctDaataataStcYtRDSaMtDttgttSagtRRca\n" + + "tttHatSttMtWgtcgtatSSagactYaaattcaMtWatttaSgYttaRgKaRtccactt\n" + + "tattRggaMcDaWaWagttttgacatgttctacaaaRaatataataaMttcgDacgaSSt\n" + + "acaStYRctVaNMtMgtaggcKatcttttattaaaaagVWaHKYagtttttatttaacct\n" + + "tacgtVtcVaattVMBcttaMtttaStgacttagattWWacVtgWYagWVRctDattBYt\n" + + "gtttaagaagattattgacVatMaacattVctgtBSgaVtgWWggaKHaatKWcBScSWa\n" + + "accRVacacaaactaccScattRatatKVtactatatttHttaagtttSKtRtacaaagt\n" + + "RDttcaaaaWgcacatWaDgtDKacgaacaattacaRNWaatHtttStgttattaaMtgt\n" + + "tgDcgtMgcatBtgcttcgcgaDWgagctgcgaggggVtaaScNatttacttaatgacag\n" + + "cccccacatYScaMgtaggtYaNgttctgaMaacNaMRaacaaacaKctacatagYWctg\n" + + "ttWaaataaaataRattagHacacaagcgKatacBttRttaagtatttccgatctHSaat\n" + + "actcNttMaagtattMtgRtgaMgcataatHcMtaBSaRattagttgatHtMttaaKagg\n" + + "YtaaBataSaVatactWtataVWgKgttaaaacagtgcgRatatacatVtHRtVYataSa\n" + + "KtWaStVcNKHKttactatccctcatgWHatWaRcttactaggatctataDtDHBttata\n" + + "aaaHgtacVtagaYttYaKcctattcttcttaataNDaaggaaaDYgcggctaaWSctBa\n" + + "aNtgctggMBaKctaMVKagBaactaWaDaMaccYVtNtaHtVWtKgRtcaaNtYaNacg\n" + + "gtttNattgVtttctgtBaWgtaattcaagtcaVWtactNggattctttaYtaaagccgc\n" + + "tcttagHVggaYtgtNcDaVagctctctKgacgtatagYcctRYHDtgBattDaaDgccK\n" + + "tcHaaStttMcctagtattgcRgWBaVatHaaaataYtgtttagMDMRtaataaggatMt\n" + + "ttctWgtNtgtgaaaaMaatatRtttMtDgHHtgtcattttcWattRSHcVagaagtacg\n" + + "ggtaKVattKYagactNaatgtttgKMMgYNtcccgSKttctaStatatNVataYHgtNa\n" + + "BKRgNacaactgatttcctttaNcgatttctctataScaHtataRagtcRVttacDSDtt\n" + + "aRtSatacHgtSKacYagttMHtWataggatgactNtatSaNctataVtttRNKtgRacc\n" + + "tttYtatgttactttttcctttaaacatacaHactMacacggtWataMtBVacRaSaatc\n" + + "cgtaBVttccagccBcttaRKtgtgcctttttRtgtcagcRttKtaaacKtaaatctcac\n" + + "aattgcaNtSBaaccgggttattaaBcKatDagttactcttcattVtttHaaggctKKga\n" + + "tacatcBggScagtVcacattttgaHaDSgHatRMaHWggtatatRgccDttcgtatcga\n" + + "aacaHtaagttaRatgaVacttagattVKtaaYttaaatcaNatccRttRRaMScNaaaD\n" + + "gttVHWgtcHaaHgacVaWtgttScactaagSgttatcttagggDtaccagWattWtRtg\n" + + "ttHWHacgattBtgVcaYatcggttgagKcWtKKcaVtgaYgWctgYggVctgtHgaNcV\n" + + "taBtWaaYatcDRaaRtSctgaHaYRttagatMatgcatttNattaDttaattgttctaa\n" + + "ccctcccctagaWBtttHtBccttagaVaatMcBHagaVcWcagBVttcBtaYMccagat\n" + + "gaaaaHctctaacgttagNWRtcggattNatcRaNHttcagtKttttgWatWttcSaNgg\n" + + "gaWtactKKMaacatKatacNattgctWtatctaVgagctatgtRaHtYcWcttagccaa\n" + + "tYttWttaWSSttaHcaaaaagVacVgtaVaRMgattaVcDactttcHHggHRtgNcctt\n" + + "tYatcatKgctcctctatVcaaaaKaaaagtatatctgMtWtaaaacaStttMtcgactt\n" + + "taSatcgDataaactaaacaagtaaVctaggaSccaatMVtaaSKNVattttgHccatca\n" + + "cBVctgcaVatVttRtactgtVcaattHgtaaattaaattttYtatattaaRSgYtgBag\n" + + "aHSBDgtagcacRHtYcBgtcacttacactaYcgctWtattgSHtSatcataaatataHt\n" + + "cgtYaaMNgBaatttaRgaMaatatttBtttaaaHHKaatctgatWatYaacttMctctt\n" + + "ttVctagctDaaagtaVaKaKRtaacBgtatccaaccactHHaagaagaaggaNaaatBW\n" + + "attccgStaMSaMatBttgcatgRSacgttVVtaaDMtcSgVatWcaSatcttttVatag\n" + + "ttactttacgatcaccNtaDVgSRcgVcgtgaacgaNtaNatatagtHtMgtHcMtagaa\n" + + "attBgtataRaaaacaYKgtRccYtatgaagtaataKgtaaMttgaaRVatgcagaKStc\n" + + "tHNaaatctBBtcttaYaBWHgtVtgacagcaRcataWctcaBcYacYgatDgtDHccta\n" + + "aagacYRcaggattHaYgtKtaatgcVcaataMYacccatatcacgWDBtgaatcBaata\n" + + "cKcttRaRtgatgaBDacggtaattaaYtataStgVHDtDctgactcaaatKtacaatgc\n" + + "gYatBtRaDatHaactgtttatatDttttaaaKVccYcaaccNcBcgHaaVcattHctcg\n" + + "attaaatBtatgcaaaaatYMctSactHatacgaWacattacMBgHttcgaatVaaaaca\n" + + "BatatVtctgaaaaWtctRacgBMaatSgRgtgtcgactatcRtattaScctaStagKga\n" + + "DcWgtYtDDWKRgRtHatRtggtcgaHgggcgtattaMgtcagccaBggWVcWctVaaat\n" + + "tcgNaatcKWagcNaHtgaaaSaaagctcYctttRVtaaaatNtataaccKtaRgtttaM\n" + + "tgtKaBtRtNaggaSattHatatWactcagtgtactaKctatttgRYYatKatgtccgtR\n" + + "tttttatttaatatVgKtttgtatgtNtataRatWYNgtRtHggtaaKaYtKSDcatcKg\n" + + "taaYatcSRctaVtSMWtVtRWHatttagataDtVggacagVcgKWagBgatBtaaagNc\n" + + "aRtagcataBggactaacacRctKgttaatcctHgDgttKHHagttgttaatgHBtatHc\n" + + "DaagtVaBaRccctVgtgDtacRHSctaagagcggWYaBtSaKtHBtaaactYacgNKBa\n" + + "VYgtaacttagtVttcttaatgtBtatMtMtttaattaatBWccatRtttcatagVgMMt\n" + + "agctStKctaMactacDNYgKYHgaWcgaHgagattacVgtttgtRaSttaWaVgataat\n" + + "gtgtYtaStattattMtNgWtgttKaccaatagNYttattcgtatHcWtctaaaNVYKKt\n" + + "tWtggcDtcgaagtNcagatacgcattaagaccWctgcagcttggNSgaNcHggatgtVt\n" + + "catNtRaaBNcHVagagaaBtaaSggDaatWaatRccaVgggStctDaacataKttKatt\n" + + "tggacYtattcSatcttagcaatgaVBMcttDattctYaaRgatgcattttNgVHtKcYR\n" + + "aatRKctgtaaacRatVSagctgtWacBtKVatctgttttKcgtctaaDcaagtatcSat\n" + + "aWVgcKKataWaYttcccSaatgaaaacccWgcRctWatNcWtBRttYaattataaNgac\n" + + "acaatagtttVNtataNaYtaatRaVWKtBatKagtaatataDaNaaaaataMtaagaaS\n" + + "tccBcaatNgaataWtHaNactgtcDtRcYaaVaaaaaDgtttRatctatgHtgttKtga\n" + + "aNSgatactttcgagWaaatctKaaDaRttgtggKKagcDgataaattgSaacWaVtaNM\n" + + "acKtcaDaaatttctRaaVcagNacaScRBatatctRatcctaNatWgRtcDcSaWSgtt\n" + + "RtKaRtMtKaatgttBHcYaaBtgatSgaSWaScMgatNtctcctatttctYtatMatMt\n" + + "RRtSaattaMtagaaaaStcgVgRttSVaScagtgDtttatcatcatacRcatatDctta\n" + + "tcatVRtttataaHtattcYtcaaaatactttgVctagtaaYttagatagtSYacKaaac\n" + + "gaaKtaaatagataatSatatgaaatSgKtaatVtttatcctgKHaatHattagaaccgt\n" + + "YaaHactRcggSBNgtgctaaBagBttgtRttaaattYtVRaaaattgtaatVatttctc\n" + + "ttcatgBcVgtgKgaHaaatattYatagWacNctgaaMcgaattStagWaSgtaaKagtt\n" + + "ttaagaDgatKcctgtaHtcatggKttVDatcaaggtYcgccagNgtgcVttttagagat\n" + + "gctaccacggggtNttttaSHaNtatNcctcatSaaVgtactgBHtagcaYggYVKNgta\n" + + "KBcRttgaWatgaatVtagtcgattYgatgtaatttacDacSctgctaaaStttaWMagD\n" + + "aaatcaVYctccgggcgaVtaaWtStaKMgDtttcaaMtVgBaatccagNaaatcYRMBg\n" + + "gttWtaaScKttMWtYataRaDBMaDataatHBcacDaaKDactaMgagttDattaHatH\n" + + "taYatDtattDcRNStgaatattSDttggtattaaNSYacttcDMgYgBatWtaMagact\n" + + "VWttctttgYMaYaacRgHWaattgRtaagcattctMKVStatactacHVtatgatcBtV\n" + + "NataaBttYtSttacKgggWgYDtgaVtYgatDaacattYgatggtRDaVDttNactaSa\n" + + "MtgNttaacaaSaBStcDctaccacagacgcaHatMataWKYtaYattMcaMtgSttDag\n" + + "cHacgatcaHttYaKHggagttccgatYcaatgatRaVRcaagatcagtatggScctata\n" + + "ttaNtagcgacgtgKaaWaactSgagtMYtcttccaKtStaacggMtaagNttattatcg\n" + + "tctaRcactctctDtaacWYtgaYaSaagaWtNtatttRacatgNaatgttattgWDDcN\n" + + "aHcctgaaHacSgaataaRaataMHttatMtgaSDSKatatHHaNtacagtccaYatWtc\n" + + "actaactatKDacSaStcggataHgYatagKtaatKagStaNgtatactatggRHacttg\n" + + "tattatgtDVagDVaRctacMYattDgtttYgtctatggtKaRSttRccRtaaccttaga\n" + + "gRatagSaaMaacgcaNtatgaaatcaRaagataatagatactcHaaYKBctccaagaRa\n" + + "BaStNagataggcgaatgaMtagaatgtcaKttaaatgtaWcaBttaatRcggtgNcaca\n" + + "aKtttScRtWtgcatagtttWYaagBttDKgcctttatMggNttattBtctagVtacata\n" + + "aaYttacacaaRttcYtWttgHcaYYtaMgBaBatctNgcDtNttacgacDcgataaSat\n" + + "YaSttWtcctatKaatgcagHaVaacgctgcatDtgttaSataaaaYSNttatagtaNYt\n" + + "aDaaaNtggggacttaBggcHgcgtNtaaMcctggtVtaKcgNacNtatVaSWctWtgaW\n" + + "cggNaBagctctgaYataMgaagatBSttctatacttgtgtKtaattttRagtDtacata\n" + + "tatatgatNHVgBMtKtaKaNttDHaagatactHaccHtcatttaaagttVaMcNgHata\n" + + "tKtaNtgYMccttatcaaNagctggacStttcNtggcaVtattactHaSttatgNMVatt\n" + + "MMDtMactattattgWMSgtHBttStStgatatRaDaagattttctatMtaaaaaggtac\n" + + "taaVttaSacNaatactgMttgacHaHRttgMacaaaatagttaatatWKRgacDgaRta\n" + + "tatttattatcYttaWtgtBRtWatgHaaattHataagtVaDtWaVaWtgStcgtMSgaS\n" + + "RgMKtaaataVacataatgtaSaatttagtcgaaHtaKaatgcacatcggRaggSKctDc\n" + + "agtcSttcccStYtccRtctctYtcaaKcgagtaMttttcRaYDttgttatctaatcata\n" + + "NctctgctatcaMatactataggDaHaaSttMtaDtcNatataattctMcStaaBYtaNa\n" + + "gatgtaatHagagSttgWHVcttatKaYgDctcttggtgttMcRaVgSgggtagacaata\n" + + "aDtaattSaDaNaHaBctattgNtaccaaRgaVtKNtaaYggHtaKKgHcatctWtctDt\n" + + "ttctttggSDtNtaStagttataaacaattgcaBaBWggHgcaaaBtYgctaatgaaatW\n" + + "cDcttHtcMtWWattBHatcatcaaatctKMagtDNatttWaBtHaaaNgMttaaStagt\n" + + "tctctaatDtcRVaYttgttMtRtgtcaSaaYVgSWDRtaatagctcagDgcWWaaaBaa\n" + + "RaBctgVgggNgDWStNaNBKcBctaaKtttDcttBaaggBttgaccatgaaaNgttttt\n" + + "tttatctatgttataccaaDRaaSagtaVtDtcaWatBtacattaWacttaSgtattggD\n" + + "gKaaatScaattacgWcagKHaaccaYcRcaRttaDttRtttHgaHVggcttBaRgtccc\n" + + "tDatKaVtKtcRgYtaKttacgtatBtStaagcaattaagaRgBagSaattccSWYttta\n" + + "ttVaataNctgHgttaaNBgcVYgtRtcccagWNaaaacaDNaBcaaaaRVtcWMgBagM\n" + + "tttattacgDacttBtactatcattggaaatVccggttRttcatagttVYcatYaSHaHc\n" + + "ttaaagcNWaHataaaRWtctVtRYtagHtaaaYMataHYtNBctNtKaatattStgaMc\n" + + "BtRgctaKtgcScSttDgYatcVtggaaKtaagatWccHccgKYctaNNctacaWctttt\n" + + "gcRtgtVcgaKttcMRHgctaHtVaataaDtatgKDcttatBtDttggNtacttttMtga\n" + + "acRattaaNagaactcaaaBBVtcDtcgaStaDctgaaaSgttMaDtcgttcaccaaaag\n" + + "gWtcKcgSMtcDtatgtttStaaBtatagDcatYatWtaaaBacaKgcaDatgRggaaYc\n" + + "taRtccagattDaWtttggacBaVcHtHtaacDacYgtaatataMagaatgHMatcttat\n" + + "acgtatttttatattacHactgttataMgStYaattYaccaattgagtcaaattaYtgta\n" + + "tcatgMcaDcgggtcttDtKgcatgWRtataatatRacacNRBttcHtBgcRttgtgcgt\n" + + "catacMtttBctatctBaatcattMttMYgattaaVYatgDaatVagtattDacaacDMa\n" + + "tcMtHcccataagatgBggaccattVWtRtSacatgctcaaggggYtttDtaaNgNtaaB\n" + + "atggaatgtctRtaBgBtcNYatatNRtagaacMgagSaSDDSaDcctRagtVWSHtVSR\n" + + "ggaacaBVaccgtttaStagaacaMtactccagtttVctaaRaaHttNcttagcaattta\n" + + "ttaatRtaaaatctaacDaBttggSagagctacHtaaRWgattcaaBtctRtSHaNtgta\n" + + "cattVcaHaNaagtataccacaWtaRtaaVKgMYaWgttaKggKMtKcgWatcaDatYtK\n" + + "SttgtacgaccNctSaattcDcatcttcaaaDKttacHtggttHggRRaRcaWacaMtBW\n" + + "VHSHgaaMcKattgtaRWttScNattBBatYtaNRgcggaagacHSaattRtttcYgacc\n" + + "BRccMacccKgatgaacttcgDgHcaaaaaRtatatDtatYVtttttHgSHaSaatagct\n" + + "NYtaHYaVYttattNtttgaaaYtaKttWtctaNtgagaaaNctNDctaaHgttagDcRt\n" + + "tatagccBaacgcaRBtRctRtggtaMYYttWtgataatcgaataattattataVaaaaa\n" + + "ttacNRVYcaaMacNatRttcKatMctgaagactaattataaYgcKcaSYaatMNctcaa\n" + + "cgtgatttttBacNtgatDccaattattKWWcattttatatatgatBcDtaaaagttgaa\n" + + "VtaHtaHHtBtataRBgtgDtaataMttRtDgDcttattNtggtctatctaaBcatctaR\n" + + "atgNacWtaatgaagtcMNaacNgHttatactaWgcNtaStaRgttaaHacccgaYStac\n" + + "aaaatWggaYaWgaattattcMaactcBKaaaRVNcaNRDcYcgaBctKaacaaaaaSgc\n" + + "tccYBBHYaVagaatagaaaacagYtctVccaMtcgtttVatcaatttDRtgWctagtac\n" + + "RttMctgtDctttcKtWttttataaatgVttgBKtgtKWDaWagMtaaagaaattDVtag\n" + + "gttacatcatttatgtcgMHaVcttaBtVRtcgtaYgBRHatttHgaBcKaYWaatcNSc\n" + + "tagtaaaaatttacaatcactSWacgtaatgKttWattagttttNaggtctcaagtcact\n" + + "attcttctaagKggaataMgtttcataagataaaaatagattatDgcBVHWgaBKttDgc\n" + + "atRHaagcaYcRaattattatgtMatatattgHDtcaDtcaaaHctStattaatHaccga\n" + + "cNattgatatattttgtgtDtRatagSacaMtcRtcattcccgacacSattgttKaWatt\n" + + "NHcaacttccgtttSRtgtctgDcgctcaaMagVtBctBMcMcWtgtaacgactctcttR\n" + + "ggRKSttgYtYatDccagttDgaKccacgVatWcataVaaagaataMgtgataaKYaaat\n" + + "cHDaacgataYctRtcYatcgcaMgtNttaBttttgatttaRtStgcaacaaaataccVg\n" + + "aaDgtVgDcStctatatttattaaaaRKDatagaaagaKaaYYcaYSgKStctccSttac\n" + + "agtcNactttDVttagaaagMHttRaNcSaRaMgBttattggtttaRMggatggcKDgWR\n" + + "tNaataataWKKacttcKWaaagNaBttaBatMHtccattaacttccccYtcBcYRtaga\n" + + "ttaagctaaYBDttaNtgaaaccHcaRMtKtaaHMcNBttaNaNcVcgVttWNtDaBatg\n" + + "ataaVtcWKcttRggWatcattgaRagHgaattNtatttctctattaattaatgaDaaMa\n" + + "tacgttgggcHaYVaaNaDDttHtcaaHtcVVDgBVagcMacgtgttaaBRNtatRtcag\n" + + "taagaggtttaagacaVaaggttaWatctccgtVtaDtcDatttccVatgtacNtttccg\n" + + "tHttatKgScBatgtVgHtYcWagcaKtaMYaaHgtaattaSaHcgcagtWNaatNccNN\n" + + "YcacgVaagaRacttctcattcccRtgtgtaattagcSttaaStWaMtctNNcSMacatt\n" + + "ataaactaDgtatWgtagtttaagaaaattgtagtNagtcaataaatttgatMMYactaa\n" + + "tatcggBWDtVcYttcDHtVttatacYaRgaMaacaStaatcRttttVtagaDtcacWat\n" + + "ttWtgaaaagaaagNRacDtttStVatBaDNtaactatatcBSMcccaSttccggaMatg\n" + + "attaaWatKMaBaBatttgataNctgttKtVaagtcagScgaaaDggaWgtgttttKtWt\n" + + "atttHaatgtagttcactaaKMagttSYBtKtaYgaactcagagRtatagtVtatcaaaW\n" + + "YagcgNtaDagtacNSaaYDgatBgtcgataacYDtaaactacagWDcYKaagtttatta\n" + + "gcatcgagttKcatDaattgattatDtcagRtWSKtcgNtMaaaaacaMttKcaWcaaSV\n" + + "MaaaccagMVtaMaDtMaHaBgaacataBBVtaatVYaNSWcSgNtDNaaKacacBttta\n" + + "tKtgtttcaaHaMctcagtaacgtcgYtactDcgcctaNgagagcYgatattttaaattt\n" + + "ccattttacatttDaaRctattttWctttacgtDatYtttcagacgcaaVttagtaaKaa\n" + + "aRtgVtccataBggacttatttgtttaWNtgttVWtaWNVDaattgtatttBaagcBtaa\n" + + "BttaaVatcHcaVgacattccNggtcgacKttaaaRtagRtctWagaYggtgMtataatM\n" + + "tgaaRttattttgWcttNtDRRgMDKacagaaaaggaaaRStcccagtYccVattaNaaK\n" + + "StNWtgacaVtagaagcttSaaDtcacaacgDYacWDYtgtttKatcVtgcMaDaSKStV\n" + + "cgtagaaWaKaagtttcHaHgMgMtctataagBtKaaaKKcactggagRRttaagaBaaN\n" + + "atVVcgRcKSttDaactagtSttSattgttgaaRYatggttVttaataaHttccaagDtg\n" + + "atNWtaagHtgcYtaactRgcaatgMgtgtRaatRaNaacHKtagactactggaatttcg\n" + + "ccataacgMctRgatgttaccctaHgtgWaYcactcacYaattcttaBtgacttaaacct\n" + + "gYgaWatgBttcttVttcgttWttMcNYgtaaaatctYgMgaaattacNgaHgaacDVVM\n" + + "tttggtHtctaaRgtacagacgHtVtaBMNBgattagcttaRcttacaHcRctgttcaaD\n" + + "BggttKaacatgKtttYataVaNattccgMcgcgtagtRaVVaattaKaatggttRgaMc\n" + + "agtatcWBttNtHagctaatctagaaNaaacaYBctatcgcVctBtgcaaagDgttVtga\n" + + "HtactSNYtaaNccatgtgDacgaVtDcgKaRtacDcttgctaagggcagMDagggtBWR\n" + + "tttSgccttttttaacgtcHctaVtVDtagatcaNMaVtcVacatHctDWNaataRgcgt\n" + + "aVHaggtaaaaSgtttMtattDgBtctgatSgtRagagYtctSaKWaataMgattRKtaa\n" + + "catttYcgtaacacattRWtBtcggtaaatMtaaacBatttctKagtcDtttgcBtKYYB\n" + + "aKttctVttgttaDtgattttcttccacttgSaaacggaaaNDaattcYNNaWcgaaYat\n" + + "tttMgcBtcatRtgtaaagatgaWtgaccaYBHgaatagataVVtHtttVgYBtMctaMt\n" + + "cctgaDcYttgtccaaaRNtacagcMctKaaaggatttacatgtttaaWSaYaKttBtag\n" + + "DacactagctMtttNaKtctttcNcSattNacttggaacaatDagtattRtgSHaataat\n" + + "gccVgacccgatactatccctgtRctttgagaSgatcatatcgDcagWaaHSgctYYWta\n" + + "tHttggttctttatVattatcgactaagtgtagcatVgtgHMtttgtttcgttaKattcM\n" + + "atttgtttWcaaStNatgtHcaaaDtaagBaKBtRgaBgDtSagtatMtaacYaatYtVc\n" + + "KatgtgcaacVaaaatactKcRgtaYtgtNgBBNcKtcttaccttKgaRaYcaNKtactt\n" + + "tgagSBtgtRagaNgcaaaNcacagtVtttHWatgttaNatBgtttaatNgVtctgaata\n" + + "tcaRtattcttttttttRaaKcRStctcggDgKagattaMaaaKtcaHacttaataataK\n" + + "taRgDtKVBttttcgtKaggHHcatgttagHggttNctcgtatKKagVagRaaaggaaBt\n" + + "NatttVKcRttaHctaHtcaaatgtaggHccaBataNaNaggttgcWaatctgatYcaaa\n" + + "HaatWtaVgaaBttagtaagaKKtaaaKtRHatMaDBtBctagcatWtatttgWttVaaa\n" + + "ScMNattRactttgtYtttaaaagtaagtMtaMaSttMBtatgaBtttaKtgaatgagYg\n" + + "tNNacMtcNRacMMHcttWtgtRtctttaacaacattattcYaMagBaacYttMatcttK\n" + + "cRMtgMNccattaRttNatHaHNaSaaHMacacaVaatacaKaSttHatattMtVatWga\n" + + "ttttttaYctttKttHgScWaacgHtttcaVaaMgaacagNatcgttaacaaaaagtaca\n" + + "HBNaattgttKtcttVttaaBtctgctacgBgcWtttcaggacacatMgacatcccagcg\n" + + "gMgaVKaBattgacttaatgacacacaaaaaatRKaaBctacgtRaDcgtagcVBaacDS\n" + + "BHaaaaSacatatacagacRNatcttNaaVtaaaataHattagtaaaaSWccgtatWatg\n" + + "gDttaactattgcccatcttHaSgYataBttBaactattBtcHtgatcaataSttaBtat\n" + + "KSHYttWggtcYtttBttaataccRgVatStaHaKagaatNtagRMNgtcttYaaSaact\n" + + "cagDSgagaaYtMttDtMRVgWKWtgMaKtKaDttttgactatacataatcNtatNaHat\n" + + "tVagacgYgatatatttttgtStWaaatctWaMgagaRttRatacgStgattcttaagaD\n" + + "taWccaaatRcagcagaaNKagtaaDggcgccBtYtagSBMtactaaataMataBSacRM\n" + + "gDgattMMgtcHtcaYDtRaDaacggttDaggcMtttatgttaNctaattaVacgaaMMt\n" + + "aatDccSgtattgaRtWWaccaccgagtactMcgVNgctDctaMScatagcgtcaactat\n" + + "acRacgHRttgctatttaatgaattataYKttgtaagWgtYttgcHgMtaMattWaWVta\n" + + "RgcttgYgttBHtYataSccStBtgtagMgtDtggcVaaSBaatagDttgBgtctttctc\n" + + "attttaNagtHKtaMWcYactVcgcgtatMVtttRacVagDaatcttgctBBcRDgcaac\n" + + "KttgatSKtYtagBMagaRtcgBattHcBWcaactgatttaatttWDccatttatcgagS\n" + + "KaWttataHactaHMttaatHtggaHtHagaatgtKtaaRactgtttMatacgatcaagD\n" + + "gatKaDctataMggtHDtggHacctttRtatcttYattttgacttgaaSaataaatYcgB\n" + + "aaaaccgNatVBttMacHaKaataagtatKgtcaagactcttaHttcggaattgttDtct\n" + + "aaccHttttWaaatgaaatataaaWattccYDtKtaaaacggtgaggWVtctattagtga\n" + + "ctattaagtMgtttaagcatttgSgaaatatccHaaggMaaaattttcWtatKctagDtY\n" + + "tMcctagagHcactttactatacaaacattaacttaHatcVMYattYgVgtMttaaRtga\n" + + "aataaDatcaHgtHHatKcDYaatcttMtNcgatYatgSaMaNtcttKcWataScKggta\n" + + "tcttacgcttWaaagNatgMgHtctttNtaacVtgttcMaaRatccggggactcMtttaY\n" + + "MtcWRgNctgNccKatcttgYDcMgattNYaRagatHaaHgKctcataRDttacatBatc\n" + + "cattgDWttatttaWgtcggagaaaaatacaatacSNtgggtttccttacSMaagBatta\n" + + "caMaNcactMttatgaRBacYcYtcaaaWtagctSaacttWgDMHgaggatgBVgcHaDt\n" + + "ggaactttggtcNatNgtaKaBcccaNtaagttBaacagtatacDYttcctNgWgcgSMc\n" + + "acatStctHatgRcNcgtacacaatRttMggaNKKggataaaSaYcMVcMgtaMaHtgat\n" + + "tYMatYcggtcttcctHtcDccgtgRatcattgcgccgatatMaaYaataaYSggatagc\n" + + "gcBtNtaaaScaKgttBgagVagttaKagagtatVaactaSacWactSaKatWccaKaaa\n" + + "atBKgaaKtDMattttgtaaatcRctMatcaaMagMttDgVatggMaaWgttcgaWatga\n" + + "aatttgRtYtattaWHKcRgctacatKttctaccaaHttRatctaYattaaWatVNccat\n" + + "NgagtcKttKataStRaatatattcctRWatDctVagttYDgSBaatYgttttgtVaatt\n" + + "taatagcagMatRaacttBctattgtMagagattaaactaMatVtHtaaatctRgaaaaa\n" + + "aaatttWacaacaYccYDSaattMatgaccKtaBKWBattgtcaagcHKaagttMMtaat\n" + + "ttcKcMagNaaKagattggMagaggtaatttYacatcWaaDgatMgKHacMacgcVaaca\n" + + "DtaDatatYggttBcgtatgWgaSatttgtagaHYRVacaRtctHaaRtatgaactaata\n" + + "tctSSBgggaaHMWtcaagatKgagtDaSatagttgattVRatNtctMtcSaagaSHaat\n" + + "aNataataRaaRgattctttaataaagWaRHcYgcatgtWRcttgaaggaMcaataBRaa\n" + + "ccagStaaacNtttcaatataYtaatatgHaDgcStcWttaacctaRgtYaRtataKtgM\n" + + "ttttatgactaaaatttacYatcccRWtttHRtattaaatgtttatatttgttYaatMca\n" + + "RcSVaaDatcgtaYMcatgtagacatgaaattgRtcaaYaaYtRBatKacttataccaNa\n" + + "aattVaBtctggacaagKaaYaaatatWtMtatcYaaVNtcgHaactBaagKcHgtctac\n" + + "aatWtaDtSgtaHcataHtactgataNctRgttMtDcDttatHtcgtacatcccaggStt\n" + + "aBgtcacacWtccNMcNatMVaVgtccDYStatMaccDatggYaRKaaagataRatttHK\n" + + "tSaaatDgataaacttaHgttgVBtcttVttHgDacgaKatgtatatNYataactctSat\n" + + "atatattgcHRRYttStggaactHgttttYtttaWtatMcttttctatctDtagVHYgMR\n" + + "BgtHttcctaatYRttKtaagatggaVRataKDctaMtKBNtMtHNtWtttYcVtattMc\n" + + "gRaacMcctNSctcatttaaagDcaHtYccSgatgcaatYaaaaDcttcgtaWtaattct\n" + + "cgttttScttggtaatctttYgtctaactKataHacctMctcttacHtKataacacagcN\n" + + "RatgKatttttSaaatRYcgDttaMRcgaaattactMtgcgtaagcgttatBtttttaat\n" + + "taagtNacatHgttcRgacKcBBtVgatKttcgaBaatactDRgtRtgaNacWtcacYtt\n" + + "aaKcgttctHaKttaNaMgWgWaggtctRgaKgWttSttBtDcNtgtttacaaatYcDRt\n" + + "gVtgcctattcNtctaaaDMNttttNtggctgagaVctDaacVtWccaagtaacacaNct\n" + + "gaScattccDHcVBatcgatgtMtaatBgHaatDctMYgagaatgYWKcctaatNaStHa\n" + + "aaKccgHgcgtYaaYtattgtStgtgcaaRtattaKatattagaWVtcaMtBagttatta\n" + + "gNaWHcVgcaattttDcMtgtaRHVYtHtctgtaaaaHVtMKacatcgNaatttMatatg\n" + + "ttgttactagWYtaRacgataKagYNKcattataNaRtgaacKaYgcaaYYacaNccHat\n" + + "MatDcNgtHttRaWttagaaDcaaaaaatagggtKDtStaDaRtaVtHWKNtgtattVct\n" + + "SVgRgataDaRaWataBgaagaaKtaataaYgDcaStaNgtaDaaggtattHaRaWMYaY\n" + + "aWtggttHYgagVtgtgcttttcaaDKcagVcgttagacNaaWtagtaataDttctggtt\n" + + "VcatcataaagtgKaaaNaMtaBBaattaatWaattgctHaVKaSgDaaVKaHtatatat\n" + + "HatcatSBagNgHtatcHYMHgttDgtaHtBttWatcgtttaRaattgStKgSKNWKatc\n" + + "agDtctcagatttctRtYtBatBgHHtKaWtgYBgacVVWaKtacKcDttKMaKaVcggt\n" + + "gttataagaataaHaatattagtataatMHgttYgaRttagtaRtcaaVatacggtcMcg\n" + + "agtaaRttacWgactKRYataaaagSattYaWgagatYagKagatgSaagKgttaatMgg\n" + + "tataatgttWYttatgagaaacctNVataatHcccKtDctcctaatactggctHggaSag\n" + + "gRtKHaWaattcgSatMatttagaggcYtctaMcgctcataSatatgRagacNaaDagga\n" + + "VBagaYttKtacNaKgtSYtagttggaWcatcWttaatctatgaVtcgtgtMtatcaYcg\n" + + "tRccaaYgDctgcMgtgtWgacWtgataacacgcgctBtgttaKtYDtatDcatcagKaV\n" + + "MctaatcttgVcaaRgcRMtDcgattaHttcaNatgaatMtactacVgtRgatggaWttt\n" + + "actaaKatgagSaaKggtaNtactVaYtaaKRagaacccacaMtaaMtKtatBcttgtaa\n" + + "WBtMctaataaVcDaaYtcRHBtcgttNtaaHatttBNgRStVDattBatVtaagttaYa\n" + + "tVattaagaBcacggtSgtVtatttaRattgatgtaHDKgcaatattKtggcctatgaWD\n" + + "KRYcggattgRctatNgatacaatMNttctgtcRBYRaaaHctNYattcHtaWcaattct\n" + + "BtMKtVgYataatMgYtcagcttMDataVtggRtKtgaatgccNcRttcaMtRgattaac\n" + + "attRcagcctHtWMtgtDRagaKaBtgDttYaaaaKatKgatctVaaYaacWcgcatagB\n" + + "VtaNtRtYRaggBaaBtgKgttacataagagcatgtRattccacttaccatRaaatgWgD\n" + + "aMHaYVgVtaSctatcgKaatatattaDgacccYagtgtaYNaaatKcagtBRgagtcca\n" + + "tgKgaaaccBgaagBtgSttWtacgatWHaYatcgatttRaaNRgcaNaKVacaNtDgat\n" + + "tgHVaatcDaagcgtatgcNttaDataatcSataaKcaataaHWataBtttatBtcaKtK\n" + + "tatagttaDgSaYctacaRatNtaWctSaatatttYaKaKtaccWtatcRagacttaYtt\n" + + "VcKgSDcgagaagatccHtaattctSttatggtKYgtMaHagVaBRatttctgtRgtcta\n" + + "tgggtaHKgtHacHtSYacgtacacHatacKaaBaVaccaDtatcSaataaHaagagaat\n" + + "ScagactataaRttagcaaVcaHataKgDacatWccccaagcaBgagWatctaYttgaaa\n" + + "tctVNcYtttWagHcgcgcDcVaaatgttKcHtNtcaatagtgtNRaactttttcaatgg\n" + + "WgBcgDtgVgtttctacMtaaataaaRggaaacWaHttaRtNtgctaaRRtVBctYtVta\n" + + "tDcattDtgaccYatagatYRKatNYKttNgcctagtaWtgaactaMVaacctgaStttc\n" + + "tgaKVtaaVaRKDttVtVctaDNtataaaDtccccaagtWtcgatcactDgYaBcatcct\n" + + "MtVtacDaaBtYtMaKNatNtcaNacgDatYcatcgcaRatWBgaacWttKttagYtaat\n" + + "tcggttgSWttttDWctttacYtatatWtcatDtMgtBttgRtVDggttaacYtacgtac\n" + + "atgaattgaaWcttMStaDgtatattgaDtcRBcattSgaaVBRgagccaaKtttcDgcg\n" + + "aSMtatgWattaKttWtgDBMaggBBttBaatWttRtgcNtHcgttttHtKtcWtagHSt\n" + + "aacagttgatatBtaWSaWggtaataaMttaKacDaatactcBttcaatatHttcBaaSa\n" + + ">THREE Homo sapiens frequency\n" + + "aagtccgatgagtttcaatcatgactgcgaggagatccatgcggtgtacctaaacctaca\n" + + "tcgtatgtatttgctgacgttcattcttgatacataaagatccgatatcggtccactttg\n" + + "tttaccaaaagccctaccttcgtaacgatggaaatgtgaatgagagtgaaatacacgatg\n" + + "gggatattgccggtgagtacaagttagaccacacattagaactgacctatattcgtcatc\n" + + "atagagatggagtatgaattgattctgcgaagtacactggctttacgagtatctagacgc\n" + + "cgcggtatatctcccgtcaatactatgaaggtatatatatagaggctgaaaattcatgtt\n" + + "caatcctctttctaagagtgagtgggagccccttctgttgtcggagtaaaaaggcattat\n" + + "tcctcaaattgtcagaagcaaagtatacgtgatgtttgcttagaacaaaagagttacctt\n" + + "agggtaggtaaatctcgattcaccgagagaagtgattttggcggtgtgcgattaattctt\n" + + "ttgatgacagatctcattattttatatagctccctctttgtatttagagtttgcgtaggt\n" + + "aacctggcaaaaccatatcccggggggagagtgcgctgaacattttatacgatgtgatta\n" + + "ctcaaaggataaggttcgaggcctctatactcatggaactatcttataattataatggat\n" + + "cgtggctcattccacctatccaaacttctttgtgatctgatgctacgagtgtgaacaaac\n" + + "gtacatcttctaaggaatttgggacgtttcatagctcgcatttcattcctgaaaacttaa\n" + + "atatttttaaaaattgattctactgcgaggaactaaggtgtagacaagcccttagtaacc\n" + + "ggtggatgtcgcttcagttttatagcaaacattattcaatttcagtcttgactgaaatta\n" + + "gtttgttagtgttagaggtccatatgtcacatgcatatggtctagatgccattgtacagt\n" + + "aataccttagattagtattagcggcatgcgtacttggatttcacttgtaagaatgagctt\n" + + "aggacggtcgcctgtagggctgcaaataggaatacttacaatttttgatgacttgttagc\n" + + "atatcgctatcacccataaaaaacctgatacttgatgagcgggtgattgagactatgtac\n" + + "tgatataattcaatagctccaatagatgaaacagctatgcgcctatttatgtcaaataat\n" + + "cgatgtgatacaagcttagagctgaacgagcgcgagtggaattagcggtgatctctatcc\n" + + "taaaaagccacgaaatcgatcccagaagctaatacccgaggtgtcaagcttgagttcagt\n" + + "taaatttgcatctcatgccccacgaagaatgggtagagagtttgaaggtgcttctggatt\n" + + "ttcctaagtacgtggtaaaaatttgatgtaaatgaacacctcctaatggttgtgttaacc\n" + + "acaaacccctgggtgaatctgattagccaacccagtgatctgatttcagttgtcaaatct\n" + + "cttttttataactaccttttgtttccataatttaaccggatctcataatgaacaaacggg\n" + + "tagaataatggtagcacatagcgagcttgtctattcagaaatatggcctactcagaatgt\n" + + "attctccaaatcagtgttatgcgaaacgtaattttacgtgtaataatgatgatttcttat\n" + + "cggttccttgtactacaatactcttgcccaacaaatactaagcataacagcaaaattcga\n" + + "atccccctccttttaataaatggtttttcaatatagccgattcgtattcgttagtctttc\n" + + "accaactattaacctggcatctaattaataaaatcaccaaaggactctataatatgacag\n" + + "tcacttcggcctcttttaagacagttgattattgcaggtccgcaattgatggtgacatgc\n" + + "acaattagttagaatccgactatggagacaattaacaattgtagtgcccatttggtccag\n" + + "ttgacttcaaccacgagttataaaggtattttaatttatagtcgatagtaccaacaacaa\n" + + "gcacaatcataattatgttagaaaacccagggggtaatgctctaaatccagctttaaggc\n" + + "cagagtgcactatgaaatcgccattgatcattgtgtcattcgctgaacttggtgtctagg\n" + + "aggtgccgagtgagaatatcagataccttatgaagcaacgattatatctggactagatca\n" + + "tgatgatcggaataaaacattgaaataagtccttatcaaggagcataaacattttattta\n" + + "atttatacttcgtaaataaattcagaattttttttcaagacattaatctgagtaaatgac\n" + + "ggctagaaagggttcctactcgaatcgtagcctacgcatgtgggcagtaacctggcttgc\n" + + "gtttttactgaaacaaaggttcaccggaaagaaggctgccacttttagcttcttgacgat\n" + + "ctttagcgtcatatttttagattagtcgaaaaacggaaaacaaacttaacgaagctggtt\n" + + "gcacggggtaccgagaaaccaaagagcaggacaactccttgatcgggaagaactgaaata\n" + + "gacagctgtcattttcattggtcaacttatcaatataacgaccaccgtagtgacgcttgc\n" + + "atgaaaatactgaggatgtaaactatagccagtcaggcccgcgtgttgactaattgatga\n" + + "agcaaacaaaatagccggtattcgttaaaaggaacgggttgccagctacagatatactct\n" + + "aggtatatcccaaacaagagacgtcctttggctgttgtaatcggtcataatacttgtcac\n" + + "ataaacaagatcgctgaattaaacattaaacagttagtgatacacaatcgtggttggggc\n" + + "tgggatgtgcaataaaaagtcatctatcgtctatcacagagcgacgtaaatttagacaaa\n" + + "cattattatttcttgacaatggaatcgataagcgttcctctaacttggtatatatatctc\n" + + "gaccccgggattccagccattcttgtatgaagatttaaccatttaactatgcatagttga\n" + + "atggtaaggaaaatgatattgactgcaacagattttggatgcaaaaatatttgtgaatta\n" + + "ttggttatatactggttgtatagcacaatcattaggtcctagaaggcatactcaacctca\n" + + "gcgagagagctagcatgcataattgtaccgcccatattaatattcctgaaatgatttctt\n" + + "acattacgcccaatttcagtcatcgaacacccccatcaatttacccgatagagaacgtga\n" + + "tcatacgcaataccctatgcgaacgtccactctatagcgtctgtatacaatgattattcg\n" + + "ttccatttacaacgttaagtaatttaaacttacataaggacaaggaaatccgcgaacctc\n" + + "ctggaatgtatgagttatttatgcagttaacttcgtctcgaccggaactaaaggcgtcgt\n" + + "acgaatgaaaggccacttttagaagagacctttgtatccattgtggagaatatcataaat\n" + + "tcaagatggggtgtcatgctattcggtcctaaacattcttaatggctgttctattgttag\n" + + "tctgatttaaaatggaaccatagcacgaatagttagatagggctcatacccctgtaacga\n" + + "tctacaaatccttccccgggtgtgtgcgttagcgacggaaagttttacggtttgtgatca\n" + + "aagaacactcacacgtcagattattacactgatacgaattatttcagtcgacagtaattg\n" + + "aatagaaacttattaacgccagcacctgacacggtaagtaaggcaggtctgaactgtttg\n" + + "actgtaaaaaaatggtaatatttttaaaaatcttgatttctatatcaaatgatgtgtagt\n" + + "tttttctctgttattaaaatcccagtgcgcgaaatttagatcgttacgactcacgtacaa\n" + + "gatcacacatcacacgcgttagcgaaagcggaatggctaatacagccctacgcaacgtag\n" + + "tgggatcaacatatggacgaatttatgctcaatgagccaacctcccccgcattgcggttc\n" + + "attttaaggcctgggtaacatctatcgtttagataatcaaaggaatccgactatgcaatt\n" + + "gtctgacttcatccgctctcaagtccaatgcaggcgctacgtgtttctttaatcaatacc\n" + + "atattgaaatcgtaatacgataattgttgctattgactacaggttatgaaaaaacttact\n" + + "ttgcgggtacatgcatatttttgtaccacattattacgcgatatctctcagtgtactcta\n" + + "aattaaaccctcttcgaacattttagttcctattcgtaaacacgtgctacgcggcaattt\n" + + "gccggtcgtagaatggacaactccagttcaactgcatgtaactcatagctcgcgttagta\n" + + "taaattgactagtagccatgggacaaagtaactagtcagcggaaaagatccctttaaaga\n" + + "tatatgcaggttgcaagcataaagctcattgctcgaggtgcaccgtggtattccaaaagc\n" + + "gtctctatcgtatcttctaattttgggccgtgagaatcgaaactactctgatttgctgca\n" + + "cacgttaggtaatatcgcccattttcccgtataagctccgtacttatacgaactacacga\n" + + "ccttttaagcattagccgctcatatcgtgattcgtgtacagatgagtctattaaaattac\n" + + "agacatactccatatctcgctccttgaactttgaataatgcgctaacttgtactatgaat\n" + + "aggcagaacccaactttcccgtttgcgtcaagcggggaaacgatacatgttgtcagattt\n" + + "atgattatctagttttagatcacgtttaccgataatcggctgtggtctgagcagtcctac\n" + + "actgagtatttacttcagcttcatatcggtccgaaaaaaggttgtgaccgaatgtcaaaa\n" + + "tacggagtacgatgggcatcttttttcgagtcgcggttgcagggcagcaaaaggcttaaa\n" + + "ccatttttacgatttttactatagcggtcatgaagtgcgaaactgcttgcaaattttcta\n" + + "cacacattgtggctcttgtccttgaagcttatggcgaaaatttgaaacatagtataccag\n" + + "ggaaagcgcgaattatttggtgactaatagtccgtgggtttgagccatatacctaacgcc\n" + + "ataaactacgtggtgctttagatgcaatctaaacagaacagaaagcgtagcgctcatcag\n" + + "cacagactaactttttcagtttgagtcgccggagggacttcgagacaagaacgcgtcaag\n" + + "tcgcttgcgcggcacggattcgattgggcggctcaatcttgcctaatttctactattgtc\n" + + "agctgtacgactgtactaagtgtatagccccaaataaaagaagtatcgatgcgtctttat\n" + + "gaccaaaggtcttataattgaagcgcacttccgttcatcaaattaaatcctggcttaccc\n" + + "gattctccggaagtctgacctagagattgacgacggccgcgtattattgagacctcttca\n" + + "ggattaatcaataacgaagtagttgatctgtttggcgacgtaccttaagccgactccgct\n" + + "acacgagtttctactaaaccaatgtagccttatgcttagatgaataccgtcctaattaga\n" + + "tattccggcataacagcagtaaattatctgttcaatggacgaacattgaattgttagtat\n" + + "tctacacaagtcaggcctcgtaaatattaggtaaggccgtgggataacctacgtgatatg\n" + + "cttgagcttgcgttgcaagctctcgttaatcattaatttaggtgcgtgagggttaaacac\n" + + "cagcatattctatatgctagacgtcttccttaaaggatcgtagtattataattaataata\n" + + "agaaatatggttgacgtctagtcagcgggcatacgctgctctatatactggcattattca\n" + + "aaacttgacggtaaaaaaacgaattttaaggcgctcacgtcgaatgagccgaactcatgg\n" + + "gaaccaaaatgtcacagaaaacacctctttattgccaagcatgcaataaaaaaaatgtta\n" + + "atagtacgtttacgacattttattttataataaagagaaactattacacctattgatatg\n" + + "ataggacgtaaattaacgagtagcctgcatagaggcaaatgaggtttctacatggtatag\n" + + "acctgatgctgaaacatcgatgagttttggtcccctcgctcgttgaaatctagtcattta\n" + + "ctactgtctttcgagctattataccacttcactatgtggtgtttctttgctatgtatggg\n" + + "gctagtcaaacatgatgactatagctacaactcagagagcgggcgtgttaagagtatctc\n" + + "atgctagaactgcacgacgaacttgatacaaagtaacaacatttacgattccacaaggtg\n" + + "actttgaagaaacatagtttaattctctgcttcgatcatttctataaaccggtaccatcg\n" + + "cagcggatagatgcataacatttctactactccaggcatcttaaaacacacgtagtactt\n" + + "cactagattaagacacgataagtgtataacttggcagtgggaagcaaggagattggcgaa\n" + + "ctcctggcatctgttacgttttgttcaggctcggttgttgataatgtccgactcctgcca\n" + + "tattgaagactcgctcgagggagatcgggattcgttgattataagtacacgtgttccgta\n" + + "atactatgaggcagtgattcaaaatggcacttctgacttacatgactaggtattattacc\n" + + "acggaagcgttaaaggcacactcttatggacttaagattgcaagtgccttcttctagcct\n" + + "gaattcgcgggttcaacacaaactctctttagacatccgttgcctaaaggctgagacgta\n" + + "ggggcaaccctttaactatgtactaaaaaactagttggtaatttaacaacgtgtccaatc\n" + + "aagacgatgcaccaacgcggtgcgaaaatcgggttaagcaaacacaaataggaattgtga\n" + + "taaaccccaccttgagaggtcgcaagaccaacctcgggaacaacggctctaagagaataa\n" + + "cctaaatccggatgagtagactgtgtaactctctaaagggaagtgaaaaaaagctaagca\n" + + "tacatttaggtctcctgcattgcattcaattgaatcgtttgtattatgagctgtacagta\n" + + "gctatatcagctatagttatcccagaggaacaggtaaactagctctgagcgtgaaatccg\n" + + "gatattagaacccctagatgggattgattctagctaatacaggcttatctggttttacag\n" + + "ttatctagatgattggtaaggtgaaacgcttggtgccttccaccacttaaacaaaagtat\n" + + "tgcccgggaagctattttctaggtattataaagtcgagcattaatatcaatttgacagta\n" + + "aaggtctttcaccagcttcatatgccatagggcccatactcgatttaaattgaacggttt\n" + + "aacgagtattggaactctcacttataactgagtagctatacgaaaaatctggtccatttc\n" + + "cagaaatttattatcgatttgctgcttagtacccaggaagtgataacccttgaaggcaca\n" + + "acactgtaataagttttcctgtcacatctgtaatattcggtcactacgcattcacgacta\n" + + "aagataattactatactaattaaaagttcaatgttagggccgaatcatagtagaaattct\n" + + "cgtctagcctaatcggacttacctatgggctgtgaggatttatcagtatgtggacaaaaa\n" + + "tgctagagataggtatagttaaagtcaccatggtacatctatgtgaggaagtttgtagtt\n" + + "cgcttctttagtccgggcgtttgggatgacaactactatacgtagagccgtactcaggat\n" + + "tagatagtgtgaaagagtcaaataaaagggttaatattaatttaacgttgcaaatgtgtt\n" + + "taggccaaacattaaccgttgtagggatattctaatacaggccttcaccgaaccctaatg\n" + + "ataatctgtcttaataacattaaatgattgtctccgctacgagctcttagggcctcattt\n" + + "taaatgactaatgtccaaagaagagactttcccaatttcaatctgtcacgtatagacggc\n" + + "accttagtgagtcatatcattaagatagaagattatcaggagggaagtttctattatcaa\n" + + "ccgttacgcaaccataaacttttaaatctcataatggcattgagatcaagagctttcatg\n" + + "atggtaaagttcgtatgtgatgctggggagctagatatcggtataccacttcggttgtgg\n" + + "taagcccgagtgggccgttagtaatattaatagacgattatccgacaatgcattcgctga\n" + + "aataatcttacttaggagaaattaatgctatgagccaaaactatttatgtctgtcacatt\n" + + "attgactaaagtatctatcgacaaaactgatgtccataagttgtagcagatagtcggtgt\n" + + "atggtgtcaccaatgaaaacctcgagcgaaaaatgaattatagttatccaatttgagtaa\n" + + "attgcctattatacagataggcttgtttagtcagataaggttccgcttgaggtgctctaa\n" + + "cttagcgagagttagaaagcctagtgagaggcattttggtgccaaactccggctcgcatg\n" + + "agtaggccagagagtcactttctttcgtcgaagaagttggtgaacagccttttgattagt\n" + + "tgtttgtcttgtggctatgtgctactatataagttagaacgcaaactaatctaatcagca\n" + + "aagtaaaataggaccttgaacgagacggggtacgccgttgaggctcgagatagtagataa\n" + + "actagaggaatgtagataaaacattagctagggggtttagttactggattacataggaag\n" + + "tgcaccatcacggtgtgggggttcgtacgtaaagtcgcatcaatattgtcagtggactta\n" + + "acaagttcgtgcataatgaaatcctatacggactttgcatatctctaccgactcatctgg\n" + + "tcgtctatgcgggtaattgtattgctccaagtggatgactattttggcgtcccagcacat\n" + + "agtaaatgtaaatccttataatagcataagcaattattagactgcgtgaagtcttagtag\n" + + "ttctcaagctttacgttgtatgtaaataactcacgtaatcagccgtccccaaatcaccat\n" + + "tgaggtcattgaatgtacggagcactattatcaatgcggtatgcgattttctgagcgatt\n" + + "attgttaaagacttagcgttgagccccggaacacttgattacagattctttaaggagtta\n" + + "tccaaatatcattttaaataatagtagtatcgtgctttggacaataaaaaaagacccgtt\n" + + "ctcttatgttgttttgcgacgtacttctctgatatatacttcaactatgaagattctatt\n" + + "catcgataacccaggtatatttatatgcccgttcactgcgcagggcaaattatctacgga\n" + + "caataatgacgtagttggacccggtaagaactaacgcttaatatgattaaggatgtatgc\n" + + "cagtattatcttattatgtcagagtagaagtttctctgagattttccgtcgttgtggtac\n" + + "accggatttggctctctttttagaactgagaactcggagtgtgtagtcttgtttccttca\n" + + "atttatcaatatgcttttataccgccctcatcaactataacaggacgacaagttccgtct\n" + + "tgctccatcatatactaccgatacaccaatcgtatcaagtttagtatacttgctttctct\n" + + "cttctacagcttactcgcttgtccgagaagcggttggtgctcataaagttagtagtaaat\n" + + "gtacaactagtagccagtccttacctgtttttacgactactacggacaccatgagataca\n" + + "gaagttagtgctacaattataccattacatgctcaatatcgttgtcggccataagatcga\n" + + "agagtgcatcacgcgtgtgaatacgtaaaatctaccatcccgtcaatgcacaaaaacaca\n" + + "ctccccttgttgactaacatcttttacaagaggctaaatcattgtccaggatcgaatacc\n" + + "ttgtgtacaatcgtcacccatcggaagaataccacttttccgatgtagtatgatttacaa\n" + + "aaaacatctatgtgagtaggccaattgtagtagaatatattcatttgaccgtcattagcc\n" + + "ttcttcttaggttgtgtacggatagtaggtacataaaccgtcgtgtggcatacgctgcga\n" + + "tttcatacagctgccaacaccttttttaccaggctagagtcagaaaagttggagccatgt\n" + + "taaatagttaccatcataaaccactgttgtctactagtctgatcagctttcatgcctgtg\n" + + "caagcaatatggattctcacgtaatggtaacaactgttgcgttacttaggctggttaatt\n" + + "tgtcagagtaataaatacatgtcttgttgtgtttcctaatcctcggaaagtacacaagcc\n" + + "taggaataggaaaagtaaagctcttttattctgatagtgactaactcaggatctaaatac\n" + + "gcgattatactaaccttcaccaaagctcaaaaatcatctgctggtgaccagttatagaca\n" + + "gggtaattcaatatttaatgtctcccttaacatttcaccagcatggattgaagatagtat\n" + + "aaagttttacatggcagtcattgtgtcacggttctatacaaattctgatagttagacggt\n" + + "atttgaaatgtgcttctagcatggtatcttacacaactgaatgaacgactggagccgttc\n" + + "gtatactatttgcgagcctcgagaccccgtttcctaatgttaacgaatatagtataatat\n" + + "aaattgtgatatgaataacacaagtaactacagtttggacaattaattgttctaaactaa\n" + + "aaatcattcacttcagatggcatagagttatggctactacacatataaagcggtatgtga\n" + + "aacacccgttttagccggaaaccctctactgctcgggacaatgaatgatttccaaaatat\n" + + "ggatgtgcagaattgttagtgtgactcaggtccaaatagacactttagtttcgtcaagtc\n" + + "gttgcaaagtttaaaaccatcgcagcattctttatttggtctacattgagaaatgaaaaa\n" + + "acgtgacagaaagtctagaagaactgtgaataatgtctattactgattaactagtaagac\n" + + "attagtgcatctggtccactgaagcacccgcttggcgttaggcaatctctgtgaactgtc\n" + + "gtggctgttccggtaatgtacgaaagcaagcctataggttgatcgagtcgcttcattaag\n" + + "gtcaatttcacaatatccgatcacattgtgctaggttcgtcctttaccttgcttagtgct\n" + + "gcatgtacggggtgtcatgacttgttatcggcagactctttatcccaagaatggataata\n" + + "tgtacatggaaagtgtccataattaagtcccttcactgtaaagaatgactgccacgtgat\n" + + "ccatgaggtctacagaaaccgacttacttgctttttgatcaacttaattatggattcata\n" + + "aagttcagatatcggtacaattggtgtacaatatgaaattaatgaggaaacatggaaatc\n" + + "tgaatgacagtgatagaaaagatccccatttgcccggtcagttcatgttacaccactcat\n" + + "tagtactgtaagtgtttcgtcagcattgagatccacgatcatgtgtttatgccttcgaaa\n" + + "ctggatgtacgacgatcgagacgaagaggtatatataacctaaatactaggtacgttgtt\n" + + "agagagacgatgaaaattaatcgtcaatacgctggcgaacactgagggggacccaatgct\n" + + "cttctcggtctaaaaaggaatgtgtcagaaattggtcagttcaaaagtagaccggatctt\n" + + "tgcggagaacaattcacggaacgtagcgttgggaaatatcctttctaccacacatcggat\n" + + "tttcgccctctcccattatttattgtgttctcacatagaattattgtttagacatccctc\n" + + "gttgtatggagagttgcccgagcgtaaaggcataatccatataccgccgggtgagtgacc\n" + + "tgaaattgtttttagttgggatttcgctatggattagcttacacgaagagattctaatgg\n" + + "tactataggataattataatgctgcgtggcgcagtacaccgttacaaacgtcgttcgcat\n" + + "atgtggctaacacggtgaaaatacctacatcgtatttgcaatttcggtcgtttcatagag\n" + + "cgcattgaattactcaaaaattatatatgttgattatttgattagactgcgtggaaagaa\n" + + "ggggtactcaagccatttgtaaaagctgcatctcgcttaagtttgagagcttacattagt\n" + + "ctatttcagtcttctaggaaatgtctgtgtgagtggttgtcgtccataggtcactggcat\n" + + "atgcgattcatgacatgctaaactaagaaagtagattactattaccggcatgcctaatgc\n" + + "gattgcactgctatgaaggtgcggacgtcgcgcccatgtagccctgataataccaatact\n" + + "tacatttggtcagcaattctgacattatacctagcacccataaatttactcagacttgag\n" + + "gacaggctcttggagtcgatcttctgtttgtatgcatgtgatcatatagatgaataagcg\n" + + "atgcgactagttagggcatagtatagatctgtgtatacagttcagctgaacgtccgcgag\n" + + "tggaagtacagctgagatctatcctaaaatgcaaccatatcgttcacacatgatatgaac\n" + + "ccagggggaaacattgagttcagttaaattggcagcgaatcccccaagaagaaggcggag\n" + + "tgacgttgaacgggcttatggtttttcagtacttcctccgtataagttgagcgaaatgta\n" + + "aacagaataatcgttgtgttaacaacattaaaatcgcggaatatgatgagaatacacagt\n" + + "gtgagcatttcacttgtaaaatatctttggtagaacttactttgctttaaatatgttaaa\n" + + "ccgatctaataatctacaaaacggtagattttgcctagcacattgcgtccttctctattc\n" + + "agatagaggcaatactcagaaggttttatccaaagcactgtgttgactaacctaagtttt\n" + + "agtctaataatcatgattgattataggtgccgtggactacatgactcgtccacaaataat\n" + + "acttagcagatcagcaattggccaagcacccgacttttatttaatggttgtgcaatagtc\n" + + "cagattcgtattcgggactctttcaaataatagtttcctggcatctaagtaagaaaagct\n" + + "cataaggaagcgatattatgacacgctcttccgccgctgttttgaaacttgagtattgct\n" + + "cgtccgaaattgagggtcacttcaaaatttactgagaagacgaagatcgactaaagttaa\n" + + "aatgctagtccacagttggtcaagttgaattcatccacgagttatatagctattttaatt\n" + + "tatagtcgagtgtacaaaaaacatccacaataagatttatcttagaataacaacccccgt\n" + + "atcatcgaaatcctccgttatggcctgactcctcgagcttatagcatttgtgctggcgct\n" + + "cttgccaggaacttgctcgcgaggtggtgacgagtgagatgatcagtttcattatgatga\n" + + "tacgattttatcgcgactagttaatcatcatagcaagtaaaatttgaattatgtcattat\n" + + "catgctccattaacaggttatttaattgatactgacgaaattttttcacaatgggttttc\n" + + "tagaatttaatatcagtaattgaagccttcataggggtcctactagtatcctacacgacg\n" + + "caggtccgcagtatcctggagggacgtgttactgattaaaagggtcaaaggaatgaaggc\n" + + "tcacaatgttacctgcttcaccatagtgagccgatgagttttacattagtactaaatccc\n" + + "aaatcatactttacgatgaggcttgctagcgctaaagagaatacatacaccaccacatag\n" + + "aattgttagcgatgatatcaaatagactcctggaagtgtcagggggaaactgttcaatat\n" + + "ttcgtccacaggactgaccaggcatggaaaagactgacgttggaaactataccatctcac\n" + + "gcccgacgcttcactaattgatgatccaaaaaatatagcccggattcctgattagcaaag\n" + + "ggttcacagagaaagatattatcgacgtatatcccaaaaaacagacgtaatgtgcatctt\n" + + "cgaatcgggatgaatacttgtatcataaaaatgtgacctctagtatacaggttaatgtta\n" + + "gtgatacacaatactcgtgggccatgggttctcaaataaaatgtaatattgcgtcgatca\n" + + "ctcacccacgtatttggtctaattatgttttatttagtgacaatccaatagataaccggt\n" + + "cctattaagggctatatttttagcgaccacgcgtttaaacaaaggattgtatgtagatgg\n" + + "taccagtttaattgccagtgggcaatcctaagcaaaatgagattctatcctaaagtttgg\n" + + "gcttgatataagatttcggatgtatgggttttataatcgttggagagctcaatcatgagc\n" + + "taatacatggatttcgctacctcaccgagagaccttgcatgaagaattctaaccaaaagt\n" + + "ttaataggccggattggattgagttaattaagaccttgttcagtcatagtaaaaaccctt\n" + + "aaattttaccgattgacaaagtgagcagtcgcaataccctatgcgaaacgcctcgatagt\n" + + "gactaggtatacaaggtttttgagttcctttgaaatagttaactaatttaaaattaatta\n" + + "acgacatggaaatcacagaacctaatgctttgtaggagttatttatgctgtttactgcct\n" + + "ctacaaccctaataaagcagtcctaagaatgaaacgcatcttttagttcagaaagtggta\n" + + "tccagggtggtcaatttaataaattcaacatcgggtctcaggatattcggtcatataatt\n" + + "tattaagggctcttcgagtcttactctgagtgaaattggaaacagtcatccttttcgttg\n" + + "tgaggcatcttacaccgctatcgatatacaatgcattccaccgcggtgtcccgtacacaa\n" + + "ggaaacttgttaccttggggatataagaaaactcacacgtctcattattaaactgagtac\n" + + "aatttttgcacgagaaagtaatgcaatacaatatgatgaaagccagctaatgaaaaggga\n" + + "tggaacgcacctcggatctgttgcactggattaaaatccgattatttttaaaaatattca\n" + + "gtgctagagcatatcaggtctacttttttatctggtatgtaaagcccacggagcgatagt\n" + + "gagatccttacgactcaacgaaaagttataacataactcccgttagccaaagcccaatcc\n" + + "cgattactgccctaccctaacgtctgccatctaaatatcgaacttgttatgatcaatgtg\n" + + "actacctcccaccctttccccttcatttgttccactggggataagctagcgttttcagaa\n" + + "tcaatgcaataagaatagccaattgtctcacttcatcagagctcttggcaattccaggcg\n" + + "ctacgtggttctggaatatattcatttttcaaatagtaatacgtttagtgttgctattgt\n" + + "ctacacgtttggatattacgttatgtgagcggacatcaatagttgtctaactctttagta\n" + + "agccagagatagcactcttagcgaatggataccatcttccataagtttagttaatagtcc\n" + + "gaaacaactgcttcgagcatatttgaacctccttgtaggcaaatagcctcttcaaagcaa\n" + + "tcttactaatagatagagtttgttttaagggactactagaaatgggacaatcttaatagt\n" + + "atgacctaaactgacatttaaagatatatccaggtggcaagcataaagatcattgcgcca\n" + + "cctccaccgtgggattacttatcagtcgatatcctatatgctaagtttgcgacggcagaa\n" + + "tacaaactaagctgagttgatgctaaccttacctatgataccccattggaccggttaaca\n" + + "gccctacttattccaaataaaagaacttttatgctgtagaagctattatagtgatgcctg\n" + + "gtaacttcagtatattaaaatgacacacatacgccatatagagctcctggaactttgaat\n" + + "aatgagcgaacttcgaagttgaagagcaagaaaccatatgtcacggttgcctaaagcccg\n" + + "gtaaccagacatgtgctatcattgatcattatcgaggttttcataaccttgacccattat\n" + + "cggctgtgcgcggacaagtacttaaatcactagtttcttcacctgcttatcggtaagaaa\n" + + "taaggttggcaaagaatcgcataagacggacgtagagccgcagcgttgtgcgagtccagg\n" + + "tgcatgcgcagcaataggattttaaattttgttccatttttaatttagccgtaaggatgt\n" + + "ccgtaaatgattgaaaattggattcaatctttgggcctatgctactggaacctgatcgac\n" + + "aaaatttcaaacatacgttaactccgaaagaccgtatttttgcggctagaatagtcagtc\n" + + "gcttggagccatataccttaccacttaaacgacgtgctcctgtagttgaaatataaacag\n" + + "aacacaaagactaccgatcatatcaactgaagatctttgtaactttgaggcgaagcaccc\n" + + "tcttcgagacaactaagagtaaagtaccgggcgccgcaaggagtcgattgggaccctaaa\n" + + "tcttgacgaattgctaagaggctcagagctaccactgtaatttctctagagcccataata\n" + + "aatgaacgatacatccgtaggtagcacctaagggattataatggaagccaaatgcagtta\n" + + "ataatattatatactggcgtacacgattcgacggatctctcacatagtgattcacgaccc\n" + + "ccccctttgattgacacagcgtcagcattttgcaagaacgatcttctgcatagggtgcgc\n" + + "caccgtaaggatgacgtcgaagctacaactgggtataatttaccatgcttccctgatgct\n" + + "gagtgcaatacactaagaatgagtttttaccccatatcaccagtatttgttctgttattg\n" + + "cgaagaaatggctatgctgagttggcgactaaagtcacccatcctttttattaggtaacc\n" + + "ccctcccttaaactaactgatttgctggagctgccctgcatacatatactttatcattta\n" + + "tggacgtccgtgacgcttattatccaccatagtcgatatgctacacggattcattaatgg\n" + + "atcgtaggagtttaagttatatttactaagatcggtctcggctactatcccgccttaccc\n" + + "ggcgctatttacggccatttttaatatattgacggtaattattcctatggtttcgaccgc\n" + + "acgtccttggacaagaaagaatggcaaaaaaaatgtaaaagaaaaaaaatattgagtccc\n" + + "taccatcatataaaaaatatgtgatgagtaacttgacgaaatgttagtggttattaaaga\n" + + "ctatctattacaccttttgttttctgtcgtagtatattaaagtctagaagccttacagga\n" + + "aaatcagggttatacagccgatactccgcagcatgaatcatcgaggaggtgtcctaccat\n" + + "cgcgccttgtaatcttgtctgtgtatactgtatttagaccttttatacaaagtaaatatc\n" + + "tcggctttatgtgattgggaggggcctactcaaacatgatgacttgacctaataatcact\n" + + "gtgcgggcgtcttatgactagctattccttgaaatccaccaccaaatggttaatatgtaa\n" + + "aaactttgacgatgaaacaaggtgaatgtgtagttactttgtgtaattagctgcgtcgag\n" + + "cattgcttgtaaaaccgtcaatcgcacacgttacttccataaaatttctacgaatacacc\n" + + "cttcttaaaaaaaacgtaggaattcacgagtttaacaaacgataactgtataaagtggaa\n" + + "gtccgaagaaagcagatgcccgaactactcgaagatgtttcgttttcttaaccatagggg\n" + + "cttcttaatggcccactacgcacattttgttcaagcccgagagggacatccccattacgg\n" + + "gagtattactaaaactgttccgtaatacgttcagcaagggatgaaaaaggccactgctca\n" + + "agttattgacgtgggagtattacatcggaagcctgaatcccacactatgatggtctgtac\n" + + "aggcctagggactgcgtctagacggtattaccggcttctaatcatacgatcgtgagtctt\n" + + "aacgggaagtaaggctcacacctaccccaaaccatttatctatgtaagtataaaattgtg\n" + + "cgtaagtgttcaaagtggacaataaagacgtggcaaaaacccccgcacataagccgcttt\n" + + "agatttcacaaataccaatgcggttaaaaacatccttgagtcgtacatacaccatactcg\n" + + "cgttaaacggatataacagaagataataaatccggatgtggagtcggtgtaactatagaa\n" + + "agccaagtgaaataatgcttaccagtcatttagctatacggctttcatttcatgtcaaga\n" + + "gggtggagtttgacctgtacagttgatatatcaccgatacttagaactcacctaaagcta\n" + + "aaattgctcgcagcgtgtaatccgcatattacaaacaatagatgggattcattatacata\n" + + "agacacgatgatctgctttttcaggttgcgagatgttgcctatcgtcaatcgagtcctgc\n" + + "cttacaccacttaaacaaaagtattgacagggaacctattttcgaggtattatatagtcc\n" + + "agcttgaatatcaatttgacagttaacctagtgaaaatcagtaagaggaaatacgccaca\n" + + "ttctccagtgaaattctacgggttatcgtctagtccaactatcaattataactcacgaga\n" + + "tataagtaaattctcgtacttggcctgatttttattatactttggatccttagtaaacag\n" + + "gaagggagaaaccttcaacgaaaaacactggattttgttttactctcaaagctcttatat\n" + + "gacggaaataccctgtcaagtcttaactttattactagactaatgaaatgggcttggggt\n" + + "ggccagaatcatagtacaatttagcggatacactattcggactttcctatcggctgtctg\n" + + "gttggataagtatggggactaataggctagacatacctatacttaaactatacaggcgtc\n" + + "atctatctctgcaactttggagttccctgatgttctcccgccctttgggttcacatcttc\n" + + "tataccgacacccctaataacgattagtttgtgggttagagtaaattaatacggttaata\n" + + "ttaatgtatcgttgaaaagctggtgtcgccaataaggtaaccggctaggcagagtatatg\n" + + "tcacgaagtataactaccctaatgataagctgtaggaataaaattaatgctgtctctaag\n" + + "cgaagagatatttccgactctgttttaatgacgaatctcattacttctgacttgcaaatg\n" + + "ttcaatatggcacggtttcacggcacctttgtgacgcatataatgaacttagaagattat\n" + + "aacgacggaactttatatgataatccgttacgattaaagaatctgttaaatatcataatg\n" + + "gcattcagttctagaccgtgcatcatggtaaacttactttctctgcatggcgacatacat\n" + + "ttcgctattcaaattcgcgtgtggttacacccactcgcacctttggaatattaagagaag\n" + + "atgatcagaaaatccattcgctcaatttttctgacgtacgtctaatttatcctaggagac\n" + + "aaatcgttttatgtctctcacatttttgaagaaaggttcgagagacaatactcaggtcct\n" + + "gaactgctagaagatactcggtggagcgtggcaacaatgaaaaactcgtgacataaatga\n" + + "atgatacttttccaagttcagttaagtgaatatgtttaacatacccggcttttcgatctt\n" + + "aagctgacgctggacgtgcgagtaatgtcagtctcttacatacactagtgactccaagtt\n" + + "tcgtcaaaaacgccccctcccttctcgagcccactcacgctatgtattgacgcgaacttg\n" + + "ttcgggatcagacttttcaggagttcggtcgcgtgtccctatgtgctaatatataagtta\n" + + "gatcgcattagatgctaatctgaatacttatagacgaccttcaacgagaacgggtaccac\n" + + "cttgaggctagagttaggtgtgaaacgacaggtagggacatataaaatttgagtgcggct\n" + + "ttagttaagggtttaattacctactcaaacatcacgctcgcgcccttcgtacgtaatcga\n" + + "ccatctagaggctaaggggactgtactaggtagtgattaatgatatcctagacgcacgtg\n" + + "ccttagatcttcagactctgatggtccgcgatcaccgtaattgtagtcctccaactcgat\n" + + "cactttgttggcgtcaaagaaattacgatatctaaatacttataatacaataaccaagga\n" + + "tgagaatgactcatcgcgttggagttatattgcttgaagttctatggaatgaaagcacgt\n" + + "tatctgccgtcccaatatctccagtgagctaattcattggacggtccactttgatcaatc\n" + + "cccgaggagatgttcggacactttagtctgtaacacttagcgttgagaccacgaacaatt\n" + + "gattactcagtcttgaaggtgttttccaaagttcattttaaataagactacgataggcct\n" + + "ttcctattgatataaactacccggctctgttgttcgtgtgagtcgtacttctctgtgttt\n" + + "ttctgattatagcaagattcgattcttagtgtaaacagcgatttttatttgacccgtcaa\n" + + "tgagaagcgcataggatctaagcaaaattatcaagttgtgccacaaggtaagatctttcc\n" + + "agttattgcaggtaggatgtatcccacgttgatagtatgaggtctgacgtcaactgtcta\n" + + "ggagagttgaccgcgtgcgggtacaccggatttgcatcgatgttgagaacgcagaactcc\n" + + "cactgtcgtggcggcgttcctgatatttagcaagaggcgttgataaagccctcatcatct\n" + + "agatctcgacctcatctgccctcttgctccatcattttctacacagactactttcctatc\n" + + "tacgttagtataattgctttctatcttagtatcatttagagcttctccgtcaacaggttc\n" + + "gtgctattaaagttagtacgaaagggacaacttgtagcaacgcatttaatcggttttcga\n" + + "ctacttcgcacaaaatcagataaagaagtttgtcattctattagacattgaattgcgcaa\n" + + "ttgacttgtaccacttatgatcgaacactgaatcaagactgtgattaactaaaatagaca\n" + + "agccactatatcaactaataaaaacgcccctggtggtcgaacatagttgactacaggata\n" + + "attaattggactggagccattacattctctacaatcgtatcacttcccaagtagacaact\n" + + "ttgaccttgtagtttcatgtacaaaaaaatgctttcgcaggagcacattggtagttcaat\n" + + "agtttcatgggaacctcttgagccgtcttctgtgggtgtgttcggatagtaggtactgat\n" + + "aaagtcgtgtcgctttcgatgagagggaattcaccggaaaacaccttggttaacaggata\n" + + "gtctatgtaaacttcgagacatgtttaagagttaccagcttaatccacggtgctctacta\n" + + "gtatcatcagctgtcttgcctcgcctagaaatatgcattctatcgttatcctatcaacgg\n" + + "ttgccgtactgagcagccttattgtggaagagtaatatataaatgtagtcttgtctttac\n" + + "gaagcagacgtaagtaataatgacttggaataccaaaactaaacatagtggattatcata\n" + + "ctcaagaactctccagataaataacagtttttacgatacgtcaccaatgagcttaaagat\n" + + "taggatcctcaaaactgatacaaacgctaattcatttgttattggatccagtatcagtta\n" + + "aactgaatggagtgaagattgtagaatgttgttctggcctcgcatggggtctaggtgata\n" + + "tacaatttctcatacttacacggtagtggaaatctgattctagcttcgtagctgactata\n" + + "ctcaaggaaccactgctcaaggtaggagactagttccgaccctacagtcaaagtggccga\n" + + "agcttaaactatagactagttgttaaatgctgatttcaagatatcatctatatacagttt\n" + + "ggacaattatgtgtgcgaaactaaaattcatgctattcagatggatttcacttatgcctt\n" + + "agaaacagatattgcccgagctcaatcaacagttttagccggaaacaatcgaagcatagg\n" + + "gacaatgtatcttttcctaaattgccatgtgcagatttctgagtgtcacgaagcgcataa\n" + + "tagaatcttgtgttgcctcaactcgttgaaaagtttaaaacaatcgcagcagtctttttg\n" + + "gggtctactgtgtgtttgcaaaataactgaaagaaacgcttgaacaactctgaagtagct\n" + + "cgagtactcattaaagtgtaacacattagtgaatatcggccaatgaaccaaacgcttccc\n" + + "ggtacgctatctctctcatcgggaggcgatgtgcaggttatctacgaaagcatcccttta\n" + + "cgttgagagtgtcgatgcatgaacctcattgtaacaatagcccagcaaattctcatacgt\n" + + "gcctcagggtccgggcgtactcctccatggaagggcgcgcatctagtgttataccaactc\n" + + "gctttttaactactatgctgtagttctacaggcatagtggccagtattttctaacttctc\n" + + "tggatagatgctctcactcctcatccatcacggcttcagtttacgtcttacttgcttgtt\n" + + "cagcaacggatggaggcattaagtatcttcactgttccctaaaattgctgttcaatatca\n" + + "aagtaaggacgatacagggaaagctcaagcacactcattgaatactgccccagttgcaac\n" + + "ctcacttaatctgacaaaaataatgactactctaagtgttgcggaagcagtctcttccac\n" + + "gagcttgtctgtatcacttcgtataggcatgtaactcgatagacacgaacaccgagtgag\n" + + "aaactatattcttgcttccgtgtgtgtgacaccaggtaattgatgcggatataagctgga\n" + + "gatcactcacgcccacacaaggcgctgctacctctttattccaatgtgtaagaatttgct\n" + + "aacttcatttctagaccgcagctttgcggtcataatttcacggtacggacccttgggtta\n" + + "gagacttgataacacacttcgcagtttccaccgcgcacatgttttagtggcttctaacat\n" + + "agaatttttgttgtgacataaagagtgcgtgggagacttgcccgaccgttaagccataat\n" + + "caattgaaagccccgtgagtcacatctaattggttgtactgcgcatttagctatccttta\n" + + "gctgactcgaagagattcgattcctaatataggttaattagatggctgccgcgcgaagta\n" + + "aaacgtgaaaaacgtagtgcgcagatctgcataactcgcgcttaattacttatgagtagt\n" + + "tccaagttcgctacgttatgagagagattggaattaagcaaatatgttttatggtgattt\n" + + "tgggatgagaaggactgctaagtacggctactaaacaaatttctaaaaccgccatctacc\n" + + "ttatcttggagacatttaagttgtatatgtcactagtctagcttttgtctgtgggacgcg\n" + + "ttctcggaatgagggaaatgcaagagccgattcatcaaatgcttatctaagaaagtagtg\n" + + "gactattacaccaagcacgaatgccagggaactgctttcttgctcaggacctcgcgacaa\n" + + "ggtaccccgcataagtcctagaattacatttggtcagcaatgctgacatttgaccgtgaa\n" + + "aacataattttaatcagaaggcagctcacccgcttgctctagatcttatctttgtatgaa\n" + + "tgtcagaatttactgcaatatccgttccgaatagtgagggcttagtatagttctctgtat\n" + + "acaggtcacatcaaactccccctgtcctagtacagctctgagctttaattaattgcatac\n" + + "atttccttcaatcatcagatgaaaacaccgcgaatcatgctcttctcgtatagggcaaga\n" + + "gaagcaacaaacaactagcccgactcacgttcatccgccgtatccttgttcagttcttac\n" + + "tccgtattaggtcagcgaaatctaatcagaataatcggtcgcgtatcaaaattaaaatcc\n" + + "cgcttgaggttgacaattaaaacgctgagcagttatcggctattagatagtggggtgaaa\n" + + "gtaattggctggaattatgttaaaacgtgatattaagctaaaatacgctacttgttgccg\n" + + "acctaattcagtcattcgatattcagttagagccaagaataacaagcttgtataaattga\n" + + "acggggtgcactaaacgatgtgttactctaatattcagcttggagtatacctgaaggcga\n" + + "attcatgtatcggccaataataagacgttgaagatcacaatttggactagcaaaagaagg\n" + + "tgatttatgcgtggggattgagtccactgtacgagtacggtctctggaaaattataggtt\n" + + "cagggaatataaggaagtaaagataattaccaagagatttttggtatcgctatgacccag\n" + + "aggtgttctaacgtctgttttgatccgcagaatttctgcctcaatgcatatttgacggac\n" + + "ttgaactagagcctctaaagttaaatggcgacgcaactgttcctaaacttcaattattac\n" + + "tactctttttttcctagggtattgtagaggccagtggacaaaataaatcaaatttaagat\n" + + "gtttcggacattaacatcccccgtagcatagaaatcatcagttatccaatctctcatcga\n" + + "gcttttacaatttctgctggcgctatggacagcatatgccgcgagacctccgcaagactc\n" + + "acttgatcactgtaagtatcttcattagaggttagagcctatagttaagctgctgaccta\n" + + "gtaaaattggtattttctaattttattgctcaagttaaaggttagtgaagggataatgac\n" + + "gttatttttgaacaatgggttgtattcaattttatatcacgaatggaacccttcattccc\n" + + "ggcataatactagacgacacgaacaagctccgatctatcagccaggcacgtgttaaggtt\n" + + "taattccggcaaaccaatgaagcatcaaaaggtgacctgatgcaacttagggtcacgatg\n" + + "agtttttcaggactacttattacctattaataagttaacatgagccttcataccccgtaa\n" + + "gacaatacatactccaccaattagaattctgagccatcttatctttttgtatcatcgaag\n" + + "ggtatggccgaataggttaattagttactcctaacgtctctacaggcatgcatttgacgc\n" + + "accttcgaaaatagtcaatctctcgccacacgcgtctagtatgcagcatcaaaaatatag\n" + + "tccacggtttccggattaccaaacgcggcaaagagaaacattgtatcgacggagataact\n" + + "taatacagaaggaaggggcatcttcgaatacggatgaataattctatctgtttattctga\n" + + "catcttgttttcaggttaatcttacgcattcaaatgacgcctgccccatgcgtgcgcaat\n" + + "tattttctaatattgacgagagcaatctcactccttttgggtctatttatgttttattga\n" + + "ggcacaagcctatacagaacaggtactattaaggccgtgagtgtgagactcaaaccgtgg\n" + + "aaacaaaggatgggttgttcttggtacaagttttagtgcatgtgggcaatccttaccaaa\n" + + "atcagatgctatccttaactttgggctgcatttaagatggcggttggaggcctgtgagaa\n" + + "tcctgcgtgtcatctttaatgaccgaattcatccatgtagattcagatcacacactcatt\n" + + "ccttgatgttgtctaaacaaaagttgttgtggacgcattggagggagttaagtaacaact\n" + + "tgggatcgcatacttataaaaattatatgttaaactttcacaaacgctgaagtccaaagt\n" + + "aactagcccaaacgcctcgagagtcactaggtattaatggtgtttgagttcctgtgaaat\n" + + "agtgttcgaaggtaaaatttatgtaccaaatcgaaagaacacttaataaggcttgcttgc\n" + + "acggaggtatgatgtttactgactctacaaccctaattttccagtacgtacattcattcc\n" + + "aataggttagttctcaaagtgctatacaggctcctcaattgatgatatgcttcagccgct\n" + + "ctatggatattagctcattttatttaggaagcccgcttagaggcttactatgagggaaat\n" + + "gccaaaatgtcatacttttcggtgtgtcccatatgacaccgctttacatagaatttgaat\n" + + "taaaacgcgctctcccgttcactaccatacttggtaccgtgcgcatattacatatagata\n" + + "taggatcattttttaaagctgtactaggtttgatcgacaatcttatgctatactatatga\n" + + "tgtaaccctcataatcaataccgatcgtacgatcctagcataggtggcaagcgattttat\n" + + "gccgattattgtgttaaatagtctgtgagtgtgattatcagggctacgttggtagagggg\n" + + "ttgtatagacctcgcacacattgtgacatacttaacaatatacgaaaactgatataataa\n" + + "atccccttacccaaacaccaatcccgttgaatcaactaccataacgtctcccatataaat\n" + + "tgcctacttgtttgcataaatctgaatacataacaccattgcaccttcttgtgttccaat\n" + + "cccgttaagattgccttgtcagatgatatgcaagaacaatagcatttgctagcaattatt\n" + + "aacagctcttcgaattgcctccacataacgcgggagggtatattttaatttggcaaatac\n" + + "taagtactgttggcgtcatatgctattaacggttggatattaagttatgtcagccgtaag\n" + + "caagagtgggcgaaatattttgttacccagtgagagcactcttagagtttggatacaata\n" + + "ggccatatgttgacttaagaggacgtaactacgccgtacaccattgttcaaccgacttct\n" + + "tggcaaatagaatcgtattagcaatcttaagaatagagacacgttcgtgttagggtatac\n" + + "tacaaatccgaaaatcttaagaggatcacctaaactgaaatttatacatatttcaacgtg\n" + + "gatagatttaacataattcagccacctccaacctgggagtaattttcagtagatttacta\n" + + "gatgattagtggcccaacgcacttgactatataagatctggggatcctaacctgacctat\n" + + "gagacaaaattggaaacgttaacagcccttatgtgtacaaagaaaagtaagttgttgctg\n" + + "ttcaacagatgatagtcatgacgcgtaacttcactatagtaaattgaaacaaatacgcaa\n" + + "tttagacagaatggtacggtcatgaatgacagtaattcgaagtgctagaccaacttaaaa\n" + + "taggtaaacgtgcccgaaaccccccttaacagaaagctgctatcatggtgcagtatcgac\n" + + "gtgttcagaaacttgtaacttttgagcaggtccgagcacatggaagtatatcacgtgttt\n" + + "ctgaaccggcttatccctaagatatatccgtcgcaaactttcgatttagtcccacgtaga\n" + + "gcccaagcgttgtgcgactccacgtgcatgcccagaaatacgagtttaaatttggttaca\n" + + "tggttaattttgaccgaagcatcgcactttatgattgataattggattcaatatgtcgcc\n" + + "ctatgcgaatgcaacatgatccacaatttggctataagacgtttaatccgtatcacactt\n" + + "tgtttgcggctagtatagtaacgcccgtgcaccaagagtcagtaacaattataagtactc\n" + + "cgcaggtacttcaaatataaaaactaatcaaacacgacccatatgatcatctgaagatat\n" + + "ttggaactttctcgacaaccaccctcgtactcaatacttacactaatcgacaggcacacg\n" + + "caacgtgtacagtcgcaccatattgagtcaagatttgcttagtggcgatgagcgtacacg\n" + + "cttatttctctagtcacaattagttatctacgagacatcacgagggagcaaataagcgat\n" + + "gttatggctacacataggcacgtatgaatatgatataagccagttaaacagtcgaaccat\n" + + "cgagcaaattctcatgcaccaacccacacgttgaggcacaaagagtaagctgtttgaatg\n" + + "taacttcttctgctgagcgggccccaacgtaaggatcaactagaagagaaaactcggtat\n" + + "tagtttaaatgcgtcacggagcatgagtgcatttcactaagaatgtctgtgtaaccaata\n" + + "taacatctatttgttatctgattgcctacttatggctttgcggtcgtggcgactaatgtc\n" + + "tccaatccttttgaggtcggtaccaactccctttaaattacgctgtgcaggctcatgcac\n" + + "tgcatacatatacggtagcaggtagggacctcacgcacccttattataatcaatagtagt\n" + + "tatcagtcaacgaggcaggaatgctgaggtcgaggtgttggtatattttctatgtgccgt\n" + + "ctaggcgactatcacgcattaccaggcgagatttaagccaattttgaatatagtcaacgt\n" + + "aatttttactatgggttccaccgaaacgccttgcacaactaagaatcccataaaatatcg\n" + + "atatcaaataaaagattgtgtcaataccttcatatatattttttcggttgactaacgtga\n" + + "actaaggttaggggttttgtatgtctatataggaaacagtttcttttctgtcctacttta\n" + + "gtaaagtcttcaagccttactccaaaatcacggtgattaagccgttactcagcagcatga\n" + + "ttctgcctgctcgggtcctaaaatccagccttgtaagagtcgctgtgtattagctaggga\n" + + "gacctttgttaaaaaggatatatcgcggcgggatgtgagtgcgtggcgcatactcaatct\n" + + "tcagctcgtgtcattataatatctctcccccacgcttttcactagatatgccgtgtaagc\n" + + "aaacaccttatgcttaatttcgaaaatattggtacttgaaaaaagctgtaggggtactta\n" + + "atgtctggtaggagatcaggagagaattgagtgtaaaaccgtaaagccctcacctgactt\n" + + "catgtaaatggcttagaagactccatgatttaataaatactacgaaggaaagactggatc"; +} diff --git a/src/main/java/org/linaro/benchmarks/benchmarksgame/mandelbrot.java b/src/main/java/org/linaro/benchmarks/benchmarksgame/mandelbrot.java new file mode 100644 index 0000000..df979d8 --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/benchmarksgame/mandelbrot.java @@ -0,0 +1,104 @@ +/* + * This benchmark has been ported from "The Computer Language Benchmarks Game" suite and slightly + * modified to fit the benchmarking framework. + * + * The original file is `mandelbrot/mandelbrot.java` from the archive + * available at + * http://benchmarksgame.alioth.debian.org/download/benchmarksgame-sourcecode.zip. + * See LICENSE file in the same folder (BSD 3-clause) + * + * The Computer Language Benchmarks Game + * http://benchmarksgame.alioth.debian.org/ + * + * contributed by Stefan Krause + * slightly modified by Chad Whipkey + */ + +/* + * Description: Generate Mandelbrot set portable bitmap file. + * Main Focus: TODO + * + */ + +package org.linaro.benchmarks.benchmarksgame; + +import java.io.IOException; +import java.io.PrintStream; +import java.lang.System; +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + +// CHECKSTYLE.OFF: .* +public class mandelbrot { + private static final int PREDEFINED_SIZE = 200; + + private static final int BUFFER_SIZE = 8192; + + public mandelbrot() { + this.size = PREDEFINED_SIZE; + fac = 2.0 / size; + shift = size % 8 == 0 ? 0 : (8- size % 8); + } + final int size; + final byte [] buf = new byte[BUFFER_SIZE]; + int bufLen = 0; + final double fac; + final int shift; + + public void compute() + { + for (int y = 0; y<size; y++) + computeRow(y); + } + + private void computeRow(int y) + { + int bits = 0; + + final double Ci = (y*fac - 1.0); + final byte[] bufLocal = buf; + for (int x = 0; x<size;x++) { + double Zr = 0.0; + double Zi = 0.0; + double Cr = (x*fac - 1.5); + int i = 50; + double ZrN = 0; + double ZiN = 0; + do { + Zi = 2.0 * Zr * Zi + Ci; + Zr = ZrN - ZiN + Cr; + ZiN = Zi * Zi; + ZrN = Zr * Zr; + } while (!(ZiN + ZrN > 4.0) && --i > 0); + + bits = bits << 1; + if (i == 0) bits++; + + if (x%8 == 7) { + bufLocal[bufLen++] = (byte) bits; + if ( bufLen == BUFFER_SIZE) { + bufLen = 0; + } + bits = 0; + } + } + if (shift!=0) { + bits = bits << shift; + bufLocal[bufLen++] = (byte) bits; + if ( bufLen == BUFFER_SIZE) { + bufLen = 0; + } + } + } + + // CHECKSTYLE.OFF: .* + @Benchmark + public void jmhTimeMandelbrot() { + bufLen = 0; + compute(); + } +} diff --git a/src/main/java/org/linaro/benchmarks/benchmarksgame/meteor.java b/src/main/java/org/linaro/benchmarks/benchmarksgame/meteor.java new file mode 100644 index 0000000..6671bb2 --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/benchmarksgame/meteor.java @@ -0,0 +1,479 @@ +/* + * This benchmark has been ported from "The Computer Language Benchmarks Game" suite and slightly + * modified to fit the benchmarking framework. + * + * The original file is `meteor/meteor.java` from the archive available at + * http://benchmarksgame.alioth.debian.org/download/benchmarksgame-sourcecode.zip. + * See LICENSE file in the same folder (BSD 3-clause) + * + * The Computer Language Benchmarks Game + * http://benchmarksgame.alioth.debian.org/ + * + * contributed by Tony Seebregts + * modified by + */ + +/* + * Description: Search for solutions to shape packing puzzle + * Main Focus: TODO + * + */ + +package org.linaro.benchmarks.benchmarksgame; + +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +//package benchmarks.benchmarksgame; + + +import java.util.ArrayList; +import java.util.Date; +import java.util.SortedSet; +import java.util.TreeSet; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + +/** First hack at a Java solver for the meteor puzzle - just the IBM + * developerWorks article algorithm optimized with precalculated shapes + * and bitmasks. Should be possible to optimize it some more to take + * advantage of reflections but its turning out to be less obvious + * than expected :-). + * <p> + * Notes: + * <ul> + * <li>Seems to run faster without the -server switch. + * <li>Testing for islands seems to be slower than just fitting pieces. + * </ul> + * + * @author Tony Seebregts + * + */ + +// CHECKSTYLE.OFF: .* +public class meteor + { // CONSTANTS + + private static final int[] SHIFT = { 0,6,11,17,22,28,33,39,44,50 }; + private static final long[][] MASK = { { 0x01L, 0x02L, 0x04L, 0x08L, 0x10L }, + { 0x01L << 6, 0x02L << 6, 0x04L << 6, 0x08L << 6,0x10L << 6 }, + { 0x01L << 11,0x02L << 11,0x04L << 11,0x08L << 11,0x10L << 11 }, + { 0x01L << 17,0x02L << 17,0x04L << 17,0x08L << 17,0x10L << 17 }, + { 0x01L << 22,0x02L << 22,0x04L << 22,0x08L << 22,0x10L << 22 }, + { 0x01L << 28,0x02L << 28,0x04L << 28,0x08L << 28,0x10L << 28 }, + { 0x01L << 33,0x02L << 33,0x04L << 33,0x08L << 33,0x10L << 33 }, + { 0x01L << 39,0x02L << 39,0x04L << 39,0x08L << 39,0x10L << 39 }, + { 0x01L << 44,0x02L << 44,0x04L << 44,0x08L << 44,0x10L << 44 }, + { 0x01L << 50,0x02L << 50,0x04L << 50,0x08L << 50,0x10L << 50 } + }; + + private static final boolean DEBUG = false; + + // CLASS VARIABLES + + // INSTANCE VARIABLES + + private SortedSet<String> solutions = new TreeSet<String>(); + private Entry[] solution = new Entry[10]; + private int depth = 0; + private Piece[] pieces = { new Piece(PIECE0), + new Piece(PIECE1), + new Piece(PIECE2), + new Piece(PIECE3), + new Piece(PIECE4), + new Piece(PIECE5), + new Piece(PIECE6), + new Piece(PIECE7), + new Piece(PIECE8), + new Piece(PIECE9) + }; + + // CLASS METHODS + + /** Prints out the puzzle. + * + * + */ + + private static void print (String solution) + { System.out.print(solution.replaceAll("(\\d{5})(\\d{5})","$1 $2") + .replaceAll("(\\d{5})","$1\n") + .replaceAll("(\\d)","$1 ")); + } + + // CONSTRUCTORS + + /** Initialises the puzzle. + * + */ + + public meteor () + { for (int i=0; i<10; i++) + solution[i] = new Entry(); + } + + // INSTANCE METHODS + + /** Initialises the puzzle and solution set at [0,0] + * + * @return Sorted list of solution strings. + */ + + private SortedSet<String> solve() + { solve(0x0002004008010020L,0,0); + + return solutions; + } + + /** Recursively solves the puzzle by fitting pieces into the + * next available hexagon. + * + * @param puzzle Current puzzle bitmask. + * @param row Row of next available hexagon. + * @param col Column next available hexagon. + * + */ + + private void solve (long puzzle,int row,int col) + { for (int ix=0; ix<pieces.length; ix++) + { Piece piece; + Shape[] list; + + // ... find shapes that fit + + if ((piece = pieces[ix]) == null) + continue; + else + list = pieces[ix].shapes(row,col); + + for (Shape shape: list) + { // ... fits badly ? + + if ((shape.bitmap & puzzle) != 0) + continue; + + // ... try piece in puzzle + + long clone = puzzle | shape.bitmap; + + // ... find next position + + int irow = row; + int icol = col/2 + 1; + + next: + while (irow < 10) + { while (icol < 5) + { if ((clone & MASK[irow][icol]) == 0) + break next; + + icol++; + } + + irow++; + icol = 0; + } + + // ... solve next + + Entry entry; + + pieces[ix] = null; + entry = solution[depth++]; + entry.row = row; + entry.col = col; + entry.shape = shape; + + if (depth == 10) + solutions.add(serialize(solution)); + else + solve (clone,irow,2*icol + (irow % 2)); + + depth--; + pieces[ix] = piece; + } + } + } + + /** Serializes the current solution to a string. + * + */ + + private String serialize (Entry[] solution) + { char[] puzzle = new char[50]; + Shape shape; + int row; + int col; + + for (Entry entry: solution) + { shape = entry.shape; + row = entry.row; + col = entry.col; + + for (int[] xy: shape.vector) + puzzle[5 * (row + xy[0]) + (col + xy[1])/2] = shape.symbol; + } + + return new String(puzzle); + } + + // INNER CLASSES + + /** Container class for a solution set entry. + * + */ + + private static class Entry + { public int row; + public int col; + public Shape shape; + } + + /** Container class for the shapes for a single puzzle piece. + * + * + */ + + private static class Piece + { private Shape[][][] shapes = new Shape[10][10][]; + + @SuppressWarnings("unchecked") + private Piece (Shape[] list) + { // ... initialise + + ArrayList[][] array = new ArrayList[10][10]; + + for (int i=0; i<10; i++) + for (int j=0; j<10; j++) + array[i][j] = new ArrayList<Shape>(); + + // ... generate list + + for (Shape mutant: list) + for (int row=0; row<=mutant.maxRow; row++) + for (int col=mutant.minCol; col<=mutant.maxCol; col++) + { if (!mutant.islet) + array[row][col].add(new Shape(mutant,row,col)); + else if ((row != 0) || (col != 0)) + array[row][col].add(new Shape(mutant,row,col)); + } + + for (int row=0; row<10; row++) + for (int col=0; col<10; col++) + shapes[row][col] = (Shape[]) array[row][col].toArray(new Shape[0]); + } + + @SuppressWarnings("unchecked") + private Shape[] shapes(int row,int col) + { return shapes[row][col]; + } + + } + + /** Container class for the shape vector and bitmap single puzzle piece mutation. + * + * + */ + + private static class Shape + { private char symbol; + private int[][] vector; + private long bitmap; + private int shift; + + private boolean islet; + private int maxRow; + private int minCol; + private int maxCol; + + private Shape (char symbol, + int[][] vector, + long bitmap, + int shift, + boolean islet, + int maxRow, + int minCol, + int maxCol) + { this.symbol = symbol; + this.vector = vector; + this.bitmap = bitmap; + this.shift = shift; + + this.islet = islet; + this.maxRow = maxRow; + this.minCol = minCol; + this.maxCol = maxCol; + } + + private Shape (Shape shape, + int row, + int col) + { this.symbol = shape.symbol; + this.vector = shape.vector; + this.bitmap = shape.bitmap << ((SHIFT[row] + (col - (row % 2))/2) - shape.shift); + + this.islet = shape.islet; + this.maxRow = shape.maxRow; + this.minCol = shape.minCol; + this.maxCol = shape.maxCol; + } + } + + // PIECES + + private static final Shape[] PIECE0 = { new Shape ('0',new int[][] {{3, 5},{2, 4},{1, 3},{0, 2},{0, 0}},0x0000000000082083L,0,false,6,0,4), + new Shape ('0',new int[][] {{4,-2},{3,-1},{2, 0},{1, 1},{0, 0}},0x0000000000421082L,1,false,5,2,8), + new Shape ('0',new int[][] {{1,-7},{1,-5},{1,-3},{1,-1},{0, 0}},0x00000000000003D0L,4,false,8,7,9), + new Shape ('0',new int[][] {{0, 0},{1, 1},{2, 2},{3, 3},{3, 5}},0x00000000000C1041L,0,false,6,0,4), + new Shape ('0',new int[][] {{0, 0},{1,-1},{2,-2},{3,-3},{4,-2}},0x0000000000821084L,2,false,5,3,9), + new Shape ('0',new int[][] {{0, 6},{0, 4},{0, 2},{0, 0},{1,-1}},0x000000000000005EL,1,false,8,1,3), + new Shape ('0',new int[][] {{0, 0},{1, 1},{2, 2},{3, 3},{4, 2}},0x0000000000841041L,0,false,5,0,6), + new Shape ('0',new int[][] {{0, 0},{1,-1},{2,-2},{3,-3},{3,-5}},0x0000000000062108L,3,false,6,5,9), + new Shape ('0',new int[][] {{1, 7},{1, 5},{1, 3},{1, 1},{0, 0}},0x00000000000003C1L,0,false,8,0,2), + new Shape ('0',new int[][] {{4, 2},{3, 1},{2, 0},{1,-1},{0, 0}},0x0000000001041042L,1,false,5,1,7), + new Shape ('0',new int[][] {{3,-3},{2,-2},{1,-1},{0, 0},{0, 2}},0x000000000002108CL,2,false,6,3,7), + new Shape ('0',new int[][] {{0, 0},{0, 2},{0, 4},{0, 6},{1, 7}},0x000000000000020FL,0,false,8,0,2) + }; + + private static final Shape[] PIECE1 = { new Shape ('1',new int[][] {{0, 2},{0, 0},{1,-1},{2, 0},{3,-1}},0x0000000000021046L,1,false,6,1,7), + new Shape ('1',new int[][] {{1, 3},{0, 2},{0, 0},{1,-1},{1,-3}},0x00000000000002CCL,2,false,8,3,6), + new Shape ('1',new int[][] {{3, 3},{2, 4},{1, 3},{1, 1},{0, 0}},0x00000000000420C1L,0,false,6,0,5), + new Shape ('1',new int[][] {{3,-3},{3,-1},{2, 0},{1,-1},{0, 0}},0x0000000000062084L,2,false,6,3,9), + new Shape ('1',new int[][] {{0, 0},{1, 1},{1, 3},{0, 4},{0, 6}},0x00000000000000CDL,0,true, 8,0,3), + new Shape ('1',new int[][] {{0, 0},{1,-1},{2, 0},{2, 2},{3, 3}},0x0000000000083042L,1,false,6,1,6), + new Shape ('1',new int[][] {{0, 6},{1, 5},{1, 3},{0, 2},{0, 0}},0x000000000000018BL,0,true, 8,0,3), + new Shape ('1',new int[][] {{3, 3},{3, 1},{2, 0},{1, 1},{0, 0}},0x0000000000060841L,0,false,6,0,6), + new Shape ('1',new int[][] {{3,-3},{2,-4},{1,-3},{1,-1},{0, 0}},0x00000000000208C4L,2,false,6,4,9), + new Shape ('1',new int[][] {{1,-1},{0, 0},{0, 2},{1, 3},{1, 5}},0x0000000000000346L,1,false,8,1,4), + new Shape ('1',new int[][] {{0, 0},{0, 2},{1, 3},{2, 2},{3, 3}},0x0000000000041083L,0,false,6,0,6), + new Shape ('1',new int[][] {{0, 0},{1, 1},{2, 0},{2,-2},{3,-3}},0x0000000000023104L,2,false,6,3,8) + }; + + private static final Shape[] PIECE2 = { new Shape ('2',new int[][] {{1, 1},{0, 0},{2, 0},{2,-2},{2,-4}},0x0000000000003904L,2,false,7,4,8), + new Shape ('2',new int[][] {{2, 4},{1, 5},{2, 2},{1, 1},{0, 0}},0x0000000000003141L,0,false,7,0,4), + new Shape ('2',new int[][] {{3,-1},{3, 1},{2,-2},{1,-1},{0, 0}},0x0000000000060842L,1,false,6,2,8), + new Shape ('2',new int[][] {{1,-1},{2, 0},{0, 0},{0, 2},{0, 4}},0x000000000000104EL,1,false,7,1,5), + new Shape ('2',new int[][] {{0, 0},{1,-1},{0, 2},{1, 3},{2, 4}},0x0000000000004146L,1,false,7,1,5), + new Shape ('2',new int[][] {{0, 2},{0, 0},{1, 3},{2, 2},{3, 1}},0x0000000000021083L,0,true, 6,0,6), + new Shape ('2',new int[][] {{0, 2},{1, 3},{0, 0},{1,-1},{2,-2}},0x0000000000000946L,1,false,7,2,6), + new Shape ('2',new int[][] {{1, 5},{2, 4},{0, 4},{0, 2},{0, 0}},0x0000000000002107L,0,false,7,0,4), + new Shape ('2',new int[][] {{3, 1},{3,-1},{2, 2},{1, 1},{0, 0}},0x0000000000062082L,1,false,6,1,7), + new Shape ('2',new int[][] {{2,-4},{1,-5},{2,-2},{1,-1},{0, 0}},0x0000000000003148L,3,false,7,5,9), + new Shape ('2',new int[][] {{1,-1},{0, 0},{2, 0},{2, 2},{2, 4}},0x0000000000007042L,1,false,7,1,5), + new Shape ('2',new int[][] {{0, 0},{0, 2},{1,-1},{2, 0},{3, 1}},0x0000000000041046L,1,false,6,1,7) + }; + + private static final Shape[] PIECE3 = { new Shape ('3',new int[][] {{0, 0},{2, 0},{1,-1},{2,-2},{2,-4}},0x0000000000003884L,2,false,7,4,9), + new Shape ('3',new int[][] {{1, 5},{2, 2},{1, 3},{1, 1},{0, 0}},0x00000000000011C1L,0,false,7,0,4), + new Shape ('3',new int[][] {{3, 1},{2,-2},{2, 0},{1,-1},{0, 0}},0x0000000000041842L,1,false,6,2,8), + new Shape ('3',new int[][] {{2, 0},{0, 0},{1, 1},{0, 2},{0, 4}},0x0000000000000847L,0,false,7,0,5), + new Shape ('3',new int[][] {{1,-3},{0, 0},{1,-1},{1, 1},{2, 2}},0x00000000000041C4L,2,false,7,3,7), + new Shape ('3',new int[][] {{0, 0},{1, 3},{1, 1},{2, 2},{3, 1}},0x00000000000210C1L,0,true, 6,0,6), + new Shape ('3',new int[][] {{1, 3},{0, 0},{1, 1},{1,-1},{2,-2}},0x00000000000009C2L,1,false,7,2,6), + new Shape ('3',new int[][] {{2, 4},{0, 4},{1, 3},{0, 2},{0, 0}},0x0000000000002087L,0,false,7,0,5), + new Shape ('3',new int[][] {{3,-1},{2, 2},{2, 0},{1, 1},{0, 0}},0x0000000000023082L,1,false,6,1,7), + new Shape ('3',new int[][] {{1,-5},{2,-2},{1,-3},{1,-1},{0, 0}},0x00000000000021C8L,3,false,7,5,9), + new Shape ('3',new int[][] {{0, 0},{2, 0},{1, 1},{2, 2},{2, 4}},0x0000000000003841L,0,false,7,0,5), + new Shape ('3',new int[][] {{0, 0},{1,-3},{1,-1},{2,-2},{3,-1}},0x00000000000410C4L,2,false,6,3,9) + }; + + private static final Shape[] PIECE4 = { new Shape ('4',new int[][] {{1, 5},{2, 2},{1, 3},{0, 2},{0, 0}},0x0000000000001183L,0,false,7,0,4), + new Shape ('4',new int[][] {{3, 1},{2,-2},{2, 0},{1, 1},{0, 0}},0x0000000000041882L,1,false,6,2,8), + new Shape ('4',new int[][] {{2, 0},{0, 0},{1, 1},{1, 3},{0, 4}},0x00000000000008C5L,0,true, 7,0,5), + new Shape ('4',new int[][] {{1,-3},{0, 0},{1,-1},{2, 0},{2, 2}},0x00000000000060C4L,2,false,7,3,7), + new Shape ('4',new int[][] {{0, 0},{1, 3},{1, 1},{2, 0},{3, 1}},0x00000000000208C1L,0,false,6,0,6), + new Shape ('4',new int[][] {{0, 0},{2, 0},{1,-1},{1,-3},{2,-4}},0x00000000000028C4L,2,false,7,4,9), + new Shape ('4',new int[][] {{0, 0},{1,-3},{1,-1},{2, 0},{3,-1}},0x00000000000420C4L,2,false,6,3,9), + new Shape ('4',new int[][] {{1, 3},{0, 0},{1, 1},{2, 0},{2,-2}},0x0000000000001982L,1,false,7,2,6), + new Shape ('4',new int[][] {{2, 4},{0, 4},{1, 3},{1, 1},{0, 0}},0x00000000000020C5L,0,true, 7,0,5), + new Shape ('4',new int[][] {{3,-1},{2, 2},{2, 0},{1,-1},{0, 0}},0x0000000000023042L,1,false,6,1,7), + new Shape ('4',new int[][] {{1,-3},{2, 0},{1,-1},{0, 0},{0, 2}},0x00000000000020CCL,2,false,7,3,7), + new Shape ('4',new int[][] {{0, 0},{2, 0},{1, 1},{1, 3},{2, 4}},0x00000000000028C1L,0,false,7,0,5) + }; + + private static final Shape[] PIECE5 = { new Shape ('5',new int[][] {{0, 2},{1, 1},{0, 0},{1,-1},{2,-2}},0x00000000000008C6L,1,false,7,2,7), + new Shape ('5',new int[][] {{1, 5},{1, 3},{0, 4},{0, 2},{0, 0}},0x0000000000000187L,0,false,8,0,4), + new Shape ('5',new int[][] {{3, 1},{2, 0},{2, 2},{1, 1},{0, 0}},0x0000000000021841L,0,false,6,0,7), + new Shape ('5',new int[][] {{2,-4},{1,-3},{2,-2},{1,-1},{0, 0}},0x00000000000018C4L,2,false,7,4,9), + new Shape ('5',new int[][] {{0, 0},{0, 2},{1, 1},{1, 3},{1, 5}},0x00000000000001C3L,0,false,8,0,4), + new Shape ('5',new int[][] {{0, 0},{1, 1},{1,-1},{2, 0},{3, 1}},0x00000000000410C2L,1,false,6,1,8), + new Shape ('5',new int[][] {{0, 2},{0, 0},{1, 1},{1,-1},{1,-3}},0x00000000000001CCL,2,false,8,3,7), + new Shape ('5',new int[][] {{2, 4},{1, 3},{2, 2},{1, 1},{0, 0}},0x00000000000030C1L,0,false,7,0,5), + new Shape ('5',new int[][] {{3,-1},{2, 0},{2,-2},{1,-1},{0, 0}},0x0000000000021842L,1,false,6,2,9), + new Shape ('5',new int[][] {{1,-1},{1, 1},{0, 0},{0, 2},{0, 4}},0x00000000000000CEL,1,false,8,1,5), + new Shape ('5',new int[][] {{0, 0},{1, 1},{0, 2},{1, 3},{2, 4}},0x00000000000020C3L,0,false,7,0,5), + new Shape ('5',new int[][] {{0, 0},{1,-1},{1, 1},{2, 0},{3,-1}},0x00000000000210C2L,1,false,6,1,8) + }; + + private static final Shape[] PIECE6 = { new Shape ('6',new int[][] {{1, 1},{0, 0},{1,-1},{1,-3},{2,-4}},0x00000000000009C4L,2,false,7,4,8), + new Shape ('6',new int[][] {{2, 4},{1, 5},{1, 3},{0, 2},{0, 0}},0x0000000000002183L,0,false,7,0,4), + new Shape ('6',new int[][] {{3,-1},{3, 1},{2, 0},{1, 1},{0, 0}},0x0000000000061082L,1,false,6,1,8), + new Shape ('6',new int[][] {{1,-5},{2,-4},{1,-3},{1,-1},{0, 0}},0x00000000000011C8L,3,false,7,5,9), + new Shape ('6',new int[][] {{0, 0},{1,-1},{1, 1},{2, 2},{2, 4}},0x00000000000060C2L,1,false,7,1,5), + new Shape ('6',new int[][] {{0, 2},{0, 0},{1, 1},{2, 0},{3, 1}},0x0000000000020843L,0,false,6,0,7), + new Shape ('6',new int[][] {{0, 0},{1, 1},{1,-1},{2,-2},{2,-4}},0x0000000000001984L,2,false,7,4,8), + new Shape ('6',new int[][] {{1, 5},{2, 4},{1, 3},{1, 1},{0, 0}},0x00000000000021C1L,0,false,7,0,4), + new Shape ('6',new int[][] {{3, 1},{3,-1},{2, 0},{1,-1},{0, 0}},0x0000000000061042L,1,false,6,1,8), + new Shape ('6',new int[][] {{2,-2},{1,-3},{1,-1},{0, 0},{0, 2}},0x00000000000010CCL,2,false,7,3,7), + new Shape ('6',new int[][] {{1,-1},{0, 0},{1, 1},{1, 3},{2, 4}},0x00000000000041C2L,1,false,7,1,5), + new Shape ('6',new int[][] {{0, 0},{0, 2},{1, 1},{2, 2},{3, 1}},0x0000000000021043L,0,false,6,0,7) + }; + + private static final Shape[] PIECE7 = { new Shape ('7',new int[][] {{0, 2},{1, 1},{0, 0},{2, 0},{2,-2}},0x0000000000001886L,1,false,7,2,7), + new Shape ('7',new int[][] {{1, 5},{1, 3},{0, 4},{1, 1},{0, 0}},0x00000000000001C5L,0,true, 8,0,4), + new Shape ('7',new int[][] {{3, 1},{2, 0},{2, 2},{1,-1},{0, 0}},0x0000000000043042L,1,false,6,1,7), + new Shape ('7',new int[][] {{2,-2},{1,-1},{2, 0},{0, 0},{0, 2}},0x0000000000001846L,1,false,7,2,7), + new Shape ('7',new int[][] {{0, 0},{0, 2},{1, 1},{0, 4},{1, 5}},0x0000000000000147L,0,false,8,0,4), + new Shape ('7',new int[][] {{0, 0},{1, 1},{1,-1},{2, 2},{3, 1}},0x00000000000420C2L,1,false,6,1,7), + new Shape ('7',new int[][] {{0, 4},{0, 2},{1, 3},{0, 0},{1,-1}},0x000000000000014EL,1,false,8,1,5), + new Shape ('7',new int[][] {{2, 4},{1, 3},{2, 2},{0, 2},{0, 0}},0x0000000000003083L,0,false,7,0,5), + new Shape ('7',new int[][] {{3,-1},{2, 0},{2,-2},{1, 1},{0, 0}},0x0000000000021882L,1,false,6,2,8), + new Shape ('7',new int[][] {{1,-1},{1, 1},{0, 0},{1, 3},{0, 4}},0x00000000000001CAL,1,false,8,1,5), + new Shape ('7',new int[][] {{0, 0},{1, 1},{0, 2},{2, 2},{2, 4}},0x0000000000003043L,0,false,7,0,5), + new Shape ('7',new int[][] {{0, 0},{1,-1},{1, 1},{2,-2},{3,-1}},0x00000000000208C2L,1,false,6,2,8) + }; + + private static final Shape[] PIECE8 = { new Shape ('8',new int[][] {{4, 2},{3, 1},{2, 0},{1, 1},{0, 0}},0x0000000000820841L,0,false,5,0,7), + new Shape ('8',new int[][] {{3,-5},{2,-4},{1,-3},{1,-1},{0, 0}},0x0000000000021188L,3,false,6,5,9), + new Shape ('8',new int[][] {{0, 0},{0, 2},{0, 4},{1, 5},{1, 7}},0x0000000000000307L,0,false,8,0,2), + new Shape ('8',new int[][] {{0, 0},{1, 1},{2, 2},{3, 1},{4, 2}},0x0000000000821041L,0,true, 5,0,7), + new Shape ('8',new int[][] {{0, 0},{1,-1},{2,-2},{2,-4},{3,-5}},0x0000000000023108L,3,false,6,5,9), + new Shape ('8',new int[][] {{1, 7},{1, 5},{1, 3},{0, 2},{0, 0}},0x0000000000000383L,0,false,8,0,2), + new Shape ('8',new int[][] {{0, 0},{1, 1},{2, 2},{2, 4},{3, 5}},0x0000000000083041L,0,false,6,0,4), + new Shape ('8',new int[][] {{0, 0},{1,-1},{2,-2},{3,-1},{4,-2}},0x0000000000420842L,1,false,5,2,9), + new Shape ('8',new int[][] {{0, 4},{0, 2},{0, 0},{1,-1},{1,-3}},0x00000000000000DCL,2,false,8,3,5), + new Shape ('8',new int[][] {{3, 5},{2, 4},{1, 3},{1, 1},{0, 0}},0x00000000000820C1L,0,false,6,0,4), + new Shape ('8',new int[][] {{4,-2},{3,-1},{2, 0},{1,-1},{0, 0}},0x0000000000421042L,1,false,5,2,9), + new Shape ('8',new int[][] {{1,-5},{1,-3},{1,-1},{0, 0},{0, 2}},0x00000000000001D8L,3,false,8,5,7) + }; + + private static final Shape[] PIECE9 = { new Shape ('9',new int[][] {{3, 3},{2, 2},{1, 1},{0, 0},{0, 2}},0x0000000000041043L,0,false,6,0,6), + new Shape ('9',new int[][] {{3,-3},{2,-2},{1,-1},{0, 0},{1, 1}},0x0000000000021184L,2,false,6,3,8), + new Shape ('9',new int[][] {{0, 0},{0, 2},{0, 4},{0, 6},{1, 5}},0x000000000000010FL,0,false,8,0,3), + new Shape ('9',new int[][] {{0, 0},{1, 1},{2, 2},{3, 3},{3, 1}},0x0000000000061041L,0,true, 6,0,6), + new Shape ('9',new int[][] {{0, 0},{1,-1},{2,-2},{3,-3},{2,-4}},0x0000000000021884L,2,false,6,4,9), + new Shape ('9',new int[][] {{1, 5},{1, 3},{1, 1},{1,-1},{0, 0}},0x00000000000003C2L,1,false,8,1,4), + new Shape ('9',new int[][] {{0, 0},{1, 1},{2, 2},{3, 3},{2, 4}},0x0000000000043041L,0,false,6,0,5), + new Shape ('9',new int[][] {{0, 0},{1,-1},{2,-2},{3,-3},{3,-1}},0x0000000000061084L,2,false,6,3,9), + new Shape ('9',new int[][] {{0, 6},{0, 4},{0, 2},{0, 0},{1, 1}},0x000000000000004FL,0,false,8,0,3), + new Shape ('9',new int[][] {{3, 3},{2, 2},{1, 1},{0, 0},{1,-1}},0x00000000000820C2L,1,false,6,1,6), + new Shape ('9',new int[][] {{3,-1},{2, 0},{1, 1},{0, 2},{0, 0}},0x0000000000021086L,1,false,6,1,7), + new Shape ('9',new int[][] {{1,-5},{1,-3},{1,-1},{1, 1},{0, 0}},0x00000000000003C8L,3,false,8,5,8) + }; + + // CHECKSTYLE.ON: .* + + public void resetMeteor() { + for (int i = 0; i < 10; ++i) { + solution[i] = new Entry(); + } + } + + @Benchmark + public void jmhTimeMeteor() { + solve(); + resetMeteor(); + } +} diff --git a/src/main/java/org/linaro/benchmarks/benchmarksgame/nbody.java b/src/main/java/org/linaro/benchmarks/benchmarksgame/nbody.java new file mode 100644 index 0000000..ab5ebf3 --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/benchmarksgame/nbody.java @@ -0,0 +1,204 @@ +/* + * This benchmark has been ported from "The Computer Language Benchmarks Game" suite and slightly + * modified to fit the benchmarking framework. + * + * The original file is `nbody/nbody.java` from the archive available at + * http://benchmarksgame.alioth.debian.org/download/benchmarksgame-sourcecode.zip. + * See LICENSE file in the same folder (BSD 3-clause) + * + * The Computer Language Benchmarks Game + * http://benchmarksgame.alioth.debian.org/ + * + * contributed by Mark C. Lewis + * modified slightly by Chad Whipkey + * + * Same program, different command-line: + * -XX:MaxMetaspaceSize=3m -XX:InitialCodeCacheSize=2048K -XX:ReservedCodeCacheSize=2048K + */ + +/* + * Description: Double-precision N-body simulation. + * Main Focus: TODO + * + */ + +package org.linaro.benchmarks.benchmarksgame; + +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +// CHECKSTYLE.OFF: .* +final class NBodySystem { + private Body[] bodies; + + public NBodySystem(){ + bodies = new Body[]{ + Body.sun(), + Body.jupiter(), + Body.saturn(), + Body.uranus(), + Body.neptune() + }; + + double px = 0.0; + double py = 0.0; + double pz = 0.0; + for(int i=0; i < bodies.length; ++i) { + px += bodies[i].vx * bodies[i].mass; + py += bodies[i].vy * bodies[i].mass; + pz += bodies[i].vz * bodies[i].mass; + } + bodies[0].offsetMomentum(px,py,pz); + } + + public void advance(double dt) { + + for(int i=0; i < bodies.length; ++i) { + Body iBody = bodies[i]; + for(int j=i+1; j < bodies.length; ++j) { + double dx = iBody.x - bodies[j].x; + double dy = iBody.y - bodies[j].y; + double dz = iBody.z - bodies[j].z; + + double dSquared = dx * dx + dy * dy + dz * dz; + double distance = Math.sqrt(dSquared); + double mag = dt / (dSquared * distance); + + iBody.vx -= dx * bodies[j].mass * mag; + iBody.vy -= dy * bodies[j].mass * mag; + iBody.vz -= dz * bodies[j].mass * mag; + + bodies[j].vx += dx * iBody.mass * mag; + bodies[j].vy += dy * iBody.mass * mag; + bodies[j].vz += dz * iBody.mass * mag; + } + } + + for ( Body body : bodies) { + body.x += dt * body.vx; + body.y += dt * body.vy; + body.z += dt * body.vz; + } + } + + public double energy(){ + double dx, dy, dz, distance; + double e = 0.0; + + for (int i=0; i < bodies.length; ++i) { + Body iBody = bodies[i]; + e += 0.5 * iBody.mass * + ( iBody.vx * iBody.vx + + iBody.vy * iBody.vy + + iBody.vz * iBody.vz ); + + for (int j=i+1; j < bodies.length; ++j) { + Body jBody = bodies[j]; + dx = iBody.x - jBody.x; + dy = iBody.y - jBody.y; + dz = iBody.z - jBody.z; + + distance = Math.sqrt(dx*dx + dy*dy + dz*dz); + e -= (iBody.mass * jBody.mass) / distance; + } + } + return e; + } +} + + +final class Body { + static final double PI = 3.141592653589793; + static final double SOLAR_MASS = 4 * PI * PI; + static final double DAYS_PER_YEAR = 365.24; + + public double x, y, z, vx, vy, vz, mass; + + public Body(){} + + static Body jupiter(){ + Body p = new Body(); + p.x = 4.84143144246472090e+00; + p.y = -1.16032004402742839e+00; + p.z = -1.03622044471123109e-01; + p.vx = 1.66007664274403694e-03 * DAYS_PER_YEAR; + p.vy = 7.69901118419740425e-03 * DAYS_PER_YEAR; + p.vz = -6.90460016972063023e-05 * DAYS_PER_YEAR; + p.mass = 9.54791938424326609e-04 * SOLAR_MASS; + return p; + } + + static Body saturn(){ + Body p = new Body(); + p.x = 8.34336671824457987e+00; + p.y = 4.12479856412430479e+00; + p.z = -4.03523417114321381e-01; + p.vx = -2.76742510726862411e-03 * DAYS_PER_YEAR; + p.vy = 4.99852801234917238e-03 * DAYS_PER_YEAR; + p.vz = 2.30417297573763929e-05 * DAYS_PER_YEAR; + p.mass = 2.85885980666130812e-04 * SOLAR_MASS; + return p; + } + + static Body uranus(){ + Body p = new Body(); + p.x = 1.28943695621391310e+01; + p.y = -1.51111514016986312e+01; + p.z = -2.23307578892655734e-01; + p.vx = 2.96460137564761618e-03 * DAYS_PER_YEAR; + p.vy = 2.37847173959480950e-03 * DAYS_PER_YEAR; + p.vz = -2.96589568540237556e-05 * DAYS_PER_YEAR; + p.mass = 4.36624404335156298e-05 * SOLAR_MASS; + return p; + } + + static Body neptune(){ + Body p = new Body(); + p.x = 1.53796971148509165e+01; + p.y = -2.59193146099879641e+01; + p.z = 1.79258772950371181e-01; + p.vx = 2.68067772490389322e-03 * DAYS_PER_YEAR; + p.vy = 1.62824170038242295e-03 * DAYS_PER_YEAR; + p.vz = -9.51592254519715870e-05 * DAYS_PER_YEAR; + p.mass = 5.15138902046611451e-05 * SOLAR_MASS; + return p; + } + + static Body sun(){ + Body p = new Body(); + p.mass = SOLAR_MASS; + return p; + } + + Body offsetMomentum(double px, double py, double pz){ + vx = -px / SOLAR_MASS; + vy = -py / SOLAR_MASS; + vz = -pz / SOLAR_MASS; + return this; + } +} + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + +public class nbody { + // CHECKSTYLE.ON: .* + private NBodySystem bodies; + + public nbody() { + bodies = new NBodySystem(); + } + + private static final int PREDEFINED_N_STEPS = 1000; + + public void solve() { + for (int i = 0; i < PREDEFINED_N_STEPS; ++i) { + bodies.advance(0.01); + } + } + @Benchmark + public void jmhTimeNBody() { + solve(); + } +} diff --git a/src/main/java/org/linaro/benchmarks/benchmarksgame/pidigits.java b/src/main/java/org/linaro/benchmarks/benchmarksgame/pidigits.java new file mode 100644 index 0000000..fffb7d1 --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/benchmarksgame/pidigits.java @@ -0,0 +1,156 @@ +/* + * This benchmark has been ported from "The Computer Language Benchmarks Game" suite and slightly + * modified to fit the benchmarking framework. + * + * The original file is `pidigits/pidigits.java` from the archive + * available at + * http://benchmarksgame.alioth.debian.org/download/benchmarksgame-sourcecode.zip. + * See LICENSE file in the same folder (BSD 3-clause) + * + * The Computer Language Benchmarks Game + * http://benchmarksgame.alioth.debian.org/ + * + * contributed by Isaac Gouy + */ + +/* + * Description: Streaming arbitrary-precision arithmetic. + * Main Focus: TODO + * + */ + +package org.linaro.benchmarks.benchmarksgame; + +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; +import java.math.BigInteger; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + +// CHECKSTYLE.OFF: .* +public class pidigits { + static final int L = 10; + private static final int PREDEFINED_N_DIGITS = 27; + + public static void old_main() { + int n = PREDEFINED_N_DIGITS; + int j = 0; + + PiDigitSpigot digits = new PiDigitSpigot(); + + while (n > 0){ + if (n >= L){ + for (int i=0; i<L; i++) digits.next(); + j += L; + } else { + for (int i=0; i<n; i++) digits.next(); + j += n; + } + n -= L; + } + } + // CHECKSTYLE.ON: .* + @Benchmark + public void jmhTimePidigits() { + old_main(); + } +} + + +// CHECKSTYLE.OFF: .* +class PiDigitSpigot { + Transformation z, x, inverse; + + public PiDigitSpigot(){ + z = new Transformation(1,0,0,1); + x = new Transformation(0,0,0,0); + inverse = new Transformation(0,0,0,0); + } + + public int next(){ + int y = digit(); + if (isSafe(y)){ + z = produce(y); return y; + } else { + z = consume( x.next() ); return next(); + } + } + + public int digit(){ + return z.extract(3); + } + + public boolean isSafe(int digit){ + return digit == z.extract(4); + } + + public Transformation produce(int i){ + return ( inverse.qrst(10,-10*i,0,1) ).compose(z); + } + + public Transformation consume(Transformation a){ + return z.compose(a); + } +} + + +class Transformation { + BigInteger q, r, s, t; + int k; + + public Transformation(int q, int r, int s, int t){ + this.q = BigInteger.valueOf(q); + this.r = BigInteger.valueOf(r); + this.s = BigInteger.valueOf(s); + this.t = BigInteger.valueOf(t); + k = 0; + } + + public Transformation(BigInteger q, BigInteger r, BigInteger s, BigInteger t){ + this.q = q; + this.r = r; + this.s = s; + this.t = t; + k = 0; + } + + public Transformation next(){ + k++; + q = BigInteger.valueOf(k); + r = BigInteger.valueOf(4 * k + 2); + s = BigInteger.valueOf(0); + t = BigInteger.valueOf(2 * k + 1); + return this; + } + + public int extract(int j){ + BigInteger bigj = BigInteger.valueOf(j); + BigInteger numerator = (q.multiply(bigj)).add(r); + BigInteger denominator = (s.multiply(bigj)).add(t); + return ( numerator.divide(denominator) ).intValue(); + } + + public Transformation qrst(int q, int r, int s, int t){ + this.q = BigInteger.valueOf(q); + this.r = BigInteger.valueOf(r); + this.s = BigInteger.valueOf(s); + this.t = BigInteger.valueOf(t); + k = 0; + return this; + } + + public Transformation compose(Transformation a){ + return new Transformation( + q.multiply(a.q) + ,(q.multiply(a.r)).add( (r.multiply(a.t)) ) + ,(s.multiply(a.q)).add( (t.multiply(a.s)) ) + ,(s.multiply(a.r)).add( (t.multiply(a.t)) ) + ); + } +} +// CHECKSTYLE.ON: .* + + + diff --git a/src/main/java/org/linaro/benchmarks/benchmarksgame/regexdna.java b/src/main/java/org/linaro/benchmarks/benchmarksgame/regexdna.java new file mode 100644 index 0000000..63a214c --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/benchmarksgame/regexdna.java @@ -0,0 +1,1160 @@ +/* + * This benchmark has been ported from "The Computer Language Benchmarks Game" suite and slightly + * modified to fit the benchmarking framework. + * + * The original file is `regexdna/regexdna.java-4.java` from the archive + * available at + * http://benchmarksgame.alioth.debian.org/download/benchmarksgame-sourcecode.zip. + * See LICENSE file in the same folder (BSD 3-clause) + * + * The Computer Language Benchmarks Game + * http://benchmarksgame.alioth.debian.org/ + * contributed by Razii, idea taken from Elliott Hughes and Roger Millington + */ + +/* + * Description: Match DNA 8-mers and substitute nucleotides for IUB codes. + * Main Focus: TODO + * + */ + +package org.linaro.benchmarks.benchmarksgame; + +// CHECKSTYLE.OFF: .* +import java.io.*; +import java.util.regex.*; +import java.util.*; +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + +public class regexdna { + + private static final Map<String, String> replacements = new HashMap<String, String>(); + private InputStream stream; + private char[] cbuf; + private Reader r; + private StringBuilder sb; + static String[] variants = { "agggtaaa|tttaccct" , + "[cgt]gggtaaa|tttaccc[acg]", + "a[act]ggtaaa|tttacc[agt]t", + "ag[act]gtaaa|tttac[agt]ct", + "agg[act]taaa|ttta[agt]cct", + "aggg[acg]aaa|ttt[cgt]ccct", + "agggt[cgt]aa|tt[acg]accct", + "agggta[cgt]a|t[acg]taccct", + "agggtaa[cgt]|[acg]ttaccct" + }; + + public regexdna() { + stream = new ByteArrayInputStream(fastaStr.getBytes()); + cbuf = new char[16384]; + //TODO (jmh) Catch IOException in JMH instead of catched here. + // Because class regexdna in art-testing throws IOException not catched here. + try { + r = new InputStreamReader(stream, "ISO-8859-1"); + // Move code block below from main loop to here to reduce noise. + stream.reset(); + sb = new StringBuilder(5100000); + int charsRead; + while ((charsRead = r.read(cbuf)) != -1) + sb.append(cbuf, 0, charsRead); + // int initialLength = sb.length(); + } catch (IOException e){ + e.printStackTrace(); + } + } + + static { + + replacements.put("W", "(a|t)"); + replacements.put("Y", "(c|t)"); + replacements.put("K", "(g|t)"); + replacements.put("M", "(a|c)"); + replacements.put("S", "(c|g)"); + replacements.put("R", "(a|g)"); + replacements.put("B", "(c|g|t)"); + replacements.put("D", "(a|g|t)"); + replacements.put("V", "(a|c|g)"); + replacements.put("H", "(a|c|t)"); + replacements.put("N", "(a|c|g|t)"); + } + + static abstract class Rewriter { + private Pattern pattern; + private Matcher matcher; + + public Rewriter(String regularExpression) { + + this.pattern = Pattern.compile(regularExpression); + } + + public String group(int i) { + return matcher.group(i); + } + + public abstract String replacement(); + + public String rewrite(CharSequence original) { + return rewrite(original, new StringBuffer(original.length())).toString(); + } + + public StringBuffer rewrite(CharSequence original, StringBuffer destination) { + this.matcher = pattern.matcher(original); + while (matcher.find()) { + matcher.appendReplacement(destination, ""); + destination.append(replacement()); + } + matcher.appendTail(destination); + return destination; + } + } + + public static void main(String [] args) throws Exception { + regexdna rd = new regexdna(); + for (int i = 0; i < 100; i++) + rd.old_main(); + } + + public int old_main() throws IOException { + + String sequence = new Rewriter(">.*\n|\n") { + + public String replacement() { + return ""; + } + }.rewrite(sb); + + // int codeLength = sequence.length(); + + int count = 0; + for (String variant : variants) { + + Matcher m = Pattern.compile(variant).matcher(sequence); + while (m.find()) + count++; + } + + sequence = new Rewriter("[WYKMSRBDVHN]") { + + public String replacement() { + return replacements.get(group(0)); + } + }.rewrite(sequence); + + return count; + } + // CHECKSTYLE.ON: .* + + @Benchmark + public void jmhTimeRegexDna() throws IOException { + old_main(); + } + + private static final String fastaStr = ">ONE Homo sapiens alu\n" + + "GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA\n" + + "TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT\n" + + "AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG\n" + + "GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG\n" + + "CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT\n" + + "GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA\n" + + "GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA\n" + + "TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG\n" + + "AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA\n" + + "GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT\n" + + "AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC\n" + + "AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG\n" + + "GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC\n" + + "CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG\n" + + "AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT\n" + + "TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA\n" + + "TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT\n" + + "GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG\n" + + "TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT\n" + + "CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG\n" + + "CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG\n" + + "TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA\n" + + "CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG\n" + + "AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG\n" + + "GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC\n" + + "TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA\n" + + "TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA\n" + + "GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT\n" + + "GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC\n" + + "ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT\n" + + "TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC\n" + + "CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG\n" + + "CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG\n" + + "GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC\n" + + "CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT\n" + + "GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC\n" + + "GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA\n" + + "GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA\n" + + "GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA\n" + + "GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG\n" + + "AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT\n" + + "CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA\n" + + "GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA\n" + + "AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC\n" + + "GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT\n" + + "ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG\n" + + "GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC\n" + + "GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC\n" + + "GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG\n" + + "TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA\n" + + "AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG\n" + + "GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT\n" + + "CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC\n" + + "TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG\n" + + "ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC\n" + + "GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA\n" + + "ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA\n" + + "CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA\n" + + "CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA\n" + + "ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG\n" + + "CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG\n" + + "AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC\n" + + "CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG\n" + + "AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC\n" + + "CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG\n" + + "CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG\n" + + "CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG\n" + + "CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC\n" + + "ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA\n" + + "AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC\n" + + "TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC\n" + + "ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG\n" + + "CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG\n" + + "AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT\n" + + "AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA\n" + + "TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC\n" + + "CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA\n" + + "TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG\n" + + "CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT\n" + + "GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG\n" + + "GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG\n" + + "CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG\n" + + "GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG\n" + + "GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT\n" + + "AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT\n" + + "GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT\n" + + "CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG\n" + + "GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC\n" + + "TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT\n" + + "CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG\n" + + "ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG\n" + + "CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG\n" + + "AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA\n" + + "CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG\n" + + "CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC\n" + + "ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC\n" + + "GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC\n" + + "GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG\n" + + "GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT\n" + + "TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG\n" + + "CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA\n" + + "GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG\n" + + "CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC\n" + + "GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG\n" + + "CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA\n" + + "CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG\n" + + "CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA\n" + + "ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC\n" + + "CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT\n" + + "GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA\n" + + "AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG\n" + + "ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC\n" + + "TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA\n" + + "GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC\n" + + "GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG\n" + + "TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC\n" + + "AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA\n" + + "ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA\n" + + "GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC\n" + + "AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG\n" + + "TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC\n" + + "CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT\n" + + "GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC\n" + + "CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA\n" + + "GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT\n" + + "TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC\n" + + "ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC\n" + + "TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG\n" + + "GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG\n" + + "TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG\n" + + "GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC\n" + + "GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT\n" + + "ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC\n" + + "GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC\n" + + "GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC\n" + + "CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA\n" + + "ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG\n" + + "AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC\n" + + "TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT\n" + + "CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG\n" + + "TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG\n" + + "CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC\n" + + "GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT\n" + + "GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC\n" + + "CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC\n" + + "TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG\n" + + "CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG\n" + + "AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG\n" + + "AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG\n" + + "AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT\n" + + "GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA\n" + + "TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC\n" + + "AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA\n" + + "AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG\n" + + "CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC\n" + + "TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG\n" + + "GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT\n" + + "CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG\n" + + "CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG\n" + + "GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA\n" + + "AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA\n" + + "GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC\n" + + "TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC\n" + + "CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA\n" + + "GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG\n" + + "CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG\n" + + "AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG\n" + + "ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC\n" + + "ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC\n" + + "AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC\n" + + "GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG\n" + + "GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT\n" + + "CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC\n" + + "GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC\n" + + "CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA\n" + + "GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA\n" + + "GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG\n" + + "GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT\n" + + "CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA\n" + + "AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG\n" + + "CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC\n" + + "CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG\n" + + "GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG\n" + + "GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT\n" + + "TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA\n" + + "ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG\n" + + "CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA\n" + + "ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA\n" + + "GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG\n" + + "TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC\n" + + "GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA\n" + + "GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT\n" + + "GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT\n" + + "GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG\n" + + "TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT\n" + + "TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC\n" + + "TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC\n" + + "GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT\n" + + "CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC\n" + + "TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA\n" + + ">TWO IUB ambiguity codes\n" + + "cttBtatcatatgctaKggNcataaaSatgtaaaDcDRtBggDtctttataattcBgtcg\n" + + "tactDtDagcctatttSVHtHttKtgtHMaSattgWaHKHttttagacatWatgtRgaaa\n" + + "NtactMcSMtYtcMgRtacttctWBacgaaatatagScDtttgaagacacatagtVgYgt\n" + + "cattHWtMMWcStgttaggKtSgaYaaccWStcgBttgcgaMttBYatcWtgacaYcaga\n" + + "gtaBDtRacttttcWatMttDBcatWtatcttactaBgaYtcttgttttttttYaaScYa\n" + + "HgtgttNtSatcMtcVaaaStccRcctDaataataStcYtRDSaMtDttgttSagtRRca\n" + + "tttHatSttMtWgtcgtatSSagactYaaattcaMtWatttaSgYttaRgKaRtccactt\n" + + "tattRggaMcDaWaWagttttgacatgttctacaaaRaatataataaMttcgDacgaSSt\n" + + "acaStYRctVaNMtMgtaggcKatcttttattaaaaagVWaHKYagtttttatttaacct\n" + + "tacgtVtcVaattVMBcttaMtttaStgacttagattWWacVtgWYagWVRctDattBYt\n" + + "gtttaagaagattattgacVatMaacattVctgtBSgaVtgWWggaKHaatKWcBScSWa\n" + + "accRVacacaaactaccScattRatatKVtactatatttHttaagtttSKtRtacaaagt\n" + + "RDttcaaaaWgcacatWaDgtDKacgaacaattacaRNWaatHtttStgttattaaMtgt\n" + + "tgDcgtMgcatBtgcttcgcgaDWgagctgcgaggggVtaaScNatttacttaatgacag\n" + + "cccccacatYScaMgtaggtYaNgttctgaMaacNaMRaacaaacaKctacatagYWctg\n" + + "ttWaaataaaataRattagHacacaagcgKatacBttRttaagtatttccgatctHSaat\n" + + "actcNttMaagtattMtgRtgaMgcataatHcMtaBSaRattagttgatHtMttaaKagg\n" + + "YtaaBataSaVatactWtataVWgKgttaaaacagtgcgRatatacatVtHRtVYataSa\n" + + "KtWaStVcNKHKttactatccctcatgWHatWaRcttactaggatctataDtDHBttata\n" + + "aaaHgtacVtagaYttYaKcctattcttcttaataNDaaggaaaDYgcggctaaWSctBa\n" + + "aNtgctggMBaKctaMVKagBaactaWaDaMaccYVtNtaHtVWtKgRtcaaNtYaNacg\n" + + "gtttNattgVtttctgtBaWgtaattcaagtcaVWtactNggattctttaYtaaagccgc\n" + + "tcttagHVggaYtgtNcDaVagctctctKgacgtatagYcctRYHDtgBattDaaDgccK\n" + + "tcHaaStttMcctagtattgcRgWBaVatHaaaataYtgtttagMDMRtaataaggatMt\n" + + "ttctWgtNtgtgaaaaMaatatRtttMtDgHHtgtcattttcWattRSHcVagaagtacg\n" + + "ggtaKVattKYagactNaatgtttgKMMgYNtcccgSKttctaStatatNVataYHgtNa\n" + + "BKRgNacaactgatttcctttaNcgatttctctataScaHtataRagtcRVttacDSDtt\n" + + "aRtSatacHgtSKacYagttMHtWataggatgactNtatSaNctataVtttRNKtgRacc\n" + + "tttYtatgttactttttcctttaaacatacaHactMacacggtWataMtBVacRaSaatc\n" + + "cgtaBVttccagccBcttaRKtgtgcctttttRtgtcagcRttKtaaacKtaaatctcac\n" + + "aattgcaNtSBaaccgggttattaaBcKatDagttactcttcattVtttHaaggctKKga\n" + + "tacatcBggScagtVcacattttgaHaDSgHatRMaHWggtatatRgccDttcgtatcga\n" + + "aacaHtaagttaRatgaVacttagattVKtaaYttaaatcaNatccRttRRaMScNaaaD\n" + + "gttVHWgtcHaaHgacVaWtgttScactaagSgttatcttagggDtaccagWattWtRtg\n" + + "ttHWHacgattBtgVcaYatcggttgagKcWtKKcaVtgaYgWctgYggVctgtHgaNcV\n" + + "taBtWaaYatcDRaaRtSctgaHaYRttagatMatgcatttNattaDttaattgttctaa\n" + + "ccctcccctagaWBtttHtBccttagaVaatMcBHagaVcWcagBVttcBtaYMccagat\n" + + "gaaaaHctctaacgttagNWRtcggattNatcRaNHttcagtKttttgWatWttcSaNgg\n" + + "gaWtactKKMaacatKatacNattgctWtatctaVgagctatgtRaHtYcWcttagccaa\n" + + "tYttWttaWSSttaHcaaaaagVacVgtaVaRMgattaVcDactttcHHggHRtgNcctt\n" + + "tYatcatKgctcctctatVcaaaaKaaaagtatatctgMtWtaaaacaStttMtcgactt\n" + + "taSatcgDataaactaaacaagtaaVctaggaSccaatMVtaaSKNVattttgHccatca\n" + + "cBVctgcaVatVttRtactgtVcaattHgtaaattaaattttYtatattaaRSgYtgBag\n" + + "aHSBDgtagcacRHtYcBgtcacttacactaYcgctWtattgSHtSatcataaatataHt\n" + + "cgtYaaMNgBaatttaRgaMaatatttBtttaaaHHKaatctgatWatYaacttMctctt\n" + + "ttVctagctDaaagtaVaKaKRtaacBgtatccaaccactHHaagaagaaggaNaaatBW\n" + + "attccgStaMSaMatBttgcatgRSacgttVVtaaDMtcSgVatWcaSatcttttVatag\n" + + "ttactttacgatcaccNtaDVgSRcgVcgtgaacgaNtaNatatagtHtMgtHcMtagaa\n" + + "attBgtataRaaaacaYKgtRccYtatgaagtaataKgtaaMttgaaRVatgcagaKStc\n" + + "tHNaaatctBBtcttaYaBWHgtVtgacagcaRcataWctcaBcYacYgatDgtDHccta\n" + + "aagacYRcaggattHaYgtKtaatgcVcaataMYacccatatcacgWDBtgaatcBaata\n" + + "cKcttRaRtgatgaBDacggtaattaaYtataStgVHDtDctgactcaaatKtacaatgc\n" + + "gYatBtRaDatHaactgtttatatDttttaaaKVccYcaaccNcBcgHaaVcattHctcg\n" + + "attaaatBtatgcaaaaatYMctSactHatacgaWacattacMBgHttcgaatVaaaaca\n" + + "BatatVtctgaaaaWtctRacgBMaatSgRgtgtcgactatcRtattaScctaStagKga\n" + + "DcWgtYtDDWKRgRtHatRtggtcgaHgggcgtattaMgtcagccaBggWVcWctVaaat\n" + + "tcgNaatcKWagcNaHtgaaaSaaagctcYctttRVtaaaatNtataaccKtaRgtttaM\n" + + "tgtKaBtRtNaggaSattHatatWactcagtgtactaKctatttgRYYatKatgtccgtR\n" + + "tttttatttaatatVgKtttgtatgtNtataRatWYNgtRtHggtaaKaYtKSDcatcKg\n" + + "taaYatcSRctaVtSMWtVtRWHatttagataDtVggacagVcgKWagBgatBtaaagNc\n" + + "aRtagcataBggactaacacRctKgttaatcctHgDgttKHHagttgttaatgHBtatHc\n" + + "DaagtVaBaRccctVgtgDtacRHSctaagagcggWYaBtSaKtHBtaaactYacgNKBa\n" + + "VYgtaacttagtVttcttaatgtBtatMtMtttaattaatBWccatRtttcatagVgMMt\n" + + "agctStKctaMactacDNYgKYHgaWcgaHgagattacVgtttgtRaSttaWaVgataat\n" + + "gtgtYtaStattattMtNgWtgttKaccaatagNYttattcgtatHcWtctaaaNVYKKt\n" + + "tWtggcDtcgaagtNcagatacgcattaagaccWctgcagcttggNSgaNcHggatgtVt\n" + + "catNtRaaBNcHVagagaaBtaaSggDaatWaatRccaVgggStctDaacataKttKatt\n" + + "tggacYtattcSatcttagcaatgaVBMcttDattctYaaRgatgcattttNgVHtKcYR\n" + + "aatRKctgtaaacRatVSagctgtWacBtKVatctgttttKcgtctaaDcaagtatcSat\n" + + "aWVgcKKataWaYttcccSaatgaaaacccWgcRctWatNcWtBRttYaattataaNgac\n" + + "acaatagtttVNtataNaYtaatRaVWKtBatKagtaatataDaNaaaaataMtaagaaS\n" + + "tccBcaatNgaataWtHaNactgtcDtRcYaaVaaaaaDgtttRatctatgHtgttKtga\n" + + "aNSgatactttcgagWaaatctKaaDaRttgtggKKagcDgataaattgSaacWaVtaNM\n" + + "acKtcaDaaatttctRaaVcagNacaScRBatatctRatcctaNatWgRtcDcSaWSgtt\n" + + "RtKaRtMtKaatgttBHcYaaBtgatSgaSWaScMgatNtctcctatttctYtatMatMt\n" + + "RRtSaattaMtagaaaaStcgVgRttSVaScagtgDtttatcatcatacRcatatDctta\n" + + "tcatVRtttataaHtattcYtcaaaatactttgVctagtaaYttagatagtSYacKaaac\n" + + "gaaKtaaatagataatSatatgaaatSgKtaatVtttatcctgKHaatHattagaaccgt\n" + + "YaaHactRcggSBNgtgctaaBagBttgtRttaaattYtVRaaaattgtaatVatttctc\n" + + "ttcatgBcVgtgKgaHaaatattYatagWacNctgaaMcgaattStagWaSgtaaKagtt\n" + + "ttaagaDgatKcctgtaHtcatggKttVDatcaaggtYcgccagNgtgcVttttagagat\n" + + "gctaccacggggtNttttaSHaNtatNcctcatSaaVgtactgBHtagcaYggYVKNgta\n" + + "KBcRttgaWatgaatVtagtcgattYgatgtaatttacDacSctgctaaaStttaWMagD\n" + + "aaatcaVYctccgggcgaVtaaWtStaKMgDtttcaaMtVgBaatccagNaaatcYRMBg\n" + + "gttWtaaScKttMWtYataRaDBMaDataatHBcacDaaKDactaMgagttDattaHatH\n" + + "taYatDtattDcRNStgaatattSDttggtattaaNSYacttcDMgYgBatWtaMagact\n" + + "VWttctttgYMaYaacRgHWaattgRtaagcattctMKVStatactacHVtatgatcBtV\n" + + "NataaBttYtSttacKgggWgYDtgaVtYgatDaacattYgatggtRDaVDttNactaSa\n" + + "MtgNttaacaaSaBStcDctaccacagacgcaHatMataWKYtaYattMcaMtgSttDag\n" + + "cHacgatcaHttYaKHggagttccgatYcaatgatRaVRcaagatcagtatggScctata\n" + + "ttaNtagcgacgtgKaaWaactSgagtMYtcttccaKtStaacggMtaagNttattatcg\n" + + "tctaRcactctctDtaacWYtgaYaSaagaWtNtatttRacatgNaatgttattgWDDcN\n" + + "aHcctgaaHacSgaataaRaataMHttatMtgaSDSKatatHHaNtacagtccaYatWtc\n" + + "actaactatKDacSaStcggataHgYatagKtaatKagStaNgtatactatggRHacttg\n" + + "tattatgtDVagDVaRctacMYattDgtttYgtctatggtKaRSttRccRtaaccttaga\n" + + "gRatagSaaMaacgcaNtatgaaatcaRaagataatagatactcHaaYKBctccaagaRa\n" + + "BaStNagataggcgaatgaMtagaatgtcaKttaaatgtaWcaBttaatRcggtgNcaca\n" + + "aKtttScRtWtgcatagtttWYaagBttDKgcctttatMggNttattBtctagVtacata\n" + + "aaYttacacaaRttcYtWttgHcaYYtaMgBaBatctNgcDtNttacgacDcgataaSat\n" + + "YaSttWtcctatKaatgcagHaVaacgctgcatDtgttaSataaaaYSNttatagtaNYt\n" + + "aDaaaNtggggacttaBggcHgcgtNtaaMcctggtVtaKcgNacNtatVaSWctWtgaW\n" + + "cggNaBagctctgaYataMgaagatBSttctatacttgtgtKtaattttRagtDtacata\n" + + "tatatgatNHVgBMtKtaKaNttDHaagatactHaccHtcatttaaagttVaMcNgHata\n" + + "tKtaNtgYMccttatcaaNagctggacStttcNtggcaVtattactHaSttatgNMVatt\n" + + "MMDtMactattattgWMSgtHBttStStgatatRaDaagattttctatMtaaaaaggtac\n" + + "taaVttaSacNaatactgMttgacHaHRttgMacaaaatagttaatatWKRgacDgaRta\n" + + "tatttattatcYttaWtgtBRtWatgHaaattHataagtVaDtWaVaWtgStcgtMSgaS\n" + + "RgMKtaaataVacataatgtaSaatttagtcgaaHtaKaatgcacatcggRaggSKctDc\n" + + "agtcSttcccStYtccRtctctYtcaaKcgagtaMttttcRaYDttgttatctaatcata\n" + + "NctctgctatcaMatactataggDaHaaSttMtaDtcNatataattctMcStaaBYtaNa\n" + + "gatgtaatHagagSttgWHVcttatKaYgDctcttggtgttMcRaVgSgggtagacaata\n" + + "aDtaattSaDaNaHaBctattgNtaccaaRgaVtKNtaaYggHtaKKgHcatctWtctDt\n" + + "ttctttggSDtNtaStagttataaacaattgcaBaBWggHgcaaaBtYgctaatgaaatW\n" + + "cDcttHtcMtWWattBHatcatcaaatctKMagtDNatttWaBtHaaaNgMttaaStagt\n" + + "tctctaatDtcRVaYttgttMtRtgtcaSaaYVgSWDRtaatagctcagDgcWWaaaBaa\n" + + "RaBctgVgggNgDWStNaNBKcBctaaKtttDcttBaaggBttgaccatgaaaNgttttt\n" + + "tttatctatgttataccaaDRaaSagtaVtDtcaWatBtacattaWacttaSgtattggD\n" + + "gKaaatScaattacgWcagKHaaccaYcRcaRttaDttRtttHgaHVggcttBaRgtccc\n" + + "tDatKaVtKtcRgYtaKttacgtatBtStaagcaattaagaRgBagSaattccSWYttta\n" + + "ttVaataNctgHgttaaNBgcVYgtRtcccagWNaaaacaDNaBcaaaaRVtcWMgBagM\n" + + "tttattacgDacttBtactatcattggaaatVccggttRttcatagttVYcatYaSHaHc\n" + + "ttaaagcNWaHataaaRWtctVtRYtagHtaaaYMataHYtNBctNtKaatattStgaMc\n" + + "BtRgctaKtgcScSttDgYatcVtggaaKtaagatWccHccgKYctaNNctacaWctttt\n" + + "gcRtgtVcgaKttcMRHgctaHtVaataaDtatgKDcttatBtDttggNtacttttMtga\n" + + "acRattaaNagaactcaaaBBVtcDtcgaStaDctgaaaSgttMaDtcgttcaccaaaag\n" + + "gWtcKcgSMtcDtatgtttStaaBtatagDcatYatWtaaaBacaKgcaDatgRggaaYc\n" + + "taRtccagattDaWtttggacBaVcHtHtaacDacYgtaatataMagaatgHMatcttat\n" + + "acgtatttttatattacHactgttataMgStYaattYaccaattgagtcaaattaYtgta\n" + + "tcatgMcaDcgggtcttDtKgcatgWRtataatatRacacNRBttcHtBgcRttgtgcgt\n" + + "catacMtttBctatctBaatcattMttMYgattaaVYatgDaatVagtattDacaacDMa\n" + + "tcMtHcccataagatgBggaccattVWtRtSacatgctcaaggggYtttDtaaNgNtaaB\n" + + "atggaatgtctRtaBgBtcNYatatNRtagaacMgagSaSDDSaDcctRagtVWSHtVSR\n" + + "ggaacaBVaccgtttaStagaacaMtactccagtttVctaaRaaHttNcttagcaattta\n" + + "ttaatRtaaaatctaacDaBttggSagagctacHtaaRWgattcaaBtctRtSHaNtgta\n" + + "cattVcaHaNaagtataccacaWtaRtaaVKgMYaWgttaKggKMtKcgWatcaDatYtK\n" + + "SttgtacgaccNctSaattcDcatcttcaaaDKttacHtggttHggRRaRcaWacaMtBW\n" + + "VHSHgaaMcKattgtaRWttScNattBBatYtaNRgcggaagacHSaattRtttcYgacc\n" + + "BRccMacccKgatgaacttcgDgHcaaaaaRtatatDtatYVtttttHgSHaSaatagct\n" + + "NYtaHYaVYttattNtttgaaaYtaKttWtctaNtgagaaaNctNDctaaHgttagDcRt\n" + + "tatagccBaacgcaRBtRctRtggtaMYYttWtgataatcgaataattattataVaaaaa\n" + + "ttacNRVYcaaMacNatRttcKatMctgaagactaattataaYgcKcaSYaatMNctcaa\n" + + "cgtgatttttBacNtgatDccaattattKWWcattttatatatgatBcDtaaaagttgaa\n" + + "VtaHtaHHtBtataRBgtgDtaataMttRtDgDcttattNtggtctatctaaBcatctaR\n" + + "atgNacWtaatgaagtcMNaacNgHttatactaWgcNtaStaRgttaaHacccgaYStac\n" + + "aaaatWggaYaWgaattattcMaactcBKaaaRVNcaNRDcYcgaBctKaacaaaaaSgc\n" + + "tccYBBHYaVagaatagaaaacagYtctVccaMtcgtttVatcaatttDRtgWctagtac\n" + + "RttMctgtDctttcKtWttttataaatgVttgBKtgtKWDaWagMtaaagaaattDVtag\n" + + "gttacatcatttatgtcgMHaVcttaBtVRtcgtaYgBRHatttHgaBcKaYWaatcNSc\n" + + "tagtaaaaatttacaatcactSWacgtaatgKttWattagttttNaggtctcaagtcact\n" + + "attcttctaagKggaataMgtttcataagataaaaatagattatDgcBVHWgaBKttDgc\n" + + "atRHaagcaYcRaattattatgtMatatattgHDtcaDtcaaaHctStattaatHaccga\n" + + "cNattgatatattttgtgtDtRatagSacaMtcRtcattcccgacacSattgttKaWatt\n" + + "NHcaacttccgtttSRtgtctgDcgctcaaMagVtBctBMcMcWtgtaacgactctcttR\n" + + "ggRKSttgYtYatDccagttDgaKccacgVatWcataVaaagaataMgtgataaKYaaat\n" + + "cHDaacgataYctRtcYatcgcaMgtNttaBttttgatttaRtStgcaacaaaataccVg\n" + + "aaDgtVgDcStctatatttattaaaaRKDatagaaagaKaaYYcaYSgKStctccSttac\n" + + "agtcNactttDVttagaaagMHttRaNcSaRaMgBttattggtttaRMggatggcKDgWR\n" + + "tNaataataWKKacttcKWaaagNaBttaBatMHtccattaacttccccYtcBcYRtaga\n" + + "ttaagctaaYBDttaNtgaaaccHcaRMtKtaaHMcNBttaNaNcVcgVttWNtDaBatg\n" + + "ataaVtcWKcttRggWatcattgaRagHgaattNtatttctctattaattaatgaDaaMa\n" + + "tacgttgggcHaYVaaNaDDttHtcaaHtcVVDgBVagcMacgtgttaaBRNtatRtcag\n" + + "taagaggtttaagacaVaaggttaWatctccgtVtaDtcDatttccVatgtacNtttccg\n" + + "tHttatKgScBatgtVgHtYcWagcaKtaMYaaHgtaattaSaHcgcagtWNaatNccNN\n" + + "YcacgVaagaRacttctcattcccRtgtgtaattagcSttaaStWaMtctNNcSMacatt\n" + + "ataaactaDgtatWgtagtttaagaaaattgtagtNagtcaataaatttgatMMYactaa\n" + + "tatcggBWDtVcYttcDHtVttatacYaRgaMaacaStaatcRttttVtagaDtcacWat\n" + + "ttWtgaaaagaaagNRacDtttStVatBaDNtaactatatcBSMcccaSttccggaMatg\n" + + "attaaWatKMaBaBatttgataNctgttKtVaagtcagScgaaaDggaWgtgttttKtWt\n" + + "atttHaatgtagttcactaaKMagttSYBtKtaYgaactcagagRtatagtVtatcaaaW\n" + + "YagcgNtaDagtacNSaaYDgatBgtcgataacYDtaaactacagWDcYKaagtttatta\n" + + "gcatcgagttKcatDaattgattatDtcagRtWSKtcgNtMaaaaacaMttKcaWcaaSV\n" + + "MaaaccagMVtaMaDtMaHaBgaacataBBVtaatVYaNSWcSgNtDNaaKacacBttta\n" + + "tKtgtttcaaHaMctcagtaacgtcgYtactDcgcctaNgagagcYgatattttaaattt\n" + + "ccattttacatttDaaRctattttWctttacgtDatYtttcagacgcaaVttagtaaKaa\n" + + "aRtgVtccataBggacttatttgtttaWNtgttVWtaWNVDaattgtatttBaagcBtaa\n" + + "BttaaVatcHcaVgacattccNggtcgacKttaaaRtagRtctWagaYggtgMtataatM\n" + + "tgaaRttattttgWcttNtDRRgMDKacagaaaaggaaaRStcccagtYccVattaNaaK\n" + + "StNWtgacaVtagaagcttSaaDtcacaacgDYacWDYtgtttKatcVtgcMaDaSKStV\n" + + "cgtagaaWaKaagtttcHaHgMgMtctataagBtKaaaKKcactggagRRttaagaBaaN\n" + + "atVVcgRcKSttDaactagtSttSattgttgaaRYatggttVttaataaHttccaagDtg\n" + + "atNWtaagHtgcYtaactRgcaatgMgtgtRaatRaNaacHKtagactactggaatttcg\n" + + "ccataacgMctRgatgttaccctaHgtgWaYcactcacYaattcttaBtgacttaaacct\n" + + "gYgaWatgBttcttVttcgttWttMcNYgtaaaatctYgMgaaattacNgaHgaacDVVM\n" + + "tttggtHtctaaRgtacagacgHtVtaBMNBgattagcttaRcttacaHcRctgttcaaD\n" + + "BggttKaacatgKtttYataVaNattccgMcgcgtagtRaVVaattaKaatggttRgaMc\n" + + "agtatcWBttNtHagctaatctagaaNaaacaYBctatcgcVctBtgcaaagDgttVtga\n" + + "HtactSNYtaaNccatgtgDacgaVtDcgKaRtacDcttgctaagggcagMDagggtBWR\n" + + "tttSgccttttttaacgtcHctaVtVDtagatcaNMaVtcVacatHctDWNaataRgcgt\n" + + "aVHaggtaaaaSgtttMtattDgBtctgatSgtRagagYtctSaKWaataMgattRKtaa\n" + + "catttYcgtaacacattRWtBtcggtaaatMtaaacBatttctKagtcDtttgcBtKYYB\n" + + "aKttctVttgttaDtgattttcttccacttgSaaacggaaaNDaattcYNNaWcgaaYat\n" + + "tttMgcBtcatRtgtaaagatgaWtgaccaYBHgaatagataVVtHtttVgYBtMctaMt\n" + + "cctgaDcYttgtccaaaRNtacagcMctKaaaggatttacatgtttaaWSaYaKttBtag\n" + + "DacactagctMtttNaKtctttcNcSattNacttggaacaatDagtattRtgSHaataat\n" + + "gccVgacccgatactatccctgtRctttgagaSgatcatatcgDcagWaaHSgctYYWta\n" + + "tHttggttctttatVattatcgactaagtgtagcatVgtgHMtttgtttcgttaKattcM\n" + + "atttgtttWcaaStNatgtHcaaaDtaagBaKBtRgaBgDtSagtatMtaacYaatYtVc\n" + + "KatgtgcaacVaaaatactKcRgtaYtgtNgBBNcKtcttaccttKgaRaYcaNKtactt\n" + + "tgagSBtgtRagaNgcaaaNcacagtVtttHWatgttaNatBgtttaatNgVtctgaata\n" + + "tcaRtattcttttttttRaaKcRStctcggDgKagattaMaaaKtcaHacttaataataK\n" + + "taRgDtKVBttttcgtKaggHHcatgttagHggttNctcgtatKKagVagRaaaggaaBt\n" + + "NatttVKcRttaHctaHtcaaatgtaggHccaBataNaNaggttgcWaatctgatYcaaa\n" + + "HaatWtaVgaaBttagtaagaKKtaaaKtRHatMaDBtBctagcatWtatttgWttVaaa\n" + + "ScMNattRactttgtYtttaaaagtaagtMtaMaSttMBtatgaBtttaKtgaatgagYg\n" + + "tNNacMtcNRacMMHcttWtgtRtctttaacaacattattcYaMagBaacYttMatcttK\n" + + "cRMtgMNccattaRttNatHaHNaSaaHMacacaVaatacaKaSttHatattMtVatWga\n" + + "ttttttaYctttKttHgScWaacgHtttcaVaaMgaacagNatcgttaacaaaaagtaca\n" + + "HBNaattgttKtcttVttaaBtctgctacgBgcWtttcaggacacatMgacatcccagcg\n" + + "gMgaVKaBattgacttaatgacacacaaaaaatRKaaBctacgtRaDcgtagcVBaacDS\n" + + "BHaaaaSacatatacagacRNatcttNaaVtaaaataHattagtaaaaSWccgtatWatg\n" + + "gDttaactattgcccatcttHaSgYataBttBaactattBtcHtgatcaataSttaBtat\n" + + "KSHYttWggtcYtttBttaataccRgVatStaHaKagaatNtagRMNgtcttYaaSaact\n" + + "cagDSgagaaYtMttDtMRVgWKWtgMaKtKaDttttgactatacataatcNtatNaHat\n" + + "tVagacgYgatatatttttgtStWaaatctWaMgagaRttRatacgStgattcttaagaD\n" + + "taWccaaatRcagcagaaNKagtaaDggcgccBtYtagSBMtactaaataMataBSacRM\n" + + "gDgattMMgtcHtcaYDtRaDaacggttDaggcMtttatgttaNctaattaVacgaaMMt\n" + + "aatDccSgtattgaRtWWaccaccgagtactMcgVNgctDctaMScatagcgtcaactat\n" + + "acRacgHRttgctatttaatgaattataYKttgtaagWgtYttgcHgMtaMattWaWVta\n" + + "RgcttgYgttBHtYataSccStBtgtagMgtDtggcVaaSBaatagDttgBgtctttctc\n" + + "attttaNagtHKtaMWcYactVcgcgtatMVtttRacVagDaatcttgctBBcRDgcaac\n" + + "KttgatSKtYtagBMagaRtcgBattHcBWcaactgatttaatttWDccatttatcgagS\n" + + "KaWttataHactaHMttaatHtggaHtHagaatgtKtaaRactgtttMatacgatcaagD\n" + + "gatKaDctataMggtHDtggHacctttRtatcttYattttgacttgaaSaataaatYcgB\n" + + "aaaaccgNatVBttMacHaKaataagtatKgtcaagactcttaHttcggaattgttDtct\n" + + "aaccHttttWaaatgaaatataaaWattccYDtKtaaaacggtgaggWVtctattagtga\n" + + "ctattaagtMgtttaagcatttgSgaaatatccHaaggMaaaattttcWtatKctagDtY\n" + + "tMcctagagHcactttactatacaaacattaacttaHatcVMYattYgVgtMttaaRtga\n" + + "aataaDatcaHgtHHatKcDYaatcttMtNcgatYatgSaMaNtcttKcWataScKggta\n" + + "tcttacgcttWaaagNatgMgHtctttNtaacVtgttcMaaRatccggggactcMtttaY\n" + + "MtcWRgNctgNccKatcttgYDcMgattNYaRagatHaaHgKctcataRDttacatBatc\n" + + "cattgDWttatttaWgtcggagaaaaatacaatacSNtgggtttccttacSMaagBatta\n" + + "caMaNcactMttatgaRBacYcYtcaaaWtagctSaacttWgDMHgaggatgBVgcHaDt\n" + + "ggaactttggtcNatNgtaKaBcccaNtaagttBaacagtatacDYttcctNgWgcgSMc\n" + + "acatStctHatgRcNcgtacacaatRttMggaNKKggataaaSaYcMVcMgtaMaHtgat\n" + + "tYMatYcggtcttcctHtcDccgtgRatcattgcgccgatatMaaYaataaYSggatagc\n" + + "gcBtNtaaaScaKgttBgagVagttaKagagtatVaactaSacWactSaKatWccaKaaa\n" + + "atBKgaaKtDMattttgtaaatcRctMatcaaMagMttDgVatggMaaWgttcgaWatga\n" + + "aatttgRtYtattaWHKcRgctacatKttctaccaaHttRatctaYattaaWatVNccat\n" + + "NgagtcKttKataStRaatatattcctRWatDctVagttYDgSBaatYgttttgtVaatt\n" + + "taatagcagMatRaacttBctattgtMagagattaaactaMatVtHtaaatctRgaaaaa\n" + + "aaatttWacaacaYccYDSaattMatgaccKtaBKWBattgtcaagcHKaagttMMtaat\n" + + "ttcKcMagNaaKagattggMagaggtaatttYacatcWaaDgatMgKHacMacgcVaaca\n" + + "DtaDatatYggttBcgtatgWgaSatttgtagaHYRVacaRtctHaaRtatgaactaata\n" + + "tctSSBgggaaHMWtcaagatKgagtDaSatagttgattVRatNtctMtcSaagaSHaat\n" + + "aNataataRaaRgattctttaataaagWaRHcYgcatgtWRcttgaaggaMcaataBRaa\n" + + "ccagStaaacNtttcaatataYtaatatgHaDgcStcWttaacctaRgtYaRtataKtgM\n" + + "ttttatgactaaaatttacYatcccRWtttHRtattaaatgtttatatttgttYaatMca\n" + + "RcSVaaDatcgtaYMcatgtagacatgaaattgRtcaaYaaYtRBatKacttataccaNa\n" + + "aattVaBtctggacaagKaaYaaatatWtMtatcYaaVNtcgHaactBaagKcHgtctac\n" + + "aatWtaDtSgtaHcataHtactgataNctRgttMtDcDttatHtcgtacatcccaggStt\n" + + "aBgtcacacWtccNMcNatMVaVgtccDYStatMaccDatggYaRKaaagataRatttHK\n" + + "tSaaatDgataaacttaHgttgVBtcttVttHgDacgaKatgtatatNYataactctSat\n" + + "atatattgcHRRYttStggaactHgttttYtttaWtatMcttttctatctDtagVHYgMR\n" + + "BgtHttcctaatYRttKtaagatggaVRataKDctaMtKBNtMtHNtWtttYcVtattMc\n" + + "gRaacMcctNSctcatttaaagDcaHtYccSgatgcaatYaaaaDcttcgtaWtaattct\n" + + "cgttttScttggtaatctttYgtctaactKataHacctMctcttacHtKataacacagcN\n" + + "RatgKatttttSaaatRYcgDttaMRcgaaattactMtgcgtaagcgttatBtttttaat\n" + + "taagtNacatHgttcRgacKcBBtVgatKttcgaBaatactDRgtRtgaNacWtcacYtt\n" + + "aaKcgttctHaKttaNaMgWgWaggtctRgaKgWttSttBtDcNtgtttacaaatYcDRt\n" + + "gVtgcctattcNtctaaaDMNttttNtggctgagaVctDaacVtWccaagtaacacaNct\n" + + "gaScattccDHcVBatcgatgtMtaatBgHaatDctMYgagaatgYWKcctaatNaStHa\n" + + "aaKccgHgcgtYaaYtattgtStgtgcaaRtattaKatattagaWVtcaMtBagttatta\n" + + "gNaWHcVgcaattttDcMtgtaRHVYtHtctgtaaaaHVtMKacatcgNaatttMatatg\n" + + "ttgttactagWYtaRacgataKagYNKcattataNaRtgaacKaYgcaaYYacaNccHat\n" + + "MatDcNgtHttRaWttagaaDcaaaaaatagggtKDtStaDaRtaVtHWKNtgtattVct\n" + + "SVgRgataDaRaWataBgaagaaKtaataaYgDcaStaNgtaDaaggtattHaRaWMYaY\n" + + "aWtggttHYgagVtgtgcttttcaaDKcagVcgttagacNaaWtagtaataDttctggtt\n" + + "VcatcataaagtgKaaaNaMtaBBaattaatWaattgctHaVKaSgDaaVKaHtatatat\n" + + "HatcatSBagNgHtatcHYMHgttDgtaHtBttWatcgtttaRaattgStKgSKNWKatc\n" + + "agDtctcagatttctRtYtBatBgHHtKaWtgYBgacVVWaKtacKcDttKMaKaVcggt\n" + + "gttataagaataaHaatattagtataatMHgttYgaRttagtaRtcaaVatacggtcMcg\n" + + "agtaaRttacWgactKRYataaaagSattYaWgagatYagKagatgSaagKgttaatMgg\n" + + "tataatgttWYttatgagaaacctNVataatHcccKtDctcctaatactggctHggaSag\n" + + "gRtKHaWaattcgSatMatttagaggcYtctaMcgctcataSatatgRagacNaaDagga\n" + + "VBagaYttKtacNaKgtSYtagttggaWcatcWttaatctatgaVtcgtgtMtatcaYcg\n" + + "tRccaaYgDctgcMgtgtWgacWtgataacacgcgctBtgttaKtYDtatDcatcagKaV\n" + + "MctaatcttgVcaaRgcRMtDcgattaHttcaNatgaatMtactacVgtRgatggaWttt\n" + + "actaaKatgagSaaKggtaNtactVaYtaaKRagaacccacaMtaaMtKtatBcttgtaa\n" + + "WBtMctaataaVcDaaYtcRHBtcgttNtaaHatttBNgRStVDattBatVtaagttaYa\n" + + "tVattaagaBcacggtSgtVtatttaRattgatgtaHDKgcaatattKtggcctatgaWD\n" + + "KRYcggattgRctatNgatacaatMNttctgtcRBYRaaaHctNYattcHtaWcaattct\n" + + "BtMKtVgYataatMgYtcagcttMDataVtggRtKtgaatgccNcRttcaMtRgattaac\n" + + "attRcagcctHtWMtgtDRagaKaBtgDttYaaaaKatKgatctVaaYaacWcgcatagB\n" + + "VtaNtRtYRaggBaaBtgKgttacataagagcatgtRattccacttaccatRaaatgWgD\n" + + "aMHaYVgVtaSctatcgKaatatattaDgacccYagtgtaYNaaatKcagtBRgagtcca\n" + + "tgKgaaaccBgaagBtgSttWtacgatWHaYatcgatttRaaNRgcaNaKVacaNtDgat\n" + + "tgHVaatcDaagcgtatgcNttaDataatcSataaKcaataaHWataBtttatBtcaKtK\n" + + "tatagttaDgSaYctacaRatNtaWctSaatatttYaKaKtaccWtatcRagacttaYtt\n" + + "VcKgSDcgagaagatccHtaattctSttatggtKYgtMaHagVaBRatttctgtRgtcta\n" + + "tgggtaHKgtHacHtSYacgtacacHatacKaaBaVaccaDtatcSaataaHaagagaat\n" + + "ScagactataaRttagcaaVcaHataKgDacatWccccaagcaBgagWatctaYttgaaa\n" + + "tctVNcYtttWagHcgcgcDcVaaatgttKcHtNtcaatagtgtNRaactttttcaatgg\n" + + "WgBcgDtgVgtttctacMtaaataaaRggaaacWaHttaRtNtgctaaRRtVBctYtVta\n" + + "tDcattDtgaccYatagatYRKatNYKttNgcctagtaWtgaactaMVaacctgaStttc\n" + + "tgaKVtaaVaRKDttVtVctaDNtataaaDtccccaagtWtcgatcactDgYaBcatcct\n" + + "MtVtacDaaBtYtMaKNatNtcaNacgDatYcatcgcaRatWBgaacWttKttagYtaat\n" + + "tcggttgSWttttDWctttacYtatatWtcatDtMgtBttgRtVDggttaacYtacgtac\n" + + "atgaattgaaWcttMStaDgtatattgaDtcRBcattSgaaVBRgagccaaKtttcDgcg\n" + + "aSMtatgWattaKttWtgDBMaggBBttBaatWttRtgcNtHcgttttHtKtcWtagHSt\n" + + "aacagttgatatBtaWSaWggtaataaMttaKacDaatactcBttcaatatHttcBaaSa\n" + + ">THREE Homo sapiens frequency\n" + + "aagtccgatgagtttcaatcatgactgcgaggagatccatgcggtgtacctaaacctaca\n" + + "tcgtatgtatttgctgacgttcattcttgatacataaagatccgatatcggtccactttg\n" + + "tttaccaaaagccctaccttcgtaacgatggaaatgtgaatgagagtgaaatacacgatg\n" + + "gggatattgccggtgagtacaagttagaccacacattagaactgacctatattcgtcatc\n" + + "atagagatggagtatgaattgattctgcgaagtacactggctttacgagtatctagacgc\n" + + "cgcggtatatctcccgtcaatactatgaaggtatatatatagaggctgaaaattcatgtt\n" + + "caatcctctttctaagagtgagtgggagccccttctgttgtcggagtaaaaaggcattat\n" + + "tcctcaaattgtcagaagcaaagtatacgtgatgtttgcttagaacaaaagagttacctt\n" + + "agggtaggtaaatctcgattcaccgagagaagtgattttggcggtgtgcgattaattctt\n" + + "ttgatgacagatctcattattttatatagctccctctttgtatttagagtttgcgtaggt\n" + + "aacctggcaaaaccatatcccggggggagagtgcgctgaacattttatacgatgtgatta\n" + + "ctcaaaggataaggttcgaggcctctatactcatggaactatcttataattataatggat\n" + + "cgtggctcattccacctatccaaacttctttgtgatctgatgctacgagtgtgaacaaac\n" + + "gtacatcttctaaggaatttgggacgtttcatagctcgcatttcattcctgaaaacttaa\n" + + "atatttttaaaaattgattctactgcgaggaactaaggtgtagacaagcccttagtaacc\n" + + "ggtggatgtcgcttcagttttatagcaaacattattcaatttcagtcttgactgaaatta\n" + + "gtttgttagtgttagaggtccatatgtcacatgcatatggtctagatgccattgtacagt\n" + + "aataccttagattagtattagcggcatgcgtacttggatttcacttgtaagaatgagctt\n" + + "aggacggtcgcctgtagggctgcaaataggaatacttacaatttttgatgacttgttagc\n" + + "atatcgctatcacccataaaaaacctgatacttgatgagcgggtgattgagactatgtac\n" + + "tgatataattcaatagctccaatagatgaaacagctatgcgcctatttatgtcaaataat\n" + + "cgatgtgatacaagcttagagctgaacgagcgcgagtggaattagcggtgatctctatcc\n" + + "taaaaagccacgaaatcgatcccagaagctaatacccgaggtgtcaagcttgagttcagt\n" + + "taaatttgcatctcatgccccacgaagaatgggtagagagtttgaaggtgcttctggatt\n" + + "ttcctaagtacgtggtaaaaatttgatgtaaatgaacacctcctaatggttgtgttaacc\n" + + "acaaacccctgggtgaatctgattagccaacccagtgatctgatttcagttgtcaaatct\n" + + "cttttttataactaccttttgtttccataatttaaccggatctcataatgaacaaacggg\n" + + "tagaataatggtagcacatagcgagcttgtctattcagaaatatggcctactcagaatgt\n" + + "attctccaaatcagtgttatgcgaaacgtaattttacgtgtaataatgatgatttcttat\n" + + "cggttccttgtactacaatactcttgcccaacaaatactaagcataacagcaaaattcga\n" + + "atccccctccttttaataaatggtttttcaatatagccgattcgtattcgttagtctttc\n" + + "accaactattaacctggcatctaattaataaaatcaccaaaggactctataatatgacag\n" + + "tcacttcggcctcttttaagacagttgattattgcaggtccgcaattgatggtgacatgc\n" + + "acaattagttagaatccgactatggagacaattaacaattgtagtgcccatttggtccag\n" + + "ttgacttcaaccacgagttataaaggtattttaatttatagtcgatagtaccaacaacaa\n" + + "gcacaatcataattatgttagaaaacccagggggtaatgctctaaatccagctttaaggc\n" + + "cagagtgcactatgaaatcgccattgatcattgtgtcattcgctgaacttggtgtctagg\n" + + "aggtgccgagtgagaatatcagataccttatgaagcaacgattatatctggactagatca\n" + + "tgatgatcggaataaaacattgaaataagtccttatcaaggagcataaacattttattta\n" + + "atttatacttcgtaaataaattcagaattttttttcaagacattaatctgagtaaatgac\n" + + "ggctagaaagggttcctactcgaatcgtagcctacgcatgtgggcagtaacctggcttgc\n" + + "gtttttactgaaacaaaggttcaccggaaagaaggctgccacttttagcttcttgacgat\n" + + "ctttagcgtcatatttttagattagtcgaaaaacggaaaacaaacttaacgaagctggtt\n" + + "gcacggggtaccgagaaaccaaagagcaggacaactccttgatcgggaagaactgaaata\n" + + "gacagctgtcattttcattggtcaacttatcaatataacgaccaccgtagtgacgcttgc\n" + + "atgaaaatactgaggatgtaaactatagccagtcaggcccgcgtgttgactaattgatga\n" + + "agcaaacaaaatagccggtattcgttaaaaggaacgggttgccagctacagatatactct\n" + + "aggtatatcccaaacaagagacgtcctttggctgttgtaatcggtcataatacttgtcac\n" + + "ataaacaagatcgctgaattaaacattaaacagttagtgatacacaatcgtggttggggc\n" + + "tgggatgtgcaataaaaagtcatctatcgtctatcacagagcgacgtaaatttagacaaa\n" + + "cattattatttcttgacaatggaatcgataagcgttcctctaacttggtatatatatctc\n" + + "gaccccgggattccagccattcttgtatgaagatttaaccatttaactatgcatagttga\n" + + "atggtaaggaaaatgatattgactgcaacagattttggatgcaaaaatatttgtgaatta\n" + + "ttggttatatactggttgtatagcacaatcattaggtcctagaaggcatactcaacctca\n" + + "gcgagagagctagcatgcataattgtaccgcccatattaatattcctgaaatgatttctt\n" + + "acattacgcccaatttcagtcatcgaacacccccatcaatttacccgatagagaacgtga\n" + + "tcatacgcaataccctatgcgaacgtccactctatagcgtctgtatacaatgattattcg\n" + + "ttccatttacaacgttaagtaatttaaacttacataaggacaaggaaatccgcgaacctc\n" + + "ctggaatgtatgagttatttatgcagttaacttcgtctcgaccggaactaaaggcgtcgt\n" + + "acgaatgaaaggccacttttagaagagacctttgtatccattgtggagaatatcataaat\n" + + "tcaagatggggtgtcatgctattcggtcctaaacattcttaatggctgttctattgttag\n" + + "tctgatttaaaatggaaccatagcacgaatagttagatagggctcatacccctgtaacga\n" + + "tctacaaatccttccccgggtgtgtgcgttagcgacggaaagttttacggtttgtgatca\n" + + "aagaacactcacacgtcagattattacactgatacgaattatttcagtcgacagtaattg\n" + + "aatagaaacttattaacgccagcacctgacacggtaagtaaggcaggtctgaactgtttg\n" + + "actgtaaaaaaatggtaatatttttaaaaatcttgatttctatatcaaatgatgtgtagt\n" + + "tttttctctgttattaaaatcccagtgcgcgaaatttagatcgttacgactcacgtacaa\n" + + "gatcacacatcacacgcgttagcgaaagcggaatggctaatacagccctacgcaacgtag\n" + + "tgggatcaacatatggacgaatttatgctcaatgagccaacctcccccgcattgcggttc\n" + + "attttaaggcctgggtaacatctatcgtttagataatcaaaggaatccgactatgcaatt\n" + + "gtctgacttcatccgctctcaagtccaatgcaggcgctacgtgtttctttaatcaatacc\n" + + "atattgaaatcgtaatacgataattgttgctattgactacaggttatgaaaaaacttact\n" + + "ttgcgggtacatgcatatttttgtaccacattattacgcgatatctctcagtgtactcta\n" + + "aattaaaccctcttcgaacattttagttcctattcgtaaacacgtgctacgcggcaattt\n" + + "gccggtcgtagaatggacaactccagttcaactgcatgtaactcatagctcgcgttagta\n" + + "taaattgactagtagccatgggacaaagtaactagtcagcggaaaagatccctttaaaga\n" + + "tatatgcaggttgcaagcataaagctcattgctcgaggtgcaccgtggtattccaaaagc\n" + + "gtctctatcgtatcttctaattttgggccgtgagaatcgaaactactctgatttgctgca\n" + + "cacgttaggtaatatcgcccattttcccgtataagctccgtacttatacgaactacacga\n" + + "ccttttaagcattagccgctcatatcgtgattcgtgtacagatgagtctattaaaattac\n" + + "agacatactccatatctcgctccttgaactttgaataatgcgctaacttgtactatgaat\n" + + "aggcagaacccaactttcccgtttgcgtcaagcggggaaacgatacatgttgtcagattt\n" + + "atgattatctagttttagatcacgtttaccgataatcggctgtggtctgagcagtcctac\n" + + "actgagtatttacttcagcttcatatcggtccgaaaaaaggttgtgaccgaatgtcaaaa\n" + + "tacggagtacgatgggcatcttttttcgagtcgcggttgcagggcagcaaaaggcttaaa\n" + + "ccatttttacgatttttactatagcggtcatgaagtgcgaaactgcttgcaaattttcta\n" + + "cacacattgtggctcttgtccttgaagcttatggcgaaaatttgaaacatagtataccag\n" + + "ggaaagcgcgaattatttggtgactaatagtccgtgggtttgagccatatacctaacgcc\n" + + "ataaactacgtggtgctttagatgcaatctaaacagaacagaaagcgtagcgctcatcag\n" + + "cacagactaactttttcagtttgagtcgccggagggacttcgagacaagaacgcgtcaag\n" + + "tcgcttgcgcggcacggattcgattgggcggctcaatcttgcctaatttctactattgtc\n" + + "agctgtacgactgtactaagtgtatagccccaaataaaagaagtatcgatgcgtctttat\n" + + "gaccaaaggtcttataattgaagcgcacttccgttcatcaaattaaatcctggcttaccc\n" + + "gattctccggaagtctgacctagagattgacgacggccgcgtattattgagacctcttca\n" + + "ggattaatcaataacgaagtagttgatctgtttggcgacgtaccttaagccgactccgct\n" + + "acacgagtttctactaaaccaatgtagccttatgcttagatgaataccgtcctaattaga\n" + + "tattccggcataacagcagtaaattatctgttcaatggacgaacattgaattgttagtat\n" + + "tctacacaagtcaggcctcgtaaatattaggtaaggccgtgggataacctacgtgatatg\n" + + "cttgagcttgcgttgcaagctctcgttaatcattaatttaggtgcgtgagggttaaacac\n" + + "cagcatattctatatgctagacgtcttccttaaaggatcgtagtattataattaataata\n" + + "agaaatatggttgacgtctagtcagcgggcatacgctgctctatatactggcattattca\n" + + "aaacttgacggtaaaaaaacgaattttaaggcgctcacgtcgaatgagccgaactcatgg\n" + + "gaaccaaaatgtcacagaaaacacctctttattgccaagcatgcaataaaaaaaatgtta\n" + + "atagtacgtttacgacattttattttataataaagagaaactattacacctattgatatg\n" + + "ataggacgtaaattaacgagtagcctgcatagaggcaaatgaggtttctacatggtatag\n" + + "acctgatgctgaaacatcgatgagttttggtcccctcgctcgttgaaatctagtcattta\n" + + "ctactgtctttcgagctattataccacttcactatgtggtgtttctttgctatgtatggg\n" + + "gctagtcaaacatgatgactatagctacaactcagagagcgggcgtgttaagagtatctc\n" + + "atgctagaactgcacgacgaacttgatacaaagtaacaacatttacgattccacaaggtg\n" + + "actttgaagaaacatagtttaattctctgcttcgatcatttctataaaccggtaccatcg\n" + + "cagcggatagatgcataacatttctactactccaggcatcttaaaacacacgtagtactt\n" + + "cactagattaagacacgataagtgtataacttggcagtgggaagcaaggagattggcgaa\n" + + "ctcctggcatctgttacgttttgttcaggctcggttgttgataatgtccgactcctgcca\n" + + "tattgaagactcgctcgagggagatcgggattcgttgattataagtacacgtgttccgta\n" + + "atactatgaggcagtgattcaaaatggcacttctgacttacatgactaggtattattacc\n" + + "acggaagcgttaaaggcacactcttatggacttaagattgcaagtgccttcttctagcct\n" + + "gaattcgcgggttcaacacaaactctctttagacatccgttgcctaaaggctgagacgta\n" + + "ggggcaaccctttaactatgtactaaaaaactagttggtaatttaacaacgtgtccaatc\n" + + "aagacgatgcaccaacgcggtgcgaaaatcgggttaagcaaacacaaataggaattgtga\n" + + "taaaccccaccttgagaggtcgcaagaccaacctcgggaacaacggctctaagagaataa\n" + + "cctaaatccggatgagtagactgtgtaactctctaaagggaagtgaaaaaaagctaagca\n" + + "tacatttaggtctcctgcattgcattcaattgaatcgtttgtattatgagctgtacagta\n" + + "gctatatcagctatagttatcccagaggaacaggtaaactagctctgagcgtgaaatccg\n" + + "gatattagaacccctagatgggattgattctagctaatacaggcttatctggttttacag\n" + + "ttatctagatgattggtaaggtgaaacgcttggtgccttccaccacttaaacaaaagtat\n" + + "tgcccgggaagctattttctaggtattataaagtcgagcattaatatcaatttgacagta\n" + + "aaggtctttcaccagcttcatatgccatagggcccatactcgatttaaattgaacggttt\n" + + "aacgagtattggaactctcacttataactgagtagctatacgaaaaatctggtccatttc\n" + + "cagaaatttattatcgatttgctgcttagtacccaggaagtgataacccttgaaggcaca\n" + + "acactgtaataagttttcctgtcacatctgtaatattcggtcactacgcattcacgacta\n" + + "aagataattactatactaattaaaagttcaatgttagggccgaatcatagtagaaattct\n" + + "cgtctagcctaatcggacttacctatgggctgtgaggatttatcagtatgtggacaaaaa\n" + + "tgctagagataggtatagttaaagtcaccatggtacatctatgtgaggaagtttgtagtt\n" + + "cgcttctttagtccgggcgtttgggatgacaactactatacgtagagccgtactcaggat\n" + + "tagatagtgtgaaagagtcaaataaaagggttaatattaatttaacgttgcaaatgtgtt\n" + + "taggccaaacattaaccgttgtagggatattctaatacaggccttcaccgaaccctaatg\n" + + "ataatctgtcttaataacattaaatgattgtctccgctacgagctcttagggcctcattt\n" + + "taaatgactaatgtccaaagaagagactttcccaatttcaatctgtcacgtatagacggc\n" + + "accttagtgagtcatatcattaagatagaagattatcaggagggaagtttctattatcaa\n" + + "ccgttacgcaaccataaacttttaaatctcataatggcattgagatcaagagctttcatg\n" + + "atggtaaagttcgtatgtgatgctggggagctagatatcggtataccacttcggttgtgg\n" + + "taagcccgagtgggccgttagtaatattaatagacgattatccgacaatgcattcgctga\n" + + "aataatcttacttaggagaaattaatgctatgagccaaaactatttatgtctgtcacatt\n" + + "attgactaaagtatctatcgacaaaactgatgtccataagttgtagcagatagtcggtgt\n" + + "atggtgtcaccaatgaaaacctcgagcgaaaaatgaattatagttatccaatttgagtaa\n" + + "attgcctattatacagataggcttgtttagtcagataaggttccgcttgaggtgctctaa\n" + + "cttagcgagagttagaaagcctagtgagaggcattttggtgccaaactccggctcgcatg\n" + + "agtaggccagagagtcactttctttcgtcgaagaagttggtgaacagccttttgattagt\n" + + "tgtttgtcttgtggctatgtgctactatataagttagaacgcaaactaatctaatcagca\n" + + "aagtaaaataggaccttgaacgagacggggtacgccgttgaggctcgagatagtagataa\n" + + "actagaggaatgtagataaaacattagctagggggtttagttactggattacataggaag\n" + + "tgcaccatcacggtgtgggggttcgtacgtaaagtcgcatcaatattgtcagtggactta\n" + + "acaagttcgtgcataatgaaatcctatacggactttgcatatctctaccgactcatctgg\n" + + "tcgtctatgcgggtaattgtattgctccaagtggatgactattttggcgtcccagcacat\n" + + "agtaaatgtaaatccttataatagcataagcaattattagactgcgtgaagtcttagtag\n" + + "ttctcaagctttacgttgtatgtaaataactcacgtaatcagccgtccccaaatcaccat\n" + + "tgaggtcattgaatgtacggagcactattatcaatgcggtatgcgattttctgagcgatt\n" + + "attgttaaagacttagcgttgagccccggaacacttgattacagattctttaaggagtta\n" + + "tccaaatatcattttaaataatagtagtatcgtgctttggacaataaaaaaagacccgtt\n" + + "ctcttatgttgttttgcgacgtacttctctgatatatacttcaactatgaagattctatt\n" + + "catcgataacccaggtatatttatatgcccgttcactgcgcagggcaaattatctacgga\n" + + "caataatgacgtagttggacccggtaagaactaacgcttaatatgattaaggatgtatgc\n" + + "cagtattatcttattatgtcagagtagaagtttctctgagattttccgtcgttgtggtac\n" + + "accggatttggctctctttttagaactgagaactcggagtgtgtagtcttgtttccttca\n" + + "atttatcaatatgcttttataccgccctcatcaactataacaggacgacaagttccgtct\n" + + "tgctccatcatatactaccgatacaccaatcgtatcaagtttagtatacttgctttctct\n" + + "cttctacagcttactcgcttgtccgagaagcggttggtgctcataaagttagtagtaaat\n" + + "gtacaactagtagccagtccttacctgtttttacgactactacggacaccatgagataca\n" + + "gaagttagtgctacaattataccattacatgctcaatatcgttgtcggccataagatcga\n" + + "agagtgcatcacgcgtgtgaatacgtaaaatctaccatcccgtcaatgcacaaaaacaca\n" + + "ctccccttgttgactaacatcttttacaagaggctaaatcattgtccaggatcgaatacc\n" + + "ttgtgtacaatcgtcacccatcggaagaataccacttttccgatgtagtatgatttacaa\n" + + "aaaacatctatgtgagtaggccaattgtagtagaatatattcatttgaccgtcattagcc\n" + + "ttcttcttaggttgtgtacggatagtaggtacataaaccgtcgtgtggcatacgctgcga\n" + + "tttcatacagctgccaacaccttttttaccaggctagagtcagaaaagttggagccatgt\n" + + "taaatagttaccatcataaaccactgttgtctactagtctgatcagctttcatgcctgtg\n" + + "caagcaatatggattctcacgtaatggtaacaactgttgcgttacttaggctggttaatt\n" + + "tgtcagagtaataaatacatgtcttgttgtgtttcctaatcctcggaaagtacacaagcc\n" + + "taggaataggaaaagtaaagctcttttattctgatagtgactaactcaggatctaaatac\n" + + "gcgattatactaaccttcaccaaagctcaaaaatcatctgctggtgaccagttatagaca\n" + + "gggtaattcaatatttaatgtctcccttaacatttcaccagcatggattgaagatagtat\n" + + "aaagttttacatggcagtcattgtgtcacggttctatacaaattctgatagttagacggt\n" + + "atttgaaatgtgcttctagcatggtatcttacacaactgaatgaacgactggagccgttc\n" + + "gtatactatttgcgagcctcgagaccccgtttcctaatgttaacgaatatagtataatat\n" + + "aaattgtgatatgaataacacaagtaactacagtttggacaattaattgttctaaactaa\n" + + "aaatcattcacttcagatggcatagagttatggctactacacatataaagcggtatgtga\n" + + "aacacccgttttagccggaaaccctctactgctcgggacaatgaatgatttccaaaatat\n" + + "ggatgtgcagaattgttagtgtgactcaggtccaaatagacactttagtttcgtcaagtc\n" + + "gttgcaaagtttaaaaccatcgcagcattctttatttggtctacattgagaaatgaaaaa\n" + + "acgtgacagaaagtctagaagaactgtgaataatgtctattactgattaactagtaagac\n" + + "attagtgcatctggtccactgaagcacccgcttggcgttaggcaatctctgtgaactgtc\n" + + "gtggctgttccggtaatgtacgaaagcaagcctataggttgatcgagtcgcttcattaag\n" + + "gtcaatttcacaatatccgatcacattgtgctaggttcgtcctttaccttgcttagtgct\n" + + "gcatgtacggggtgtcatgacttgttatcggcagactctttatcccaagaatggataata\n" + + "tgtacatggaaagtgtccataattaagtcccttcactgtaaagaatgactgccacgtgat\n" + + "ccatgaggtctacagaaaccgacttacttgctttttgatcaacttaattatggattcata\n" + + "aagttcagatatcggtacaattggtgtacaatatgaaattaatgaggaaacatggaaatc\n" + + "tgaatgacagtgatagaaaagatccccatttgcccggtcagttcatgttacaccactcat\n" + + "tagtactgtaagtgtttcgtcagcattgagatccacgatcatgtgtttatgccttcgaaa\n" + + "ctggatgtacgacgatcgagacgaagaggtatatataacctaaatactaggtacgttgtt\n" + + "agagagacgatgaaaattaatcgtcaatacgctggcgaacactgagggggacccaatgct\n" + + "cttctcggtctaaaaaggaatgtgtcagaaattggtcagttcaaaagtagaccggatctt\n" + + "tgcggagaacaattcacggaacgtagcgttgggaaatatcctttctaccacacatcggat\n" + + "tttcgccctctcccattatttattgtgttctcacatagaattattgtttagacatccctc\n" + + "gttgtatggagagttgcccgagcgtaaaggcataatccatataccgccgggtgagtgacc\n" + + "tgaaattgtttttagttgggatttcgctatggattagcttacacgaagagattctaatgg\n" + + "tactataggataattataatgctgcgtggcgcagtacaccgttacaaacgtcgttcgcat\n" + + "atgtggctaacacggtgaaaatacctacatcgtatttgcaatttcggtcgtttcatagag\n" + + "cgcattgaattactcaaaaattatatatgttgattatttgattagactgcgtggaaagaa\n" + + "ggggtactcaagccatttgtaaaagctgcatctcgcttaagtttgagagcttacattagt\n" + + "ctatttcagtcttctaggaaatgtctgtgtgagtggttgtcgtccataggtcactggcat\n" + + "atgcgattcatgacatgctaaactaagaaagtagattactattaccggcatgcctaatgc\n" + + "gattgcactgctatgaaggtgcggacgtcgcgcccatgtagccctgataataccaatact\n" + + "tacatttggtcagcaattctgacattatacctagcacccataaatttactcagacttgag\n" + + "gacaggctcttggagtcgatcttctgtttgtatgcatgtgatcatatagatgaataagcg\n" + + "atgcgactagttagggcatagtatagatctgtgtatacagttcagctgaacgtccgcgag\n" + + "tggaagtacagctgagatctatcctaaaatgcaaccatatcgttcacacatgatatgaac\n" + + "ccagggggaaacattgagttcagttaaattggcagcgaatcccccaagaagaaggcggag\n" + + "tgacgttgaacgggcttatggtttttcagtacttcctccgtataagttgagcgaaatgta\n" + + "aacagaataatcgttgtgttaacaacattaaaatcgcggaatatgatgagaatacacagt\n" + + "gtgagcatttcacttgtaaaatatctttggtagaacttactttgctttaaatatgttaaa\n" + + "ccgatctaataatctacaaaacggtagattttgcctagcacattgcgtccttctctattc\n" + + "agatagaggcaatactcagaaggttttatccaaagcactgtgttgactaacctaagtttt\n" + + "agtctaataatcatgattgattataggtgccgtggactacatgactcgtccacaaataat\n" + + "acttagcagatcagcaattggccaagcacccgacttttatttaatggttgtgcaatagtc\n" + + "cagattcgtattcgggactctttcaaataatagtttcctggcatctaagtaagaaaagct\n" + + "cataaggaagcgatattatgacacgctcttccgccgctgttttgaaacttgagtattgct\n" + + "cgtccgaaattgagggtcacttcaaaatttactgagaagacgaagatcgactaaagttaa\n" + + "aatgctagtccacagttggtcaagttgaattcatccacgagttatatagctattttaatt\n" + + "tatagtcgagtgtacaaaaaacatccacaataagatttatcttagaataacaacccccgt\n" + + "atcatcgaaatcctccgttatggcctgactcctcgagcttatagcatttgtgctggcgct\n" + + "cttgccaggaacttgctcgcgaggtggtgacgagtgagatgatcagtttcattatgatga\n" + + "tacgattttatcgcgactagttaatcatcatagcaagtaaaatttgaattatgtcattat\n" + + "catgctccattaacaggttatttaattgatactgacgaaattttttcacaatgggttttc\n" + + "tagaatttaatatcagtaattgaagccttcataggggtcctactagtatcctacacgacg\n" + + "caggtccgcagtatcctggagggacgtgttactgattaaaagggtcaaaggaatgaaggc\n" + + "tcacaatgttacctgcttcaccatagtgagccgatgagttttacattagtactaaatccc\n" + + "aaatcatactttacgatgaggcttgctagcgctaaagagaatacatacaccaccacatag\n" + + "aattgttagcgatgatatcaaatagactcctggaagtgtcagggggaaactgttcaatat\n" + + "ttcgtccacaggactgaccaggcatggaaaagactgacgttggaaactataccatctcac\n" + + "gcccgacgcttcactaattgatgatccaaaaaatatagcccggattcctgattagcaaag\n" + + "ggttcacagagaaagatattatcgacgtatatcccaaaaaacagacgtaatgtgcatctt\n" + + "cgaatcgggatgaatacttgtatcataaaaatgtgacctctagtatacaggttaatgtta\n" + + "gtgatacacaatactcgtgggccatgggttctcaaataaaatgtaatattgcgtcgatca\n" + + "ctcacccacgtatttggtctaattatgttttatttagtgacaatccaatagataaccggt\n" + + "cctattaagggctatatttttagcgaccacgcgtttaaacaaaggattgtatgtagatgg\n" + + "taccagtttaattgccagtgggcaatcctaagcaaaatgagattctatcctaaagtttgg\n" + + "gcttgatataagatttcggatgtatgggttttataatcgttggagagctcaatcatgagc\n" + + "taatacatggatttcgctacctcaccgagagaccttgcatgaagaattctaaccaaaagt\n" + + "ttaataggccggattggattgagttaattaagaccttgttcagtcatagtaaaaaccctt\n" + + "aaattttaccgattgacaaagtgagcagtcgcaataccctatgcgaaacgcctcgatagt\n" + + "gactaggtatacaaggtttttgagttcctttgaaatagttaactaatttaaaattaatta\n" + + "acgacatggaaatcacagaacctaatgctttgtaggagttatttatgctgtttactgcct\n" + + "ctacaaccctaataaagcagtcctaagaatgaaacgcatcttttagttcagaaagtggta\n" + + "tccagggtggtcaatttaataaattcaacatcgggtctcaggatattcggtcatataatt\n" + + "tattaagggctcttcgagtcttactctgagtgaaattggaaacagtcatccttttcgttg\n" + + "tgaggcatcttacaccgctatcgatatacaatgcattccaccgcggtgtcccgtacacaa\n" + + "ggaaacttgttaccttggggatataagaaaactcacacgtctcattattaaactgagtac\n" + + "aatttttgcacgagaaagtaatgcaatacaatatgatgaaagccagctaatgaaaaggga\n" + + "tggaacgcacctcggatctgttgcactggattaaaatccgattatttttaaaaatattca\n" + + "gtgctagagcatatcaggtctacttttttatctggtatgtaaagcccacggagcgatagt\n" + + "gagatccttacgactcaacgaaaagttataacataactcccgttagccaaagcccaatcc\n" + + "cgattactgccctaccctaacgtctgccatctaaatatcgaacttgttatgatcaatgtg\n" + + "actacctcccaccctttccccttcatttgttccactggggataagctagcgttttcagaa\n" + + "tcaatgcaataagaatagccaattgtctcacttcatcagagctcttggcaattccaggcg\n" + + "ctacgtggttctggaatatattcatttttcaaatagtaatacgtttagtgttgctattgt\n" + + "ctacacgtttggatattacgttatgtgagcggacatcaatagttgtctaactctttagta\n" + + "agccagagatagcactcttagcgaatggataccatcttccataagtttagttaatagtcc\n" + + "gaaacaactgcttcgagcatatttgaacctccttgtaggcaaatagcctcttcaaagcaa\n" + + "tcttactaatagatagagtttgttttaagggactactagaaatgggacaatcttaatagt\n" + + "atgacctaaactgacatttaaagatatatccaggtggcaagcataaagatcattgcgcca\n" + + "cctccaccgtgggattacttatcagtcgatatcctatatgctaagtttgcgacggcagaa\n" + + "tacaaactaagctgagttgatgctaaccttacctatgataccccattggaccggttaaca\n" + + "gccctacttattccaaataaaagaacttttatgctgtagaagctattatagtgatgcctg\n" + + "gtaacttcagtatattaaaatgacacacatacgccatatagagctcctggaactttgaat\n" + + "aatgagcgaacttcgaagttgaagagcaagaaaccatatgtcacggttgcctaaagcccg\n" + + "gtaaccagacatgtgctatcattgatcattatcgaggttttcataaccttgacccattat\n" + + "cggctgtgcgcggacaagtacttaaatcactagtttcttcacctgcttatcggtaagaaa\n" + + "taaggttggcaaagaatcgcataagacggacgtagagccgcagcgttgtgcgagtccagg\n" + + "tgcatgcgcagcaataggattttaaattttgttccatttttaatttagccgtaaggatgt\n" + + "ccgtaaatgattgaaaattggattcaatctttgggcctatgctactggaacctgatcgac\n" + + "aaaatttcaaacatacgttaactccgaaagaccgtatttttgcggctagaatagtcagtc\n" + + "gcttggagccatataccttaccacttaaacgacgtgctcctgtagttgaaatataaacag\n" + + "aacacaaagactaccgatcatatcaactgaagatctttgtaactttgaggcgaagcaccc\n" + + "tcttcgagacaactaagagtaaagtaccgggcgccgcaaggagtcgattgggaccctaaa\n" + + "tcttgacgaattgctaagaggctcagagctaccactgtaatttctctagagcccataata\n" + + "aatgaacgatacatccgtaggtagcacctaagggattataatggaagccaaatgcagtta\n" + + "ataatattatatactggcgtacacgattcgacggatctctcacatagtgattcacgaccc\n" + + "ccccctttgattgacacagcgtcagcattttgcaagaacgatcttctgcatagggtgcgc\n" + + "caccgtaaggatgacgtcgaagctacaactgggtataatttaccatgcttccctgatgct\n" + + "gagtgcaatacactaagaatgagtttttaccccatatcaccagtatttgttctgttattg\n" + + "cgaagaaatggctatgctgagttggcgactaaagtcacccatcctttttattaggtaacc\n" + + "ccctcccttaaactaactgatttgctggagctgccctgcatacatatactttatcattta\n" + + "tggacgtccgtgacgcttattatccaccatagtcgatatgctacacggattcattaatgg\n" + + "atcgtaggagtttaagttatatttactaagatcggtctcggctactatcccgccttaccc\n" + + "ggcgctatttacggccatttttaatatattgacggtaattattcctatggtttcgaccgc\n" + + "acgtccttggacaagaaagaatggcaaaaaaaatgtaaaagaaaaaaaatattgagtccc\n" + + "taccatcatataaaaaatatgtgatgagtaacttgacgaaatgttagtggttattaaaga\n" + + "ctatctattacaccttttgttttctgtcgtagtatattaaagtctagaagccttacagga\n" + + "aaatcagggttatacagccgatactccgcagcatgaatcatcgaggaggtgtcctaccat\n" + + "cgcgccttgtaatcttgtctgtgtatactgtatttagaccttttatacaaagtaaatatc\n" + + "tcggctttatgtgattgggaggggcctactcaaacatgatgacttgacctaataatcact\n" + + "gtgcgggcgtcttatgactagctattccttgaaatccaccaccaaatggttaatatgtaa\n" + + "aaactttgacgatgaaacaaggtgaatgtgtagttactttgtgtaattagctgcgtcgag\n" + + "cattgcttgtaaaaccgtcaatcgcacacgttacttccataaaatttctacgaatacacc\n" + + "cttcttaaaaaaaacgtaggaattcacgagtttaacaaacgataactgtataaagtggaa\n" + + "gtccgaagaaagcagatgcccgaactactcgaagatgtttcgttttcttaaccatagggg\n" + + "cttcttaatggcccactacgcacattttgttcaagcccgagagggacatccccattacgg\n" + + "gagtattactaaaactgttccgtaatacgttcagcaagggatgaaaaaggccactgctca\n" + + "agttattgacgtgggagtattacatcggaagcctgaatcccacactatgatggtctgtac\n" + + "aggcctagggactgcgtctagacggtattaccggcttctaatcatacgatcgtgagtctt\n" + + "aacgggaagtaaggctcacacctaccccaaaccatttatctatgtaagtataaaattgtg\n" + + "cgtaagtgttcaaagtggacaataaagacgtggcaaaaacccccgcacataagccgcttt\n" + + "agatttcacaaataccaatgcggttaaaaacatccttgagtcgtacatacaccatactcg\n" + + "cgttaaacggatataacagaagataataaatccggatgtggagtcggtgtaactatagaa\n" + + "agccaagtgaaataatgcttaccagtcatttagctatacggctttcatttcatgtcaaga\n" + + "gggtggagtttgacctgtacagttgatatatcaccgatacttagaactcacctaaagcta\n" + + "aaattgctcgcagcgtgtaatccgcatattacaaacaatagatgggattcattatacata\n" + + "agacacgatgatctgctttttcaggttgcgagatgttgcctatcgtcaatcgagtcctgc\n" + + "cttacaccacttaaacaaaagtattgacagggaacctattttcgaggtattatatagtcc\n" + + "agcttgaatatcaatttgacagttaacctagtgaaaatcagtaagaggaaatacgccaca\n" + + "ttctccagtgaaattctacgggttatcgtctagtccaactatcaattataactcacgaga\n" + + "tataagtaaattctcgtacttggcctgatttttattatactttggatccttagtaaacag\n" + + "gaagggagaaaccttcaacgaaaaacactggattttgttttactctcaaagctcttatat\n" + + "gacggaaataccctgtcaagtcttaactttattactagactaatgaaatgggcttggggt\n" + + "ggccagaatcatagtacaatttagcggatacactattcggactttcctatcggctgtctg\n" + + "gttggataagtatggggactaataggctagacatacctatacttaaactatacaggcgtc\n" + + "atctatctctgcaactttggagttccctgatgttctcccgccctttgggttcacatcttc\n" + + "tataccgacacccctaataacgattagtttgtgggttagagtaaattaatacggttaata\n" + + "ttaatgtatcgttgaaaagctggtgtcgccaataaggtaaccggctaggcagagtatatg\n" + + "tcacgaagtataactaccctaatgataagctgtaggaataaaattaatgctgtctctaag\n" + + "cgaagagatatttccgactctgttttaatgacgaatctcattacttctgacttgcaaatg\n" + + "ttcaatatggcacggtttcacggcacctttgtgacgcatataatgaacttagaagattat\n" + + "aacgacggaactttatatgataatccgttacgattaaagaatctgttaaatatcataatg\n" + + "gcattcagttctagaccgtgcatcatggtaaacttactttctctgcatggcgacatacat\n" + + "ttcgctattcaaattcgcgtgtggttacacccactcgcacctttggaatattaagagaag\n" + + "atgatcagaaaatccattcgctcaatttttctgacgtacgtctaatttatcctaggagac\n" + + "aaatcgttttatgtctctcacatttttgaagaaaggttcgagagacaatactcaggtcct\n" + + "gaactgctagaagatactcggtggagcgtggcaacaatgaaaaactcgtgacataaatga\n" + + "atgatacttttccaagttcagttaagtgaatatgtttaacatacccggcttttcgatctt\n" + + "aagctgacgctggacgtgcgagtaatgtcagtctcttacatacactagtgactccaagtt\n" + + "tcgtcaaaaacgccccctcccttctcgagcccactcacgctatgtattgacgcgaacttg\n" + + "ttcgggatcagacttttcaggagttcggtcgcgtgtccctatgtgctaatatataagtta\n" + + "gatcgcattagatgctaatctgaatacttatagacgaccttcaacgagaacgggtaccac\n" + + "cttgaggctagagttaggtgtgaaacgacaggtagggacatataaaatttgagtgcggct\n" + + "ttagttaagggtttaattacctactcaaacatcacgctcgcgcccttcgtacgtaatcga\n" + + "ccatctagaggctaaggggactgtactaggtagtgattaatgatatcctagacgcacgtg\n" + + "ccttagatcttcagactctgatggtccgcgatcaccgtaattgtagtcctccaactcgat\n" + + "cactttgttggcgtcaaagaaattacgatatctaaatacttataatacaataaccaagga\n" + + "tgagaatgactcatcgcgttggagttatattgcttgaagttctatggaatgaaagcacgt\n" + + "tatctgccgtcccaatatctccagtgagctaattcattggacggtccactttgatcaatc\n" + + "cccgaggagatgttcggacactttagtctgtaacacttagcgttgagaccacgaacaatt\n" + + "gattactcagtcttgaaggtgttttccaaagttcattttaaataagactacgataggcct\n" + + "ttcctattgatataaactacccggctctgttgttcgtgtgagtcgtacttctctgtgttt\n" + + "ttctgattatagcaagattcgattcttagtgtaaacagcgatttttatttgacccgtcaa\n" + + "tgagaagcgcataggatctaagcaaaattatcaagttgtgccacaaggtaagatctttcc\n" + + "agttattgcaggtaggatgtatcccacgttgatagtatgaggtctgacgtcaactgtcta\n" + + "ggagagttgaccgcgtgcgggtacaccggatttgcatcgatgttgagaacgcagaactcc\n" + + "cactgtcgtggcggcgttcctgatatttagcaagaggcgttgataaagccctcatcatct\n" + + "agatctcgacctcatctgccctcttgctccatcattttctacacagactactttcctatc\n" + + "tacgttagtataattgctttctatcttagtatcatttagagcttctccgtcaacaggttc\n" + + "gtgctattaaagttagtacgaaagggacaacttgtagcaacgcatttaatcggttttcga\n" + + "ctacttcgcacaaaatcagataaagaagtttgtcattctattagacattgaattgcgcaa\n" + + "ttgacttgtaccacttatgatcgaacactgaatcaagactgtgattaactaaaatagaca\n" + + "agccactatatcaactaataaaaacgcccctggtggtcgaacatagttgactacaggata\n" + + "attaattggactggagccattacattctctacaatcgtatcacttcccaagtagacaact\n" + + "ttgaccttgtagtttcatgtacaaaaaaatgctttcgcaggagcacattggtagttcaat\n" + + "agtttcatgggaacctcttgagccgtcttctgtgggtgtgttcggatagtaggtactgat\n" + + "aaagtcgtgtcgctttcgatgagagggaattcaccggaaaacaccttggttaacaggata\n" + + "gtctatgtaaacttcgagacatgtttaagagttaccagcttaatccacggtgctctacta\n" + + "gtatcatcagctgtcttgcctcgcctagaaatatgcattctatcgttatcctatcaacgg\n" + + "ttgccgtactgagcagccttattgtggaagagtaatatataaatgtagtcttgtctttac\n" + + "gaagcagacgtaagtaataatgacttggaataccaaaactaaacatagtggattatcata\n" + + "ctcaagaactctccagataaataacagtttttacgatacgtcaccaatgagcttaaagat\n" + + "taggatcctcaaaactgatacaaacgctaattcatttgttattggatccagtatcagtta\n" + + "aactgaatggagtgaagattgtagaatgttgttctggcctcgcatggggtctaggtgata\n" + + "tacaatttctcatacttacacggtagtggaaatctgattctagcttcgtagctgactata\n" + + "ctcaaggaaccactgctcaaggtaggagactagttccgaccctacagtcaaagtggccga\n" + + "agcttaaactatagactagttgttaaatgctgatttcaagatatcatctatatacagttt\n" + + "ggacaattatgtgtgcgaaactaaaattcatgctattcagatggatttcacttatgcctt\n" + + "agaaacagatattgcccgagctcaatcaacagttttagccggaaacaatcgaagcatagg\n" + + "gacaatgtatcttttcctaaattgccatgtgcagatttctgagtgtcacgaagcgcataa\n" + + "tagaatcttgtgttgcctcaactcgttgaaaagtttaaaacaatcgcagcagtctttttg\n" + + "gggtctactgtgtgtttgcaaaataactgaaagaaacgcttgaacaactctgaagtagct\n" + + "cgagtactcattaaagtgtaacacattagtgaatatcggccaatgaaccaaacgcttccc\n" + + "ggtacgctatctctctcatcgggaggcgatgtgcaggttatctacgaaagcatcccttta\n" + + "cgttgagagtgtcgatgcatgaacctcattgtaacaatagcccagcaaattctcatacgt\n" + + "gcctcagggtccgggcgtactcctccatggaagggcgcgcatctagtgttataccaactc\n" + + "gctttttaactactatgctgtagttctacaggcatagtggccagtattttctaacttctc\n" + + "tggatagatgctctcactcctcatccatcacggcttcagtttacgtcttacttgcttgtt\n" + + "cagcaacggatggaggcattaagtatcttcactgttccctaaaattgctgttcaatatca\n" + + "aagtaaggacgatacagggaaagctcaagcacactcattgaatactgccccagttgcaac\n" + + "ctcacttaatctgacaaaaataatgactactctaagtgttgcggaagcagtctcttccac\n" + + "gagcttgtctgtatcacttcgtataggcatgtaactcgatagacacgaacaccgagtgag\n" + + "aaactatattcttgcttccgtgtgtgtgacaccaggtaattgatgcggatataagctgga\n" + + "gatcactcacgcccacacaaggcgctgctacctctttattccaatgtgtaagaatttgct\n" + + "aacttcatttctagaccgcagctttgcggtcataatttcacggtacggacccttgggtta\n" + + "gagacttgataacacacttcgcagtttccaccgcgcacatgttttagtggcttctaacat\n" + + "agaatttttgttgtgacataaagagtgcgtgggagacttgcccgaccgttaagccataat\n" + + "caattgaaagccccgtgagtcacatctaattggttgtactgcgcatttagctatccttta\n" + + "gctgactcgaagagattcgattcctaatataggttaattagatggctgccgcgcgaagta\n" + + "aaacgtgaaaaacgtagtgcgcagatctgcataactcgcgcttaattacttatgagtagt\n" + + "tccaagttcgctacgttatgagagagattggaattaagcaaatatgttttatggtgattt\n" + + "tgggatgagaaggactgctaagtacggctactaaacaaatttctaaaaccgccatctacc\n" + + "ttatcttggagacatttaagttgtatatgtcactagtctagcttttgtctgtgggacgcg\n" + + "ttctcggaatgagggaaatgcaagagccgattcatcaaatgcttatctaagaaagtagtg\n" + + "gactattacaccaagcacgaatgccagggaactgctttcttgctcaggacctcgcgacaa\n" + + "ggtaccccgcataagtcctagaattacatttggtcagcaatgctgacatttgaccgtgaa\n" + + "aacataattttaatcagaaggcagctcacccgcttgctctagatcttatctttgtatgaa\n" + + "tgtcagaatttactgcaatatccgttccgaatagtgagggcttagtatagttctctgtat\n" + + "acaggtcacatcaaactccccctgtcctagtacagctctgagctttaattaattgcatac\n" + + "atttccttcaatcatcagatgaaaacaccgcgaatcatgctcttctcgtatagggcaaga\n" + + "gaagcaacaaacaactagcccgactcacgttcatccgccgtatccttgttcagttcttac\n" + + "tccgtattaggtcagcgaaatctaatcagaataatcggtcgcgtatcaaaattaaaatcc\n" + + "cgcttgaggttgacaattaaaacgctgagcagttatcggctattagatagtggggtgaaa\n" + + "gtaattggctggaattatgttaaaacgtgatattaagctaaaatacgctacttgttgccg\n" + + "acctaattcagtcattcgatattcagttagagccaagaataacaagcttgtataaattga\n" + + "acggggtgcactaaacgatgtgttactctaatattcagcttggagtatacctgaaggcga\n" + + "attcatgtatcggccaataataagacgttgaagatcacaatttggactagcaaaagaagg\n" + + "tgatttatgcgtggggattgagtccactgtacgagtacggtctctggaaaattataggtt\n" + + "cagggaatataaggaagtaaagataattaccaagagatttttggtatcgctatgacccag\n" + + "aggtgttctaacgtctgttttgatccgcagaatttctgcctcaatgcatatttgacggac\n" + + "ttgaactagagcctctaaagttaaatggcgacgcaactgttcctaaacttcaattattac\n" + + "tactctttttttcctagggtattgtagaggccagtggacaaaataaatcaaatttaagat\n" + + "gtttcggacattaacatcccccgtagcatagaaatcatcagttatccaatctctcatcga\n" + + "gcttttacaatttctgctggcgctatggacagcatatgccgcgagacctccgcaagactc\n" + + "acttgatcactgtaagtatcttcattagaggttagagcctatagttaagctgctgaccta\n" + + "gtaaaattggtattttctaattttattgctcaagttaaaggttagtgaagggataatgac\n" + + "gttatttttgaacaatgggttgtattcaattttatatcacgaatggaacccttcattccc\n" + + "ggcataatactagacgacacgaacaagctccgatctatcagccaggcacgtgttaaggtt\n" + + "taattccggcaaaccaatgaagcatcaaaaggtgacctgatgcaacttagggtcacgatg\n" + + "agtttttcaggactacttattacctattaataagttaacatgagccttcataccccgtaa\n" + + "gacaatacatactccaccaattagaattctgagccatcttatctttttgtatcatcgaag\n" + + "ggtatggccgaataggttaattagttactcctaacgtctctacaggcatgcatttgacgc\n" + + "accttcgaaaatagtcaatctctcgccacacgcgtctagtatgcagcatcaaaaatatag\n" + + "tccacggtttccggattaccaaacgcggcaaagagaaacattgtatcgacggagataact\n" + + "taatacagaaggaaggggcatcttcgaatacggatgaataattctatctgtttattctga\n" + + "catcttgttttcaggttaatcttacgcattcaaatgacgcctgccccatgcgtgcgcaat\n" + + "tattttctaatattgacgagagcaatctcactccttttgggtctatttatgttttattga\n" + + "ggcacaagcctatacagaacaggtactattaaggccgtgagtgtgagactcaaaccgtgg\n" + + "aaacaaaggatgggttgttcttggtacaagttttagtgcatgtgggcaatccttaccaaa\n" + + "atcagatgctatccttaactttgggctgcatttaagatggcggttggaggcctgtgagaa\n" + + "tcctgcgtgtcatctttaatgaccgaattcatccatgtagattcagatcacacactcatt\n" + + "ccttgatgttgtctaaacaaaagttgttgtggacgcattggagggagttaagtaacaact\n" + + "tgggatcgcatacttataaaaattatatgttaaactttcacaaacgctgaagtccaaagt\n" + + "aactagcccaaacgcctcgagagtcactaggtattaatggtgtttgagttcctgtgaaat\n" + + "agtgttcgaaggtaaaatttatgtaccaaatcgaaagaacacttaataaggcttgcttgc\n" + + "acggaggtatgatgtttactgactctacaaccctaattttccagtacgtacattcattcc\n" + + "aataggttagttctcaaagtgctatacaggctcctcaattgatgatatgcttcagccgct\n" + + "ctatggatattagctcattttatttaggaagcccgcttagaggcttactatgagggaaat\n" + + "gccaaaatgtcatacttttcggtgtgtcccatatgacaccgctttacatagaatttgaat\n" + + "taaaacgcgctctcccgttcactaccatacttggtaccgtgcgcatattacatatagata\n" + + "taggatcattttttaaagctgtactaggtttgatcgacaatcttatgctatactatatga\n" + + "tgtaaccctcataatcaataccgatcgtacgatcctagcataggtggcaagcgattttat\n" + + "gccgattattgtgttaaatagtctgtgagtgtgattatcagggctacgttggtagagggg\n" + + "ttgtatagacctcgcacacattgtgacatacttaacaatatacgaaaactgatataataa\n" + + "atccccttacccaaacaccaatcccgttgaatcaactaccataacgtctcccatataaat\n" + + "tgcctacttgtttgcataaatctgaatacataacaccattgcaccttcttgtgttccaat\n" + + "cccgttaagattgccttgtcagatgatatgcaagaacaatagcatttgctagcaattatt\n" + + "aacagctcttcgaattgcctccacataacgcgggagggtatattttaatttggcaaatac\n" + + "taagtactgttggcgtcatatgctattaacggttggatattaagttatgtcagccgtaag\n" + + "caagagtgggcgaaatattttgttacccagtgagagcactcttagagtttggatacaata\n" + + "ggccatatgttgacttaagaggacgtaactacgccgtacaccattgttcaaccgacttct\n" + + "tggcaaatagaatcgtattagcaatcttaagaatagagacacgttcgtgttagggtatac\n" + + "tacaaatccgaaaatcttaagaggatcacctaaactgaaatttatacatatttcaacgtg\n" + + "gatagatttaacataattcagccacctccaacctgggagtaattttcagtagatttacta\n" + + "gatgattagtggcccaacgcacttgactatataagatctggggatcctaacctgacctat\n" + + "gagacaaaattggaaacgttaacagcccttatgtgtacaaagaaaagtaagttgttgctg\n" + + "ttcaacagatgatagtcatgacgcgtaacttcactatagtaaattgaaacaaatacgcaa\n" + + "tttagacagaatggtacggtcatgaatgacagtaattcgaagtgctagaccaacttaaaa\n" + + "taggtaaacgtgcccgaaaccccccttaacagaaagctgctatcatggtgcagtatcgac\n" + + "gtgttcagaaacttgtaacttttgagcaggtccgagcacatggaagtatatcacgtgttt\n" + + "ctgaaccggcttatccctaagatatatccgtcgcaaactttcgatttagtcccacgtaga\n" + + "gcccaagcgttgtgcgactccacgtgcatgcccagaaatacgagtttaaatttggttaca\n" + + "tggttaattttgaccgaagcatcgcactttatgattgataattggattcaatatgtcgcc\n" + + "ctatgcgaatgcaacatgatccacaatttggctataagacgtttaatccgtatcacactt\n" + + "tgtttgcggctagtatagtaacgcccgtgcaccaagagtcagtaacaattataagtactc\n" + + "cgcaggtacttcaaatataaaaactaatcaaacacgacccatatgatcatctgaagatat\n" + + "ttggaactttctcgacaaccaccctcgtactcaatacttacactaatcgacaggcacacg\n" + + "caacgtgtacagtcgcaccatattgagtcaagatttgcttagtggcgatgagcgtacacg\n" + + "cttatttctctagtcacaattagttatctacgagacatcacgagggagcaaataagcgat\n" + + "gttatggctacacataggcacgtatgaatatgatataagccagttaaacagtcgaaccat\n" + + "cgagcaaattctcatgcaccaacccacacgttgaggcacaaagagtaagctgtttgaatg\n" + + "taacttcttctgctgagcgggccccaacgtaaggatcaactagaagagaaaactcggtat\n" + + "tagtttaaatgcgtcacggagcatgagtgcatttcactaagaatgtctgtgtaaccaata\n" + + "taacatctatttgttatctgattgcctacttatggctttgcggtcgtggcgactaatgtc\n" + + "tccaatccttttgaggtcggtaccaactccctttaaattacgctgtgcaggctcatgcac\n" + + "tgcatacatatacggtagcaggtagggacctcacgcacccttattataatcaatagtagt\n" + + "tatcagtcaacgaggcaggaatgctgaggtcgaggtgttggtatattttctatgtgccgt\n" + + "ctaggcgactatcacgcattaccaggcgagatttaagccaattttgaatatagtcaacgt\n" + + "aatttttactatgggttccaccgaaacgccttgcacaactaagaatcccataaaatatcg\n" + + "atatcaaataaaagattgtgtcaataccttcatatatattttttcggttgactaacgtga\n" + + "actaaggttaggggttttgtatgtctatataggaaacagtttcttttctgtcctacttta\n" + + "gtaaagtcttcaagccttactccaaaatcacggtgattaagccgttactcagcagcatga\n" + + "ttctgcctgctcgggtcctaaaatccagccttgtaagagtcgctgtgtattagctaggga\n" + + "gacctttgttaaaaaggatatatcgcggcgggatgtgagtgcgtggcgcatactcaatct\n" + + "tcagctcgtgtcattataatatctctcccccacgcttttcactagatatgccgtgtaagc\n" + + "aaacaccttatgcttaatttcgaaaatattggtacttgaaaaaagctgtaggggtactta\n" + + "atgtctggtaggagatcaggagagaattgagtgtaaaaccgtaaagccctcacctgactt\n" + + "catgtaaatggcttagaagactccatgatttaataaatactacgaaggaaagactggatc"; +} diff --git a/src/main/java/org/linaro/benchmarks/benchmarksgame/revcomp.java b/src/main/java/org/linaro/benchmarks/benchmarksgame/revcomp.java new file mode 100644 index 0000000..0c2f88d --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/benchmarksgame/revcomp.java @@ -0,0 +1,1103 @@ +/* + * This benchmark has been ported from "The Computer Language Benchmarks Game" suite and slightly + * modified to fit the benchmarking framework. + * + * The original file is `revcomp/revcomp.java-4.java` from the archive + * available at + * http://benchmarksgame.alioth.debian.org/download/benchmarksgame-sourcecode.zip. + * See LICENSE file in the same folder (BSD 3-clause) + * + * The Computer Language Benchmarks Game + * http://benchmarksgame.alioth.debian.org/ + * contributed by Anthony Donnefort + * slightly modified to read 82 bytes at a time by Razii + */ + +/* + * Description: Read DNA sequences - write their reverse-complement. + * Main Focus: TODO + * + */ + +package org.linaro.benchmarks.benchmarksgame; + +import java.io.*; +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + +// CHECKSTYLE.OFF: .* +public class revcomp { + private ReversibleByteArray buf = new ReversibleByteArray(); + InputStream stream = new ByteArrayInputStream(fastaStr.getBytes()); + static final byte[] cmp = new byte[128]; + static { + for (int i = 0; i < cmp.length; i++) cmp[i] = (byte) i; + cmp['t'] = cmp['T'] = 'A'; + cmp['a'] = cmp['A'] = 'T'; + cmp['g'] = cmp['G'] = 'C'; + cmp['c'] = cmp['C'] = 'G'; + cmp['v'] = cmp['V'] = 'B'; + cmp['h'] = cmp['H'] = 'D'; + cmp['r'] = cmp['R'] = 'Y'; + cmp['m'] = cmp['M'] = 'K'; + cmp['y'] = cmp['Y'] = 'R'; + cmp['k'] = cmp['K'] = 'M'; + cmp['b'] = cmp['B'] = 'V'; + cmp['d'] = cmp['D'] = 'H'; + cmp['u'] = cmp['U'] = 'A'; + } + + static class ReversibleByteArray extends java.io.ByteArrayOutputStream { + void reverse() throws Exception { + if (count > 0) { + int begin = 0, end = count - 1; + while (buf[begin++] != '\n'); + while (begin <= end) { + if (buf[begin] == '\n') begin++; + if (buf[end] == '\n') end--; + if (begin <= end) { + byte tmp = buf[begin]; + buf[begin++] = cmp[buf[end]]; + buf[end--] = cmp[tmp]; + } + } + } + } + } + + public void old_main() throws Exception { + byte[] line = new byte[82]; + int read; + buf.reset(); + stream.reset(); + + while ((read = stream.read(line)) != -1) { + int i = 0, last = 0; + while (i < read) { + if (line[i] == '>') { + buf.write(line, last, i - last); + buf.reverse(); + buf.reset(); + last = i; + } + i++; + } + buf.write(line, last, read - last); + } + buf.reverse(); + stream.reset(); + } + // CHECKSTYLE.ON: .* + @Benchmark + public void jmhTimeRevComp() throws Exception { + old_main(); + } + + private static final String fastaStr = ">ONE Homo sapiens alu\n" + + "GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA\n" + + "TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT\n" + + "AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG\n" + + "GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG\n" + + "CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT\n" + + "GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA\n" + + "GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA\n" + + "TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG\n" + + "AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA\n" + + "GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT\n" + + "AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC\n" + + "AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG\n" + + "GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC\n" + + "CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG\n" + + "AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT\n" + + "TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA\n" + + "TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT\n" + + "GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG\n" + + "TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT\n" + + "CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG\n" + + "CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG\n" + + "TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA\n" + + "CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG\n" + + "AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG\n" + + "GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC\n" + + "TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA\n" + + "TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA\n" + + "GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT\n" + + "GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC\n" + + "ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT\n" + + "TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC\n" + + "CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG\n" + + "CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG\n" + + "GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC\n" + + "CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT\n" + + "GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC\n" + + "GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA\n" + + "GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA\n" + + "GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA\n" + + "GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG\n" + + "AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT\n" + + "CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA\n" + + "GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA\n" + + "AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC\n" + + "GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT\n" + + "ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG\n" + + "GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC\n" + + "GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC\n" + + "GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG\n" + + "TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA\n" + + "AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG\n" + + "GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT\n" + + "CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC\n" + + "TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG\n" + + "ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC\n" + + "GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA\n" + + "ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA\n" + + "CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA\n" + + "CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA\n" + + "ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG\n" + + "CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG\n" + + "AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC\n" + + "CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG\n" + + "AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC\n" + + "CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG\n" + + "CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG\n" + + "CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG\n" + + "CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC\n" + + "ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA\n" + + "AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC\n" + + "TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC\n" + + "ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG\n" + + "CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG\n" + + "AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT\n" + + "AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA\n" + + "TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC\n" + + "CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA\n" + + "TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG\n" + + "CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT\n" + + "GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG\n" + + "GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG\n" + + "CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG\n" + + "GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG\n" + + "GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT\n" + + "AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT\n" + + "GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT\n" + + "CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG\n" + + "GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC\n" + + "TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT\n" + + "CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG\n" + + "ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG\n" + + "CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG\n" + + "AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA\n" + + "CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG\n" + + "CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC\n" + + "ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC\n" + + "GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC\n" + + "GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG\n" + + "GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT\n" + + "TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG\n" + + "CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA\n" + + "GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG\n" + + "CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC\n" + + "GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG\n" + + "CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA\n" + + "CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG\n" + + "CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA\n" + + "ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC\n" + + "CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT\n" + + "GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA\n" + + "AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG\n" + + "ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC\n" + + "TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA\n" + + "GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC\n" + + "GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG\n" + + "TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC\n" + + "AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA\n" + + "ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA\n" + + "GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC\n" + + "AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG\n" + + "TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC\n" + + "CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT\n" + + "GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC\n" + + "CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA\n" + + "GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT\n" + + "TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC\n" + + "ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC\n" + + "TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG\n" + + "GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG\n" + + "TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG\n" + + "GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC\n" + + "GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT\n" + + "ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC\n" + + "GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC\n" + + "GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC\n" + + "CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA\n" + + "ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG\n" + + "AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC\n" + + "TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT\n" + + "CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG\n" + + "TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG\n" + + "CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC\n" + + "GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT\n" + + "GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC\n" + + "CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC\n" + + "TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG\n" + + "CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG\n" + + "AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG\n" + + "AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG\n" + + "AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT\n" + + "GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA\n" + + "TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC\n" + + "AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA\n" + + "AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG\n" + + "CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC\n" + + "TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG\n" + + "GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT\n" + + "CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG\n" + + "CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG\n" + + "GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA\n" + + "AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA\n" + + "GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC\n" + + "TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC\n" + + "CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA\n" + + "GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG\n" + + "CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG\n" + + "AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG\n" + + "ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC\n" + + "ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC\n" + + "AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC\n" + + "GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG\n" + + "GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT\n" + + "CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC\n" + + "GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC\n" + + "CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA\n" + + "GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA\n" + + "GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG\n" + + "GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT\n" + + "CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA\n" + + "AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG\n" + + "CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC\n" + + "CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG\n" + + "GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG\n" + + "GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT\n" + + "TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA\n" + + "ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG\n" + + "CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA\n" + + "ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA\n" + + "GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG\n" + + "TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC\n" + + "GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA\n" + + "GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT\n" + + "GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT\n" + + "GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG\n" + + "TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT\n" + + "TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC\n" + + "TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC\n" + + "GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT\n" + + "CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC\n" + + "TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA\n" + + ">TWO IUB ambiguity codes\n" + + "cttBtatcatatgctaKggNcataaaSatgtaaaDcDRtBggDtctttataattcBgtcg\n" + + "tactDtDagcctatttSVHtHttKtgtHMaSattgWaHKHttttagacatWatgtRgaaa\n" + + "NtactMcSMtYtcMgRtacttctWBacgaaatatagScDtttgaagacacatagtVgYgt\n" + + "cattHWtMMWcStgttaggKtSgaYaaccWStcgBttgcgaMttBYatcWtgacaYcaga\n" + + "gtaBDtRacttttcWatMttDBcatWtatcttactaBgaYtcttgttttttttYaaScYa\n" + + "HgtgttNtSatcMtcVaaaStccRcctDaataataStcYtRDSaMtDttgttSagtRRca\n" + + "tttHatSttMtWgtcgtatSSagactYaaattcaMtWatttaSgYttaRgKaRtccactt\n" + + "tattRggaMcDaWaWagttttgacatgttctacaaaRaatataataaMttcgDacgaSSt\n" + + "acaStYRctVaNMtMgtaggcKatcttttattaaaaagVWaHKYagtttttatttaacct\n" + + "tacgtVtcVaattVMBcttaMtttaStgacttagattWWacVtgWYagWVRctDattBYt\n" + + "gtttaagaagattattgacVatMaacattVctgtBSgaVtgWWggaKHaatKWcBScSWa\n" + + "accRVacacaaactaccScattRatatKVtactatatttHttaagtttSKtRtacaaagt\n" + + "RDttcaaaaWgcacatWaDgtDKacgaacaattacaRNWaatHtttStgttattaaMtgt\n" + + "tgDcgtMgcatBtgcttcgcgaDWgagctgcgaggggVtaaScNatttacttaatgacag\n" + + "cccccacatYScaMgtaggtYaNgttctgaMaacNaMRaacaaacaKctacatagYWctg\n" + + "ttWaaataaaataRattagHacacaagcgKatacBttRttaagtatttccgatctHSaat\n" + + "actcNttMaagtattMtgRtgaMgcataatHcMtaBSaRattagttgatHtMttaaKagg\n" + + "YtaaBataSaVatactWtataVWgKgttaaaacagtgcgRatatacatVtHRtVYataSa\n" + + "KtWaStVcNKHKttactatccctcatgWHatWaRcttactaggatctataDtDHBttata\n" + + "aaaHgtacVtagaYttYaKcctattcttcttaataNDaaggaaaDYgcggctaaWSctBa\n" + + "aNtgctggMBaKctaMVKagBaactaWaDaMaccYVtNtaHtVWtKgRtcaaNtYaNacg\n" + + "gtttNattgVtttctgtBaWgtaattcaagtcaVWtactNggattctttaYtaaagccgc\n" + + "tcttagHVggaYtgtNcDaVagctctctKgacgtatagYcctRYHDtgBattDaaDgccK\n" + + "tcHaaStttMcctagtattgcRgWBaVatHaaaataYtgtttagMDMRtaataaggatMt\n" + + "ttctWgtNtgtgaaaaMaatatRtttMtDgHHtgtcattttcWattRSHcVagaagtacg\n" + + "ggtaKVattKYagactNaatgtttgKMMgYNtcccgSKttctaStatatNVataYHgtNa\n" + + "BKRgNacaactgatttcctttaNcgatttctctataScaHtataRagtcRVttacDSDtt\n" + + "aRtSatacHgtSKacYagttMHtWataggatgactNtatSaNctataVtttRNKtgRacc\n" + + "tttYtatgttactttttcctttaaacatacaHactMacacggtWataMtBVacRaSaatc\n" + + "cgtaBVttccagccBcttaRKtgtgcctttttRtgtcagcRttKtaaacKtaaatctcac\n" + + "aattgcaNtSBaaccgggttattaaBcKatDagttactcttcattVtttHaaggctKKga\n" + + "tacatcBggScagtVcacattttgaHaDSgHatRMaHWggtatatRgccDttcgtatcga\n" + + "aacaHtaagttaRatgaVacttagattVKtaaYttaaatcaNatccRttRRaMScNaaaD\n" + + "gttVHWgtcHaaHgacVaWtgttScactaagSgttatcttagggDtaccagWattWtRtg\n" + + "ttHWHacgattBtgVcaYatcggttgagKcWtKKcaVtgaYgWctgYggVctgtHgaNcV\n" + + "taBtWaaYatcDRaaRtSctgaHaYRttagatMatgcatttNattaDttaattgttctaa\n" + + "ccctcccctagaWBtttHtBccttagaVaatMcBHagaVcWcagBVttcBtaYMccagat\n" + + "gaaaaHctctaacgttagNWRtcggattNatcRaNHttcagtKttttgWatWttcSaNgg\n" + + "gaWtactKKMaacatKatacNattgctWtatctaVgagctatgtRaHtYcWcttagccaa\n" + + "tYttWttaWSSttaHcaaaaagVacVgtaVaRMgattaVcDactttcHHggHRtgNcctt\n" + + "tYatcatKgctcctctatVcaaaaKaaaagtatatctgMtWtaaaacaStttMtcgactt\n" + + "taSatcgDataaactaaacaagtaaVctaggaSccaatMVtaaSKNVattttgHccatca\n" + + "cBVctgcaVatVttRtactgtVcaattHgtaaattaaattttYtatattaaRSgYtgBag\n" + + "aHSBDgtagcacRHtYcBgtcacttacactaYcgctWtattgSHtSatcataaatataHt\n" + + "cgtYaaMNgBaatttaRgaMaatatttBtttaaaHHKaatctgatWatYaacttMctctt\n" + + "ttVctagctDaaagtaVaKaKRtaacBgtatccaaccactHHaagaagaaggaNaaatBW\n" + + "attccgStaMSaMatBttgcatgRSacgttVVtaaDMtcSgVatWcaSatcttttVatag\n" + + "ttactttacgatcaccNtaDVgSRcgVcgtgaacgaNtaNatatagtHtMgtHcMtagaa\n" + + "attBgtataRaaaacaYKgtRccYtatgaagtaataKgtaaMttgaaRVatgcagaKStc\n" + + "tHNaaatctBBtcttaYaBWHgtVtgacagcaRcataWctcaBcYacYgatDgtDHccta\n" + + "aagacYRcaggattHaYgtKtaatgcVcaataMYacccatatcacgWDBtgaatcBaata\n" + + "cKcttRaRtgatgaBDacggtaattaaYtataStgVHDtDctgactcaaatKtacaatgc\n" + + "gYatBtRaDatHaactgtttatatDttttaaaKVccYcaaccNcBcgHaaVcattHctcg\n" + + "attaaatBtatgcaaaaatYMctSactHatacgaWacattacMBgHttcgaatVaaaaca\n" + + "BatatVtctgaaaaWtctRacgBMaatSgRgtgtcgactatcRtattaScctaStagKga\n" + + "DcWgtYtDDWKRgRtHatRtggtcgaHgggcgtattaMgtcagccaBggWVcWctVaaat\n" + + "tcgNaatcKWagcNaHtgaaaSaaagctcYctttRVtaaaatNtataaccKtaRgtttaM\n" + + "tgtKaBtRtNaggaSattHatatWactcagtgtactaKctatttgRYYatKatgtccgtR\n" + + "tttttatttaatatVgKtttgtatgtNtataRatWYNgtRtHggtaaKaYtKSDcatcKg\n" + + "taaYatcSRctaVtSMWtVtRWHatttagataDtVggacagVcgKWagBgatBtaaagNc\n" + + "aRtagcataBggactaacacRctKgttaatcctHgDgttKHHagttgttaatgHBtatHc\n" + + "DaagtVaBaRccctVgtgDtacRHSctaagagcggWYaBtSaKtHBtaaactYacgNKBa\n" + + "VYgtaacttagtVttcttaatgtBtatMtMtttaattaatBWccatRtttcatagVgMMt\n" + + "agctStKctaMactacDNYgKYHgaWcgaHgagattacVgtttgtRaSttaWaVgataat\n" + + "gtgtYtaStattattMtNgWtgttKaccaatagNYttattcgtatHcWtctaaaNVYKKt\n" + + "tWtggcDtcgaagtNcagatacgcattaagaccWctgcagcttggNSgaNcHggatgtVt\n" + + "catNtRaaBNcHVagagaaBtaaSggDaatWaatRccaVgggStctDaacataKttKatt\n" + + "tggacYtattcSatcttagcaatgaVBMcttDattctYaaRgatgcattttNgVHtKcYR\n" + + "aatRKctgtaaacRatVSagctgtWacBtKVatctgttttKcgtctaaDcaagtatcSat\n" + + "aWVgcKKataWaYttcccSaatgaaaacccWgcRctWatNcWtBRttYaattataaNgac\n" + + "acaatagtttVNtataNaYtaatRaVWKtBatKagtaatataDaNaaaaataMtaagaaS\n" + + "tccBcaatNgaataWtHaNactgtcDtRcYaaVaaaaaDgtttRatctatgHtgttKtga\n" + + "aNSgatactttcgagWaaatctKaaDaRttgtggKKagcDgataaattgSaacWaVtaNM\n" + + "acKtcaDaaatttctRaaVcagNacaScRBatatctRatcctaNatWgRtcDcSaWSgtt\n" + + "RtKaRtMtKaatgttBHcYaaBtgatSgaSWaScMgatNtctcctatttctYtatMatMt\n" + + "RRtSaattaMtagaaaaStcgVgRttSVaScagtgDtttatcatcatacRcatatDctta\n" + + "tcatVRtttataaHtattcYtcaaaatactttgVctagtaaYttagatagtSYacKaaac\n" + + "gaaKtaaatagataatSatatgaaatSgKtaatVtttatcctgKHaatHattagaaccgt\n" + + "YaaHactRcggSBNgtgctaaBagBttgtRttaaattYtVRaaaattgtaatVatttctc\n" + + "ttcatgBcVgtgKgaHaaatattYatagWacNctgaaMcgaattStagWaSgtaaKagtt\n" + + "ttaagaDgatKcctgtaHtcatggKttVDatcaaggtYcgccagNgtgcVttttagagat\n" + + "gctaccacggggtNttttaSHaNtatNcctcatSaaVgtactgBHtagcaYggYVKNgta\n" + + "KBcRttgaWatgaatVtagtcgattYgatgtaatttacDacSctgctaaaStttaWMagD\n" + + "aaatcaVYctccgggcgaVtaaWtStaKMgDtttcaaMtVgBaatccagNaaatcYRMBg\n" + + "gttWtaaScKttMWtYataRaDBMaDataatHBcacDaaKDactaMgagttDattaHatH\n" + + "taYatDtattDcRNStgaatattSDttggtattaaNSYacttcDMgYgBatWtaMagact\n" + + "VWttctttgYMaYaacRgHWaattgRtaagcattctMKVStatactacHVtatgatcBtV\n" + + "NataaBttYtSttacKgggWgYDtgaVtYgatDaacattYgatggtRDaVDttNactaSa\n" + + "MtgNttaacaaSaBStcDctaccacagacgcaHatMataWKYtaYattMcaMtgSttDag\n" + + "cHacgatcaHttYaKHggagttccgatYcaatgatRaVRcaagatcagtatggScctata\n" + + "ttaNtagcgacgtgKaaWaactSgagtMYtcttccaKtStaacggMtaagNttattatcg\n" + + "tctaRcactctctDtaacWYtgaYaSaagaWtNtatttRacatgNaatgttattgWDDcN\n" + + "aHcctgaaHacSgaataaRaataMHttatMtgaSDSKatatHHaNtacagtccaYatWtc\n" + + "actaactatKDacSaStcggataHgYatagKtaatKagStaNgtatactatggRHacttg\n" + + "tattatgtDVagDVaRctacMYattDgtttYgtctatggtKaRSttRccRtaaccttaga\n" + + "gRatagSaaMaacgcaNtatgaaatcaRaagataatagatactcHaaYKBctccaagaRa\n" + + "BaStNagataggcgaatgaMtagaatgtcaKttaaatgtaWcaBttaatRcggtgNcaca\n" + + "aKtttScRtWtgcatagtttWYaagBttDKgcctttatMggNttattBtctagVtacata\n" + + "aaYttacacaaRttcYtWttgHcaYYtaMgBaBatctNgcDtNttacgacDcgataaSat\n" + + "YaSttWtcctatKaatgcagHaVaacgctgcatDtgttaSataaaaYSNttatagtaNYt\n" + + "aDaaaNtggggacttaBggcHgcgtNtaaMcctggtVtaKcgNacNtatVaSWctWtgaW\n" + + "cggNaBagctctgaYataMgaagatBSttctatacttgtgtKtaattttRagtDtacata\n" + + "tatatgatNHVgBMtKtaKaNttDHaagatactHaccHtcatttaaagttVaMcNgHata\n" + + "tKtaNtgYMccttatcaaNagctggacStttcNtggcaVtattactHaSttatgNMVatt\n" + + "MMDtMactattattgWMSgtHBttStStgatatRaDaagattttctatMtaaaaaggtac\n" + + "taaVttaSacNaatactgMttgacHaHRttgMacaaaatagttaatatWKRgacDgaRta\n" + + "tatttattatcYttaWtgtBRtWatgHaaattHataagtVaDtWaVaWtgStcgtMSgaS\n" + + "RgMKtaaataVacataatgtaSaatttagtcgaaHtaKaatgcacatcggRaggSKctDc\n" + + "agtcSttcccStYtccRtctctYtcaaKcgagtaMttttcRaYDttgttatctaatcata\n" + + "NctctgctatcaMatactataggDaHaaSttMtaDtcNatataattctMcStaaBYtaNa\n" + + "gatgtaatHagagSttgWHVcttatKaYgDctcttggtgttMcRaVgSgggtagacaata\n" + + "aDtaattSaDaNaHaBctattgNtaccaaRgaVtKNtaaYggHtaKKgHcatctWtctDt\n" + + "ttctttggSDtNtaStagttataaacaattgcaBaBWggHgcaaaBtYgctaatgaaatW\n" + + "cDcttHtcMtWWattBHatcatcaaatctKMagtDNatttWaBtHaaaNgMttaaStagt\n" + + "tctctaatDtcRVaYttgttMtRtgtcaSaaYVgSWDRtaatagctcagDgcWWaaaBaa\n" + + "RaBctgVgggNgDWStNaNBKcBctaaKtttDcttBaaggBttgaccatgaaaNgttttt\n" + + "tttatctatgttataccaaDRaaSagtaVtDtcaWatBtacattaWacttaSgtattggD\n" + + "gKaaatScaattacgWcagKHaaccaYcRcaRttaDttRtttHgaHVggcttBaRgtccc\n" + + "tDatKaVtKtcRgYtaKttacgtatBtStaagcaattaagaRgBagSaattccSWYttta\n" + + "ttVaataNctgHgttaaNBgcVYgtRtcccagWNaaaacaDNaBcaaaaRVtcWMgBagM\n" + + "tttattacgDacttBtactatcattggaaatVccggttRttcatagttVYcatYaSHaHc\n" + + "ttaaagcNWaHataaaRWtctVtRYtagHtaaaYMataHYtNBctNtKaatattStgaMc\n" + + "BtRgctaKtgcScSttDgYatcVtggaaKtaagatWccHccgKYctaNNctacaWctttt\n" + + "gcRtgtVcgaKttcMRHgctaHtVaataaDtatgKDcttatBtDttggNtacttttMtga\n" + + "acRattaaNagaactcaaaBBVtcDtcgaStaDctgaaaSgttMaDtcgttcaccaaaag\n" + + "gWtcKcgSMtcDtatgtttStaaBtatagDcatYatWtaaaBacaKgcaDatgRggaaYc\n" + + "taRtccagattDaWtttggacBaVcHtHtaacDacYgtaatataMagaatgHMatcttat\n" + + "acgtatttttatattacHactgttataMgStYaattYaccaattgagtcaaattaYtgta\n" + + "tcatgMcaDcgggtcttDtKgcatgWRtataatatRacacNRBttcHtBgcRttgtgcgt\n" + + "catacMtttBctatctBaatcattMttMYgattaaVYatgDaatVagtattDacaacDMa\n" + + "tcMtHcccataagatgBggaccattVWtRtSacatgctcaaggggYtttDtaaNgNtaaB\n" + + "atggaatgtctRtaBgBtcNYatatNRtagaacMgagSaSDDSaDcctRagtVWSHtVSR\n" + + "ggaacaBVaccgtttaStagaacaMtactccagtttVctaaRaaHttNcttagcaattta\n" + + "ttaatRtaaaatctaacDaBttggSagagctacHtaaRWgattcaaBtctRtSHaNtgta\n" + + "cattVcaHaNaagtataccacaWtaRtaaVKgMYaWgttaKggKMtKcgWatcaDatYtK\n" + + "SttgtacgaccNctSaattcDcatcttcaaaDKttacHtggttHggRRaRcaWacaMtBW\n" + + "VHSHgaaMcKattgtaRWttScNattBBatYtaNRgcggaagacHSaattRtttcYgacc\n" + + "BRccMacccKgatgaacttcgDgHcaaaaaRtatatDtatYVtttttHgSHaSaatagct\n" + + "NYtaHYaVYttattNtttgaaaYtaKttWtctaNtgagaaaNctNDctaaHgttagDcRt\n" + + "tatagccBaacgcaRBtRctRtggtaMYYttWtgataatcgaataattattataVaaaaa\n" + + "ttacNRVYcaaMacNatRttcKatMctgaagactaattataaYgcKcaSYaatMNctcaa\n" + + "cgtgatttttBacNtgatDccaattattKWWcattttatatatgatBcDtaaaagttgaa\n" + + "VtaHtaHHtBtataRBgtgDtaataMttRtDgDcttattNtggtctatctaaBcatctaR\n" + + "atgNacWtaatgaagtcMNaacNgHttatactaWgcNtaStaRgttaaHacccgaYStac\n" + + "aaaatWggaYaWgaattattcMaactcBKaaaRVNcaNRDcYcgaBctKaacaaaaaSgc\n" + + "tccYBBHYaVagaatagaaaacagYtctVccaMtcgtttVatcaatttDRtgWctagtac\n" + + "RttMctgtDctttcKtWttttataaatgVttgBKtgtKWDaWagMtaaagaaattDVtag\n" + + "gttacatcatttatgtcgMHaVcttaBtVRtcgtaYgBRHatttHgaBcKaYWaatcNSc\n" + + "tagtaaaaatttacaatcactSWacgtaatgKttWattagttttNaggtctcaagtcact\n" + + "attcttctaagKggaataMgtttcataagataaaaatagattatDgcBVHWgaBKttDgc\n" + + "atRHaagcaYcRaattattatgtMatatattgHDtcaDtcaaaHctStattaatHaccga\n" + + "cNattgatatattttgtgtDtRatagSacaMtcRtcattcccgacacSattgttKaWatt\n" + + "NHcaacttccgtttSRtgtctgDcgctcaaMagVtBctBMcMcWtgtaacgactctcttR\n" + + "ggRKSttgYtYatDccagttDgaKccacgVatWcataVaaagaataMgtgataaKYaaat\n" + + "cHDaacgataYctRtcYatcgcaMgtNttaBttttgatttaRtStgcaacaaaataccVg\n" + + "aaDgtVgDcStctatatttattaaaaRKDatagaaagaKaaYYcaYSgKStctccSttac\n" + + "agtcNactttDVttagaaagMHttRaNcSaRaMgBttattggtttaRMggatggcKDgWR\n" + + "tNaataataWKKacttcKWaaagNaBttaBatMHtccattaacttccccYtcBcYRtaga\n" + + "ttaagctaaYBDttaNtgaaaccHcaRMtKtaaHMcNBttaNaNcVcgVttWNtDaBatg\n" + + "ataaVtcWKcttRggWatcattgaRagHgaattNtatttctctattaattaatgaDaaMa\n" + + "tacgttgggcHaYVaaNaDDttHtcaaHtcVVDgBVagcMacgtgttaaBRNtatRtcag\n" + + "taagaggtttaagacaVaaggttaWatctccgtVtaDtcDatttccVatgtacNtttccg\n" + + "tHttatKgScBatgtVgHtYcWagcaKtaMYaaHgtaattaSaHcgcagtWNaatNccNN\n" + + "YcacgVaagaRacttctcattcccRtgtgtaattagcSttaaStWaMtctNNcSMacatt\n" + + "ataaactaDgtatWgtagtttaagaaaattgtagtNagtcaataaatttgatMMYactaa\n" + + "tatcggBWDtVcYttcDHtVttatacYaRgaMaacaStaatcRttttVtagaDtcacWat\n" + + "ttWtgaaaagaaagNRacDtttStVatBaDNtaactatatcBSMcccaSttccggaMatg\n" + + "attaaWatKMaBaBatttgataNctgttKtVaagtcagScgaaaDggaWgtgttttKtWt\n" + + "atttHaatgtagttcactaaKMagttSYBtKtaYgaactcagagRtatagtVtatcaaaW\n" + + "YagcgNtaDagtacNSaaYDgatBgtcgataacYDtaaactacagWDcYKaagtttatta\n" + + "gcatcgagttKcatDaattgattatDtcagRtWSKtcgNtMaaaaacaMttKcaWcaaSV\n" + + "MaaaccagMVtaMaDtMaHaBgaacataBBVtaatVYaNSWcSgNtDNaaKacacBttta\n" + + "tKtgtttcaaHaMctcagtaacgtcgYtactDcgcctaNgagagcYgatattttaaattt\n" + + "ccattttacatttDaaRctattttWctttacgtDatYtttcagacgcaaVttagtaaKaa\n" + + "aRtgVtccataBggacttatttgtttaWNtgttVWtaWNVDaattgtatttBaagcBtaa\n" + + "BttaaVatcHcaVgacattccNggtcgacKttaaaRtagRtctWagaYggtgMtataatM\n" + + "tgaaRttattttgWcttNtDRRgMDKacagaaaaggaaaRStcccagtYccVattaNaaK\n" + + "StNWtgacaVtagaagcttSaaDtcacaacgDYacWDYtgtttKatcVtgcMaDaSKStV\n" + + "cgtagaaWaKaagtttcHaHgMgMtctataagBtKaaaKKcactggagRRttaagaBaaN\n" + + "atVVcgRcKSttDaactagtSttSattgttgaaRYatggttVttaataaHttccaagDtg\n" + + "atNWtaagHtgcYtaactRgcaatgMgtgtRaatRaNaacHKtagactactggaatttcg\n" + + "ccataacgMctRgatgttaccctaHgtgWaYcactcacYaattcttaBtgacttaaacct\n" + + "gYgaWatgBttcttVttcgttWttMcNYgtaaaatctYgMgaaattacNgaHgaacDVVM\n" + + "tttggtHtctaaRgtacagacgHtVtaBMNBgattagcttaRcttacaHcRctgttcaaD\n" + + "BggttKaacatgKtttYataVaNattccgMcgcgtagtRaVVaattaKaatggttRgaMc\n" + + "agtatcWBttNtHagctaatctagaaNaaacaYBctatcgcVctBtgcaaagDgttVtga\n" + + "HtactSNYtaaNccatgtgDacgaVtDcgKaRtacDcttgctaagggcagMDagggtBWR\n" + + "tttSgccttttttaacgtcHctaVtVDtagatcaNMaVtcVacatHctDWNaataRgcgt\n" + + "aVHaggtaaaaSgtttMtattDgBtctgatSgtRagagYtctSaKWaataMgattRKtaa\n" + + "catttYcgtaacacattRWtBtcggtaaatMtaaacBatttctKagtcDtttgcBtKYYB\n" + + "aKttctVttgttaDtgattttcttccacttgSaaacggaaaNDaattcYNNaWcgaaYat\n" + + "tttMgcBtcatRtgtaaagatgaWtgaccaYBHgaatagataVVtHtttVgYBtMctaMt\n" + + "cctgaDcYttgtccaaaRNtacagcMctKaaaggatttacatgtttaaWSaYaKttBtag\n" + + "DacactagctMtttNaKtctttcNcSattNacttggaacaatDagtattRtgSHaataat\n" + + "gccVgacccgatactatccctgtRctttgagaSgatcatatcgDcagWaaHSgctYYWta\n" + + "tHttggttctttatVattatcgactaagtgtagcatVgtgHMtttgtttcgttaKattcM\n" + + "atttgtttWcaaStNatgtHcaaaDtaagBaKBtRgaBgDtSagtatMtaacYaatYtVc\n" + + "KatgtgcaacVaaaatactKcRgtaYtgtNgBBNcKtcttaccttKgaRaYcaNKtactt\n" + + "tgagSBtgtRagaNgcaaaNcacagtVtttHWatgttaNatBgtttaatNgVtctgaata\n" + + "tcaRtattcttttttttRaaKcRStctcggDgKagattaMaaaKtcaHacttaataataK\n" + + "taRgDtKVBttttcgtKaggHHcatgttagHggttNctcgtatKKagVagRaaaggaaBt\n" + + "NatttVKcRttaHctaHtcaaatgtaggHccaBataNaNaggttgcWaatctgatYcaaa\n" + + "HaatWtaVgaaBttagtaagaKKtaaaKtRHatMaDBtBctagcatWtatttgWttVaaa\n" + + "ScMNattRactttgtYtttaaaagtaagtMtaMaSttMBtatgaBtttaKtgaatgagYg\n" + + "tNNacMtcNRacMMHcttWtgtRtctttaacaacattattcYaMagBaacYttMatcttK\n" + + "cRMtgMNccattaRttNatHaHNaSaaHMacacaVaatacaKaSttHatattMtVatWga\n" + + "ttttttaYctttKttHgScWaacgHtttcaVaaMgaacagNatcgttaacaaaaagtaca\n" + + "HBNaattgttKtcttVttaaBtctgctacgBgcWtttcaggacacatMgacatcccagcg\n" + + "gMgaVKaBattgacttaatgacacacaaaaaatRKaaBctacgtRaDcgtagcVBaacDS\n" + + "BHaaaaSacatatacagacRNatcttNaaVtaaaataHattagtaaaaSWccgtatWatg\n" + + "gDttaactattgcccatcttHaSgYataBttBaactattBtcHtgatcaataSttaBtat\n" + + "KSHYttWggtcYtttBttaataccRgVatStaHaKagaatNtagRMNgtcttYaaSaact\n" + + "cagDSgagaaYtMttDtMRVgWKWtgMaKtKaDttttgactatacataatcNtatNaHat\n" + + "tVagacgYgatatatttttgtStWaaatctWaMgagaRttRatacgStgattcttaagaD\n" + + "taWccaaatRcagcagaaNKagtaaDggcgccBtYtagSBMtactaaataMataBSacRM\n" + + "gDgattMMgtcHtcaYDtRaDaacggttDaggcMtttatgttaNctaattaVacgaaMMt\n" + + "aatDccSgtattgaRtWWaccaccgagtactMcgVNgctDctaMScatagcgtcaactat\n" + + "acRacgHRttgctatttaatgaattataYKttgtaagWgtYttgcHgMtaMattWaWVta\n" + + "RgcttgYgttBHtYataSccStBtgtagMgtDtggcVaaSBaatagDttgBgtctttctc\n" + + "attttaNagtHKtaMWcYactVcgcgtatMVtttRacVagDaatcttgctBBcRDgcaac\n" + + "KttgatSKtYtagBMagaRtcgBattHcBWcaactgatttaatttWDccatttatcgagS\n" + + "KaWttataHactaHMttaatHtggaHtHagaatgtKtaaRactgtttMatacgatcaagD\n" + + "gatKaDctataMggtHDtggHacctttRtatcttYattttgacttgaaSaataaatYcgB\n" + + "aaaaccgNatVBttMacHaKaataagtatKgtcaagactcttaHttcggaattgttDtct\n" + + "aaccHttttWaaatgaaatataaaWattccYDtKtaaaacggtgaggWVtctattagtga\n" + + "ctattaagtMgtttaagcatttgSgaaatatccHaaggMaaaattttcWtatKctagDtY\n" + + "tMcctagagHcactttactatacaaacattaacttaHatcVMYattYgVgtMttaaRtga\n" + + "aataaDatcaHgtHHatKcDYaatcttMtNcgatYatgSaMaNtcttKcWataScKggta\n" + + "tcttacgcttWaaagNatgMgHtctttNtaacVtgttcMaaRatccggggactcMtttaY\n" + + "MtcWRgNctgNccKatcttgYDcMgattNYaRagatHaaHgKctcataRDttacatBatc\n" + + "cattgDWttatttaWgtcggagaaaaatacaatacSNtgggtttccttacSMaagBatta\n" + + "caMaNcactMttatgaRBacYcYtcaaaWtagctSaacttWgDMHgaggatgBVgcHaDt\n" + + "ggaactttggtcNatNgtaKaBcccaNtaagttBaacagtatacDYttcctNgWgcgSMc\n" + + "acatStctHatgRcNcgtacacaatRttMggaNKKggataaaSaYcMVcMgtaMaHtgat\n" + + "tYMatYcggtcttcctHtcDccgtgRatcattgcgccgatatMaaYaataaYSggatagc\n" + + "gcBtNtaaaScaKgttBgagVagttaKagagtatVaactaSacWactSaKatWccaKaaa\n" + + "atBKgaaKtDMattttgtaaatcRctMatcaaMagMttDgVatggMaaWgttcgaWatga\n" + + "aatttgRtYtattaWHKcRgctacatKttctaccaaHttRatctaYattaaWatVNccat\n" + + "NgagtcKttKataStRaatatattcctRWatDctVagttYDgSBaatYgttttgtVaatt\n" + + "taatagcagMatRaacttBctattgtMagagattaaactaMatVtHtaaatctRgaaaaa\n" + + "aaatttWacaacaYccYDSaattMatgaccKtaBKWBattgtcaagcHKaagttMMtaat\n" + + "ttcKcMagNaaKagattggMagaggtaatttYacatcWaaDgatMgKHacMacgcVaaca\n" + + "DtaDatatYggttBcgtatgWgaSatttgtagaHYRVacaRtctHaaRtatgaactaata\n" + + "tctSSBgggaaHMWtcaagatKgagtDaSatagttgattVRatNtctMtcSaagaSHaat\n" + + "aNataataRaaRgattctttaataaagWaRHcYgcatgtWRcttgaaggaMcaataBRaa\n" + + "ccagStaaacNtttcaatataYtaatatgHaDgcStcWttaacctaRgtYaRtataKtgM\n" + + "ttttatgactaaaatttacYatcccRWtttHRtattaaatgtttatatttgttYaatMca\n" + + "RcSVaaDatcgtaYMcatgtagacatgaaattgRtcaaYaaYtRBatKacttataccaNa\n" + + "aattVaBtctggacaagKaaYaaatatWtMtatcYaaVNtcgHaactBaagKcHgtctac\n" + + "aatWtaDtSgtaHcataHtactgataNctRgttMtDcDttatHtcgtacatcccaggStt\n" + + "aBgtcacacWtccNMcNatMVaVgtccDYStatMaccDatggYaRKaaagataRatttHK\n" + + "tSaaatDgataaacttaHgttgVBtcttVttHgDacgaKatgtatatNYataactctSat\n" + + "atatattgcHRRYttStggaactHgttttYtttaWtatMcttttctatctDtagVHYgMR\n" + + "BgtHttcctaatYRttKtaagatggaVRataKDctaMtKBNtMtHNtWtttYcVtattMc\n" + + "gRaacMcctNSctcatttaaagDcaHtYccSgatgcaatYaaaaDcttcgtaWtaattct\n" + + "cgttttScttggtaatctttYgtctaactKataHacctMctcttacHtKataacacagcN\n" + + "RatgKatttttSaaatRYcgDttaMRcgaaattactMtgcgtaagcgttatBtttttaat\n" + + "taagtNacatHgttcRgacKcBBtVgatKttcgaBaatactDRgtRtgaNacWtcacYtt\n" + + "aaKcgttctHaKttaNaMgWgWaggtctRgaKgWttSttBtDcNtgtttacaaatYcDRt\n" + + "gVtgcctattcNtctaaaDMNttttNtggctgagaVctDaacVtWccaagtaacacaNct\n" + + "gaScattccDHcVBatcgatgtMtaatBgHaatDctMYgagaatgYWKcctaatNaStHa\n" + + "aaKccgHgcgtYaaYtattgtStgtgcaaRtattaKatattagaWVtcaMtBagttatta\n" + + "gNaWHcVgcaattttDcMtgtaRHVYtHtctgtaaaaHVtMKacatcgNaatttMatatg\n" + + "ttgttactagWYtaRacgataKagYNKcattataNaRtgaacKaYgcaaYYacaNccHat\n" + + "MatDcNgtHttRaWttagaaDcaaaaaatagggtKDtStaDaRtaVtHWKNtgtattVct\n" + + "SVgRgataDaRaWataBgaagaaKtaataaYgDcaStaNgtaDaaggtattHaRaWMYaY\n" + + "aWtggttHYgagVtgtgcttttcaaDKcagVcgttagacNaaWtagtaataDttctggtt\n" + + "VcatcataaagtgKaaaNaMtaBBaattaatWaattgctHaVKaSgDaaVKaHtatatat\n" + + "HatcatSBagNgHtatcHYMHgttDgtaHtBttWatcgtttaRaattgStKgSKNWKatc\n" + + "agDtctcagatttctRtYtBatBgHHtKaWtgYBgacVVWaKtacKcDttKMaKaVcggt\n" + + "gttataagaataaHaatattagtataatMHgttYgaRttagtaRtcaaVatacggtcMcg\n" + + "agtaaRttacWgactKRYataaaagSattYaWgagatYagKagatgSaagKgttaatMgg\n" + + "tataatgttWYttatgagaaacctNVataatHcccKtDctcctaatactggctHggaSag\n" + + "gRtKHaWaattcgSatMatttagaggcYtctaMcgctcataSatatgRagacNaaDagga\n" + + "VBagaYttKtacNaKgtSYtagttggaWcatcWttaatctatgaVtcgtgtMtatcaYcg\n" + + "tRccaaYgDctgcMgtgtWgacWtgataacacgcgctBtgttaKtYDtatDcatcagKaV\n" + + "MctaatcttgVcaaRgcRMtDcgattaHttcaNatgaatMtactacVgtRgatggaWttt\n" + + "actaaKatgagSaaKggtaNtactVaYtaaKRagaacccacaMtaaMtKtatBcttgtaa\n" + + "WBtMctaataaVcDaaYtcRHBtcgttNtaaHatttBNgRStVDattBatVtaagttaYa\n" + + "tVattaagaBcacggtSgtVtatttaRattgatgtaHDKgcaatattKtggcctatgaWD\n" + + "KRYcggattgRctatNgatacaatMNttctgtcRBYRaaaHctNYattcHtaWcaattct\n" + + "BtMKtVgYataatMgYtcagcttMDataVtggRtKtgaatgccNcRttcaMtRgattaac\n" + + "attRcagcctHtWMtgtDRagaKaBtgDttYaaaaKatKgatctVaaYaacWcgcatagB\n" + + "VtaNtRtYRaggBaaBtgKgttacataagagcatgtRattccacttaccatRaaatgWgD\n" + + "aMHaYVgVtaSctatcgKaatatattaDgacccYagtgtaYNaaatKcagtBRgagtcca\n" + + "tgKgaaaccBgaagBtgSttWtacgatWHaYatcgatttRaaNRgcaNaKVacaNtDgat\n" + + "tgHVaatcDaagcgtatgcNttaDataatcSataaKcaataaHWataBtttatBtcaKtK\n" + + "tatagttaDgSaYctacaRatNtaWctSaatatttYaKaKtaccWtatcRagacttaYtt\n" + + "VcKgSDcgagaagatccHtaattctSttatggtKYgtMaHagVaBRatttctgtRgtcta\n" + + "tgggtaHKgtHacHtSYacgtacacHatacKaaBaVaccaDtatcSaataaHaagagaat\n" + + "ScagactataaRttagcaaVcaHataKgDacatWccccaagcaBgagWatctaYttgaaa\n" + + "tctVNcYtttWagHcgcgcDcVaaatgttKcHtNtcaatagtgtNRaactttttcaatgg\n" + + "WgBcgDtgVgtttctacMtaaataaaRggaaacWaHttaRtNtgctaaRRtVBctYtVta\n" + + "tDcattDtgaccYatagatYRKatNYKttNgcctagtaWtgaactaMVaacctgaStttc\n" + + "tgaKVtaaVaRKDttVtVctaDNtataaaDtccccaagtWtcgatcactDgYaBcatcct\n" + + "MtVtacDaaBtYtMaKNatNtcaNacgDatYcatcgcaRatWBgaacWttKttagYtaat\n" + + "tcggttgSWttttDWctttacYtatatWtcatDtMgtBttgRtVDggttaacYtacgtac\n" + + "atgaattgaaWcttMStaDgtatattgaDtcRBcattSgaaVBRgagccaaKtttcDgcg\n" + + "aSMtatgWattaKttWtgDBMaggBBttBaatWttRtgcNtHcgttttHtKtcWtagHSt\n" + + "aacagttgatatBtaWSaWggtaataaMttaKacDaatactcBttcaatatHttcBaaSa\n" + + ">THREE Homo sapiens frequency\n" + + "aagtccgatgagtttcaatcatgactgcgaggagatccatgcggtgtacctaaacctaca\n" + + "tcgtatgtatttgctgacgttcattcttgatacataaagatccgatatcggtccactttg\n" + + "tttaccaaaagccctaccttcgtaacgatggaaatgtgaatgagagtgaaatacacgatg\n" + + "gggatattgccggtgagtacaagttagaccacacattagaactgacctatattcgtcatc\n" + + "atagagatggagtatgaattgattctgcgaagtacactggctttacgagtatctagacgc\n" + + "cgcggtatatctcccgtcaatactatgaaggtatatatatagaggctgaaaattcatgtt\n" + + "caatcctctttctaagagtgagtgggagccccttctgttgtcggagtaaaaaggcattat\n" + + "tcctcaaattgtcagaagcaaagtatacgtgatgtttgcttagaacaaaagagttacctt\n" + + "agggtaggtaaatctcgattcaccgagagaagtgattttggcggtgtgcgattaattctt\n" + + "ttgatgacagatctcattattttatatagctccctctttgtatttagagtttgcgtaggt\n" + + "aacctggcaaaaccatatcccggggggagagtgcgctgaacattttatacgatgtgatta\n" + + "ctcaaaggataaggttcgaggcctctatactcatggaactatcttataattataatggat\n" + + "cgtggctcattccacctatccaaacttctttgtgatctgatgctacgagtgtgaacaaac\n" + + "gtacatcttctaaggaatttgggacgtttcatagctcgcatttcattcctgaaaacttaa\n" + + "atatttttaaaaattgattctactgcgaggaactaaggtgtagacaagcccttagtaacc\n" + + "ggtggatgtcgcttcagttttatagcaaacattattcaatttcagtcttgactgaaatta\n" + + "gtttgttagtgttagaggtccatatgtcacatgcatatggtctagatgccattgtacagt\n" + + "aataccttagattagtattagcggcatgcgtacttggatttcacttgtaagaatgagctt\n" + + "aggacggtcgcctgtagggctgcaaataggaatacttacaatttttgatgacttgttagc\n" + + "atatcgctatcacccataaaaaacctgatacttgatgagcgggtgattgagactatgtac\n" + + "tgatataattcaatagctccaatagatgaaacagctatgcgcctatttatgtcaaataat\n" + + "cgatgtgatacaagcttagagctgaacgagcgcgagtggaattagcggtgatctctatcc\n" + + "taaaaagccacgaaatcgatcccagaagctaatacccgaggtgtcaagcttgagttcagt\n" + + "taaatttgcatctcatgccccacgaagaatgggtagagagtttgaaggtgcttctggatt\n" + + "ttcctaagtacgtggtaaaaatttgatgtaaatgaacacctcctaatggttgtgttaacc\n" + + "acaaacccctgggtgaatctgattagccaacccagtgatctgatttcagttgtcaaatct\n" + + "cttttttataactaccttttgtttccataatttaaccggatctcataatgaacaaacggg\n" + + "tagaataatggtagcacatagcgagcttgtctattcagaaatatggcctactcagaatgt\n" + + "attctccaaatcagtgttatgcgaaacgtaattttacgtgtaataatgatgatttcttat\n" + + "cggttccttgtactacaatactcttgcccaacaaatactaagcataacagcaaaattcga\n" + + "atccccctccttttaataaatggtttttcaatatagccgattcgtattcgttagtctttc\n" + + "accaactattaacctggcatctaattaataaaatcaccaaaggactctataatatgacag\n" + + "tcacttcggcctcttttaagacagttgattattgcaggtccgcaattgatggtgacatgc\n" + + "acaattagttagaatccgactatggagacaattaacaattgtagtgcccatttggtccag\n" + + "ttgacttcaaccacgagttataaaggtattttaatttatagtcgatagtaccaacaacaa\n" + + "gcacaatcataattatgttagaaaacccagggggtaatgctctaaatccagctttaaggc\n" + + "cagagtgcactatgaaatcgccattgatcattgtgtcattcgctgaacttggtgtctagg\n" + + "aggtgccgagtgagaatatcagataccttatgaagcaacgattatatctggactagatca\n" + + "tgatgatcggaataaaacattgaaataagtccttatcaaggagcataaacattttattta\n" + + "atttatacttcgtaaataaattcagaattttttttcaagacattaatctgagtaaatgac\n" + + "ggctagaaagggttcctactcgaatcgtagcctacgcatgtgggcagtaacctggcttgc\n" + + "gtttttactgaaacaaaggttcaccggaaagaaggctgccacttttagcttcttgacgat\n" + + "ctttagcgtcatatttttagattagtcgaaaaacggaaaacaaacttaacgaagctggtt\n" + + "gcacggggtaccgagaaaccaaagagcaggacaactccttgatcgggaagaactgaaata\n" + + "gacagctgtcattttcattggtcaacttatcaatataacgaccaccgtagtgacgcttgc\n" + + "atgaaaatactgaggatgtaaactatagccagtcaggcccgcgtgttgactaattgatga\n" + + "agcaaacaaaatagccggtattcgttaaaaggaacgggttgccagctacagatatactct\n" + + "aggtatatcccaaacaagagacgtcctttggctgttgtaatcggtcataatacttgtcac\n" + + "ataaacaagatcgctgaattaaacattaaacagttagtgatacacaatcgtggttggggc\n" + + "tgggatgtgcaataaaaagtcatctatcgtctatcacagagcgacgtaaatttagacaaa\n" + + "cattattatttcttgacaatggaatcgataagcgttcctctaacttggtatatatatctc\n" + + "gaccccgggattccagccattcttgtatgaagatttaaccatttaactatgcatagttga\n" + + "atggtaaggaaaatgatattgactgcaacagattttggatgcaaaaatatttgtgaatta\n" + + "ttggttatatactggttgtatagcacaatcattaggtcctagaaggcatactcaacctca\n" + + "gcgagagagctagcatgcataattgtaccgcccatattaatattcctgaaatgatttctt\n" + + "acattacgcccaatttcagtcatcgaacacccccatcaatttacccgatagagaacgtga\n" + + "tcatacgcaataccctatgcgaacgtccactctatagcgtctgtatacaatgattattcg\n" + + "ttccatttacaacgttaagtaatttaaacttacataaggacaaggaaatccgcgaacctc\n" + + "ctggaatgtatgagttatttatgcagttaacttcgtctcgaccggaactaaaggcgtcgt\n" + + "acgaatgaaaggccacttttagaagagacctttgtatccattgtggagaatatcataaat\n" + + "tcaagatggggtgtcatgctattcggtcctaaacattcttaatggctgttctattgttag\n" + + "tctgatttaaaatggaaccatagcacgaatagttagatagggctcatacccctgtaacga\n" + + "tctacaaatccttccccgggtgtgtgcgttagcgacggaaagttttacggtttgtgatca\n" + + "aagaacactcacacgtcagattattacactgatacgaattatttcagtcgacagtaattg\n" + + "aatagaaacttattaacgccagcacctgacacggtaagtaaggcaggtctgaactgtttg\n" + + "actgtaaaaaaatggtaatatttttaaaaatcttgatttctatatcaaatgatgtgtagt\n" + + "tttttctctgttattaaaatcccagtgcgcgaaatttagatcgttacgactcacgtacaa\n" + + "gatcacacatcacacgcgttagcgaaagcggaatggctaatacagccctacgcaacgtag\n" + + "tgggatcaacatatggacgaatttatgctcaatgagccaacctcccccgcattgcggttc\n" + + "attttaaggcctgggtaacatctatcgtttagataatcaaaggaatccgactatgcaatt\n" + + "gtctgacttcatccgctctcaagtccaatgcaggcgctacgtgtttctttaatcaatacc\n" + + "atattgaaatcgtaatacgataattgttgctattgactacaggttatgaaaaaacttact\n" + + "ttgcgggtacatgcatatttttgtaccacattattacgcgatatctctcagtgtactcta\n" + + "aattaaaccctcttcgaacattttagttcctattcgtaaacacgtgctacgcggcaattt\n" + + "gccggtcgtagaatggacaactccagttcaactgcatgtaactcatagctcgcgttagta\n" + + "taaattgactagtagccatgggacaaagtaactagtcagcggaaaagatccctttaaaga\n" + + "tatatgcaggttgcaagcataaagctcattgctcgaggtgcaccgtggtattccaaaagc\n" + + "gtctctatcgtatcttctaattttgggccgtgagaatcgaaactactctgatttgctgca\n" + + "cacgttaggtaatatcgcccattttcccgtataagctccgtacttatacgaactacacga\n" + + "ccttttaagcattagccgctcatatcgtgattcgtgtacagatgagtctattaaaattac\n" + + "agacatactccatatctcgctccttgaactttgaataatgcgctaacttgtactatgaat\n" + + "aggcagaacccaactttcccgtttgcgtcaagcggggaaacgatacatgttgtcagattt\n" + + "atgattatctagttttagatcacgtttaccgataatcggctgtggtctgagcagtcctac\n" + + "actgagtatttacttcagcttcatatcggtccgaaaaaaggttgtgaccgaatgtcaaaa\n" + + "tacggagtacgatgggcatcttttttcgagtcgcggttgcagggcagcaaaaggcttaaa\n" + + "ccatttttacgatttttactatagcggtcatgaagtgcgaaactgcttgcaaattttcta\n" + + "cacacattgtggctcttgtccttgaagcttatggcgaaaatttgaaacatagtataccag\n" + + "ggaaagcgcgaattatttggtgactaatagtccgtgggtttgagccatatacctaacgcc\n" + + "ataaactacgtggtgctttagatgcaatctaaacagaacagaaagcgtagcgctcatcag\n" + + "cacagactaactttttcagtttgagtcgccggagggacttcgagacaagaacgcgtcaag\n" + + "tcgcttgcgcggcacggattcgattgggcggctcaatcttgcctaatttctactattgtc\n" + + "agctgtacgactgtactaagtgtatagccccaaataaaagaagtatcgatgcgtctttat\n" + + "gaccaaaggtcttataattgaagcgcacttccgttcatcaaattaaatcctggcttaccc\n" + + "gattctccggaagtctgacctagagattgacgacggccgcgtattattgagacctcttca\n" + + "ggattaatcaataacgaagtagttgatctgtttggcgacgtaccttaagccgactccgct\n" + + "acacgagtttctactaaaccaatgtagccttatgcttagatgaataccgtcctaattaga\n" + + "tattccggcataacagcagtaaattatctgttcaatggacgaacattgaattgttagtat\n" + + "tctacacaagtcaggcctcgtaaatattaggtaaggccgtgggataacctacgtgatatg\n" + + "cttgagcttgcgttgcaagctctcgttaatcattaatttaggtgcgtgagggttaaacac\n" + + "cagcatattctatatgctagacgtcttccttaaaggatcgtagtattataattaataata\n" + + "agaaatatggttgacgtctagtcagcgggcatacgctgctctatatactggcattattca\n" + + "aaacttgacggtaaaaaaacgaattttaaggcgctcacgtcgaatgagccgaactcatgg\n" + + "gaaccaaaatgtcacagaaaacacctctttattgccaagcatgcaataaaaaaaatgtta\n" + + "atagtacgtttacgacattttattttataataaagagaaactattacacctattgatatg\n" + + "ataggacgtaaattaacgagtagcctgcatagaggcaaatgaggtttctacatggtatag\n" + + "acctgatgctgaaacatcgatgagttttggtcccctcgctcgttgaaatctagtcattta\n" + + "ctactgtctttcgagctattataccacttcactatgtggtgtttctttgctatgtatggg\n" + + "gctagtcaaacatgatgactatagctacaactcagagagcgggcgtgttaagagtatctc\n" + + "atgctagaactgcacgacgaacttgatacaaagtaacaacatttacgattccacaaggtg\n" + + "actttgaagaaacatagtttaattctctgcttcgatcatttctataaaccggtaccatcg\n" + + "cagcggatagatgcataacatttctactactccaggcatcttaaaacacacgtagtactt\n" + + "cactagattaagacacgataagtgtataacttggcagtgggaagcaaggagattggcgaa\n" + + "ctcctggcatctgttacgttttgttcaggctcggttgttgataatgtccgactcctgcca\n" + + "tattgaagactcgctcgagggagatcgggattcgttgattataagtacacgtgttccgta\n" + + "atactatgaggcagtgattcaaaatggcacttctgacttacatgactaggtattattacc\n" + + "acggaagcgttaaaggcacactcttatggacttaagattgcaagtgccttcttctagcct\n" + + "gaattcgcgggttcaacacaaactctctttagacatccgttgcctaaaggctgagacgta\n" + + "ggggcaaccctttaactatgtactaaaaaactagttggtaatttaacaacgtgtccaatc\n" + + "aagacgatgcaccaacgcggtgcgaaaatcgggttaagcaaacacaaataggaattgtga\n" + + "taaaccccaccttgagaggtcgcaagaccaacctcgggaacaacggctctaagagaataa\n" + + "cctaaatccggatgagtagactgtgtaactctctaaagggaagtgaaaaaaagctaagca\n" + + "tacatttaggtctcctgcattgcattcaattgaatcgtttgtattatgagctgtacagta\n" + + "gctatatcagctatagttatcccagaggaacaggtaaactagctctgagcgtgaaatccg\n" + + "gatattagaacccctagatgggattgattctagctaatacaggcttatctggttttacag\n" + + "ttatctagatgattggtaaggtgaaacgcttggtgccttccaccacttaaacaaaagtat\n" + + "tgcccgggaagctattttctaggtattataaagtcgagcattaatatcaatttgacagta\n" + + "aaggtctttcaccagcttcatatgccatagggcccatactcgatttaaattgaacggttt\n" + + "aacgagtattggaactctcacttataactgagtagctatacgaaaaatctggtccatttc\n" + + "cagaaatttattatcgatttgctgcttagtacccaggaagtgataacccttgaaggcaca\n" + + "acactgtaataagttttcctgtcacatctgtaatattcggtcactacgcattcacgacta\n" + + "aagataattactatactaattaaaagttcaatgttagggccgaatcatagtagaaattct\n" + + "cgtctagcctaatcggacttacctatgggctgtgaggatttatcagtatgtggacaaaaa\n" + + "tgctagagataggtatagttaaagtcaccatggtacatctatgtgaggaagtttgtagtt\n" + + "cgcttctttagtccgggcgtttgggatgacaactactatacgtagagccgtactcaggat\n" + + "tagatagtgtgaaagagtcaaataaaagggttaatattaatttaacgttgcaaatgtgtt\n" + + "taggccaaacattaaccgttgtagggatattctaatacaggccttcaccgaaccctaatg\n" + + "ataatctgtcttaataacattaaatgattgtctccgctacgagctcttagggcctcattt\n" + + "taaatgactaatgtccaaagaagagactttcccaatttcaatctgtcacgtatagacggc\n" + + "accttagtgagtcatatcattaagatagaagattatcaggagggaagtttctattatcaa\n" + + "ccgttacgcaaccataaacttttaaatctcataatggcattgagatcaagagctttcatg\n" + + "atggtaaagttcgtatgtgatgctggggagctagatatcggtataccacttcggttgtgg\n" + + "taagcccgagtgggccgttagtaatattaatagacgattatccgacaatgcattcgctga\n" + + "aataatcttacttaggagaaattaatgctatgagccaaaactatttatgtctgtcacatt\n" + + "attgactaaagtatctatcgacaaaactgatgtccataagttgtagcagatagtcggtgt\n" + + "atggtgtcaccaatgaaaacctcgagcgaaaaatgaattatagttatccaatttgagtaa\n" + + "attgcctattatacagataggcttgtttagtcagataaggttccgcttgaggtgctctaa\n" + + "cttagcgagagttagaaagcctagtgagaggcattttggtgccaaactccggctcgcatg\n" + + "agtaggccagagagtcactttctttcgtcgaagaagttggtgaacagccttttgattagt\n" + + "tgtttgtcttgtggctatgtgctactatataagttagaacgcaaactaatctaatcagca\n" + + "aagtaaaataggaccttgaacgagacggggtacgccgttgaggctcgagatagtagataa\n" + + "actagaggaatgtagataaaacattagctagggggtttagttactggattacataggaag\n" + + "tgcaccatcacggtgtgggggttcgtacgtaaagtcgcatcaatattgtcagtggactta\n" + + "acaagttcgtgcataatgaaatcctatacggactttgcatatctctaccgactcatctgg\n" + + "tcgtctatgcgggtaattgtattgctccaagtggatgactattttggcgtcccagcacat\n" + + "agtaaatgtaaatccttataatagcataagcaattattagactgcgtgaagtcttagtag\n" + + "ttctcaagctttacgttgtatgtaaataactcacgtaatcagccgtccccaaatcaccat\n" + + "tgaggtcattgaatgtacggagcactattatcaatgcggtatgcgattttctgagcgatt\n" + + "attgttaaagacttagcgttgagccccggaacacttgattacagattctttaaggagtta\n" + + "tccaaatatcattttaaataatagtagtatcgtgctttggacaataaaaaaagacccgtt\n" + + "ctcttatgttgttttgcgacgtacttctctgatatatacttcaactatgaagattctatt\n" + + "catcgataacccaggtatatttatatgcccgttcactgcgcagggcaaattatctacgga\n" + + "caataatgacgtagttggacccggtaagaactaacgcttaatatgattaaggatgtatgc\n" + + "cagtattatcttattatgtcagagtagaagtttctctgagattttccgtcgttgtggtac\n" + + "accggatttggctctctttttagaactgagaactcggagtgtgtagtcttgtttccttca\n" + + "atttatcaatatgcttttataccgccctcatcaactataacaggacgacaagttccgtct\n" + + "tgctccatcatatactaccgatacaccaatcgtatcaagtttagtatacttgctttctct\n" + + "cttctacagcttactcgcttgtccgagaagcggttggtgctcataaagttagtagtaaat\n" + + "gtacaactagtagccagtccttacctgtttttacgactactacggacaccatgagataca\n" + + "gaagttagtgctacaattataccattacatgctcaatatcgttgtcggccataagatcga\n" + + "agagtgcatcacgcgtgtgaatacgtaaaatctaccatcccgtcaatgcacaaaaacaca\n" + + "ctccccttgttgactaacatcttttacaagaggctaaatcattgtccaggatcgaatacc\n" + + "ttgtgtacaatcgtcacccatcggaagaataccacttttccgatgtagtatgatttacaa\n" + + "aaaacatctatgtgagtaggccaattgtagtagaatatattcatttgaccgtcattagcc\n" + + "ttcttcttaggttgtgtacggatagtaggtacataaaccgtcgtgtggcatacgctgcga\n" + + "tttcatacagctgccaacaccttttttaccaggctagagtcagaaaagttggagccatgt\n" + + "taaatagttaccatcataaaccactgttgtctactagtctgatcagctttcatgcctgtg\n" + + "caagcaatatggattctcacgtaatggtaacaactgttgcgttacttaggctggttaatt\n" + + "tgtcagagtaataaatacatgtcttgttgtgtttcctaatcctcggaaagtacacaagcc\n" + + "taggaataggaaaagtaaagctcttttattctgatagtgactaactcaggatctaaatac\n" + + "gcgattatactaaccttcaccaaagctcaaaaatcatctgctggtgaccagttatagaca\n" + + "gggtaattcaatatttaatgtctcccttaacatttcaccagcatggattgaagatagtat\n" + + "aaagttttacatggcagtcattgtgtcacggttctatacaaattctgatagttagacggt\n" + + "atttgaaatgtgcttctagcatggtatcttacacaactgaatgaacgactggagccgttc\n" + + "gtatactatttgcgagcctcgagaccccgtttcctaatgttaacgaatatagtataatat\n" + + "aaattgtgatatgaataacacaagtaactacagtttggacaattaattgttctaaactaa\n" + + "aaatcattcacttcagatggcatagagttatggctactacacatataaagcggtatgtga\n" + + "aacacccgttttagccggaaaccctctactgctcgggacaatgaatgatttccaaaatat\n" + + "ggatgtgcagaattgttagtgtgactcaggtccaaatagacactttagtttcgtcaagtc\n" + + "gttgcaaagtttaaaaccatcgcagcattctttatttggtctacattgagaaatgaaaaa\n" + + "acgtgacagaaagtctagaagaactgtgaataatgtctattactgattaactagtaagac\n" + + "attagtgcatctggtccactgaagcacccgcttggcgttaggcaatctctgtgaactgtc\n" + + "gtggctgttccggtaatgtacgaaagcaagcctataggttgatcgagtcgcttcattaag\n" + + "gtcaatttcacaatatccgatcacattgtgctaggttcgtcctttaccttgcttagtgct\n" + + "gcatgtacggggtgtcatgacttgttatcggcagactctttatcccaagaatggataata\n" + + "tgtacatggaaagtgtccataattaagtcccttcactgtaaagaatgactgccacgtgat\n" + + "ccatgaggtctacagaaaccgacttacttgctttttgatcaacttaattatggattcata\n" + + "aagttcagatatcggtacaattggtgtacaatatgaaattaatgaggaaacatggaaatc\n" + + "tgaatgacagtgatagaaaagatccccatttgcccggtcagttcatgttacaccactcat\n" + + "tagtactgtaagtgtttcgtcagcattgagatccacgatcatgtgtttatgccttcgaaa\n" + + "ctggatgtacgacgatcgagacgaagaggtatatataacctaaatactaggtacgttgtt\n" + + "agagagacgatgaaaattaatcgtcaatacgctggcgaacactgagggggacccaatgct\n" + + "cttctcggtctaaaaaggaatgtgtcagaaattggtcagttcaaaagtagaccggatctt\n" + + "tgcggagaacaattcacggaacgtagcgttgggaaatatcctttctaccacacatcggat\n" + + "tttcgccctctcccattatttattgtgttctcacatagaattattgtttagacatccctc\n" + + "gttgtatggagagttgcccgagcgtaaaggcataatccatataccgccgggtgagtgacc\n" + + "tgaaattgtttttagttgggatttcgctatggattagcttacacgaagagattctaatgg\n" + + "tactataggataattataatgctgcgtggcgcagtacaccgttacaaacgtcgttcgcat\n" + + "atgtggctaacacggtgaaaatacctacatcgtatttgcaatttcggtcgtttcatagag\n" + + "cgcattgaattactcaaaaattatatatgttgattatttgattagactgcgtggaaagaa\n" + + "ggggtactcaagccatttgtaaaagctgcatctcgcttaagtttgagagcttacattagt\n" + + "ctatttcagtcttctaggaaatgtctgtgtgagtggttgtcgtccataggtcactggcat\n" + + "atgcgattcatgacatgctaaactaagaaagtagattactattaccggcatgcctaatgc\n" + + "gattgcactgctatgaaggtgcggacgtcgcgcccatgtagccctgataataccaatact\n" + + "tacatttggtcagcaattctgacattatacctagcacccataaatttactcagacttgag\n" + + "gacaggctcttggagtcgatcttctgtttgtatgcatgtgatcatatagatgaataagcg\n" + + "atgcgactagttagggcatagtatagatctgtgtatacagttcagctgaacgtccgcgag\n" + + "tggaagtacagctgagatctatcctaaaatgcaaccatatcgttcacacatgatatgaac\n" + + "ccagggggaaacattgagttcagttaaattggcagcgaatcccccaagaagaaggcggag\n" + + "tgacgttgaacgggcttatggtttttcagtacttcctccgtataagttgagcgaaatgta\n" + + "aacagaataatcgttgtgttaacaacattaaaatcgcggaatatgatgagaatacacagt\n" + + "gtgagcatttcacttgtaaaatatctttggtagaacttactttgctttaaatatgttaaa\n" + + "ccgatctaataatctacaaaacggtagattttgcctagcacattgcgtccttctctattc\n" + + "agatagaggcaatactcagaaggttttatccaaagcactgtgttgactaacctaagtttt\n" + + "agtctaataatcatgattgattataggtgccgtggactacatgactcgtccacaaataat\n" + + "acttagcagatcagcaattggccaagcacccgacttttatttaatggttgtgcaatagtc\n" + + "cagattcgtattcgggactctttcaaataatagtttcctggcatctaagtaagaaaagct\n" + + "cataaggaagcgatattatgacacgctcttccgccgctgttttgaaacttgagtattgct\n" + + "cgtccgaaattgagggtcacttcaaaatttactgagaagacgaagatcgactaaagttaa\n" + + "aatgctagtccacagttggtcaagttgaattcatccacgagttatatagctattttaatt\n" + + "tatagtcgagtgtacaaaaaacatccacaataagatttatcttagaataacaacccccgt\n" + + "atcatcgaaatcctccgttatggcctgactcctcgagcttatagcatttgtgctggcgct\n" + + "cttgccaggaacttgctcgcgaggtggtgacgagtgagatgatcagtttcattatgatga\n" + + "tacgattttatcgcgactagttaatcatcatagcaagtaaaatttgaattatgtcattat\n" + + "catgctccattaacaggttatttaattgatactgacgaaattttttcacaatgggttttc\n" + + "tagaatttaatatcagtaattgaagccttcataggggtcctactagtatcctacacgacg\n" + + "caggtccgcagtatcctggagggacgtgttactgattaaaagggtcaaaggaatgaaggc\n" + + "tcacaatgttacctgcttcaccatagtgagccgatgagttttacattagtactaaatccc\n" + + "aaatcatactttacgatgaggcttgctagcgctaaagagaatacatacaccaccacatag\n" + + "aattgttagcgatgatatcaaatagactcctggaagtgtcagggggaaactgttcaatat\n" + + "ttcgtccacaggactgaccaggcatggaaaagactgacgttggaaactataccatctcac\n" + + "gcccgacgcttcactaattgatgatccaaaaaatatagcccggattcctgattagcaaag\n" + + "ggttcacagagaaagatattatcgacgtatatcccaaaaaacagacgtaatgtgcatctt\n" + + "cgaatcgggatgaatacttgtatcataaaaatgtgacctctagtatacaggttaatgtta\n" + + "gtgatacacaatactcgtgggccatgggttctcaaataaaatgtaatattgcgtcgatca\n" + + "ctcacccacgtatttggtctaattatgttttatttagtgacaatccaatagataaccggt\n" + + "cctattaagggctatatttttagcgaccacgcgtttaaacaaaggattgtatgtagatgg\n" + + "taccagtttaattgccagtgggcaatcctaagcaaaatgagattctatcctaaagtttgg\n" + + "gcttgatataagatttcggatgtatgggttttataatcgttggagagctcaatcatgagc\n" + + "taatacatggatttcgctacctcaccgagagaccttgcatgaagaattctaaccaaaagt\n" + + "ttaataggccggattggattgagttaattaagaccttgttcagtcatagtaaaaaccctt\n" + + "aaattttaccgattgacaaagtgagcagtcgcaataccctatgcgaaacgcctcgatagt\n" + + "gactaggtatacaaggtttttgagttcctttgaaatagttaactaatttaaaattaatta\n" + + "acgacatggaaatcacagaacctaatgctttgtaggagttatttatgctgtttactgcct\n" + + "ctacaaccctaataaagcagtcctaagaatgaaacgcatcttttagttcagaaagtggta\n" + + "tccagggtggtcaatttaataaattcaacatcgggtctcaggatattcggtcatataatt\n" + + "tattaagggctcttcgagtcttactctgagtgaaattggaaacagtcatccttttcgttg\n" + + "tgaggcatcttacaccgctatcgatatacaatgcattccaccgcggtgtcccgtacacaa\n" + + "ggaaacttgttaccttggggatataagaaaactcacacgtctcattattaaactgagtac\n" + + "aatttttgcacgagaaagtaatgcaatacaatatgatgaaagccagctaatgaaaaggga\n" + + "tggaacgcacctcggatctgttgcactggattaaaatccgattatttttaaaaatattca\n" + + "gtgctagagcatatcaggtctacttttttatctggtatgtaaagcccacggagcgatagt\n" + + "gagatccttacgactcaacgaaaagttataacataactcccgttagccaaagcccaatcc\n" + + "cgattactgccctaccctaacgtctgccatctaaatatcgaacttgttatgatcaatgtg\n" + + "actacctcccaccctttccccttcatttgttccactggggataagctagcgttttcagaa\n" + + "tcaatgcaataagaatagccaattgtctcacttcatcagagctcttggcaattccaggcg\n" + + "ctacgtggttctggaatatattcatttttcaaatagtaatacgtttagtgttgctattgt\n" + + "ctacacgtttggatattacgttatgtgagcggacatcaatagttgtctaactctttagta\n" + + "agccagagatagcactcttagcgaatggataccatcttccataagtttagttaatagtcc\n" + + "gaaacaactgcttcgagcatatttgaacctccttgtaggcaaatagcctcttcaaagcaa\n" + + "tcttactaatagatagagtttgttttaagggactactagaaatgggacaatcttaatagt\n" + + "atgacctaaactgacatttaaagatatatccaggtggcaagcataaagatcattgcgcca\n" + + "cctccaccgtgggattacttatcagtcgatatcctatatgctaagtttgcgacggcagaa\n" + + "tacaaactaagctgagttgatgctaaccttacctatgataccccattggaccggttaaca\n" + + "gccctacttattccaaataaaagaacttttatgctgtagaagctattatagtgatgcctg\n" + + "gtaacttcagtatattaaaatgacacacatacgccatatagagctcctggaactttgaat\n" + + "aatgagcgaacttcgaagttgaagagcaagaaaccatatgtcacggttgcctaaagcccg\n" + + "gtaaccagacatgtgctatcattgatcattatcgaggttttcataaccttgacccattat\n" + + "cggctgtgcgcggacaagtacttaaatcactagtttcttcacctgcttatcggtaagaaa\n" + + "taaggttggcaaagaatcgcataagacggacgtagagccgcagcgttgtgcgagtccagg\n" + + "tgcatgcgcagcaataggattttaaattttgttccatttttaatttagccgtaaggatgt\n" + + "ccgtaaatgattgaaaattggattcaatctttgggcctatgctactggaacctgatcgac\n" + + "aaaatttcaaacatacgttaactccgaaagaccgtatttttgcggctagaatagtcagtc\n" + + "gcttggagccatataccttaccacttaaacgacgtgctcctgtagttgaaatataaacag\n" + + "aacacaaagactaccgatcatatcaactgaagatctttgtaactttgaggcgaagcaccc\n" + + "tcttcgagacaactaagagtaaagtaccgggcgccgcaaggagtcgattgggaccctaaa\n" + + "tcttgacgaattgctaagaggctcagagctaccactgtaatttctctagagcccataata\n" + + "aatgaacgatacatccgtaggtagcacctaagggattataatggaagccaaatgcagtta\n" + + "ataatattatatactggcgtacacgattcgacggatctctcacatagtgattcacgaccc\n" + + "ccccctttgattgacacagcgtcagcattttgcaagaacgatcttctgcatagggtgcgc\n" + + "caccgtaaggatgacgtcgaagctacaactgggtataatttaccatgcttccctgatgct\n" + + "gagtgcaatacactaagaatgagtttttaccccatatcaccagtatttgttctgttattg\n" + + "cgaagaaatggctatgctgagttggcgactaaagtcacccatcctttttattaggtaacc\n" + + "ccctcccttaaactaactgatttgctggagctgccctgcatacatatactttatcattta\n" + + "tggacgtccgtgacgcttattatccaccatagtcgatatgctacacggattcattaatgg\n" + + "atcgtaggagtttaagttatatttactaagatcggtctcggctactatcccgccttaccc\n" + + "ggcgctatttacggccatttttaatatattgacggtaattattcctatggtttcgaccgc\n" + + "acgtccttggacaagaaagaatggcaaaaaaaatgtaaaagaaaaaaaatattgagtccc\n" + + "taccatcatataaaaaatatgtgatgagtaacttgacgaaatgttagtggttattaaaga\n" + + "ctatctattacaccttttgttttctgtcgtagtatattaaagtctagaagccttacagga\n" + + "aaatcagggttatacagccgatactccgcagcatgaatcatcgaggaggtgtcctaccat\n" + + "cgcgccttgtaatcttgtctgtgtatactgtatttagaccttttatacaaagtaaatatc\n" + + "tcggctttatgtgattgggaggggcctactcaaacatgatgacttgacctaataatcact\n" + + "gtgcgggcgtcttatgactagctattccttgaaatccaccaccaaatggttaatatgtaa\n" + + "aaactttgacgatgaaacaaggtgaatgtgtagttactttgtgtaattagctgcgtcgag\n" + + "cattgcttgtaaaaccgtcaatcgcacacgttacttccataaaatttctacgaatacacc\n" + + "cttcttaaaaaaaacgtaggaattcacgagtttaacaaacgataactgtataaagtggaa\n" + + "gtccgaagaaagcagatgcccgaactactcgaagatgtttcgttttcttaaccatagggg\n" + + "cttcttaatggcccactacgcacattttgttcaagcccgagagggacatccccattacgg\n" + + "gagtattactaaaactgttccgtaatacgttcagcaagggatgaaaaaggccactgctca\n" + + "agttattgacgtgggagtattacatcggaagcctgaatcccacactatgatggtctgtac\n" + + "aggcctagggactgcgtctagacggtattaccggcttctaatcatacgatcgtgagtctt\n" + + "aacgggaagtaaggctcacacctaccccaaaccatttatctatgtaagtataaaattgtg\n" + + "cgtaagtgttcaaagtggacaataaagacgtggcaaaaacccccgcacataagccgcttt\n" + + "agatttcacaaataccaatgcggttaaaaacatccttgagtcgtacatacaccatactcg\n" + + "cgttaaacggatataacagaagataataaatccggatgtggagtcggtgtaactatagaa\n" + + "agccaagtgaaataatgcttaccagtcatttagctatacggctttcatttcatgtcaaga\n" + + "gggtggagtttgacctgtacagttgatatatcaccgatacttagaactcacctaaagcta\n" + + "aaattgctcgcagcgtgtaatccgcatattacaaacaatagatgggattcattatacata\n" + + "agacacgatgatctgctttttcaggttgcgagatgttgcctatcgtcaatcgagtcctgc\n" + + "cttacaccacttaaacaaaagtattgacagggaacctattttcgaggtattatatagtcc\n" + + "agcttgaatatcaatttgacagttaacctagtgaaaatcagtaagaggaaatacgccaca\n" + + "ttctccagtgaaattctacgggttatcgtctagtccaactatcaattataactcacgaga\n" + + "tataagtaaattctcgtacttggcctgatttttattatactttggatccttagtaaacag\n" + + "gaagggagaaaccttcaacgaaaaacactggattttgttttactctcaaagctcttatat\n" + + "gacggaaataccctgtcaagtcttaactttattactagactaatgaaatgggcttggggt\n" + + "ggccagaatcatagtacaatttagcggatacactattcggactttcctatcggctgtctg\n" + + "gttggataagtatggggactaataggctagacatacctatacttaaactatacaggcgtc\n" + + "atctatctctgcaactttggagttccctgatgttctcccgccctttgggttcacatcttc\n" + + "tataccgacacccctaataacgattagtttgtgggttagagtaaattaatacggttaata\n" + + "ttaatgtatcgttgaaaagctggtgtcgccaataaggtaaccggctaggcagagtatatg\n" + + "tcacgaagtataactaccctaatgataagctgtaggaataaaattaatgctgtctctaag\n" + + "cgaagagatatttccgactctgttttaatgacgaatctcattacttctgacttgcaaatg\n" + + "ttcaatatggcacggtttcacggcacctttgtgacgcatataatgaacttagaagattat\n" + + "aacgacggaactttatatgataatccgttacgattaaagaatctgttaaatatcataatg\n" + + "gcattcagttctagaccgtgcatcatggtaaacttactttctctgcatggcgacatacat\n" + + "ttcgctattcaaattcgcgtgtggttacacccactcgcacctttggaatattaagagaag\n" + + "atgatcagaaaatccattcgctcaatttttctgacgtacgtctaatttatcctaggagac\n" + + "aaatcgttttatgtctctcacatttttgaagaaaggttcgagagacaatactcaggtcct\n" + + "gaactgctagaagatactcggtggagcgtggcaacaatgaaaaactcgtgacataaatga\n" + + "atgatacttttccaagttcagttaagtgaatatgtttaacatacccggcttttcgatctt\n" + + "aagctgacgctggacgtgcgagtaatgtcagtctcttacatacactagtgactccaagtt\n" + + "tcgtcaaaaacgccccctcccttctcgagcccactcacgctatgtattgacgcgaacttg\n" + + "ttcgggatcagacttttcaggagttcggtcgcgtgtccctatgtgctaatatataagtta\n" + + "gatcgcattagatgctaatctgaatacttatagacgaccttcaacgagaacgggtaccac\n" + + "cttgaggctagagttaggtgtgaaacgacaggtagggacatataaaatttgagtgcggct\n" + + "ttagttaagggtttaattacctactcaaacatcacgctcgcgcccttcgtacgtaatcga\n" + + "ccatctagaggctaaggggactgtactaggtagtgattaatgatatcctagacgcacgtg\n" + + "ccttagatcttcagactctgatggtccgcgatcaccgtaattgtagtcctccaactcgat\n" + + "cactttgttggcgtcaaagaaattacgatatctaaatacttataatacaataaccaagga\n" + + "tgagaatgactcatcgcgttggagttatattgcttgaagttctatggaatgaaagcacgt\n" + + "tatctgccgtcccaatatctccagtgagctaattcattggacggtccactttgatcaatc\n" + + "cccgaggagatgttcggacactttagtctgtaacacttagcgttgagaccacgaacaatt\n" + + "gattactcagtcttgaaggtgttttccaaagttcattttaaataagactacgataggcct\n" + + "ttcctattgatataaactacccggctctgttgttcgtgtgagtcgtacttctctgtgttt\n" + + "ttctgattatagcaagattcgattcttagtgtaaacagcgatttttatttgacccgtcaa\n" + + "tgagaagcgcataggatctaagcaaaattatcaagttgtgccacaaggtaagatctttcc\n" + + "agttattgcaggtaggatgtatcccacgttgatagtatgaggtctgacgtcaactgtcta\n" + + "ggagagttgaccgcgtgcgggtacaccggatttgcatcgatgttgagaacgcagaactcc\n" + + "cactgtcgtggcggcgttcctgatatttagcaagaggcgttgataaagccctcatcatct\n" + + "agatctcgacctcatctgccctcttgctccatcattttctacacagactactttcctatc\n" + + "tacgttagtataattgctttctatcttagtatcatttagagcttctccgtcaacaggttc\n" + + "gtgctattaaagttagtacgaaagggacaacttgtagcaacgcatttaatcggttttcga\n" + + "ctacttcgcacaaaatcagataaagaagtttgtcattctattagacattgaattgcgcaa\n" + + "ttgacttgtaccacttatgatcgaacactgaatcaagactgtgattaactaaaatagaca\n" + + "agccactatatcaactaataaaaacgcccctggtggtcgaacatagttgactacaggata\n" + + "attaattggactggagccattacattctctacaatcgtatcacttcccaagtagacaact\n" + + "ttgaccttgtagtttcatgtacaaaaaaatgctttcgcaggagcacattggtagttcaat\n" + + "agtttcatgggaacctcttgagccgtcttctgtgggtgtgttcggatagtaggtactgat\n" + + "aaagtcgtgtcgctttcgatgagagggaattcaccggaaaacaccttggttaacaggata\n" + + "gtctatgtaaacttcgagacatgtttaagagttaccagcttaatccacggtgctctacta\n" + + "gtatcatcagctgtcttgcctcgcctagaaatatgcattctatcgttatcctatcaacgg\n" + + "ttgccgtactgagcagccttattgtggaagagtaatatataaatgtagtcttgtctttac\n" + + "gaagcagacgtaagtaataatgacttggaataccaaaactaaacatagtggattatcata\n" + + "ctcaagaactctccagataaataacagtttttacgatacgtcaccaatgagcttaaagat\n" + + "taggatcctcaaaactgatacaaacgctaattcatttgttattggatccagtatcagtta\n" + + "aactgaatggagtgaagattgtagaatgttgttctggcctcgcatggggtctaggtgata\n" + + "tacaatttctcatacttacacggtagtggaaatctgattctagcttcgtagctgactata\n" + + "ctcaaggaaccactgctcaaggtaggagactagttccgaccctacagtcaaagtggccga\n" + + "agcttaaactatagactagttgttaaatgctgatttcaagatatcatctatatacagttt\n" + + "ggacaattatgtgtgcgaaactaaaattcatgctattcagatggatttcacttatgcctt\n" + + "agaaacagatattgcccgagctcaatcaacagttttagccggaaacaatcgaagcatagg\n" + + "gacaatgtatcttttcctaaattgccatgtgcagatttctgagtgtcacgaagcgcataa\n" + + "tagaatcttgtgttgcctcaactcgttgaaaagtttaaaacaatcgcagcagtctttttg\n" + + "gggtctactgtgtgtttgcaaaataactgaaagaaacgcttgaacaactctgaagtagct\n" + + "cgagtactcattaaagtgtaacacattagtgaatatcggccaatgaaccaaacgcttccc\n" + + "ggtacgctatctctctcatcgggaggcgatgtgcaggttatctacgaaagcatcccttta\n" + + "cgttgagagtgtcgatgcatgaacctcattgtaacaatagcccagcaaattctcatacgt\n" + + "gcctcagggtccgggcgtactcctccatggaagggcgcgcatctagtgttataccaactc\n" + + "gctttttaactactatgctgtagttctacaggcatagtggccagtattttctaacttctc\n" + + "tggatagatgctctcactcctcatccatcacggcttcagtttacgtcttacttgcttgtt\n" + + "cagcaacggatggaggcattaagtatcttcactgttccctaaaattgctgttcaatatca\n" + + "aagtaaggacgatacagggaaagctcaagcacactcattgaatactgccccagttgcaac\n" + + "ctcacttaatctgacaaaaataatgactactctaagtgttgcggaagcagtctcttccac\n" + + "gagcttgtctgtatcacttcgtataggcatgtaactcgatagacacgaacaccgagtgag\n" + + "aaactatattcttgcttccgtgtgtgtgacaccaggtaattgatgcggatataagctgga\n" + + "gatcactcacgcccacacaaggcgctgctacctctttattccaatgtgtaagaatttgct\n" + + "aacttcatttctagaccgcagctttgcggtcataatttcacggtacggacccttgggtta\n" + + "gagacttgataacacacttcgcagtttccaccgcgcacatgttttagtggcttctaacat\n" + + "agaatttttgttgtgacataaagagtgcgtgggagacttgcccgaccgttaagccataat\n" + + "caattgaaagccccgtgagtcacatctaattggttgtactgcgcatttagctatccttta\n" + + "gctgactcgaagagattcgattcctaatataggttaattagatggctgccgcgcgaagta\n" + + "aaacgtgaaaaacgtagtgcgcagatctgcataactcgcgcttaattacttatgagtagt\n" + + "tccaagttcgctacgttatgagagagattggaattaagcaaatatgttttatggtgattt\n" + + "tgggatgagaaggactgctaagtacggctactaaacaaatttctaaaaccgccatctacc\n" + + "ttatcttggagacatttaagttgtatatgtcactagtctagcttttgtctgtgggacgcg\n" + + "ttctcggaatgagggaaatgcaagagccgattcatcaaatgcttatctaagaaagtagtg\n" + + "gactattacaccaagcacgaatgccagggaactgctttcttgctcaggacctcgcgacaa\n" + + "ggtaccccgcataagtcctagaattacatttggtcagcaatgctgacatttgaccgtgaa\n" + + "aacataattttaatcagaaggcagctcacccgcttgctctagatcttatctttgtatgaa\n" + + "tgtcagaatttactgcaatatccgttccgaatagtgagggcttagtatagttctctgtat\n" + + "acaggtcacatcaaactccccctgtcctagtacagctctgagctttaattaattgcatac\n" + + "atttccttcaatcatcagatgaaaacaccgcgaatcatgctcttctcgtatagggcaaga\n" + + "gaagcaacaaacaactagcccgactcacgttcatccgccgtatccttgttcagttcttac\n" + + "tccgtattaggtcagcgaaatctaatcagaataatcggtcgcgtatcaaaattaaaatcc\n" + + "cgcttgaggttgacaattaaaacgctgagcagttatcggctattagatagtggggtgaaa\n" + + "gtaattggctggaattatgttaaaacgtgatattaagctaaaatacgctacttgttgccg\n" + + "acctaattcagtcattcgatattcagttagagccaagaataacaagcttgtataaattga\n" + + "acggggtgcactaaacgatgtgttactctaatattcagcttggagtatacctgaaggcga\n" + + "attcatgtatcggccaataataagacgttgaagatcacaatttggactagcaaaagaagg\n" + + "tgatttatgcgtggggattgagtccactgtacgagtacggtctctggaaaattataggtt\n" + + "cagggaatataaggaagtaaagataattaccaagagatttttggtatcgctatgacccag\n" + + "aggtgttctaacgtctgttttgatccgcagaatttctgcctcaatgcatatttgacggac\n" + + "ttgaactagagcctctaaagttaaatggcgacgcaactgttcctaaacttcaattattac\n" + + "tactctttttttcctagggtattgtagaggccagtggacaaaataaatcaaatttaagat\n" + + "gtttcggacattaacatcccccgtagcatagaaatcatcagttatccaatctctcatcga\n" + + "gcttttacaatttctgctggcgctatggacagcatatgccgcgagacctccgcaagactc\n" + + "acttgatcactgtaagtatcttcattagaggttagagcctatagttaagctgctgaccta\n" + + "gtaaaattggtattttctaattttattgctcaagttaaaggttagtgaagggataatgac\n" + + "gttatttttgaacaatgggttgtattcaattttatatcacgaatggaacccttcattccc\n" + + "ggcataatactagacgacacgaacaagctccgatctatcagccaggcacgtgttaaggtt\n" + + "taattccggcaaaccaatgaagcatcaaaaggtgacctgatgcaacttagggtcacgatg\n" + + "agtttttcaggactacttattacctattaataagttaacatgagccttcataccccgtaa\n" + + "gacaatacatactccaccaattagaattctgagccatcttatctttttgtatcatcgaag\n" + + "ggtatggccgaataggttaattagttactcctaacgtctctacaggcatgcatttgacgc\n" + + "accttcgaaaatagtcaatctctcgccacacgcgtctagtatgcagcatcaaaaatatag\n" + + "tccacggtttccggattaccaaacgcggcaaagagaaacattgtatcgacggagataact\n" + + "taatacagaaggaaggggcatcttcgaatacggatgaataattctatctgtttattctga\n" + + "catcttgttttcaggttaatcttacgcattcaaatgacgcctgccccatgcgtgcgcaat\n" + + "tattttctaatattgacgagagcaatctcactccttttgggtctatttatgttttattga\n" + + "ggcacaagcctatacagaacaggtactattaaggccgtgagtgtgagactcaaaccgtgg\n" + + "aaacaaaggatgggttgttcttggtacaagttttagtgcatgtgggcaatccttaccaaa\n" + + "atcagatgctatccttaactttgggctgcatttaagatggcggttggaggcctgtgagaa\n" + + "tcctgcgtgtcatctttaatgaccgaattcatccatgtagattcagatcacacactcatt\n" + + "ccttgatgttgtctaaacaaaagttgttgtggacgcattggagggagttaagtaacaact\n" + + "tgggatcgcatacttataaaaattatatgttaaactttcacaaacgctgaagtccaaagt\n" + + "aactagcccaaacgcctcgagagtcactaggtattaatggtgtttgagttcctgtgaaat\n" + + "agtgttcgaaggtaaaatttatgtaccaaatcgaaagaacacttaataaggcttgcttgc\n" + + "acggaggtatgatgtttactgactctacaaccctaattttccagtacgtacattcattcc\n" + + "aataggttagttctcaaagtgctatacaggctcctcaattgatgatatgcttcagccgct\n" + + "ctatggatattagctcattttatttaggaagcccgcttagaggcttactatgagggaaat\n" + + "gccaaaatgtcatacttttcggtgtgtcccatatgacaccgctttacatagaatttgaat\n" + + "taaaacgcgctctcccgttcactaccatacttggtaccgtgcgcatattacatatagata\n" + + "taggatcattttttaaagctgtactaggtttgatcgacaatcttatgctatactatatga\n" + + "tgtaaccctcataatcaataccgatcgtacgatcctagcataggtggcaagcgattttat\n" + + "gccgattattgtgttaaatagtctgtgagtgtgattatcagggctacgttggtagagggg\n" + + "ttgtatagacctcgcacacattgtgacatacttaacaatatacgaaaactgatataataa\n" + + "atccccttacccaaacaccaatcccgttgaatcaactaccataacgtctcccatataaat\n" + + "tgcctacttgtttgcataaatctgaatacataacaccattgcaccttcttgtgttccaat\n" + + "cccgttaagattgccttgtcagatgatatgcaagaacaatagcatttgctagcaattatt\n" + + "aacagctcttcgaattgcctccacataacgcgggagggtatattttaatttggcaaatac\n" + + "taagtactgttggcgtcatatgctattaacggttggatattaagttatgtcagccgtaag\n" + + "caagagtgggcgaaatattttgttacccagtgagagcactcttagagtttggatacaata\n" + + "ggccatatgttgacttaagaggacgtaactacgccgtacaccattgttcaaccgacttct\n" + + "tggcaaatagaatcgtattagcaatcttaagaatagagacacgttcgtgttagggtatac\n" + + "tacaaatccgaaaatcttaagaggatcacctaaactgaaatttatacatatttcaacgtg\n" + + "gatagatttaacataattcagccacctccaacctgggagtaattttcagtagatttacta\n" + + "gatgattagtggcccaacgcacttgactatataagatctggggatcctaacctgacctat\n" + + "gagacaaaattggaaacgttaacagcccttatgtgtacaaagaaaagtaagttgttgctg\n" + + "ttcaacagatgatagtcatgacgcgtaacttcactatagtaaattgaaacaaatacgcaa\n" + + "tttagacagaatggtacggtcatgaatgacagtaattcgaagtgctagaccaacttaaaa\n" + + "taggtaaacgtgcccgaaaccccccttaacagaaagctgctatcatggtgcagtatcgac\n" + + "gtgttcagaaacttgtaacttttgagcaggtccgagcacatggaagtatatcacgtgttt\n" + + "ctgaaccggcttatccctaagatatatccgtcgcaaactttcgatttagtcccacgtaga\n" + + "gcccaagcgttgtgcgactccacgtgcatgcccagaaatacgagtttaaatttggttaca\n" + + "tggttaattttgaccgaagcatcgcactttatgattgataattggattcaatatgtcgcc\n" + + "ctatgcgaatgcaacatgatccacaatttggctataagacgtttaatccgtatcacactt\n" + + "tgtttgcggctagtatagtaacgcccgtgcaccaagagtcagtaacaattataagtactc\n" + + "cgcaggtacttcaaatataaaaactaatcaaacacgacccatatgatcatctgaagatat\n" + + "ttggaactttctcgacaaccaccctcgtactcaatacttacactaatcgacaggcacacg\n" + + "caacgtgtacagtcgcaccatattgagtcaagatttgcttagtggcgatgagcgtacacg\n" + + "cttatttctctagtcacaattagttatctacgagacatcacgagggagcaaataagcgat\n" + + "gttatggctacacataggcacgtatgaatatgatataagccagttaaacagtcgaaccat\n" + + "cgagcaaattctcatgcaccaacccacacgttgaggcacaaagagtaagctgtttgaatg\n" + + "taacttcttctgctgagcgggccccaacgtaaggatcaactagaagagaaaactcggtat\n" + + "tagtttaaatgcgtcacggagcatgagtgcatttcactaagaatgtctgtgtaaccaata\n" + + "taacatctatttgttatctgattgcctacttatggctttgcggtcgtggcgactaatgtc\n" + + "tccaatccttttgaggtcggtaccaactccctttaaattacgctgtgcaggctcatgcac\n" + + "tgcatacatatacggtagcaggtagggacctcacgcacccttattataatcaatagtagt\n" + + "tatcagtcaacgaggcaggaatgctgaggtcgaggtgttggtatattttctatgtgccgt\n" + + "ctaggcgactatcacgcattaccaggcgagatttaagccaattttgaatatagtcaacgt\n" + + "aatttttactatgggttccaccgaaacgccttgcacaactaagaatcccataaaatatcg\n" + + "atatcaaataaaagattgtgtcaataccttcatatatattttttcggttgactaacgtga\n" + + "actaaggttaggggttttgtatgtctatataggaaacagtttcttttctgtcctacttta\n" + + "gtaaagtcttcaagccttactccaaaatcacggtgattaagccgttactcagcagcatga\n" + + "ttctgcctgctcgggtcctaaaatccagccttgtaagagtcgctgtgtattagctaggga\n" + + "gacctttgttaaaaaggatatatcgcggcgggatgtgagtgcgtggcgcatactcaatct\n" + + "tcagctcgtgtcattataatatctctcccccacgcttttcactagatatgccgtgtaagc\n" + + "aaacaccttatgcttaatttcgaaaatattggtacttgaaaaaagctgtaggggtactta\n" + + "atgtctggtaggagatcaggagagaattgagtgtaaaaccgtaaagccctcacctgactt\n" + + "catgtaaatggcttagaagactccatgatttaataaatactacgaaggaaagactggatc"; +} diff --git a/src/main/java/org/linaro/benchmarks/benchmarksgame/spectralnorm.java b/src/main/java/org/linaro/benchmarks/benchmarksgame/spectralnorm.java new file mode 100644 index 0000000..dc6d3c6 --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/benchmarksgame/spectralnorm.java @@ -0,0 +1,112 @@ +/* + * This benchmark has been ported from "The Computer Language Benchmarks Game" suite and slightly + * modified to fit the benchmarking framework. + * + * The original file is `spectralnorm/spectralnorm.java` from the archive + * available at + * http://benchmarksgame.alioth.debian.org/download/benchmarksgame-sourcecode.zip. + * See LICENSE file in the same folder (BSD 3-clause) + * + * The Computer Language Benchmarks Game + * http://benchmarksgame.alioth.debian.org/ + * + * contributed by Java novice Jarkko Miettinen + * modified ~3 lines of the original C#-version + * by Isaac Gouy + */ + + /* + * Description: Eigenvalue using the power method. + * Main Focus: TODO + * + */ + +package org.linaro.benchmarks.benchmarksgame; + +import java.text.DecimalFormat; +import java.text.NumberFormat; +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + +// CHECKSTYLE.OFF: .* +public class spectralnorm +{ + + private static final NumberFormat formatter = new DecimalFormat("#.000000000"); + + private final double Approximate(int n) { + // create unit vector + double[] u = new double[n]; + for (int i=0; i<n; i++) u[i] = 1; + + // 20 steps of the power method + double[] v = new double[n]; + for (int i=0; i<n; i++) v[i] = 0; + + for (int i=0; i<10; i++) { + MultiplyAtAv(n,u,v); + MultiplyAtAv(n,v,u); + } + + // B=AtA A multiplied by A transposed + // v.Bv /(v.v) eigenvalue of v + double vBv = 0, vv = 0; + for (int i=0; i<n; i++) { + vBv += u[i]*v[i]; + vv += v[i]*v[i]; + } + + return Math.sqrt(vBv/vv); + } + + + /* return element i,j of infinite matrix A */ + private final double A(int i, int j){ + return 1.0/((i+j)*(i+j+1)/2 +i+1); + } + + /* multiply vector v by matrix A */ + private final void MultiplyAv(int n, double[] v, double[] Av){ + for (int i=0; i<n; i++){ + Av[i] = 0; + for (int j=0; j<n; j++) Av[i] += A(i,j)*v[j]; + } + } + + /* multiply vector v by matrix A transposed */ + private final void MultiplyAtv(int n, double[] v, double[] Atv){ + for (int i=0;i<n;i++){ + Atv[i] = 0; + for (int j=0; j<n; j++) Atv[i] += A(j,i)*v[j]; + } + } + + /* multiply vector v by matrix A and then by matrix A transposed */ + private final void MultiplyAtAv(int n, double[] v, double[] AtAv){ + double[] u = new double[n]; + MultiplyAv(n,v,u); + MultiplyAtv(n,u,AtAv); + } + // CHECKSTYLE.ON: .* + + private static final int APPROXIMATE_N = 100; + + public boolean verifySpectralNorm() { + double expected = 1.2742199912349306; + double found = Approximate(APPROXIMATE_N); + + if (Math.abs(expected - found) > 0.000000001) { + System.out.println("ERROR: Expected " + expected + " but found " + found); + return false; + } + return true; + } + @Benchmark + public void jmhTimeSpectralNorm() { + Approximate(APPROXIMATE_N); + } +} diff --git a/src/main/java/org/linaro/benchmarks/benchmarksgame/threadring.java b/src/main/java/org/linaro/benchmarks/benchmarksgame/threadring.java new file mode 100644 index 0000000..c30713a --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/benchmarksgame/threadring.java @@ -0,0 +1,120 @@ +/* + * This benchmark has been ported from "The Computer Language Benchmarks Game" suite and + * significantly modified to fit the benchmarking framework. + * + * Originally the benchmark finished with 'System.exit(0)'. A new state of message "-1" was + * introduced to avoid this. + * + * The original file is `threadring/threadring.java-3.java` from the archive + * available at + * http://benchmarksgame.alioth.debian.org/download/benchmarksgame-sourcecode.zip. + * See LICENSE file in the same folder (BSD 3-clause) + * + * The Computer Language Benchmarks Game + * http://benchmarksgame.alioth.debian.org/ + * contributed by Klaus Friedel + */ + +/* + * Description: Switch from thread to thread passing one token. + * Main Focus: TODO + * + */ + +package org.linaro.benchmarks.benchmarksgame; + +import java.util.concurrent.locks.LockSupport; +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + +// CHECKSTYLE.OFF: .* +public class threadring { +// CHECKSTYLE.ON: .* + static final int THREAD_COUNT = 503; + + private static String lastActedThreadName; + + public static class MessageThread extends Thread { + MessageThread nextThread; + volatile Integer message; + + public MessageThread(MessageThread nextThread, int name) { + super("" + name); + this.nextThread = nextThread; + } + + public void run() { + Integer msg = dequeue(); + while (nextThread.enqueue(msg)) { + msg = dequeue(); + if (msg == -1) { + break; + } + } + } + + public boolean enqueue(Integer hopsRemaining) { + if (hopsRemaining == 0) { + message = -1; + lastActedThreadName = this.getName(); + + // notify all the threads that transmission is over + LockSupport.unpark(this); + MessageThread current = nextThread; + while (current != this) { + current.message = -1; + LockSupport.unpark(current); + current = current.nextThread; + } + + return false; + } + + message = hopsRemaining - 1; + LockSupport.unpark(this); + return true; + } + + private Integer dequeue() { + while (message == null) { + LockSupport.park(); + } + + Integer msg = message; + if (msg != -1) { + message = null; + } + return msg; + } + } + @Benchmark + public void jmhTimeThreadRing() throws Exception { + + int hopCount = 1000; + + MessageThread first = null; + MessageThread last = null; + for (int i = THREAD_COUNT; i >= 1; i--) { + first = new MessageThread(first, i); + if (i == THREAD_COUNT) { + last = first; + } + } + // close the ring: + last.nextThread = first; + + // start all Threads + MessageThread t = first; + do { + t.start(); + t = t.nextThread; + } while (t != first); + + first.enqueue(hopCount); + first.join(); // wait for System.exit + } +} diff --git a/src/main/java/org/linaro/benchmarks/jit_aot/Invoke.java b/src/main/java/org/linaro/benchmarks/jit_aot/Invoke.java new file mode 100644 index 0000000..36a4f76 --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/jit_aot/Invoke.java @@ -0,0 +1,92 @@ +/* + * Copyright (C) 2016 Linaro Limited. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* + * This benchmark is inspired by benchmarks/caffeinemark. + * Original benchmark implements a recursion method which calls itself with invoke-virtual. + * + * This behavior can be different on JIT and AOT mode, because: + * - JIT mode can optimize invoke-virtual with inline cache mechanism. + * - AOT mode has no such optimization. + * + * This benchmark exposes such difference between ART JIT and AOT mode. + */ + +package org.linaro.benchmarks.jit_aot; + +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.NANOSECONDS) +@State(Scope.Benchmark) + +public class Invoke { + + public int recursionInvokeVirtual(int i) { + if (i == 0) { + return 0; + } else { + return i + recursionInvokeVirtual(i - 1); + } + } + + public static int recursionInvokeStatic(int i) { + if (i == 0) { + return 0; + } else { + return i + recursionInvokeStatic(i - 1); + } + } + + public final int recursionInvokeFinal(int i) { + if (i == 0) { + return 0; + } else { + return i + recursionInvokeFinal(i - 1); + } + } + + private int recursionInvokePrivate(int i) { + if (i == 0) { + return 0; + } else { + return i + recursionInvokePrivate(i - 1); + } + } + + private static final int recursion_depth = 1000; + + @Benchmark + public void jmhTimeRecursionInvokeVirtual() { + recursionInvokeVirtual(recursion_depth); + } + + @Benchmark + public void jmhTimeRecursionInvokeStatic() { + recursionInvokeStatic(recursion_depth); + } + + @Benchmark + public void jmhTimeRecursionInvokeFinal() { + recursionInvokeFinal(recursion_depth); + } + + @Benchmark + public void jmhTimeRecursionInvokePrivate() { + recursionInvokePrivate(recursion_depth); + } +} diff --git a/src/main/java/org/linaro/benchmarks/jit_aot/LoadCheck.java b/src/main/java/org/linaro/benchmarks/jit_aot/LoadCheck.java new file mode 100644 index 0000000..8f748b8 --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/jit_aot/LoadCheck.java @@ -0,0 +1,97 @@ +/* + * Copyright (C) 2016 Linaro Limited. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* + * This benchmark is inspired by benchmarksgame/fastaredux.java. + * Original benchmark implements a Random class which is a random double generator, + * and is heavily used by another class in its inner calculation. + * + * This behavior can be very unfriendly to ART AOT because: + * Random is a user defined class. Currently in AOT mode, + * ART cannot assume this class is always loaded, + * thus ART AOT compiler has to generate LoadClass check before invoking Random.next() method. + * Since Random.next() is called inside a loop of a hot function addLine(), + * the LoadClass check overhead causes this benchmark runs twice slower + * in AOT mode compared to JIT mode. + * + * In interpreter + JIT mode, JIT compiler can assume that a user defined class is always loaded + * during previous interpretation stage, thus it avoid generating LoadClass check. + * + * This benchmark exposes such difference between ART JIT and AOT mode. + */ + +package org.linaro.benchmarks.jit_aot; + +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + +public class LoadCheck { + static final class Random { + static final int IM = 139968; + static final int IA = 3877; + static final int IC = 29573; + static final double LOOKUP_SCALE = 4 * 1024 - 1; + static final double SCALE = LOOKUP_SCALE / IM; + static int last = 42; + + static double next() { + return SCALE * (last = (last * IA + IC) % IM); + } + } + + static final int IM = 139968; + static final int IA = 3877; + static final int IC = 29573; + static final double LOOKUP_SCALE = 4 * 1024 - 1; + static final double SCALE = LOOKUP_SCALE / IM; + static int last = 42; + + public double sum; + + static double nextRandDouble() { + return SCALE * (last = (last * IA + IC) % IM); + } + + public void randomSumInvokeStaticMethod(int val) { + sum = (double)val; + for (int i = 0; i < 10000; i++) { + sum += nextRandDouble(); + } + } + + public void randomSumInvokeUserClass(int val) { + sum = (double)val; + for (int i = 0; i < 10000; i++) { + sum += Random.next(); + } + } + + private static final int loop_size = 10000; + + @Benchmark + public void jmhTimeRandomSumInvokeStaticMethod() { + randomSumInvokeStaticMethod(loop_size); + } + + @Benchmark + public void jmhTimeRandomSumInvokeUserClass() { + randomSumInvokeUserClass(loop_size); + } +} diff --git a/src/main/java/org/linaro/benchmarks/math/AccessNBody.java b/src/main/java/org/linaro/benchmarks/math/AccessNBody.java new file mode 100644 index 0000000..bdeb5c2 --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/math/AccessNBody.java @@ -0,0 +1,208 @@ +/* + * Copyright (C) 2015 Linaro Limited. Ported to Java from: + * https://github.com/WebKit/webkit/blob/master/PerformanceTests/SunSpider/tests/sunspider-1.0.2/access-nbody.js + * + * Description: N-body simulation of a galaxy composed out of a four planets and the sun. + * Main Focus: Floating-point operations. + * + */ + +/* The Great Computer Language Shootout + http://shootout.alioth.debian.org/ + contributed by Isaac Gouy */ + +// http://benchmarksgame.alioth.debian.org/license.html (BSD 3-clause license) +// See NOTICE file for license. + +package org.linaro.benchmarks.math; + +import java.lang.Math; +import java.lang.System; +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + +public class AccessNBody { + private static final double ACCESS_NBODY_EXPECTED = 1.4677045000258846; + private static final double DAYS_PER_YEAR = 365.24; + private static final double SOLAR_MASS = 4 * Math.PI * Math.PI; + + private class Body { + public double x; + public double y; + public double z; + public double vx; + public double vy; + public double vz; + public double mass; + + Body(double x, double y, double z, double vx, double vy, double vz, double mass) { + this.x = x; + this.y = y; + this.z = z; + this.vx = vx; + this.vy = vy; + this.vz = vz; + this.mass = mass; + } + + void offsetMomentum(double px, double py, double pz) { + this.vx = -px / SOLAR_MASS; + this.vy = -py / SOLAR_MASS; + this.vz = -pz / SOLAR_MASS; + } + + } + + private class NBodySystem { + private Body[] bodies; + private double px; + private double py; + private double pz; + + NBodySystem(Body[] bodies) { + this.bodies = bodies; + + for (int i = 0; i < bodies.length; i++) { + Body currentBody = this.bodies[i]; + double mass = currentBody.mass; + px += currentBody.vx * mass; + py += currentBody.vy * mass; + pz += currentBody.vz * mass; + } + this.bodies[0].offsetMomentum(px, py, pz); + } + + void advance(double dt) { + double dx; + double dy; + double dz; + double distance; + double mag; + + for (int i = 0; i < bodies.length; i++) { + Body bodyI = this.bodies[i]; + for (int j = i + 1; j < bodies.length; j++) { + Body bodyJ = this.bodies[j]; + dx = bodyI.x - bodyJ.x; + dy = bodyI.y - bodyJ.y; + dz = bodyI.z - bodyJ.z; + + distance = Math.sqrt(dx * dx + dy * dy + dz * dz); + mag = dt / (distance * distance * distance); + bodyI.vx -= dx * bodyJ.mass * mag; + bodyI.vy -= dy * bodyJ.mass * mag; + bodyI.vz -= dz * bodyJ.mass * mag; + + bodyJ.vx += dx * bodyI.mass * mag; + bodyJ.vy += dy * bodyI.mass * mag; + bodyJ.vz += dz * bodyI.mass * mag; + } + } + + for (int i = 0; i < bodies.length; i++) { + Body body = this.bodies[i]; + body.x += dt * body.vx; + body.y += dt * body.vy; + body.z += dt * body.vz; + } + } + + double energy() { + double dx; + double dy; + double dz; + double distance; + double e = 0.0; + + for (int i = 0; i < bodies.length; i++) { + Body bodyI = this.bodies[i]; + + e += 0.5 * bodyI.mass + * (bodyI.vx * bodyI.vx + bodyI.vy * bodyI.vy + bodyI.vz * bodyI.vz); + + for (int j = i + 1; j < bodies.length; j++) { + Body bodyJ = this.bodies[j]; + + dx = bodyI.x - bodyJ.x; + dy = bodyI.y - bodyJ.y; + dz = bodyJ.z - bodyJ.z; + distance = Math.sqrt(dx * dx + dy * dy + dz * dz); + e -= (bodyI.mass * bodyJ.mass) / distance; + } + } + return e; + } + } + + private Body jupiter() { + return new Body( + 4.84143144246472090e+00, + -1.16032004402742839e+00, + -1.03622044471123109e-01, + 1.66007664274403694e-03 * DAYS_PER_YEAR, + 7.69901118419740425e-03 * DAYS_PER_YEAR, + -6.90460016972063023e-05 * DAYS_PER_YEAR, + 9.54791938424326609e-04 * SOLAR_MASS); + } + + private Body saturn() { + return new Body( + 8.34336671824457987e+00, + 4.12479856412430479e+00, + -4.03523417114321381e-01, + -2.76742510726862411e-03 * DAYS_PER_YEAR, + 4.99852801234917238e-03 * DAYS_PER_YEAR, + 2.30417297573763929e-05 * DAYS_PER_YEAR, + 2.85885980666130812e-04 * SOLAR_MASS); + } + + private Body uranus() { + return new Body( + 1.28943695621391310e+01, + -1.51111514016986312e+01, + -2.23307578892655734e-01, + 2.96460137564761618e-03 * DAYS_PER_YEAR, + 2.37847173959480950e-03 * DAYS_PER_YEAR, + -2.96589568540237556e-05 * DAYS_PER_YEAR, + 4.36624404335156298e-05 * SOLAR_MASS); + } + + private Body neptune() { + return new Body( + 1.53796971148509165e+01, + -2.59193146099879641e+01, + 1.79258772950371181e-01, + 2.68067772490389322e-03 * DAYS_PER_YEAR, + 1.62824170038242295e-03 * DAYS_PER_YEAR, + -9.51592254519715870e-05 * DAYS_PER_YEAR, + 5.15138902046611451e-05 * SOLAR_MASS); + } + + private Body sun() { + return new Body(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0); + } + + private double simulateGalaxy() { + double output = 0.0; + Body[] bodies = { sun(), jupiter(), saturn(), uranus(), neptune() }; + NBodySystem galaxy = new NBodySystem(bodies); + + for (int i = 3; i <= 24; i *= 2) { + output += galaxy.energy(); + for (int j = 0; j < i * 100; j++) { + galaxy.advance(0.01); + } + output += galaxy.energy(); + } + return output; + } + + @Benchmark + public void jmhTimeAccessNBody() { + simulateGalaxy(); + } +} diff --git a/src/main/java/org/linaro/benchmarks/math/MathCordic.java b/src/main/java/org/linaro/benchmarks/math/MathCordic.java new file mode 100644 index 0000000..313e52c --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/math/MathCordic.java @@ -0,0 +1,116 @@ +/* + * Ported to java from: + * https://github.com/WebKit/webkit/blob/master/PerformanceTests/SunSpider/tests/sunspider-1.0.2/math-cordic.js + * + * Copyright (C) Rich Moore. All rights reserved. + * Copyright (C) 2015 Linaro Limited. For the port to Java + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY CONTRIBUTORS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * Description: A simple and efficient algorithm used to calculate + * trigonometric cos and sin functions using additions, + * subtractions and bitshifts. + * Main Focus: Bitshifts, Floating-Point operations. + * + */ + +package org.linaro.benchmarks.math; + +import java.lang.System; +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + +public class MathCordic { + private static double[] ANGLES; + private static final double AG_CONST = 0.6072529350; + private static final double CORDIC_EXPECTED = 10362.570468755888; + private static final double RAD_CONST = 0.017453; + private static final double TARGET_CONST = 28.027; + private static final double X_CONST = 65536.0; + + private static double fixedMul(double x) { + return x * X_CONST; + } + + private static double fixedDiv(double x) { + return x / X_CONST; + } + + private static double deg2rad(double x) { + return x * RAD_CONST; + } + + static { + ANGLES = new double[] { + fixedMul(45.0), fixedMul(26.565), fixedMul(14.0362), fixedMul(7.12502), + fixedMul(3.57633), fixedMul(1.78991), fixedMul(0.895174), fixedMul(0.447614), + fixedMul(0.223811), fixedMul(0.111906), fixedMul(0.055953), fixedMul(0.027977) }; + } + + private double cordicSinCos(double target) { + double x; + double y; + double targetAngle; + double currentAngle; + + x = fixedMul(AG_CONST); /* AG_CONST * cos(0) */ + y = 0.0; /* AG_CONST * sin(0) */ + currentAngle = 0.0; + targetAngle = fixedMul(target); + + for (int i = 0; i < ANGLES.length; i++) { + double newX; + if (targetAngle > currentAngle) { + newX = x - ((long)y >> i); + y = ((long)x >> i) + y; + x = newX; + currentAngle += ANGLES[i]; + } else { + newX = x + ((long)y >> i); + y = -((long)x >> i) + y; + x = newX; + currentAngle -= ANGLES[i]; + } + } + + return fixedDiv(x) * fixedDiv(y); + } + + @Benchmark + public double jmhTimeMathCordic() { + // When profiling, hot region is in jmhTimeMathCordic_avgt_jmhStub not jmhTimeMathCordic. + // This may be caused by inlining jmhTimeMathCordic in jmhTimeMathCordic_avgt_jmhStub. + // The following "loops" is added to work around this problem. + int loops = 400; + double s = 0; + for (int i = 0; i < loops; i++) { + s += cordicSinCos(TARGET_CONST); + } + return s; + } +} diff --git a/src/main/java/org/linaro/benchmarks/math/MathPartialSums.java b/src/main/java/org/linaro/benchmarks/math/MathPartialSums.java new file mode 100644 index 0000000..0d7919a --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/math/MathPartialSums.java @@ -0,0 +1,77 @@ +/* + * Copyright (C) 2015 Linaro Limited. Ported to Java from: + * https://github.com/WebKit/webkit/blob/master/PerformanceTests/SunSpider/tests/sunspider-1.0.2/math-partial-sums.js + * + * Description: Partial sum calculation of a series using Math().pow(), + * Math.sin() and Math.cos(). + * Main Focus: Floating-Point operations, Math.[pow(), sin(), cos()]. + * + */ + +// The Computer Language Shootout +// http://shootout.alioth.debian.org/ +// contributed by Isaac Gouy + +// http://benchmarksgame.alioth.debian.org/license.html (BSD 3-clause license) +// See NOTICE file for license. + +package org.linaro.benchmarks.math; + +import java.lang.Exception; +import java.lang.Math; +import java.lang.System; +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + +public class MathPartialSums { + private static final double PARTIAL_SUMS_EXPECTED = 33.97380678948515; + + private static double partialSums(int n) { + double a1; + double a2; + double a3; + double a4; + double a5; + double a6; + double a7; + double a8; + double a9; + double k2; + double k3; + double sk; + double ck; + double twothirds = 2.0 / 3.0; + double alt = -1.0; + + a1 = a2 = a3 = a4 = a5 = a6 = a7 = a8 = a9 = 0.0; + for (int k = 1; k <= n; k++) { + k2 = k * k; + k3 = k2 * k; + sk = Math.sin(k); + ck = Math.cos(k); + alt = -alt; + + a1 += Math.pow(twothirds, k - 1); + a2 += Math.pow(k, -0.5); + a3 += 1.0 / (k * (k + 1.0)); + a4 += 1.0 / (k3 * sk * sk); + a5 += 1.0 / (k3 * ck * ck); + a6 += 1.0 / k; + a7 += 1.0 / k2; + a8 += alt / k; + a9 += alt / (2 * k - 1); + } + return a6 + a7 + a8 + a9; + } + @Benchmark + public void jmhTimeMathPartialSums() { + for (int j = 1024; j <= 5000; j *= 2) { + partialSums(j); + } + } +} + diff --git a/src/main/java/org/linaro/benchmarks/math/MathSpectralNorm.java b/src/main/java/org/linaro/benchmarks/math/MathSpectralNorm.java new file mode 100644 index 0000000..d44e77a --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/math/MathSpectralNorm.java @@ -0,0 +1,90 @@ +/* + * Copyright (C) 2015 Linaro Limited. Ported from: + * https://github.com/WebKit/webkit/blob/master/PerformanceTests/SunSpider/tests/sunspider-1.0.2/math-spectral-norm.js + * + * Description: Martrix spectral norm calculation. + * Main Focus: Floating-Point operations. + * + */ + +// The Great Computer Language Shootout +// http://shootout.alioth.debian.org/ +// +// contributed by Ian Osgood + +// http://benchmarksgame.alioth.debian.org/license.html (BSD 3-clause license) +// See NOTICE file for license. + +package org.linaro.benchmarks.math; + +import java.lang.Math; +import java.lang.System; +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + +public class MathSpectralNorm { + private static final double SPECTRAL_NORM_EXPECTED = 5.086694231303284d; + + private double aa(int i, int j) { + return 1.0 / ((i + j) * (i + j + 1) / 2 + i + 1); + } + + private void au(double[] u, double[] v) { + for (int i = 0; i < u.length; ++i) { + double t = 0.0; + for (int j = 0; j < u.length; ++j) { + t += aa(i, j) * u[j]; + } + v[i] = t; + } + } + + private void atu(double[] u, double[] v) { + for (int i = 0; i < u.length; ++i) { + double t = 0.0; + for (int j = 0; j < u.length; ++j) { + t += aa(j, i) * u[j]; + } + v[i] = t; + } + } + + private void atAu(double[] u, double[] v, double[] w) { + au(u, w); + atu(w, v); + } + + double spectralNorm(int n) { + double[] u = new double[n]; + double[] v = new double[n]; + double[] w = new double[n]; + double vv; + double vBv; + + vv = vBv = 0.0; + for (int i = 0; i < n; ++i) { + u[i] = 1.0; + } + + for (int i = 0; i < 10; ++i) { + atAu(u, v, w); + atAu(v, u, w); + } + + for (int i = 0; i < n; ++i) { + vBv += u[i] * v[i]; + vv += v[i] * v[i]; + } + return Math.sqrt(vBv / vv); + } + @Benchmark + public void jmhTimeMathSpectralNorm() { + for (int j = 6; j <= 48; j *= 2) { + spectralNorm(j); + } + } +} diff --git a/src/main/java/org/linaro/benchmarks/micro/ArrayAccess.java b/src/main/java/org/linaro/benchmarks/micro/ArrayAccess.java new file mode 100644 index 0000000..5480562 --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/micro/ArrayAccess.java @@ -0,0 +1,68 @@ +/* + * Copyright (C) 2016 Linaro Limited. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* + * Description: Tracks performance of accessing array locations using variables and constants + * as indexes. + * Main Focus: Memory accesses using arrays. + * + */ + +package org.linaro.benchmarks.micro; + +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + +public class ArrayAccess { + + private static final int ITER_COUNT = 1000; + private int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + + public static void accessArrayConstants(int[] array) { + for (int j = 0; j < 100000; j++) { + array[4]++; + array[5]++; + } + } + + public static void accessArrayVariables(int[] array, int i) { + for (int j = 0; j < 100000; j++) { + array[i]++; + array[i + 1]++; + array[i + 2]++; + array[i - 2]++; + array[i - 1]++; + } + } + + @Benchmark + public void jmhTimeAccessArrayConstants() { + for (int i = 0; i < 1000; i++) { + accessArrayConstants(array); + } + } + + @Benchmark + public void jmhTimeAccessArrayVariables() { + for (int i = 0; i < 1000; i++) { + accessArrayVariables(array, 5); + } + } +} diff --git a/src/main/java/org/linaro/benchmarks/micro/Base64.java b/src/main/java/org/linaro/benchmarks/micro/Base64.java new file mode 100644 index 0000000..df58234 --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/micro/Base64.java @@ -0,0 +1,139 @@ +/* + * encode and decode methods from: + * https://en.wikipedia.org/wiki/Base64#Sample_Implementation_in_Java + * Available under the Creative Commons Attribution-ShareAlike License. + * http://creativecommons.org/licenses/by-sa/3.0/ + * Modifiication: added test code + */ + +/* + * Description: Uses a Base64 MIME implementation to check for regressions + in loops, array access, load/store, and string manipulation. + * Main Focus: General operations related to Base64 encoding/decoding. + * Secondary Focus: Array access, load/store, string manipulation. + * + */ + +package org.linaro.benchmarks.micro; + +import java.lang.IllegalArgumentException; +import java.lang.StringBuilder; +import java.lang.System; +import java.lang.Thread; +import java.util.Random; +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + +public class Base64 { + private static Random rnd = new Random(); + private static final int ENC_Length = 64; + private static final int NUM_Encodings = 16; + private static String[] randomStrings = new String[NUM_Encodings]; + private static String[] randomBase64 = new String[NUM_Encodings]; + private static String[] encodeResults = new String[NUM_Encodings]; + private static String[] decodeResults = new String[NUM_Encodings]; + private static final String codes = + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="; + private static char base64Pad = '='; + + static { + generateRandomStrings(); + generateRandomBase64(); + } + + private static void generateRandomStrings() { + for (int i = 0; i < NUM_Encodings; i++) { + StringBuilder sb = new StringBuilder(); + for (int j = 0; j < ENC_Length; j++) { + sb.append(Character.valueOf((char)rnd.nextInt())); + } + randomStrings[i] = sb.toString(); + } + } + + private static void generateRandomBase64() { + for (int i = 0; i < NUM_Encodings; i++) { + StringBuilder sb = new StringBuilder(); + for (int j = 0; j < ENC_Length; j++) { + sb.append(codes.charAt(rnd.nextInt(codes.length() - 1))); + } + randomBase64[i] = sb.toString(); + } + } + + private static String encode(String str) { + byte[] in = str.getBytes(); + StringBuffer out = new StringBuffer((in.length * 4) / 3); + int b; + for (int i = 0; i < in.length; i += 3) { + b = (in[i] & 0xFC) >> 2; + out.append(codes.charAt(b)); + b = (in[i] & 0x03) << 4; + if (i + 1 < in.length) { + b |= (in[i + 1] & 0xF0) >> 4; + out.append(codes.charAt(b)); + b = (in[i + 1] & 0x0F) << 2; + if (i + 2 < in.length) { + b |= (in[i + 2] & 0xC0) >> 6; + out.append(codes.charAt(b)); + b = in[i + 2] & 0x3F; + out.append(codes.charAt(b)); + } else { + out.append(codes.charAt(b)); + out.append('='); + } + } else { + out.append(codes.charAt(b)); + out.append("=="); + } + } + + return out.toString(); + } + + private static byte[] decode(String input) { + if (input.length() % 4 != 0) { + System.err.println("Invalid base64 input"); + return null; + } + int eqPos = input.indexOf('='); + int len = input.length(); + byte[] decoded = + new byte[((len * 3) / 4) - (eqPos > 0 ? (len - eqPos) : 0)]; + char[] inChars = input.toCharArray(); + int j = 0; + int[] b = new int[4]; + for (int i = 0; i < inChars.length; i += 4) { + b[0] = codes.indexOf(inChars[i]); + b[1] = codes.indexOf(inChars[i + 1]); + b[2] = codes.indexOf(inChars[i + 2]); + b[3] = codes.indexOf(inChars[i + 3]); + decoded[j++] = (byte) ((b[0] << 2) | (b[1] >> 4)); + if (b[2] < 64) { + decoded[j++] = (byte) ((b[1] << 4) | (b[2] >> 2)); + if (b[3] < 64) { + decoded[j++] = (byte) ((b[2] << 6) | b[3]); + } + } + } + return decoded; + } + + @Benchmark + public void jmhTimeEncode() { + for (int j = 0; j < NUM_Encodings; j++) { + encodeResults[j] = encode(randomStrings[j]); + } + } + + @Benchmark + public void jmhTimeDecode() { + for (int j = 0; j < NUM_Encodings; j++) { + decodeResults[j] = new String(decode(randomBase64[j])); + } + } +} diff --git a/src/main/java/org/linaro/benchmarks/micro/BitfieldRotate.java b/src/main/java/org/linaro/benchmarks/micro/BitfieldRotate.java new file mode 100644 index 0000000..f3185da --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/micro/BitfieldRotate.java @@ -0,0 +1,302 @@ +/* + * Copyright (c) 2000-2015 The Legion of the Bouncy Castle Inc. (http://www.bouncycastle.org) + * + * Modifications copyright (c) 2015 Linaro Limited. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and + * associated documentation files (the "Software"), to deal in the Software without restriction, + * including without limitation the rights to use, copy, modify, merge, publish, distribute, + * sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all copies or + * substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING + * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +/* + * Description: Check for regressions effecting Bouncy Castle SHA1Digest processing. + * Main Focus: Bitfield rotations. + * Secondary Focus: Loop optimizations. + */ + +package org.linaro.benchmarks.micro; + +import java.nio.ByteBuffer; +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.NANOSECONDS) +@State(Scope.Benchmark) + +public class BitfieldRotate { + private static final String SOURCE_Text = "That though I loved them for their faults\n" + + "As much as for their good,\n" + + "My friends were enemies on stilts\n" + + "With their heads in a cunning cloud.\n"; + + private int h1; + private int h2; + private int h3; + private int h4; + private int h5; + private int[] x = new int[80]; + private int xOff; + + // + // Additive constants + // + private static final int y1 = 0x5a827999; + private static final int y2 = 0x6ed9eba1; + private static final int y3 = 0x8f1bbcdc; + private static final int y4 = 0xca62c1d6; + + private int ffunc( + int u, + int v, + int w) { + return ((u & v) | ((~u) & w)); + } + + private int hfunc( + int u, + int v, + int w) { + return (u ^ v ^ w); + } + + private int gfunc( + int u, + int v, + int w) { + return ((u & v) | (u & w) | (v & w)); + } + + protected void processBlock() { + // + // expand 16 word block into 80 word block. + // + for (int i = 16; i < 80; i++) { + int t = x[i - 3] ^ x[i - 8] ^ x[i - 14] ^ x[i - 16]; + x[i] = t << 1 | t >>> 31; + } + + // + // set up working variables. + // + int a = h1; + int b = h2; + int c = h3; + int d = h4; + int e = h5; + + // + // round 1 + // + int idx = 0; + + for (int j = 0; j < 4; j++) { + // E = rotateLeft(a, 5) + ffunc(b, c, d) + E + x[idx++] + y1 + // B = rotateLeft(b, 30) + e += (a << 5 | a >>> 27) + ffunc(b, c, d) + x[idx++] + y1; + b = b << 30 | b >>> 2; + + d += (e << 5 | e >>> 27) + ffunc(a, b, c) + x[idx++] + y1; + a = a << 30 | a >>> 2; + + c += (d << 5 | d >>> 27) + ffunc(e, a, b) + x[idx++] + y1; + e = e << 30 | e >>> 2; + + b += (c << 5 | c >>> 27) + ffunc(d, e, a) + x[idx++] + y1; + d = d << 30 | d >>> 2; + + a += (b << 5 | b >>> 27) + ffunc(c, d, e) + x[idx++] + y1; + c = c << 30 | c >>> 2; + } + + // + // round 2 + // + for (int j = 0; j < 4; j++) { + // E = rotateLeft(a, 5) + hfunc(b, c, d) + E + x[idx++] + y2 + // B = rotateLeft(b, 30) + e += (a << 5 | a >>> 27) + hfunc(b, c, d) + x[idx++] + y2; + b = b << 30 | b >>> 2; + + d += (e << 5 | e >>> 27) + hfunc(a, b, c) + x[idx++] + y2; + a = a << 30 | a >>> 2; + + c += (d << 5 | d >>> 27) + hfunc(e, a, b) + x[idx++] + y2; + e = e << 30 | e >>> 2; + + b += (c << 5 | c >>> 27) + hfunc(d, e, a) + x[idx++] + y2; + d = d << 30 | d >>> 2; + + a += (b << 5 | b >>> 27) + hfunc(c, d, e) + x[idx++] + y2; + c = c << 30 | c >>> 2; + } + + // + // round 3 + // + for (int j = 0; j < 4; j++) { + // E = rotateLeft(a, 5) + gfunc(b, c, d) + E + x[idx++] + y3 + // B = rotateLeft(b, 30) + e += (a << 5 | a >>> 27) + gfunc(b, c, d) + x[idx++] + y3; + b = b << 30 | b >>> 2; + + d += (e << 5 | e >>> 27) + gfunc(a, b, c) + x[idx++] + y3; + a = a << 30 | a >>> 2; + + c += (d << 5 | d >>> 27) + gfunc(e, a, b) + x[idx++] + y3; + e = e << 30 | e >>> 2; + + b += (c << 5 | c >>> 27) + gfunc(d, e, a) + x[idx++] + y3; + d = d << 30 | d >>> 2; + + a += (b << 5 | b >>> 27) + gfunc(c, d, e) + x[idx++] + y3; + c = c << 30 | c >>> 2; + } + + // + // round 4 + // + for (int j = 0; j <= 3; j++) { + // E = rotateLeft(a, 5) + hfunc(b, c, d) + E + x[idx++] + y4 + // B = rotateLeft(b, 30) + e += (a << 5 | a >>> 27) + hfunc(b, c, d) + x[idx++] + y4; + b = b << 30 | b >>> 2; + + d += (e << 5 | e >>> 27) + hfunc(a, b, c) + x[idx++] + y4; + a = a << 30 | a >>> 2; + + c += (d << 5 | d >>> 27) + hfunc(e, a, b) + x[idx++] + y4; + e = e << 30 | e >>> 2; + + b += (c << 5 | c >>> 27) + hfunc(d, e, a) + x[idx++] + y4; + d = d << 30 | d >>> 2; + + a += (b << 5 | b >>> 27) + hfunc(c, d, e) + x[idx++] + y4; + c = c << 30 | c >>> 2; + } + + h1 += a; + h2 += b; + h3 += c; + h4 += d; + h5 += e; + + // + // reset start of the buffer. + // + xOff = 0; + for (int i = 0; i < 16; i++) { + x[i] = 0; + } + } + + @Benchmark + public void jmhTimeSHA1DigestProcessBlock() { + h1 = h2 = h3 = h4 = h5 = 0; + processBlock(); + } + + /** + * Integer rotate right patterns. + */ + + int resultIntegerRightRegVCSubV; + int resultIntegerRightRegVNegV; + + public static int rotateIntegerRightRegVCSubV(int value, int distance) { + return (value >>> distance) | (value << (32 - distance)); + } + + public static int rotateIntegerRightRegVNegV(int value, int distance) { + return (value >>> distance) | (value << -distance); + } + + @Benchmark + public void jmhTimeIntegerRotateRight() { + for (int distance = 0; distance < Integer.SIZE; distance++) { + resultIntegerRightRegVCSubV += rotateIntegerRightRegVCSubV(0xCAFEBABE, distance); + resultIntegerRightRegVNegV += rotateIntegerRightRegVNegV(0xCAFEBABE, distance); + } + } + + /** + * Integer rotate left patterns. + */ + + int resultIntegerLeftRegCSubVV; + int resultIntegerLeftRegNegVV; + + public static int rotateIntegerLeftRegCSubVV(int value, int distance) { + return (value >>> (32 - distance)) | (value << distance); + } + + public static int rotateIntegerLeftRegNegVV(int value, int distance) { + return (value >>> -distance) | (value << distance); + } + + @Benchmark + public void jmhTimeIntegerRotateLeft() { + for (int distance = 0; distance < Integer.SIZE; distance++) { + resultIntegerLeftRegCSubVV += rotateIntegerLeftRegCSubVV(0xCAFEBABE, distance); + resultIntegerLeftRegNegVV += rotateIntegerLeftRegNegVV(0xCAFEBABE, distance); + } + } + + /** + * Long rotate right patterns. + */ + + int resultLongRightRegVCSubV; + int resultLongRightRegVNegV; + + public static long rotateLongRightRegVCSubV(long value, int distance) { + return (value >>> distance) | (value << (64 - distance)); + } + + public static long rotateLongRightRegVNegV(long value, int distance) { + return (value >>> distance) | (value << -distance); + } + + @Benchmark + public void jmhTimeLongRotateRight() { + for (int distance = 0; distance < Long.SIZE; distance++) { + resultLongRightRegVCSubV += rotateLongRightRegVCSubV(0xCAFEBABEBAADF00DL, distance); + resultLongRightRegVNegV += rotateLongRightRegVNegV(0xCAFEBABEBAADF00DL, distance); + } + } + + /** + * Long rotate left patterns. + */ + + int resultLongLeftRegCSubVV; + int resultLongLeftRegNegVV; + + public static long rotateLongLeftRegCSubVV(long value, int distance) { + return (value >>> (64 - distance)) | (value << distance); + } + + public static long rotateLongLeftRegNegVV(long value, int distance) { + return (value >>> -distance) | (value << distance); + } + + @Benchmark + public void jmhTimeLongRotateLeft() { + for (int distance = 0; distance < Long.SIZE; distance++) { + resultLongLeftRegCSubVV += rotateLongLeftRegCSubVV(0xCAFEBABEBAADF00DL, distance); + resultLongLeftRegNegVV += rotateLongLeftRegNegVV(0xCAFEBABEBAADF00DL, distance); + } + } +} + diff --git a/src/main/java/org/linaro/benchmarks/micro/ControlFlowRecursive.java b/src/main/java/org/linaro/benchmarks/micro/ControlFlowRecursive.java new file mode 100644 index 0000000..26b4bf9 --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/micro/ControlFlowRecursive.java @@ -0,0 +1,84 @@ +/* + * Copyright (c) 2015, Linaro Limited. Ported to Java from: + * https://github.com/WebKit/webkit/blob/master/PerformanceTests/SunSpider/tests/sunspider-1.0.2/controlflow-recursive.js + * and added Tarai. + * + * Description: A control flow recursive micro benchmark case. + */ + + +// The Computer Language Shootout +// http://shootout.alioth.debian.org/ +// contributed by Isaac Gouy + +// http://benchmarksgame.alioth.debian.org/license.html (BSD 3-clause license) +// See NOTICE file for license. + +package org.linaro.benchmarks.micro; + +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + +public class ControlFlowRecursive { + private int result = 0; + private final int expected = 57775; + + private int ack(int m, int n) { + if (m == 0) { + return n + 1; + } + if (n == 0) { + return ack(m - 1, 1); + } + return ack(m - 1, ack(m, n - 1)); + } + + private int fib(int n) { + if (n < 2) { + return 1; + } + return fib(n - 2) + fib(n - 1); + } + + private int tak(int x, int y, int z) { + if (y >= x) { + return z; + } + return tak(tak(x - 1, y, z), tak(y - 1, z, x), tak(z - 1, x, y)); + } + + private int tarai(int x, int y, int z) { + if (y >= x) { + return y; + } + return tarai(tarai(x - 1, y, z), tarai(y - 1, z, x), tarai(z - 1, x, y)); + } + + @Benchmark + public void jmhTimeTak() { + for (int i = 3; i <= 5; i++) { + tak(3 * i + 3, 2 * i + 2, i + 1); + } + } + + @Benchmark + public void jmhTimeTarai() { + for (int i = 3; i <= 5; i++) { + tarai(3 * i + 3, 2 * i + 2, i + 1); + } + } + + @Benchmark + public void jmhTimeControlFlowRecursive() { + result = 0; + for (int i = 3; i <= 5; i++) { + result += ack(3, i); + result += fib(17 + i); + result += tak(3 * i + 3, 2 * i + 2, i + 1); + } + } +} diff --git a/src/main/java/org/linaro/benchmarks/micro/Exceptions.java b/src/main/java/org/linaro/benchmarks/micro/Exceptions.java new file mode 100644 index 0000000..3150f42 --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/micro/Exceptions.java @@ -0,0 +1,118 @@ +/* + * Copyright (C) 2016 Linaro Limited. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +/* + * Description: Exceptions code utilization. + * Main Focus: + * + */ + +package org.linaro.benchmarks.micro; + +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + +public class Exceptions { + + private final int SIZE = 10; + private int[] smallArray = new int[SIZE]; + private static final int ARITHM_DOUBLE_ITERS = 20000; + + /** + * Three following examples do the same arithmetics on double, but + * - arithmDouble: just does calculations + * - arirhmDoubleException: does calculations but has a try-catch which never fires. + * - arirhmDoubleExceptionFires: does calculations but has a try-catch which always fires. + */ + private int arithmDoubleExceptionFires(int n) { + double x = 1.0 * (double)n; + double y = 2.0 * (double)n; + double z = 3.0 * (double)n; + double expr = 0.0; + int a = 0; + + for (int i = 0; i < ARITHM_DOUBLE_ITERS; i++) { + expr += x + y + z * x + y * y + x * z; + try { + a += smallArray[i%SIZE + 5]; + smallArray[i%SIZE + 5] += a; + } catch (Exception e) { + a--; + } + } + + return (int)expr + a + (int)x + (int)y + (int)z; + } + + private int arithmDoubleException(int n) { + double x = 1.0 * (double)n; + double y = 2.0 * (double)n; + double z = 3.0 * (double)n; + double expr = 0.0; + int a = 0; + + for (int i = 0; i < ARITHM_DOUBLE_ITERS; i++) { + expr += x + y + z * x + y * y + x * z; + try { + a += smallArray[i%SIZE]; + smallArray[i%SIZE] += a; + } catch (Exception e) { + a--; + } + } + + return (int)expr + a + (int)x + (int)y + (int)z; + } + + private int arithmDouble(int n) { + double x = 1.0 * (double)n; + double y = 2.0 * (double)n; + double z = 3.0 * (double)n; + double expr = 0.0; + int a = 0; + + for (int i = 0; i < ARITHM_DOUBLE_ITERS; i++) { + expr += x + y + z * x + y * y + x * z; + a += smallArray[i%SIZE]; + smallArray[i%SIZE] += a; + } + + return (int)expr + a + (int)x + (int)y + (int)z; + } + + @Benchmark + public void jmhTimeArithmDoubleException() { + //TODO (jmh) Following art-testing, use current iteration as arithmDoubleException's arg instead of 10. + arithmDoubleException(10); + } + + @Benchmark + public void jmhTimeArithmDoubleExceptionFires() { + //TODO (jmh) Following art-testing, use current iteration as arithmDoubleException's arg instead of 20. + arithmDoubleExceptionFires(20); + } + + @Benchmark + public void jmhTimeArithmDouble() { + //TODO (jmh) Following art-testing, use current iteration as arithmDoubleException's arg instead of 30. + arithmDouble(30); + } +} diff --git a/src/main/java/org/linaro/benchmarks/micro/HashMapBench.java b/src/main/java/org/linaro/benchmarks/micro/HashMapBench.java new file mode 100644 index 0000000..02ffe14 --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/micro/HashMapBench.java @@ -0,0 +1,101 @@ +/* + * Copyright (c) 2015, Linaro Limited. Ported to Java from: + * http://browserbench.org/JetStream/sources/hash-map.js + * + * Description: A benchmark case for hash map + */ + +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE below for additional + * information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/******* NOTICE ********* + + Apache Harmony + Copyright 2006, 2010 The Apache Software Foundation. + + This product includes software developed at + The Apache Software Foundation (http://www.apache.org/). + + Portions of Apache Harmony were originally developed by + Intel Corporation and are licensed to the Apache Software + Foundation under the "Software Grant and Corporate Contribution + License Agreement" and for which the following copyright notices + apply + (C) Copyright 2005 Intel Corporation + (C) Copyright 2005-2006 Intel Corporation + (C) Copyright 2006 Intel Corporation + + + The following copyright notice(s) were affixed to portions of the code + with which this file is now or was at one time distributed + and are placed here unaltered. + + (C) Copyright 1997,2004 International Business Machines Corporation. + All rights reserved. + + (C) Copyright IBM Corp. 2003. + + + This software contains code derived from UNIX V7, Copyright(C) + Caldera International Inc. + + ************************/ + +package org.linaro.benchmarks.micro; + +import java.util.HashMap; +import java.util.Map; +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + +public class HashMapBench { + + private static final int COUNT = 5000; + private static final int resultExpect = 1050000; + private static final long keySumExpect = 12497500; + private static final int valueSumExpect = 210000; + private int result = 0; + private long keySum = 0; + private int valueSum = 0; + + private Map<Integer, Integer> map = new HashMap<Integer, Integer>(); + + @Benchmark + public void jmhTimeTestHashMap() { + for (int j = 0; j < COUNT; j++) { + map.put(j, 42); + } + + result = 0; + for (int k = 0; k < 5; k++) { + for (int j = 0; j < COUNT; j++) { + result += map.get(j); + } + } + + keySum = 0; + valueSum = 0; + for (Map.Entry<Integer, Integer> entry : map.entrySet()) { + keySum += entry.getKey(); + valueSum += entry.getValue(); + } + } +} diff --git a/src/main/java/org/linaro/benchmarks/micro/PrefetchLoopedArrayAccess.java b/src/main/java/org/linaro/benchmarks/micro/PrefetchLoopedArrayAccess.java new file mode 100644 index 0000000..d70a20a --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/micro/PrefetchLoopedArrayAccess.java @@ -0,0 +1,78 @@ +/* + * Copyright (C) 2015 Linaro Limited. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +/* + * Description: Tracks performance of looped array access to Java Objects. + * BitSet is an arbitrary choice. 1024 pool and update list + * sizes showed benefits when prefetching 8 references ahead + * during looped array access. Other benchmarks for different + * and mixed Object sizes would be beneficial. + * Main Focus: Looped array access to semi-random memory access patterns. + * Secondary Focus: + * + */ + +package org.linaro.benchmarks.micro; + +import java.util.BitSet; +import java.util.Random; +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + +public class PrefetchLoopedArrayAccess { + + private static final Random rnd = new Random(0); + private static final int POOL_Size = 1024; + private static final int UPDATE_Size = 1024; + + private BitSet[] bits; + private BitSet[] updateList; + + { + initBitSets(); + initUpdateList(); + } + + private void initUpdateList() { + updateList = new BitSet[UPDATE_Size]; + for (int i = 0; i < UPDATE_Size; i++) { + updateList[i] = bits[rnd.nextInt(POOL_Size)]; + } + } + + private void initBitSets() { + bits = new BitSet[POOL_Size]; + for (int i = 0; i < POOL_Size; i++) { + bits[i] = new BitSet(); + } + } + + private void updateBitSets() { + for (int i = 0; i < UPDATE_Size; i++) { + updateList[i].set(7); + } + } + + @Benchmark + public void jmhTimeRun() { + updateBitSets(); + } +} diff --git a/src/main/java/org/linaro/benchmarks/micro/ShifterOperand.java b/src/main/java/org/linaro/benchmarks/micro/ShifterOperand.java new file mode 100644 index 0000000..b29f551 --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/micro/ShifterOperand.java @@ -0,0 +1,548 @@ +/* + * Copyright (C) 2015 Linaro Limited. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +package org.linaro.benchmarks.micro; + +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.NANOSECONDS) +@State(Scope.Benchmark) + + +/* + * Description: Tests around binary operations taking shifts or type conversions + * as inputs that can be merged into the shifter operand. + * + * Main Focus: shifter operand + * + * Secondary Focus: instruction scheduling + * + * Some comments in this file assume that shift or extend operations are merged + * into the shifter operand of the binary operations using them. + */ + +// We declare many temporary local variables with similar names. Avoid the extra +// lines that would be required with one declaration per line. +// CHECKSTYLE.OFF: MultipleVariableDeclarations + +public class ShifterOperand { + + private static final int LOOP_SIZE = 32; + + @Benchmark + public static int jmhTimeIntSingleUseLatency1() { + int t1 = 0; + for (int iter = 0; iter < LOOP_SIZE; iter++) { + // Each bitfield operation has a single use. + // Results are used one instruction after being produced. + t1 |= iter >> 1; + t1 &= iter << 2; + t1 ^= iter >>> 3; + t1 += (byte)iter; + t1 -= (char)iter; + t1 += (short)iter; + } + return t1; + } + + // The `ThreadN` suffix indicates that the loop contains `N` independent + // computation threads that execute (almost exactly) the same thing. The + // multiple threads allow for instruction scheduling to kick in. + + @Benchmark + public static int jmhTimeIntSingleUseLatency1Thread2() { + int t1 = 0, t2 = 1; + for (int iter1 = 0, iter2 = 1; + iter1 < LOOP_SIZE; + iter1++, iter2++) { + // Each bitfield operation has a single use. + // Results are used one instruction after being produced. + // Computation thread 1. + t1 |= iter1 >> 1; + t1 &= iter1 << 2; + t1 ^= iter1 >>> 3; + t1 += (byte)iter1; + t1 -= (char)iter1; + t1 += (short)iter1; + // Computation thread 2. + t2 |= iter2 >> 1; + t2 &= iter2 << 2; + t2 ^= iter2 >>> 3; + t2 += (byte)iter2; + t2 -= (char)iter2; + t2 += (short)iter2; + } + return t1; + } + + @Benchmark + public static int jmhTimeIntSingleUseLatency1Thread3() { + int t1 = 0, t2 = 1, t3 = 2; + // Each bitfield operation has a single use. + // Results are used one instruction after being produced. + for (int iter1 = 0, iter2 = 1, iter3 = 2; + iter1 < LOOP_SIZE; + iter1++, iter2++, iter3++) { + // Computation thread 1. + t1 |= iter1 >> 1; + t1 &= iter1 << 2; + t1 ^= iter1 >>> 3; + t1 += (byte)iter1; + t1 -= (char)iter1; + t1 += (short)iter1; + // Computation thread 2. + t2 |= iter2 >> 1; + t2 &= iter2 << 2; + t2 ^= iter2 >>> 3; + t2 += (byte)iter2; + t2 -= (char)iter2; + t2 += (short)iter2; + // Computation thread 3. + t3 |= iter3 >> 1; + t3 &= iter3 << 2; + t3 ^= iter3 >>> 3; + t3 += (byte)iter3; + t3 -= (char)iter3; + t3 += (short)iter3; + } + return t1; + } + + @Benchmark + public static int jmhTimeIntSingleUseLatency1Thread4() { + int t1 = 0, t2 = 1, t3 = 2, t4 = 3; + // Each bitfield operation has a single use. + // Results are used one instruction after being produced. + + for (int iter1 = 0, iter2 = 1, iter3 = 2, iter4 = 3; + iter1 < LOOP_SIZE; + iter1++, iter2++, iter3++, iter4++) { + // Computation thread 1. + t1 |= iter1 >> 1; + t1 &= iter1 << 2; + t1 ^= iter1 >>> 3; + t1 += (byte)iter1; + t1 -= (char)iter1; + t1 += (short)iter1; + // Computation thread 2. + t2 |= iter2 >> 1; + t2 &= iter2 << 2; + t2 ^= iter2 >>> 3; + t2 += (byte)iter2; + t2 -= (char)iter2; + t2 += (short)iter2; + // Computation thread 3. + t3 |= iter3 >> 1; + t3 &= iter3 << 2; + t3 ^= iter3 >>> 3; + t3 += (byte)iter3; + t3 -= (char)iter3; + t3 += (short)iter3; + // Computation thread 4. + t4 |= iter4 >> 1; + t4 &= iter4 << 2; + t4 ^= iter4 >>> 3; + t4 += (byte)iter4; + t4 -= (char)iter4; + t4 += (short)iter4; + } + return t1; + } + + @Benchmark + public static int jmhTimeIntSingleUseLatency2() { + int t1 = 0, t2 = 0; + for (int iter = 0; iter < LOOP_SIZE; iter++) { + // Each bitfield operation has a single use. + // Results are used two instructions after being produced. + t1 |= iter >> 1; + t2 &= iter << 2; + t1 ^= iter >>> 3; + t2 += (byte)iter; + t1 -= (char)iter; + t2 += (short)iter; + } + return t1 | t2; + } + + @Benchmark + public static int jmhTimeIntSingleUseLatency3() { + int t1 = 0, t2 = 0, t3 = 0; + for (int iter = 0; iter < LOOP_SIZE; iter++) { + // Each bitfield operation has a single use. + // Results are used three instructions after being produced. + t1 |= iter >> 1; + t2 &= iter << 2; + t3 ^= iter >>> 3; + t1 += (byte)iter; + t2 -= (char)iter; + t3 += (short)iter; + } + return t1 | t2; + } + + @Benchmark + public static int jmhTimeIntSingleUseLatencyLoop() { + int t1 = 0, t2 = 0, t3 = 0, t4 = 0, t5 = 0, t6 = 0; + for (int iter = 0; iter < LOOP_SIZE; iter++) { + // Each bitfield operation has a single use. + // Results are only used in the next iteration of the loop. + t1 |= iter >> 1; + t2 &= iter << 2; + t3 ^= iter >>> 3; + t4 += (byte)iter; + t5 -= (char)iter; + t6 += (short)iter; + } + return t1 | t2 | t3 | t4 | t5 | t6; + } + + @Benchmark + public static long jmhTimeLongSingleUseLatency1() { + long t1 = 0; + for (long iter = 0; iter < LOOP_SIZE; iter++) { + // Each bitfield operation has a single use. + // Results are used one instruction after being produced. + t1 |= iter >> 1; + t1 &= iter << 2; + t1 ^= iter >>> 3; + t1 += (byte)iter; + t1 -= (char)iter; + t1 += (short)iter; + } + return t1; + } + + // The `ThreadN` suffix indicates that the loop contains `N` independent + // computation threads that execute (almost exactly) the same thing. The + // multiple threads allow for instruction scheduling to kick in. + @Benchmark + public static long jmhTimeLongSingleUseLatency1Thread2() { + long t1 = 0, t2 = 1; + for (long iter1 = 0, iter2 = 1; + iter1 < LOOP_SIZE; + iter1++, iter2++) { + // Each bitfield operation has a single use. + // Results are used one instruction after being produced. + // Computation thread 1. + t1 |= iter1 >> 1; + t1 &= iter1 << 2; + t1 ^= iter1 >>> 3; + t1 += (byte)iter1; + t1 -= (char)iter1; + t1 += (short)iter1; + // Computation thread 2. + t2 |= iter2 >> 1; + t2 &= iter2 << 2; + t2 ^= iter2 >>> 3; + t2 += (byte)iter2; + t2 -= (char)iter2; + t2 += (short)iter2; + } + return t1; + } + + @Benchmark + public static long jmhTimeLongSingleUseLatency1Thread3() { + long t1 = 0, t2 = 1, t3 = 2; + // Each bitfield operation has a single use. + // Results are used one instruction after being produced. + for (long iter1 = 0, iter2 = 1, iter3 = 2; + iter1 < LOOP_SIZE; + iter1++, iter2++, iter3++) { + // Computation thread 1. + t1 |= iter1 >> 1; + t1 &= iter1 << 2; + t1 ^= iter1 >>> 3; + t1 += (byte)iter1; + t1 -= (char)iter1; + t1 += (short)iter1; + // Computation thread 2. + t2 |= iter2 >> 1; + t2 &= iter2 << 2; + t2 ^= iter2 >>> 3; + t2 += (byte)iter2; + t2 -= (char)iter2; + t2 += (short)iter2; + // Computation thread 3. + t3 |= iter3 >> 1; + t3 &= iter3 << 2; + t3 ^= iter3 >>> 3; + t3 += (byte)iter3; + t3 -= (char)iter3; + t3 += (short)iter3; + } + return t1; + } + + @Benchmark + public static long jmhTimeLongSingleUseLatency1Thread4() { + long t1 = 0, t2 = 1, t3 = 2, t4 = 3; + // Each bitfield operation has a single use. + // Results are used one instruction after being produced. + + for (long iter1 = 0, iter2 = 1, iter3 = 2, iter4 = 3; + iter1 < LOOP_SIZE; + iter1++, iter2++, iter3++, iter4++) { + // Computation thread 1. + t1 |= iter1 >> 1; + t1 &= iter1 << 2; + t1 ^= iter1 >>> 3; + t1 += (byte)iter1; + t1 -= (char)iter1; + t1 += (short)iter1; + // Computation thread 2. + t2 |= iter2 >> 1; + t2 &= iter2 << 2; + t2 ^= iter2 >>> 3; + t2 += (byte)iter2; + t2 -= (char)iter2; + t2 += (short)iter2; + // Computation thread 3. + t3 |= iter3 >> 1; + t3 &= iter3 << 2; + t3 ^= iter3 >>> 3; + t3 += (byte)iter3; + t3 -= (char)iter3; + t3 += (short)iter3; + // Computation thread 4. + t4 |= iter4 >> 1; + t4 &= iter4 << 2; + t4 ^= iter4 >>> 3; + t4 += (byte)iter4; + t4 -= (char)iter4; + t4 += (short)iter4; + } + return t1; + } + + @Benchmark + public static long jmhTimeLongSingleUseLatency2() { + long t1 = 0, t2 = 0; + for (long iter = 0; iter < LOOP_SIZE; iter++) { + // Each bitfield operation has a single use. + // Results are used two instructions after being produced. + t1 |= iter >> 1; + t2 &= iter << 2; + t1 ^= iter >>> 3; + t2 += (byte)iter; + t1 -= (char)iter; + t2 += (short)iter; + } + return t1 | t2; + } + + @Benchmark + public static long jmhTimeLongSingleUseLatency3() { + long t1 = 0, t2 = 0, t3 = 0; + for (long iter = 0; iter < LOOP_SIZE; iter++) { + // Each bitfield operation has a single use. + // Results are used three instructions after being produced. + t1 |= iter >> 1; + t2 &= iter << 2; + t3 ^= iter >>> 3; + t1 += (byte)iter; + t2 -= (char)iter; + t3 += (short)iter; + } + return t1 | t2; + } + + @Benchmark + public static long jmhTimeLongSingleUseLatencyLoop() { + long t1 = 0, t2 = 0, t3 = 0, t4 = 0, t5 = 0, t6 = 0; + for (long iter = 0; iter < LOOP_SIZE; iter++) { + // Each bitfield operation has a single use. + // Results are only used in the next iteration of the loop. + t1 |= iter >> 1; + t2 &= iter << 2; + t3 ^= iter >>> 3; + t4 += (byte)iter; + t5 -= (char)iter; + t6 += (short)iter; + } + return t1 | t2 | t3 | t4 | t5 | t6; + } + + @Benchmark + public static int jmhTimeMultipleUsesDifferentPathInt() { + int res = 0; + for (int iter = 0; iter < LOOP_SIZE; iter++) { + // Each bitfield operation has two uses on different paths. + int temp1 = iter >> 1; + int temp2 = iter << 2; + int temp3 = iter >>> 3; + int temp4 = (byte)iter; + int temp5 = (char)iter; + int temp6 = (short)iter; + int temp7 = (int)iter; + // The condition is true most of the time, so the branch predictor should + // predict it correctly. + if (iter > 1) { + res += (((((temp1 | temp2) & temp3) ^ temp4) + temp5) - temp6) + temp7; + } else { + res += (((((temp1 + temp2) | temp3) & temp4) & temp5) + temp6) - temp7; + } + } + return res; + } + + @Benchmark + public static long jmhTimeMultipleUsesDifferentPathLong() { + long res = 0; + for (long iter = 0; iter < LOOP_SIZE; iter++) { + // Each bitfield operation has two uses on different paths. + long temp1 = iter >> 1; + long temp2 = iter << 2; + long temp3 = iter >>> 3; + long temp4 = (byte)iter; + long temp5 = (char)iter; + long temp6 = (short)iter; + long temp7 = (int)iter; + // The condition is true most of the time, so the branch predictor should + // predict it correctly. + if (iter > 1) { + res += (((((temp1 | temp2) & temp3) ^ temp4) + temp5) - temp6) + temp7; + } else { + res += (((((temp1 + temp2) | temp3) & temp4) & temp5) + temp6) - temp7; + } + } + return res; + } + + @Benchmark + public static int jmhTimeMultipleSuccessiveUsesSamePathInt() { + int res = 0; + for (int iter = 0; iter < LOOP_SIZE; iter++) { + // Each bitfield operation has two successive uses on the same path. + int temp1 = iter >> 1; + res += temp1; + res += temp1; + int temp2 = iter << 2; + res += temp2; + res += temp2; + int temp3 = iter >>> 3; + res += temp3; + res += temp3; + int temp4 = (byte)iter; + res += temp4; + res += temp4; + int temp5 = (char)iter; + res += temp5; + res += temp5; + int temp6 = (short)iter; + res += temp6; + res += temp6; + int temp7 = (int)iter; + res += temp7; + res += temp7; + } + return res; + } + + @Benchmark + public static long jmhTimeMultipleSuccessiveUsesSamePathLong() { + long res = 0; + for (long iter = 0; iter < LOOP_SIZE; iter++) { + // Each bitfield operation has two successive uses on the same path. + long temp1 = iter >> 1; + res += temp1; + res += temp1; + long temp2 = iter << 2; + res += temp2; + res += temp2; + long temp3 = iter >>> 3; + res += temp3; + res += temp3; + long temp4 = (byte)iter; + res += temp4; + res += temp4; + long temp5 = (char)iter; + res += temp5; + res += temp5; + long temp6 = (short)iter; + res += temp6; + res += temp6; + long temp7 = (int)iter; + res += temp7; + res += temp7; + } + return res; + } + + @Benchmark + public static int jmhTimeMultipleSeparatedUsesSamePathInt() { + int res = 0; + for (int iter = 0; iter < LOOP_SIZE; iter++) { + // Each bitfield operation has two separated uses on the same path. + int temp1 = iter >> 1; + res += temp1; + int temp2 = iter << 2; + res += temp2; + res += temp1; + int temp3 = iter >>> 3; + res += temp3; + res += temp2; + int temp4 = (byte)iter; + res += temp4; + res += temp3; + int temp5 = (char)iter; + res += temp5; + res += temp4; + int temp6 = (short)iter; + res += temp6; + res += temp5; + int temp7 = (int)iter; + res += temp7; + res += temp6; + res += temp7; + } + return res; + } + + @Benchmark + public static long jmhTimeMultipleSeparatedUsesSamePathLong() { + long res = 0; + for (long iter = 0; iter < LOOP_SIZE; iter++) { + // Each bitfield operation has two separated uses on the same path. + long temp1 = iter >> 1; + res += temp1; + long temp2 = iter << 2; + res += temp2; + res += temp1; + long temp3 = iter >>> 3; + res += temp3; + res += temp2; + long temp4 = (byte)iter; + res += temp4; + res += temp3; + long temp5 = (char)iter; + res += temp5; + res += temp4; + long temp6 = (short)iter; + res += temp6; + res += temp5; + long temp7 = (int)iter; + res += temp7; + res += temp6; + res += temp7; + } + return res; + } +} diff --git a/src/main/java/org/linaro/benchmarks/micro/StringEquals.java b/src/main/java/org/linaro/benchmarks/micro/StringEquals.java new file mode 100644 index 0000000..e0dbc72 --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/micro/StringEquals.java @@ -0,0 +1,73 @@ +/* + * Copyright (C) 2015 Linaro Limited. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +/* + * Description: Tracks performance of String.equals when working with + * cache-limiting amounts of character data. Some prefetch + * hint investigations have shown a performance gain here. + * Main Focus: Comparison of many, very large (re: L1 cache) strings. + * Secondary Focus: + * + */ + +/* + * TODO: Test various sizes of strings. + * TODO: Benchmark other cases, like comparing strings of different + * sizes together (probably the most command case), or similar + * strings that have a run of equal characters to begin with. + */ + +package org.linaro.benchmarks.micro; + +import java.lang.StringBuilder; +import java.util.Random; +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + +public class StringEquals { + private static Random rnd = new Random(0); + private static final int NUM_Equals = 1024; + private static final int STR_Length = 512; + private static String[] randomStrings = new String[NUM_Equals]; + private static Boolean[] equalsResults = new Boolean[NUM_Equals - 1]; + + @Setup + public void setup() { + generateRandomStrings(); + } + + private static void generateRandomStrings() { + for (int i = 0; i < NUM_Equals; i++) { + StringBuilder sb = new StringBuilder(); + for (int j = 0; j < STR_Length; j++) { + sb.append(Character.valueOf((char)(rnd.nextInt(25) + 65))); + } + randomStrings[i] = sb.toString(); + } + } + + @Benchmark + public void jmhTimeEquals() { + for (int j = 0; j < NUM_Equals - 1; j++) { + equalsResults[j] = randomStrings[j].equals(randomStrings[j + 1]); + } + } +} diff --git a/src/main/java/org/linaro/benchmarks/micro/StringOps.java b/src/main/java/org/linaro/benchmarks/micro/StringOps.java new file mode 100644 index 0000000..5851c36 --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/micro/StringOps.java @@ -0,0 +1,425 @@ +/* + * Copyright (C) 2016 Linaro Limited. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +/* + * Description: Tracks performance of String intrinsics, Java, and native methods. + * Main Focus: Looped memory compare. + * Secondary Focus: Array access. + * + */ + +package org.linaro.benchmarks.micro; + +import java.lang.StringBuilder; +import java.lang.System; +import java.util.Random; +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.NANOSECONDS) +@State(Scope.Benchmark) + +public class StringOps { + + private static int RANDOM_STRING_8 = 0; + private static int RANDOM_STRING_16 = 1; + private static int RANDOM_STRING_32 = 2; + private static int RANDOM_STRING_128 = 3; + private static int RANDOM_STRING_512 = 4; + private static int NUM_LENGTH_TESTS = 5; + + private static char MIN_RANDOM_CHAR = 65; + private static char MAX_RANDOM_CHAR = 123; + private static char searchChar; + + /* Intentionally use the same seed each time for consistency across benchmark runs. */ + private static int SAME_SEED = 0; + + /* Random string data. */ + private static Random rnd = new Random(SAME_SEED); + private static String[] stringData = new String[NUM_LENGTH_TESTS]; + + /* Same random string data as above for comparing different instances of the same char data. */ + private static Random rndAlt = new Random(SAME_SEED); + private static String[] stringDataAlt = new String[NUM_LENGTH_TESTS]; + + /* Benchmark results cache for preventing DCE. */ + private static boolean[] stringEqualsResults = new boolean[NUM_LENGTH_TESTS]; + private static boolean[] stringEqualsIgnoreCaseResults = new boolean[NUM_LENGTH_TESTS]; + private static boolean[] stringContentEqualsResults = new boolean[NUM_LENGTH_TESTS]; + private static int[] stringCompareToResults = new int[NUM_LENGTH_TESTS]; + private static int[] stringCompareToIgnoreCaseResults = new int[NUM_LENGTH_TESTS]; + private static boolean[] stringRegionMatchesResults = new boolean[NUM_LENGTH_TESTS]; + private static boolean[] stringRegionMatchesIgnoreCaseResults = new boolean[NUM_LENGTH_TESTS]; + private static char stringCharAtResult; + private static int stringIndexOfResult; + private static int stringIndexOfAfterResult; + private static String[] stringNewStringFromBytesResult = new String[NUM_LENGTH_TESTS]; + private static String[] stringNewStringFromCharsResult = new String[NUM_LENGTH_TESTS]; + private static String[] stringNewStringFromStringResult = new String[NUM_LENGTH_TESTS]; + private static String[] stringGetCharsNoCheckResult = new String[NUM_LENGTH_TESTS]; + + private static char []chars_8 = new char[8]; + private static char []chars_16 = new char[16]; + private static char []chars_32 = new char[32]; + private static char []chars_128 = new char[128]; + private static char []chars_512 = new char[512]; + + private static String generateRandomString(int len, Random rnd) { + StringBuilder sb = new StringBuilder(); + for (int i = 0; i < len - 1; i++) { + /* Compose random string data from upper and lower case english alphabet entries plus a few + * harmless characters in-between. */ + sb.append(Character.valueOf((char)(MIN_RANDOM_CHAR + + rnd.nextInt(MAX_RANDOM_CHAR - MIN_RANDOM_CHAR)))); + } + sb.append(Character.valueOf(MAX_RANDOM_CHAR)); + return sb.toString(); + } + + private static void generateRandomStrings(Random rnd, String[] output) { + output[RANDOM_STRING_8] = generateRandomString(8, rnd); + output[RANDOM_STRING_16] = generateRandomString(16, rnd); + output[RANDOM_STRING_32] = generateRandomString(32, rnd); + output[RANDOM_STRING_128] = generateRandomString(128, rnd); + output[RANDOM_STRING_512] = generateRandomString(512, rnd); + } + + static { + searchChar = MAX_RANDOM_CHAR; + generateRandomStrings(rnd, stringData); + generateRandomStrings(rndAlt, stringDataAlt); + } + + /** + * String.equals + */ + + @Benchmark + public void jmhTimeStringEqualsSmall() { + stringEqualsResults[RANDOM_STRING_8] + ^= stringData[RANDOM_STRING_8].equals(stringDataAlt[RANDOM_STRING_8]); + stringEqualsResults[RANDOM_STRING_16] + ^= stringData[RANDOM_STRING_16].equals(stringDataAlt[RANDOM_STRING_16]); + stringEqualsResults[RANDOM_STRING_32] + ^= stringData[RANDOM_STRING_32].equals(stringDataAlt[RANDOM_STRING_32]); + } + + @Benchmark + public void jmhTimeStringEqualsLarge() { + stringEqualsResults[RANDOM_STRING_128] + ^= stringData[RANDOM_STRING_128].equals(stringDataAlt[RANDOM_STRING_128]); + stringEqualsResults[RANDOM_STRING_512] + ^= stringData[RANDOM_STRING_512].equals(stringDataAlt[RANDOM_STRING_512]); + } + + /** + * String.equalsIgnoreCase + */ + + @Benchmark + public void jmhTimeStringEqualsIgnoreCaseSmall() { + stringEqualsIgnoreCaseResults[RANDOM_STRING_8] + ^= stringData[RANDOM_STRING_8].equalsIgnoreCase( + stringDataAlt[RANDOM_STRING_8]); + stringEqualsIgnoreCaseResults[RANDOM_STRING_16] + ^= stringData[RANDOM_STRING_16].equalsIgnoreCase( + stringDataAlt[RANDOM_STRING_16]); + stringEqualsIgnoreCaseResults[RANDOM_STRING_32] + ^= stringData[RANDOM_STRING_32].equalsIgnoreCase( + stringDataAlt[RANDOM_STRING_32]); + } + + @Benchmark + public void jmhTimeStringEqualsIgnoreCaseLarge() { + stringEqualsIgnoreCaseResults[RANDOM_STRING_128] + ^= stringData[RANDOM_STRING_128].equalsIgnoreCase( + stringDataAlt[RANDOM_STRING_128]); + stringEqualsIgnoreCaseResults[RANDOM_STRING_512] + ^= stringData[RANDOM_STRING_512].equalsIgnoreCase( + stringDataAlt[RANDOM_STRING_512]); + } + + /** + * String.contentEquals + */ + + @Benchmark + public void jmhTimeStringContentEqualsSmall() { + stringContentEqualsResults[RANDOM_STRING_8] + ^= stringData[RANDOM_STRING_8].contentEquals( + stringDataAlt[RANDOM_STRING_8]); + stringContentEqualsResults[RANDOM_STRING_16] + ^= stringData[RANDOM_STRING_16].contentEquals( + stringDataAlt[RANDOM_STRING_16]); + stringContentEqualsResults[RANDOM_STRING_32] + ^= stringData[RANDOM_STRING_32].contentEquals( + stringDataAlt[RANDOM_STRING_32]); + } + + @Benchmark + public void jmhTimeStringContentEqualsLarge() { + stringContentEqualsResults[RANDOM_STRING_128] + ^= stringData[RANDOM_STRING_128].contentEquals( + stringDataAlt[RANDOM_STRING_128]); + stringContentEqualsResults[RANDOM_STRING_512] + ^= stringData[RANDOM_STRING_512].contentEquals( + stringDataAlt[RANDOM_STRING_512]); + } + + /** + * String.compareTo + */ + + @Benchmark + public void jmhTimeStringCompareToSmall() { + stringCompareToResults[RANDOM_STRING_8] + += stringData[RANDOM_STRING_8].compareTo(stringDataAlt[RANDOM_STRING_8]); + stringCompareToResults[RANDOM_STRING_16] + += stringData[RANDOM_STRING_16].compareTo(stringDataAlt[RANDOM_STRING_16]); + stringCompareToResults[RANDOM_STRING_32] + += stringData[RANDOM_STRING_32].compareTo(stringDataAlt[RANDOM_STRING_32]); + } + + @Benchmark + public void jmhTimeStringCompareToLarge() { + stringCompareToResults[RANDOM_STRING_128] + += stringData[RANDOM_STRING_128].compareTo(stringDataAlt[RANDOM_STRING_128]); + stringCompareToResults[RANDOM_STRING_512] + += stringData[RANDOM_STRING_512].compareTo(stringDataAlt[RANDOM_STRING_512]); + } + + /** + * String.compareToIgnoreCase + */ + + @Benchmark + public void jmhTimeStringCompareToIgnoreCaseSmall() { + stringCompareToIgnoreCaseResults[RANDOM_STRING_8] + += stringData[RANDOM_STRING_8].compareToIgnoreCase( + stringDataAlt[RANDOM_STRING_8]); + stringCompareToIgnoreCaseResults[RANDOM_STRING_16] + += stringData[RANDOM_STRING_16].compareToIgnoreCase( + stringDataAlt[RANDOM_STRING_16]); + stringCompareToIgnoreCaseResults[RANDOM_STRING_32] + += stringData[RANDOM_STRING_32].compareToIgnoreCase( + stringDataAlt[RANDOM_STRING_32]); + } + + @Benchmark + public void jmhTimeStringCompareToIgnoreCaseLarge() { + stringCompareToIgnoreCaseResults[RANDOM_STRING_128] + += stringData[RANDOM_STRING_128].compareToIgnoreCase( + stringDataAlt[RANDOM_STRING_128]); + stringCompareToIgnoreCaseResults[RANDOM_STRING_512] + += stringData[RANDOM_STRING_512].compareToIgnoreCase( + stringDataAlt[RANDOM_STRING_512]); + } + + /** + * String.regionMatches + */ + + @Benchmark + public void jmhTimeStringRegionMatchesSmall() { + stringRegionMatchesResults[RANDOM_STRING_8] + ^= stringData[RANDOM_STRING_8].regionMatches( + 0, stringDataAlt[RANDOM_STRING_8], 0, 8); + stringRegionMatchesResults[RANDOM_STRING_16] + ^= stringData[RANDOM_STRING_16].regionMatches( + 0, stringDataAlt[RANDOM_STRING_16], 0, 16); + stringRegionMatchesResults[RANDOM_STRING_32] + ^= stringData[RANDOM_STRING_32].regionMatches( + 0, stringDataAlt[RANDOM_STRING_32], 0, 32); + } + + @Benchmark + public void jmhTimeStringRegionMatchesLarge() { + stringRegionMatchesResults[RANDOM_STRING_128] + ^= stringData[RANDOM_STRING_128].regionMatches( + 0, stringDataAlt[RANDOM_STRING_128], 0, 128); + stringRegionMatchesResults[RANDOM_STRING_512] + ^= stringData[RANDOM_STRING_512].regionMatches( + 0, stringDataAlt[RANDOM_STRING_512], 0, 512); + } + + /** + * String.regionMatches + */ + + @Benchmark + public void jmhTimeStringRegionMatchesIgnoreCaseSmall() { + stringRegionMatchesIgnoreCaseResults[RANDOM_STRING_8] + ^= stringData[RANDOM_STRING_8].regionMatches( + true, 0, stringDataAlt[RANDOM_STRING_8], 0, 8); + stringRegionMatchesIgnoreCaseResults[RANDOM_STRING_16] + ^= stringData[RANDOM_STRING_16].regionMatches( + true, 0, stringDataAlt[RANDOM_STRING_16], 0, 16); + stringRegionMatchesIgnoreCaseResults[RANDOM_STRING_32] + ^= stringData[RANDOM_STRING_32].regionMatches( + true, 0, stringDataAlt[RANDOM_STRING_32], 0, 32); + } + + @Benchmark + public void jmhTimeStringRegionMatchesIgnoreCaseLarge() { + stringRegionMatchesIgnoreCaseResults[RANDOM_STRING_128] + ^= stringData[RANDOM_STRING_128].regionMatches( + true, 0, stringDataAlt[RANDOM_STRING_128], 0, 128); + stringRegionMatchesIgnoreCaseResults[RANDOM_STRING_512] + ^= stringData[RANDOM_STRING_512].regionMatches( + true, 0, stringDataAlt[RANDOM_STRING_512], 0, 512); + } + + /** + * String.charAt + */ + + @Benchmark + public void jmhTimeStringCharAt() { + for (int j = 0; j < 512; j++) { + stringCharAtResult = stringData[RANDOM_STRING_512].charAt(j); + } + } + + /** + * String.indexOf + */ + + @Benchmark + public void jmhTimeStringIndexOfSmall() { + stringIndexOfResult += stringData[RANDOM_STRING_8].indexOf(searchChar); + stringIndexOfResult += stringData[RANDOM_STRING_16].indexOf(searchChar); + stringIndexOfResult += stringData[RANDOM_STRING_32].indexOf(searchChar); + } + + @Benchmark + public void jmhTimeStringIndexOfLarge() { + stringIndexOfResult += stringData[RANDOM_STRING_128].indexOf(searchChar); + stringIndexOfResult += stringData[RANDOM_STRING_512].indexOf(searchChar); + } + + /** + * String.indexOfAfter + */ + + @Benchmark + public void jmhTimeStringIndexOfAfterSmall() { + stringIndexOfAfterResult += stringData[RANDOM_STRING_8].indexOf(searchChar, 1); + stringIndexOfAfterResult += stringData[RANDOM_STRING_16].indexOf(searchChar, 1); + stringIndexOfAfterResult += stringData[RANDOM_STRING_32].indexOf(searchChar, 1); + } + + @Benchmark + public void jmhTimeStringIndexOfAfterLarge() { + stringIndexOfAfterResult += stringData[RANDOM_STRING_128].indexOf(searchChar, 1); + stringIndexOfAfterResult += stringData[RANDOM_STRING_512].indexOf(searchChar, 1); + } + + /** + * NewStringFromBytes + */ + + @Benchmark + public void jmhTimeStringNewStringFromBytesSmall() { + byte[] bytes = stringData[RANDOM_STRING_8].getBytes(); + stringNewStringFromBytesResult[RANDOM_STRING_8] = new String(bytes); + byte[] bytes2 = stringData[RANDOM_STRING_16].getBytes(); + stringNewStringFromBytesResult[RANDOM_STRING_16] = new String(bytes2); + byte[] bytes3 = stringData[RANDOM_STRING_32].getBytes(); + stringNewStringFromBytesResult[RANDOM_STRING_32] = new String(bytes3); + } + + @Benchmark + public void jmhTimeStringNewStringFromBytesLarge() { + byte[] bytes = stringData[RANDOM_STRING_128].getBytes(); + stringNewStringFromBytesResult[RANDOM_STRING_128] = new String(bytes); + byte[] bytes2 = stringData[RANDOM_STRING_512].getBytes(); + stringNewStringFromBytesResult[RANDOM_STRING_512] = new String(bytes2); + } + + /** + * NewStringFromChars + */ + + @Benchmark + public void jmhTimeStringNewStringFromCharsSmall() { + char[] chars = new char[8]; + stringData[RANDOM_STRING_8].getChars(0, 8, chars, 0); + stringNewStringFromCharsResult[RANDOM_STRING_8] = new String(chars); + char[] chars2 = new char[16]; + stringData[RANDOM_STRING_16].getChars(0, 16, chars2, 0); + stringNewStringFromCharsResult[RANDOM_STRING_16] = new String(chars2); + char[] chars3 = new char[32]; + stringData[RANDOM_STRING_32].getChars(0, 32, chars3, 0); + stringNewStringFromCharsResult[RANDOM_STRING_32] = new String(chars3); + } + + @Benchmark + public void jmhTimeStringNewStringFromCharsLarge() { + char[] chars = new char[128]; + stringData[RANDOM_STRING_128].getChars(0, 128, chars, 0); + stringNewStringFromCharsResult[RANDOM_STRING_128] = new String(chars); + char[] chars2 = new char[512]; + stringData[RANDOM_STRING_512].getChars(0, 512, chars2, 0); + stringNewStringFromCharsResult[RANDOM_STRING_512] = new String(chars2); + } + + /** + * NewStringFromString + */ + + @Benchmark + public void jmhTimeStringNewStringFromStringSmall() { + stringNewStringFromStringResult[RANDOM_STRING_8] = + new String(stringData[RANDOM_STRING_8]); + stringNewStringFromStringResult[RANDOM_STRING_16] = + new String(stringData[RANDOM_STRING_16]); + stringNewStringFromStringResult[RANDOM_STRING_32] = + new String(stringData[RANDOM_STRING_32]); + } + + @Benchmark + public void jmhTimeStringNewStringFromStringLarge() { + stringNewStringFromStringResult[RANDOM_STRING_128] = + new String(stringData[RANDOM_STRING_128]); + stringNewStringFromStringResult[RANDOM_STRING_512] = + new String(stringData[RANDOM_STRING_512]); + } + + /** + * String.getCharsNoCheck + */ + + @Benchmark + public void jmhTimeStringGetCharsNoCheckSmall() { + stringData[RANDOM_STRING_8].getChars(0, 8, chars_8, 0); + stringGetCharsNoCheckResult[RANDOM_STRING_8] = new String(chars_8); + stringData[RANDOM_STRING_16].getChars(0, 16, chars_16, 0); + stringGetCharsNoCheckResult[RANDOM_STRING_16] = new String(chars_16); + stringData[RANDOM_STRING_32].getChars(0, 32, chars_32, 0); + stringGetCharsNoCheckResult[RANDOM_STRING_32] = new String(chars_32); + } + + @Benchmark + public void jmhTimeStringGetCharsNoCheckLarge() { + stringData[RANDOM_STRING_128].getChars(0, 128, chars_128, 0); + stringGetCharsNoCheckResult[RANDOM_STRING_128] = new String(chars_128); + stringData[RANDOM_STRING_512].getChars(0, 512, chars_512, 0); + stringGetCharsNoCheckResult[RANDOM_STRING_512] = new String(chars_512); + } +} diff --git a/src/main/java/org/linaro/benchmarks/micro/SystemArrayCopy.java b/src/main/java/org/linaro/benchmarks/micro/SystemArrayCopy.java new file mode 100644 index 0000000..230bd4b --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/micro/SystemArrayCopy.java @@ -0,0 +1,115 @@ +/* + * Copyright (C) 2016 Linaro Limited. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +/* + * Description: Tracks performance of System.arraycopy intrinsics. + * Main Focus: Looped load store for varying copy lengths. + * Secondary Focus: + * + */ + +package org.linaro.benchmarks.micro; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.StringReader; +import java.lang.StringBuilder; +import java.lang.System; +import java.util.Random; +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.NANOSECONDS) +@State(Scope.Benchmark) + +public class SystemArrayCopy { + + private static Random rnd = new Random(); + private static int ARRAY_COPY_SMALL = 16; + private static int ARRAY_COPY_MEDIUM = 128; + private static int ARRAY_COPY_LARGE = 1024; + private static int MAX_BUFFER_BYTES = 8192; + private static int ARRAY_LENGTH = 1024; + private static String RANDOM_STRING = generateRandomString(MAX_BUFFER_BYTES); + private static char[] cbuf = new char[MAX_BUFFER_BYTES]; + private static char arrayCopyCharBufferedReadSmallResult; + private static char arrayCopyCharBufferedReadMediumResult; + private static char arrayCopyCharBufferedReadLargeResult; + + private static String[] stringArray = new String[ARRAY_LENGTH]; + private static String[] stringArraySmall = new String[ARRAY_LENGTH]; + private static String[] stringArrayMedium = new String[ARRAY_LENGTH]; + private static String[] stringArrayLarge = new String[ARRAY_LENGTH]; + + private static String generateRandomString(int sz) { + StringBuilder sb = new StringBuilder(); + for (int i = 0; i < sz; i++) { + sb.append(Character.valueOf((char)rnd.nextInt())); + } + return sb.toString(); + } + + static { + for (int i = 0; i < ARRAY_LENGTH; i++) { + stringArray[i] = String.valueOf(i); + } + } + + private void bufferedReadLoop(char[] cbuf, int copyLength) throws IOException { + BufferedReader reader = new BufferedReader(new StringReader(RANDOM_STRING)); + int offset = 0; + String s; + /* Read 16Kb RANDOM_STRING in chunks of copyLength chars until EOF */ + while (offset < MAX_BUFFER_BYTES && (reader.read(cbuf, offset, copyLength)) != -1) { + offset += copyLength; + } + } + + @Benchmark + public void jmhTimeArrayCopyCharBufferedReadSmall() throws IOException { + bufferedReadLoop(cbuf, ARRAY_COPY_SMALL); + arrayCopyCharBufferedReadSmallResult = cbuf[MAX_BUFFER_BYTES - 1]; + } + + @Benchmark + public void jmhTimeArrayCopyCharBufferedReadMedium() throws IOException { + bufferedReadLoop(cbuf, ARRAY_COPY_MEDIUM); + arrayCopyCharBufferedReadMediumResult = cbuf[MAX_BUFFER_BYTES - 1]; + } + + @Benchmark + public void jmhTimeArrayCopyCharBufferedReadLarge() throws IOException { + bufferedReadLoop(cbuf, ARRAY_COPY_LARGE); + arrayCopyCharBufferedReadLargeResult = cbuf[MAX_BUFFER_BYTES - 1]; + } + + @Benchmark + public void jmhTimeArrayCopySmall() { + System.arraycopy(stringArray, 0, stringArraySmall, 0, ARRAY_COPY_SMALL); + } + + @Benchmark + public void jmhTimeArrayCopyMedium() { + System.arraycopy(stringArray, 0, stringArrayMedium, 0, ARRAY_COPY_MEDIUM); + } + + @Benchmark + public void jmhTimeArrayCopyLarge() { + System.arraycopy(stringArray, 0, stringArrayLarge, 0, ARRAY_COPY_LARGE); + } +} diff --git a/src/main/java/org/linaro/benchmarks/micro/VectorCalc.java b/src/main/java/org/linaro/benchmarks/micro/VectorCalc.java new file mode 100644 index 0000000..0c2ad2a --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/micro/VectorCalc.java @@ -0,0 +1,83 @@ +/* + * Copyright (C) 2015 Linaro Limited. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +/* + * Description: Some generic vector operations. + * Main Focus: Boundary checks in loops + * Secondary Focus: Array access, load/store. + * + */ + +package org.linaro.benchmarks.micro; + +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.NANOSECONDS) +@State(Scope.Benchmark) + +public class VectorCalc { + + public static final int ARRAY_SIZE = 500; + public static final int COEFFICIENT = 2; + public static final int MAIN_ITERATIONS = 80000; + public int[] array1 = new int[ARRAY_SIZE]; + public int[] array2 = new int[ARRAY_SIZE]; + public int[] array3 = new int[ARRAY_SIZE]; + + // index : loop induction variable + loop invariable + public void setArrayValues(int[] array, int start, int length, int startValue, int step) { + for (int i = 0, value = startValue; i < length; ++i, value += step) { + array[i + start] = value; + } + } + + // index : loop induction variable + // multiple arrays + public void copyArray(int[] dst, int[] src, int start, int length) { + for (int i = start, end = start + length; i < end; ++i) { + dst[i] = src[i]; + } + } + + // index : loop induction variable + loop invariable + // multiple arrays + public void scaleProduct(int[] dst, int[] src, int start, int length, int coefficient) { + for (int i = 0; i < length; ++i) { + dst[i + start] = coefficient * src[i + start]; + } + } + + // index-1 : loop induction variable + // index-2 : loop invariable + // multiple arrays + public void dotProduct(int[] src1, int[] src2, int start, int length, int[] output, + int outputOffset) { + for (int i = start, end = start + length; i < end; ++i) { + output[outputOffset] += src1[i] * src2[i]; + } + } + + @Benchmark + public void jmhTimeRun() { + setArrayValues(array1, 0, ARRAY_SIZE, 0, 1); + copyArray(array2, array1, 0, ARRAY_SIZE); + scaleProduct(array3, array1, 0, ARRAY_SIZE, COEFFICIENT); + dotProduct(array2, array3, 0, ARRAY_SIZE, array1, 0); + } +} diff --git a/src/main/java/org/linaro/benchmarks/micro/intrinsics/CRC32Bench.java b/src/main/java/org/linaro/benchmarks/micro/intrinsics/CRC32Bench.java new file mode 100644 index 0000000..3d8d817 --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/micro/intrinsics/CRC32Bench.java @@ -0,0 +1,70 @@ +/* + * Copyright (C) 2016 Linaro Limited. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +/* + * Description: Simple loops around CRC32 intrinsics. + * Main Focus: CRC32-related intrinsics. + */ + +package org.linaro.benchmarks.micro.intrinsics; + +import java.util.Random; +import java.util.zip.CRC32; +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + +public class CRC32Bench { + private byte []bytes = new byte[8192]; + private CRC32 crc32 = new CRC32(); + private static final int iterCount = 100; + private static final int loopSize = 3000; + + public CRC32Bench() { + Random rnd = new Random(0); + rnd.nextBytes(bytes); + } + + @Benchmark + public void jmhTimeUpdateInt() { + benchUpdateInt(); + } + + @Benchmark + public void jmhTimeUpdateBytes() { + benchUpdateBytes(); + } + + public void benchUpdateInt() { + int count = loopSize * 230; + crc32.reset(); + for (int i = 0; i < count; i++) { + crc32.update(i); + } + } + + public void benchUpdateBytes() { + crc32.reset(); + + for (int i = 0; i < loopSize*100; i++) { + crc32.update(bytes); + } + } +} diff --git a/src/main/java/org/linaro/benchmarks/micro/intrinsics/Intrinsics.java b/src/main/java/org/linaro/benchmarks/micro/intrinsics/Intrinsics.java new file mode 100644 index 0000000..f43d977 --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/micro/intrinsics/Intrinsics.java @@ -0,0 +1,272 @@ +/* + * Copyright (c) 2015, ARM Limited. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +package org.linaro.benchmarks.micro.intrinsics; + +import java.lang.System; +import java.util.EnumMap; +import java.util.Map; +import java.util.Random; +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.NANOSECONDS) +@State(Scope.Benchmark) + +public class Intrinsics { + + /* Invoke each intrinsic in question the same no. of times */ + private static final int NUM_INVOKES = 128; + + /* Random pool size. + * Use a power of two to make the modulo operations below fast. */ + private static final int NUM_RANDS = 1024; + + /* Pre-allocated pool of random integers from [0, Integer.MAX_VALUE) */ + private static final int[] rand = new int[NUM_RANDS]; + + static { + // Allocate a pool of random integers to use in benchmarks that + // want to try and force branch mispredicts without the overhead + // of calling random.nextInt in times code. Same seed every time. + Random random = new Random(42L); + for (int i = 0; i < NUM_RANDS; i++) { + rand[i] = random.nextInt(Integer.MAX_VALUE); + } + } + + /** + * NumberOfLeadingZeros. + **/ + + private static int[] resultsNumberOfLeadingZerosInteger = new int[NUM_INVOKES]; + private static int[] resultsNumberOfLeadingZerosLong = new int[NUM_INVOKES]; + private static int[] resultsNumberOfLeadingZerosIntegerRandom = new int[NUM_INVOKES]; + private static int[] resultsNumberOfLeadingZerosLongRandom = new int[NUM_INVOKES]; + + @Benchmark + public void jmhTimeNumberOfLeadingZerosInteger() { + for (int i = 0; i < NUM_INVOKES; ++i) { + resultsNumberOfLeadingZerosInteger[i] = + Integer.numberOfLeadingZeros(0x80000000 >>> i); + } + } + + @Benchmark + public void jmhTimeNumberOfLeadingZerosLong() { + for (int i = 0; i < NUM_INVOKES; ++i) { + resultsNumberOfLeadingZerosLong[i] = + Long.numberOfLeadingZeros(0x8000000000000000L >>> i); + } + } + + @Benchmark + public void jmhTimeNumberOfLeadingZerosIntegerRandom() { + for (int i = 0; i < NUM_INVOKES; ++i) { + resultsNumberOfLeadingZerosIntegerRandom[i] = + Integer.numberOfLeadingZeros(rand[i % NUM_RANDS] >>> rand[i % NUM_RANDS]); + } + } + + @Benchmark + public void jmhTimeNumberOfLeadingZerosLongRandom() { + for (int i = 0; i < NUM_INVOKES; ++i) { + resultsNumberOfLeadingZerosLongRandom[i] = + Long.numberOfLeadingZeros(1 << (rand[i % NUM_RANDS] % Long.SIZE)); + } + } + + /** + * NumberOfTrailingZeros. + **/ + + private static int[] resultsNumberOfTrailingZerosInteger = new int[NUM_INVOKES]; + private static int[] resultsNumberOfTrailingZerosLong = new int[NUM_INVOKES]; + private static int[] resultsNumberOfTrailingZerosIntegerRandom = new int[NUM_INVOKES]; + private static int[] resultsNumberOfTrailingZerosLongRandom = new int[NUM_INVOKES]; + + @Benchmark + public void jmhTimeNumberOfTrailingZerosInteger() { + for (int i = 0; i < NUM_INVOKES; ++i) { + resultsNumberOfTrailingZerosInteger[i] = + Integer.numberOfTrailingZeros(0x80000000 >>> i); + } + } + + @Benchmark + public void jmhTimeNumberOfTrailingZerosLong() { + for (int i = 0; i < NUM_INVOKES; ++i) { + resultsNumberOfTrailingZerosLong[i] = + Long.numberOfTrailingZeros(0x8000000000000000L >>> i); + } + } + + @Benchmark + public void jmhTimeNumberOfTrailingZerosIntegerRandom() { + for (int i = 0; i < NUM_INVOKES; ++i) { + resultsNumberOfTrailingZerosIntegerRandom[i] = + Integer.numberOfTrailingZeros(rand[i % NUM_RANDS] >>> rand[i % NUM_RANDS]); + } + } + + @Benchmark + public void jmhTimeNumberOfTrailingZerosLongRandom() { + for (int i = 0; i < NUM_INVOKES; ++i) { + resultsNumberOfTrailingZerosLongRandom[i] = + Long.numberOfTrailingZeros(1 << (rand[i % NUM_RANDS] % Long.SIZE)); + } + } + + /** + * BitCount. + **/ + + // both Integer and Long's bitCount() return int type. + private static int[] resultsBitCountInteger = new int[NUM_INVOKES]; + private static int[] resultsBitCountLong = new int[NUM_INVOKES]; + private static int[] resultsBitCountIntegerRandom = new int[NUM_INVOKES]; + private static int[] resultsBitCountLongRandom = new int[NUM_INVOKES]; + + @Benchmark + public void jmhTimeBitCountInteger() { + for (int i = 0; i < NUM_INVOKES; ++i) { + resultsBitCountInteger[i] = Integer.bitCount(0x1234abcd); + } + } + + @Benchmark + public void jmhTimeBitCountLong() { + for (int i = 0; i < NUM_INVOKES; ++i) { + resultsBitCountLong[i] = Long.bitCount(0x1234abcd1234abcdL); + } + } + + @Benchmark + public void jmhTimeBitCountIntegerRandom() { + for (int i = 0; i < NUM_INVOKES; ++i) { + resultsBitCountIntegerRandom[i] = Integer.bitCount(rand[i % NUM_RANDS]); + } + } + + @Benchmark + public void jmhTimeBitCountLongRandom() { + for (int i = 0; i < NUM_INVOKES; ++i) { + resultsBitCountLongRandom[i] = + Long.bitCount((long)rand[i % NUM_RANDS] << 32 + rand[i % NUM_RANDS]); + } + } + + /** + * RotateRight. + **/ + + private static int[] resultsRotateRightInteger = new int[NUM_INVOKES]; + private static int[] resultsRotateRightIntegerConstant = new int[NUM_INVOKES]; + private static long[] resultsRotateRightLong = new long[NUM_INVOKES]; + private static long[] resultsRotateRightLongConstant = new long[NUM_INVOKES]; + + @Benchmark + public void jmhTimeRotateRightInteger() { + for (int i = 0; i < NUM_INVOKES; ++i) { + resultsRotateRightInteger[i] = Integer.rotateRight(0xFF0000DD, i); + } + } + + @Benchmark + public void jmhTimeRotateRightIntegerConstant() { + for (int i = 0; i < NUM_INVOKES; ++i) { + resultsRotateRightIntegerConstant[i] = Integer.rotateRight(0xFF0000DD, 16); + } + } + + @Benchmark + public void jmhTimeRotateRightLong() { + for (int i = 0; i < NUM_INVOKES; ++i) { + resultsRotateRightLong[i] = Long.rotateRight(0xBBAAAADDFF0000DDL, i); + } + } + + @Benchmark + public void jmhTimeRotateRightLongConstant() { + for (int i = 0; i < NUM_INVOKES; ++i) { + resultsRotateRightLongConstant[i] = Long.rotateRight(0xBBAAAADDFF0000DDL, 48); + } + } + + /** + * RotateLeft. + **/ + + private static int[] resultsRotateLeftInteger = new int[NUM_INVOKES]; + private static int[] resultsRotateLeftIntegerConstant = new int[NUM_INVOKES]; + private static long[] resultsRotateLeftLong = new long[NUM_INVOKES]; + private static long[] resultsRotateLeftLongConstant = new long[NUM_INVOKES]; + + @Benchmark + public void jmhTimeRotateLeftInteger() { + for (int i = 0; i < NUM_INVOKES; ++i) { + resultsRotateLeftInteger[i] = Integer.rotateLeft(0xFF0000DD, i); + } + } + + @Benchmark + public void jmhTimeRotateLeftIntegerConstant() { + for (int i = 0; i < NUM_INVOKES; ++i) { + resultsRotateLeftIntegerConstant[i] = Integer.rotateLeft(0xFF0000DD, 16); + } + } + + @Benchmark + public void jmhTimeRotateLeftLong() { + for (int i = 0; i < NUM_INVOKES; ++i) { + resultsRotateLeftLong[i] = Long.rotateLeft(0xBBAAAADDFF0000DDL, i); + } + } + + @Benchmark + public void jmhTimeRotateLeftLongConstant() { + for (int i = 0; i < NUM_INVOKES; ++i) { + resultsRotateLeftLongConstant[i] = Long.rotateLeft(0xBBAAAADDFF0000DDL, 48); + } + } + + /** + * RotateRandom. + **/ + + private static int[] resultsRotateRandomInteger = new int[NUM_INVOKES]; + private static long[] resultsRotateRandomLong = new long[NUM_INVOKES]; + + @Benchmark + public void jmhTimeRotateRandomInteger() { + for (int i = 0; i < NUM_INVOKES; ++i) { + resultsRotateRandomInteger[i] = (rand[i % NUM_RANDS] % 2 > 0) + ? Integer.rotateLeft(0xFF0000DD, rand[i % NUM_RANDS]) + : Integer.rotateRight(0xFF0000DD, rand[i % NUM_RANDS]); + } + } + + @Benchmark + public void jmhTimeRotateRandomLong() { + for (int i = 0; i < NUM_INVOKES; ++i) { + resultsRotateRandomLong[i] = (rand[i % NUM_RANDS] % 2 > 0) + ? Long.rotateLeft(0xBBAAAADDFF0000DDL, rand[i % NUM_RANDS]) + : Long.rotateRight(0xBBAAAADDFF0000DDL, rand[i % NUM_RANDS]); + } + } +} diff --git a/src/main/java/org/linaro/benchmarks/micro/intrinsics/MathIntrinsics.java b/src/main/java/org/linaro/benchmarks/micro/intrinsics/MathIntrinsics.java new file mode 100644 index 0000000..a1a86a6 --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/micro/intrinsics/MathIntrinsics.java @@ -0,0 +1,367 @@ +/* + * Copyright (c) 2016, Linaro Limited. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +/* + * Description: Simple loops around math-related intrinsics: rounding, min/max, etc. + * Main Focus: Math-related intrinsics. + */ + +package org.linaro.benchmarks.micro.intrinsics; + +import java.lang.System; +import java.util.Random; +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.NANOSECONDS) +@State(Scope.Benchmark) + +public class MathIntrinsics { + // The java.util.Random only generates random float/double numbers between 0 and 1. + // So we implement our own random floating point numbers here, + // based on a well known quick and dirty approach. + static final class MyRandom extends Random { + static int im = 139968; + static int ia = 3877; + static int ic = 29573; + static int seed = 0; + + public double nextDouble() { + double scale = 1000.0d / im; + seed = (seed * ia + ic) % im; + return scale * seed; + } + + public float nextFloat() { + float scale = 1000.0f / im; + seed = (seed * ia + ic) % im; + return scale * seed; + } + } + + /* Invoke each intrinsic in question the same no. of times */ + private static final int NUM_INVOKES = 64; + + /* Random pool size. + * Use a power of two to make the modulo operations below fast. */ + private static final int NUM_RANDS = 1024; + + /* Pre-allocated pool of random numbers. */ + private static final float[] rand_float = new float[NUM_RANDS]; + private static final double[] rand_double = new double[NUM_RANDS]; + + private static final float[] rand_pos_float = new float[NUM_RANDS]; + private static final double[] rand_pos_double = new double[NUM_RANDS]; + + private static final float[] rand_neg_float = new float[NUM_RANDS]; + private static final double[] rand_neg_double = new double[NUM_RANDS]; + + private static final int[] rand_int = new int[NUM_RANDS]; + private static final long[] rand_long = new long[NUM_RANDS]; + + // These are written but not read. The computation routines below store their + // result to these static variables to ensure the computation code is not + // removed by DCE. + private static float res_float; + private static double res_double; + private static int res_int; + private static long res_long; + + static { + MyRandom rand = new MyRandom(); + + for (int i = 0; i < NUM_RANDS; i++) { + rand_int[i] = rand.nextInt(); + rand_long[i] = rand.nextLong(); + + rand_pos_float[i] = rand.nextFloat(); + rand_pos_double[i] = rand.nextDouble(); + + rand_neg_float[i] = rand.nextFloat() * -1f; + rand_neg_double[i] = rand.nextDouble() * -1f; + + if (rand.nextInt() % 2 == 0) { + rand_float[i] = rand_pos_float[i]; + rand_double[i] = rand_pos_double[i]; + } else { + rand_float[i] = rand_neg_float[i]; + rand_double[i] = rand_neg_double[i]; + } + } + } + + @Benchmark + public void jmhTimeRoundPositiveFloat() { + int res = 0; + for (int i = 0; i < NUM_INVOKES; ++i) { + res += Math.round(rand_pos_float[i % NUM_RANDS]); + } + res_int = res; + } + + @Benchmark + public void jmhTimeRoundNegativeFloat() { + int res = 0; + for (int i = 0; i < NUM_INVOKES; ++i) { + res += Math.round(rand_neg_float[i % NUM_RANDS]); + } + res_int = res; + } + + @Benchmark + public void jmhTimeRoundFloat() { + int res = 0; + for (int i = 0; i < NUM_INVOKES; ++i) { + res += Math.round(rand_float[i % NUM_RANDS]); + } + res_int = res; + } + + @Benchmark + public void jmhTimeRoundPositiveDouble() { + long res = 0; + for (int i = 0; i < NUM_INVOKES; ++i) { + res += Math.round(rand_pos_double[i % NUM_RANDS]); + } + res_double = res; + } + + @Benchmark + public void jmhTimeRoundNegativeDouble() { + long res = 0; + for (int i = 0; i < NUM_INVOKES; ++i) { + res += Math.round(rand_neg_double[i % NUM_RANDS]); + } + res_long = res; + } + + @Benchmark + public void jmhTimeRoundDouble() { + long res = 0; + for (int i = 0; i < NUM_INVOKES; ++i) { + res += Math.round(rand_double[i % NUM_RANDS]); + } + res_double = res; + } + + @Benchmark + public void jmhTimeFloorPositiveFloat() { + float res = 0.0f; + for (int i = 0; i < NUM_INVOKES; ++i) { + res += Math.floor(rand_pos_float[i % NUM_RANDS]); + } + res_float = res; + } + + @Benchmark + public void jmhTimeFloorNegativeFloat() { + float res = 0.0f; + for (int i = 0; i < NUM_INVOKES; ++i) { + res += Math.floor(rand_neg_float[i % NUM_RANDS]); + } + res_float = res; + } + + @Benchmark + public void jmhTimeFloorFloat() { + float res = 0.0f; + for (int i = 0; i < NUM_INVOKES; ++i) { + res += Math.floor(rand_float[i % NUM_RANDS]); + } + res_float = res; + } + + @Benchmark + public void jmhTimeFloorPositiveDouble() { + double res = 0.0; + for (int i = 0; i < NUM_INVOKES; ++i) { + res += Math.floor(rand_pos_double[i % NUM_RANDS]); + } + res_double = res; + } + + @Benchmark + public void jmhTimeFloorNegativeDouble() { + double res = 0.0; + for (int i = 0; i < NUM_INVOKES; ++i) { + res += Math.floor(rand_neg_double[i % NUM_RANDS]); + } + res_double = res; + } + + @Benchmark + public void jmhTimeFloorDouble() { + double res = 0.0; + for (int i = 0; i < NUM_INVOKES; ++i) { + res += Math.floor(rand_double[i % NUM_RANDS]); + } + res_double = res; + } + + @Benchmark + public void jmhTimeCeilPositiveFloat() { + float res = 0.0f; + for (int i = 0; i < NUM_INVOKES; ++i) { + res += Math.ceil(rand_pos_float[i % NUM_RANDS]); + } + res_float = res; + } + + @Benchmark + public void jmhTimeCeilNegativeFloat() { + float res = 0.0f; + for (int i = 0; i < NUM_INVOKES; ++i) { + res += Math.ceil(rand_neg_float[i % NUM_RANDS]); + } + res_float = res; + } + + @Benchmark + public void jmhTimeCeilFloat() { + float res = 0.0f; + for (int i = 0; i < NUM_INVOKES; ++i) { + res += Math.ceil(rand_float[i % NUM_RANDS]); + } + res_float = res; + } + + @Benchmark + public void jmhTimeCeilPositiveDouble() { + double res = 0.0; + for (int i = 0; i < NUM_INVOKES; ++i) { + res += Math.ceil(rand_pos_double[i % NUM_RANDS]); + } + res_double = res; + } + + + @Benchmark + public void jmhTimeCeilNegativeDouble() { + double res = 0.0; + for (int i = 0; i < NUM_INVOKES; ++i) { + res += Math.ceil(rand_neg_double[i % NUM_RANDS]); + } + res_double = res; + } + + @Benchmark + public void jmhTimeCeilDouble() { + double res = 0.0; + for (int i = 0; i < NUM_INVOKES; ++i) { + res += Math.ceil(rand_double[i % NUM_RANDS]); + } + res_double = res; + } + + @Benchmark + public void jmhTimeRint() { + double res = 0.0; + for (int i = 0; i < NUM_INVOKES; ++i) { + res += Math.rint(rand_double[i % NUM_RANDS]); + } + res_double = res; + } + + @Benchmark + public void jmhTimeMinDouble() { + double res = 0.0; + for (int i = 0; i < NUM_INVOKES; ++i) { + double a = rand_double[i % NUM_RANDS]; + double b = rand_double[(i + 1) % NUM_RANDS]; + res += Math.min(a, b); + } + res_double = res; + } + + @Benchmark + public void jmhTimeMaxDouble() { + double res = 0.0; + for (int i = 0; i < NUM_INVOKES; ++i) { + double a = rand_double[i % NUM_RANDS]; + double b = rand_double[(i + 1) % NUM_RANDS]; + res += Math.max(a, b); + } + res_double = res; + } + + @Benchmark + public void jmhTimeMinFloat() { + float res = 0.0f; + for (int i = 0; i < NUM_INVOKES; ++i) { + float a = rand_float[i % NUM_RANDS]; + float b = rand_float[(i + 1) % NUM_RANDS]; + res += Math.min(a, b); + } + res_float = res; + } + + @Benchmark + public void jmhTimeMaxFloat() { + float res = 0.0f; + for (int i = 0; i < NUM_INVOKES; ++i) { + float a = rand_float[i % NUM_RANDS]; + float b = rand_float[(i + 1) % NUM_RANDS]; + res += Math.max(a, b); + } + res_float = res; + } + + @Benchmark + public void jmhTimeMinLong() { + long res = 0; + for (int i = 0; i < NUM_INVOKES; ++i) { + long a = rand_long[i % NUM_RANDS]; + long b = rand_long[(i + 1) % NUM_RANDS]; + res += Math.min(a, b); + } + res_long = res; + } + + @Benchmark + public void jmhTimeMaxLong() { + long res = 0; + for (int i = 0; i < NUM_INVOKES; ++i) { + long a = rand_long[i % NUM_RANDS]; + long b = rand_long[(i + 1) % NUM_RANDS]; + res += Math.max(a, b); + } + res_long = res; + } + + @Benchmark + public void jmhTimeMinInt() { + int res = 0; + for (int i = 0; i < NUM_INVOKES; ++i) { + int a = rand_int[i % NUM_RANDS]; + int b = rand_int[(i + 1) % NUM_RANDS]; + res += Math.min(a, b); + } + res_int = res; + } + + @Benchmark + public void jmhTimeMaxInt() { + int res = 0; + for (int i = 0; i < NUM_INVOKES; ++i) { + int a = rand_int[i % NUM_RANDS]; + int b = rand_int[(i + 1) % NUM_RANDS]; + res += Math.max(a, b); + } + res_int = res; + } +} diff --git a/src/main/java/org/linaro/benchmarks/misc/TestAddSubExtension.java b/src/main/java/org/linaro/benchmarks/misc/TestAddSubExtension.java new file mode 100644 index 0000000..7f77b97 --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/misc/TestAddSubExtension.java @@ -0,0 +1,427 @@ +/* + * Copyright (C) 2017 Linaro Limited. All rights received. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +package org.linaro.benchmarks.misc; + +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + +public class TestAddSubExtension { + // hot region will move to jmh framework if 'loop' is less than 100000. + private static final int loop = 100000; + + public long addConvertShift(long x0, long x1, long x2, long x3, long x4) { + long acc0 = 0; + long acc1 = 0; + long acc2 = 0; + long acc3 = 0; + long acc4 = 0; + int i0 = 1; + int i1 = 1; + int i2 = 2; + int i3 = 3; + int i4 = 4; + + for (int i = 0; i < loop; i++) { + // Another typical usage is: + // x = unsafe.getAddress(mem) + (((long)i) << 3) + acc0 += x0 + ((long)i0 << 0); + acc1 += x1 + ((long)i1 << 1); + acc2 += x2 + ((long)i2 << 2); + acc3 += x3 + ((long)i3 << 3); + acc4 += x4 + ((long)i4 << 4); + + i0 += 3; + i1 += 4; + i2 += 5; + i3 += 6; + i4 += 7; + } + return acc0 + acc1 + acc2 + acc3 + acc4; + } + + public long subConvertShift(long x0) { + long acc0 = 1; + int i0 = 1; + + // Adding more caculations (e.g. i1 << 1, i2 << 2 etc. same as + // addConvertShift function does.) will fail to match + // SubExtL_sxtw_imm pattern in AArch64.ad. + for (int i = 0; i < loop; i++) { + i0 += 2; + acc0 -= ((long)i0 << 2); + } + return acc0; + } + + public int subAnd255Shift(int x0, int x1, int x2, int x3, int x4) { + int i0 = 0; + int i1 = 1; + int i2 = 2; + int i3 = 3; + int i4 = 4; + + int acc0 = 0; + int acc1 = 0; + int acc2 = 0; + int acc3 = 0; + int acc4 = 0; + + for (long i = 0; i < loop; i++) { + acc0 -= ((i0 & 255) << 0); + acc1 -= ((i1 & 255) << 1); + acc2 -= ((i2 & 255) << 2); + acc3 -= ((i3 & 255) << 3); + acc4 -= ((i4 & 255) << 4); + + i0 += 3; + i1 += 4; + i2 += 5; + i3 += 6; + i4 += 7; + } + return acc0; + } + + public int subAnd65535Shift(int x0, int x1, int x2, int x3, int x4) { + int i0 = 0; + int i1 = 1; + int i2 = 2; + int i3 = 3; + int i4 = 4; + + int acc0 = 0; + int acc1 = 0; + int acc2 = 0; + int acc3 = 0; + int acc4 = 0; + + for (int i = 0; i < loop; i++) { + // TODO check why there is extra 'and' instruction generated in C2. + acc0 -= ((i0 & 65535) << 0); + acc1 -= ((i1 & 65535) << 1); + acc2 -= ((i2 & 65535) << 2); + acc3 -= ((i3 & 65535) << 3); + acc4 -= ((i4 & 65535) << 4); + + i0 += 3; + i1 += 4; + i2 += 5; + i3 += 6; + i4 += 7; + } + return acc0 + acc1 + acc2 + acc3 + acc4; + } + + public long subAnd255Shift(long x0, long x1, long x2, long x3, long x4) { + long i0 = 0; + long i1 = 1; + long i2 = 2; + long i3 = 3; + long i4 = 4; + + long acc0 = 0; + long acc1 = 0; + long acc2 = 0; + long acc3 = 0; + long acc4 = 0; + + for (long i = 0; i < loop; i++) { + acc0 -= ((i0 & 255) << 0); + acc1 -= ((i1 & 255) << 1); + acc2 -= ((i2 & 255) << 2); + acc3 -= ((i3 & 255) << 3); + acc4 -= ((i4 & 255) << 4); + + i0 += 3; + i1 += 4; + i2 += 5; + i3 += 6; + i4 += 7; + } + return acc0; + } + + public long subAnd65535Shift(long x0, long x1, long x2, long x3, long x4) { + long i0 = 0; + long i1 = 1; + long i2 = 2; + long i3 = 3; + long i4 = 4; + + long acc0 = 0; + long acc1 = 0; + long acc2 = 0; + long acc3 = 0; + long acc4 = 0; + + for (long i = 0; i < loop; i++) { + acc0 -= ((i0 & 65535) << 0); + acc1 -= ((i1 & 65535) << 1); + acc2 -= ((i2 & 65535) << 2); + acc3 -= ((i3 & 65535) << 3); + acc4 -= ((i4 & 65535) << 4); + + i0 += 3; + i1 += 4; + i2 += 5; + i3 += 6; + i4 += 7; + } + return acc0; + } + + public long subAnd4294967295Shift(long x0, long x1, long x2, long x3, long x4) { + long i0 = 0; + long i1 = 1; + long i2 = 2; + long i3 = 3; + long i4 = 4; + + long acc0 = 0; + long acc1 = 0; + long acc2 = 0; + long acc3 = 0; + long acc4 = 0; + + for (long i = 0; i < loop; i++) { + // 2^32 - 1 = 4294967295 + acc0 -= ((i0 & 4294967295L) << 0); + acc1 -= ((i1 & 4294967295L) << 1); + acc2 -= ((i2 & 4294967295L) << 2); + acc3 -= ((i3 & 4294967295L) << 3); + acc4 -= ((i4 & 4294967295L) << 4); + + i0 += 3; + i1 += 4; + i2 += 5; + i3 += 6; + i4 += 7; + } + return acc0; + } + + public int addAnd255Shift(int x0, int x1, int x2, int x3, int x4) { + int i0 = 0; + int i1 = 1; + int i2 = 2; + int i3 = 3; + int i4 = 4; + + int acc0 = 0; + int acc1 = 0; + int acc2 = 0; + int acc3 = 0; + int acc4 = 0; + + for (long i = 0; i < loop; i++) { + acc0 += ((i0 & 255) << 0); + acc1 += ((i1 & 255) << 1); + acc2 += ((i2 & 255) << 2); + acc3 += ((i3 & 255) << 3); + acc4 += ((i4 & 255) << 4); + + i0 += 3; + i1 += 4; + i2 += 5; + i3 += 6; + i4 += 7; + } + return acc0; + } + + public int addAnd65535Shift(int x0, int x1, int x2, int x3, int x4) { + int i0 = 0; + int i1 = 1; + int i2 = 2; + int i3 = 3; + int i4 = 4; + + int acc0 = 0; + int acc1 = 0; + int acc2 = 0; + int acc3 = 0; + int acc4 = 0; + + for (int i = 0; i < loop; i++) { + acc0 += ((i0 & 65535) << 0); + acc1 += ((i1 & 65535) << 1); + acc2 += ((i2 & 65535) << 2); + acc3 += ((i3 & 65535) << 3); + acc4 += ((i4 & 65535) << 4); + + i0 += 3; + i1 += 4; + i2 += 5; + i3 += 6; + i4 += 7; + } + return acc0 + acc1 + acc2 + acc3 + acc4; + } + + public long addAnd255Shift(long x0, long x1, long x2, long x3, long x4) { + long i0 = 0; + long i1 = 1; + long i2 = 2; + long i3 = 3; + long i4 = 4; + + long acc0 = 0; + long acc1 = 0; + long acc2 = 0; + long acc3 = 0; + long acc4 = 0; + + for (long i = 0; i < loop; i++) { + acc0 += ((i0 & 255) << 0); + acc1 += ((i1 & 255) << 1); + acc2 += ((i2 & 255) << 2); + acc3 += ((i3 & 255) << 3); + acc4 += ((i4 & 255) << 4); + + i0 += 3; + i1 += 4; + i2 += 5; + i3 += 6; + i4 += 7; + } + return acc0; + } + + public long addAnd65535Shift(long x0, long x1, long x2, long x3, long x4) { + long i0 = 0; + long i1 = 1; + long i2 = 2; + long i3 = 3; + long i4 = 4; + + long acc0 = 0; + long acc1 = 0; + long acc2 = 0; + long acc3 = 0; + long acc4 = 0; + + for (long i = 0; i < loop; i++) { + acc0 += ((i0 & 65535) << 0); + acc1 += ((i1 & 65535) << 1); + acc2 += ((i2 & 65535) << 2); + acc3 += ((i3 & 65535) << 3); + acc4 += ((i4 & 65535) << 4); + + i0 += 3; + i1 += 4; + i2 += 5; + i3 += 6; + i4 += 7; + } + return acc0; + } + + public long addAnd4294967295Shift(long x0, long x1, long x2, long x3, long x4) { + long i0 = 0; + long i1 = 1; + long i2 = 2; + long i3 = 3; + long i4 = 4; + + long acc0 = 0; + long acc1 = 0; + long acc2 = 0; + long acc3 = 0; + long acc4 = 0; + + for (long i = 0; i < loop; i++) { + // 2^32 - 1 = 4294967295 + acc0 += ((i0 & 4294967295L) << 0); + acc1 += ((i1 & 4294967295L) << 1); + acc2 += ((i2 & 4294967295L) << 2); + acc3 += ((i3 & 4294967295L) << 3); + acc4 += ((i4 & 4294967295L) << 4); + + i0 += 3; + i1 += 4; + i2 += 5; + i3 += 6; + i4 += 7; + } + return acc0; + } + + @Benchmark + public long testSubAnd255ShiftInt() { + return subAnd255Shift(10, 10, 10, 10, 10); + } + + @Benchmark + public long testSubAnd65535ShiftInt() { + return subAnd65535Shift(10, 10, 10, 10, 10); + } + + @Benchmark + public long testSubAnd255ShiftLong() { + return subAnd255Shift(10L, 10L, 10L, 10L, 10L); + } + + @Benchmark + public long testSubAnd65535ShiftLong() { + return subAnd65535Shift(10L, 10L, 10L, 10L, 10L); + } + + @Benchmark + public long testSubAnd4294967295Shift() { + return subAnd4294967295Shift(10, 10, 10, 10, 10); + } + + @Benchmark + public int testAddAnd255ShiftInt() { + return addAnd255Shift(10, 10, 10, 10, 10); + } + + @Benchmark + public int testAddAnd65535ShiftInt() { + return addAnd65535Shift(10, 10, 10, 10, 10); + } + + @Benchmark + public long testAddAnd255ShiftLong() { + return addAnd255Shift(10L, 10L, 10L, 10L, 10L); + } + + @Benchmark + public long testAddAnd65535ShiftLong() { + return addAnd65535Shift(10L, 10L, 10L, 10L, 10L); + } + + @Benchmark + public long testAddAnd4294967295Shift() { + return addAnd4294967295Shift(10, 10, 10, 10, 10); + } + + @Benchmark + public long testAddConvertShift() { + return addConvertShift(10, 10, 10, 10, 10); + } + + @Benchmark + public long testSubConvertShift() { + return subConvertShift(10); + } +} diff --git a/src/main/java/org/linaro/benchmarks/stanford/Bubblesort.java b/src/main/java/org/linaro/benchmarks/stanford/Bubblesort.java new file mode 100644 index 0000000..e53d9b9 --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/stanford/Bubblesort.java @@ -0,0 +1,81 @@ +/* Copied from https://llvm.org/svn/llvm-project/test-suite/tags/RELEASE_14/SingleSource/Benchmarks + * License: LLVM Release License. See Notice file + */ + +package org.linaro.benchmarks.stanford; + +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + +public class Bubblesort { + + private static final int sortelements = 5000; + private static final int srtelements = 500; + + private boolean error; // Used as flag for the verify() function. + private long seed; + private int[] sortlist = new int [sortelements + 1]; + private int biggest; + private int littlest; + private int top; + +// CHECKSTYLE.OFF: .* +void Initrand () { + seed = 74755L; /* constant to long WR*/ +} + +int Rand () { + seed = (seed * 1309L + 13849L) & 65535L; /* constants to long WR*/ + return( (int)seed ); /* typecast back to int WR*/ +} + + + /* Sorts an array using bubblesort */ + +void bInitarr() { + int i; + long temp; /* converted temp to long for 16 bit WR*/ + Initrand(); + biggest = 0; littlest = 0; + for ( i = 1; i <= srtelements; i++ ) { + temp = Rand(); + /* converted constants to long in next stmt, typecast back to int WR*/ + sortlist[i] = (int)(temp - (temp/100000L)*100000L - 50000L); + if ( sortlist[i] > biggest ) biggest = sortlist[i]; + else if ( sortlist[i] < littlest ) littlest = sortlist[i]; + } +} + +void Bubble() { + int i, j; + bInitarr(); + top=srtelements; + + while ( top>1 ) { + + i=1; + while ( i<top ) { + + if ( sortlist[i] > sortlist[i+1] ) { + j = sortlist[i]; + sortlist[i] = sortlist[i+1]; + sortlist[i+1] = j; + } + i=i+1; + } + + top=top-1; + } + if ( (sortlist[1] != littlest) || (sortlist[srtelements] != biggest) ) + error = true; +} + // CHECKSTYLE.ON: .* + @Benchmark + public void jmhTimeBubble() { + Bubble(); + } +} diff --git a/src/main/java/org/linaro/benchmarks/stanford/IntMM.java b/src/main/java/org/linaro/benchmarks/stanford/IntMM.java new file mode 100644 index 0000000..52ab141 --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/stanford/IntMM.java @@ -0,0 +1,75 @@ +/* Copied from https://llvm.org/svn/llvm-project/test-suite/tags/RELEASE_14/SingleSource/Benchmarks + * License: LLVM Release License. See Notice file + */ + +package org.linaro.benchmarks.stanford; + +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + +public class IntMM { + + private static final int rowsize = 40; + + // Number of (internal) iterations for IntMM runs as per original benchmark + private static final int INTMM_ITERS = 10; + private static final int EXPECTED = 300; + + private long seed; + + private int[][] ima = new int[rowsize + 1][rowsize + 1]; + private int[][] imb = new int[rowsize + 1][rowsize + 1]; + private int[][] imr = new int[rowsize + 1][rowsize + 1]; + +// CHECKSTYLE.OFF: .* +void Initrand () { + seed = 74755L; /* constant to long WR*/ +} + +int Rand () { + seed = (seed * 1309L + 13849L) & 65535L; /* constants to long WR*/ + return( (int)seed ); /* typecast back to int WR*/ +} + + + /* Multiplies two integer matrices. */ + +private void Initmatrix (int m[][]) { + int temp, i, j; + for ( i = 1; i <= rowsize; i++ ) + for ( j = 1; j <= rowsize; j++ ) { + temp = Rand(); + m[i][j] = temp - (temp/120)*120 - 60; + } +} + +void Innerproduct( int result[][], int a[][], int b[][], int row, int column) { + /* computes the inner product of A[row,*] and B[*,column] */ + int i; + int tmp = 0; + for(i = 1; i <= rowsize; i++ ) tmp = tmp+a[row][i]*b[i][column]; + result[row][column] = tmp; + } + +void Intmm (int run) { + int i, j; + Initrand(); + Initmatrix (ima); + Initmatrix (imb); + for ( i = 1; i <= rowsize; i++ ) + for ( j = 1; j <= rowsize; j++ ) + Innerproduct(imr,ima,imb,i,j); +} + // CHECKSTYLE.ON: .* + + @Benchmark + public void jmhTimeIntmm() { + for (int j = 0; j < INTMM_ITERS; j++) { + Intmm(j); + } + } +} diff --git a/src/main/java/org/linaro/benchmarks/stanford/Oscar.java b/src/main/java/org/linaro/benchmarks/stanford/Oscar.java new file mode 100644 index 0000000..5388366 --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/stanford/Oscar.java @@ -0,0 +1,168 @@ +/* Copied from https://llvm.org/svn/llvm-project/test-suite/tags/RELEASE_14/SingleSource/Benchmarks + * License: LLVM Release License. See Notice file + */ + +package org.linaro.benchmarks.stanford; + +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + +public class Oscar { + + private static final int fftsize = 256; + private static final int fftsize2 = 129; + + class Complex { + float rp; + float ip; + } + + private Complex[] z = new Complex [fftsize + 1]; + private Complex[] w = new Complex [fftsize + 1]; + private Complex[] e = new Complex [fftsize2 + 1]; + private float zr; + private float zi; + private float[] h = new float[26]; + + private long seed; /* converted to long for 16 bit WR*/ + + public Oscar() { + for (int i = 0; i < z.length; i++) z[i] = new Complex(); + for (int i = 0; i < e.length; i++) e[i] = new Complex(); + for (int i = 0; i < w.length; i++) w[i] = new Complex(); + } + +// CHECKSTYLE.OFF: .* +float Cos (float x) { +/* computes cos of x (x in radians) by an expansion */ +int i, factor; +float result, power; + + result = 1.0f; + factor = 1; + power = x; + for ( i = 2; i <= 10; i++ ) { + factor = factor * i; power = power*x; + if ( (i & 1) == 0 ) { + if ( (i & 3) == 0 ) result = result + power/factor; + else result = result - power/factor; + } + } + return (result); +} + +int Min0( int arg1, int arg2) { + if ( arg1 < arg2 ) return (arg1); + else return (arg2); +} + +int Uniform11(int iy) { + return (4855 * iy + 1731) & 8191; +} /* uniform */ + +void Exptab(int n, Complex e[]) { /* exptab */ + float theta, divisor; + int i, j, k, l, m; + + theta = 3.1415926536f; + divisor = 4.0f; + for ( i=1; i <= 25; i++ ) { + h[i] = 1/(2*Cos( theta/divisor )); + divisor = divisor + divisor; + } + + m = n / 2 ; + l = m / 2 ; + j = 1 ; + e[1].rp = 1.0f; + e[1].ip = 0.0f; + e[l+1].rp = 0.0f; + e[l+1].ip = 1.0f; + e[m+1].rp = -1.0f; + e[m+1].ip = 0.0f; + + do { + i = l / 2 ; + k = i ; + + do { + e[k+1].rp = h[j]*(e[k+i+1].rp+e[k-i+1].rp) ; + e[k+1].ip = h[j]*(e[k+i+1].ip+e[k-i+1].ip) ; + k = k+l ; + } while ( k <= m ); + + j = Min0( j+1, 25); + l = i ; + } while ( l > 1 ); + +} /* exptab */ + +void Fft( int n, Complex z[], Complex w[], Complex e[], float sqrinv) { + int i, j, k, l, m, index; + m = n / 2 ; + l = 1 ; + + do { + k = 0 ; + j = l ; + i = 1 ; + + do { + + do { + w[i+k].rp = z[i].rp+z[m+i].rp ; + w[i+k].ip = z[i].ip+z[m+i].ip ; + w[i+j].rp = e[k+1].rp*(z[i].rp-z[i+m].rp) + -e[k+1].ip*(z[i].ip-z[i+m].ip) ; + w[i+j].ip = e[k+1].rp*(z[i].ip-z[i+m].ip) + +e[k+1].ip*(z[i].rp-z[i+m].rp) ; + i = i+1 ; + } while ( i <= j ); + + k = j ; + j = k+l ; + } while ( j <= m ); + + /*z = w ;*/ index = 1; + do { + z[index].rp = w[index].rp; + z[index].ip = w[index].ip; + index = index+1; + } while ( index <= n ); + l = l+l ; + } while ( l <= m ); + + for ( i = 1; i <= n; i++ ){ + z[i].rp = sqrinv*z[i].rp ; + z[i].ip = -sqrinv*z[i].ip; + } + +} + +void Oscar() { /* oscar */ + int i; + Exptab(fftsize,e) ; + seed = 5767 ; + for ( i = 1; i <= fftsize; i++ ) { + seed = Uniform11( (int)seed ); /* typecast seed for 16 bit WR*/ + zr = seed / 8192.0f; + seed = Uniform11( (int)seed ); /* typecast seed for 16 bit WR*/ + zi = seed / 8192.0f; + z[i].rp = 20.0f*zr - 10.0f; + z[i].ip = 20.0f*zi - 10.0f; + } + for ( i = 1; i <= 20; i++ ) { + Fft(fftsize,z,w,e,0.0625f) ; + } +} /* oscar */ + // CHECKSTYLE.ON: .* + + @Benchmark + public void jmhTimeOscar() { + Oscar(); + } +} diff --git a/src/main/java/org/linaro/benchmarks/stanford/Perm.java b/src/main/java/org/linaro/benchmarks/stanford/Perm.java new file mode 100644 index 0000000..1f04a58 --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/stanford/Perm.java @@ -0,0 +1,68 @@ +/* Copied from https://llvm.org/svn/llvm-project/test-suite/tags/RELEASE_14/SingleSource/Benchmarks + * License: LLVM Release License. See Notice file + */ + +package org.linaro.benchmarks.stanford; + +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + +public class Perm { + + private static final int permrange = 10; + + private boolean error; + + /* Perm */ + private int[] permarray = new int [permrange + 1]; + /* converted pctr to unsigned int for 16 bit WR*/ + private int pctr; + +// CHECKSTYLE.OFF: .* + /* Permutation program, heavily recursive, written by Denny Brown. */ +void Swap ( int a[], int ai, int b[], int bi ) { + int t; + t = a[ai]; a[ai] = b[bi]; b[bi] = t; +} + +void Initialize () { + int i; + for ( i = 1; i <= 7; i++ ) { + permarray[i]=i-1; + } +} + +void Permute (int n) { /* permute */ + int k; + pctr = pctr + 1; + if ( n!=1 ) { + Permute(n-1); + for ( k = n-1; k >= 1; k-- ) { + Swap(permarray, n, permarray, k); + Permute(n-1); + Swap(permarray, n, permarray, k); + } + } +} /* permute */ + +void Perm () { /* Perm */ + int i; + pctr = 0; + for ( i = 1; i <= 5; i++ ) { + Initialize(); + Permute(7); + } + if ( pctr != 43300 ) + error = true; +} /* Perm */ + // CHECKSTYLE.ON: .* + + @Benchmark + public void jmhTimePerm() { + Perm(); + } +} diff --git a/src/main/java/org/linaro/benchmarks/stanford/Puzzle.java b/src/main/java/org/linaro/benchmarks/stanford/Puzzle.java new file mode 100644 index 0000000..c9a142c --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/stanford/Puzzle.java @@ -0,0 +1,128 @@ +/* Copied from https://llvm.org/svn/llvm-project/test-suite/tags/RELEASE_14/SingleSource/Benchmarks + * License: LLVM Release License. See Notice file + */ + +package org.linaro.benchmarks.stanford; + +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + +public class Puzzle { + + private static final int size = 511; + private static final int classmax = 3; + private static final int typemax = 12; + private static final int d = 8; + + private int error = 0; + + /* puzzle */ + private int[] piececount = new int [classmax + 1]; + private int[] cls = new int [typemax + 1]; + private int[] piecemax = new int [typemax + 1]; + private boolean[] puzzl = new boolean [size + 1]; + private boolean[][] p = new boolean [typemax + 1][size + 1]; + private int n; + private int kount; + +// CHECKSTYLE.OFF: .* +boolean Fit (int i, int j) { + int k; + for ( k = 0; k <= piecemax[i]; k++ ) + if ( p[i][k] ) if ( puzzl[j+k] ) return (false); + return (true); +} + +int Place (int i, int j) { + int k; + for ( k = 0; k <= piecemax[i]; k++ ) if ( p[i][k] ) puzzl[j+k] = true; + piececount[cls[i]] = piececount[cls[i]] - 1; + for ( k = j; k <= size; k++ ) if ( ! puzzl[k] ) return (k); + return (0); +} + +void Remove (int i, int j) { + int k; + for ( k = 0; k <= piecemax[i]; k++ ) if ( p[i][k] ) puzzl[j+k] = false; + piececount[cls[i]] = piececount[cls[i]] + 1; +} + +boolean Trial (int j) { + int i, k; + kount = kount + 1; + for ( i = 0; i <= typemax; i++ ) + if ( piececount[cls[i]] != 0 ) + if ( Fit (i, j) ) { + k = Place (i, j); + if ( Trial(k) || (k == 0) )return (true); + else Remove (i, j); + } + return (false); +} + +void Puzzle () { + int i, j, k, m; + for ( m = 0; m <= size; m++ ) puzzl[m] = true; + for( i = 1; i <= 5; i++ )for( j = 1; j <= 5; j++ )for( k = 1; k <= 5; k++ ) puzzl[i+d*(j+d*k)] = false; + for( i = 0; i <= typemax; i++ )for( m = 0; m<= size; m++ ) p[i][m] = false; + for( i = 0; i <= 3; i++ )for( j = 0; j <= 1; j++ )for( k = 0; k <= 0; k++ ) p[0][i+d*(j+d*k)] = true; + cls[0] = 0; + piecemax[0] = 3+d*1+d*d*0; + for( i = 0; i <= 1; i++ )for( j = 0; j <= 0; j++ )for( k = 0; k <= 3; k++ ) p[1][i+d*(j+d*k)] = true; + cls[1] = 0; + piecemax[1] = 1+d*0+d*d*3; + for( i = 0; i <= 0; i++ )for( j = 0; j <= 3; j++ )for( k = 0; k <= 1; k++ ) p[2][i+d*(j+d*k)] = true; + cls[2] = 0; + piecemax[2] = 0+d*3+d*d*1; + for( i = 0; i <= 1; i++ )for( j = 0; j <= 3; j++ )for( k = 0; k <= 0; k++ ) p[3][i+d*(j+d*k)] = true; + cls[3] = 0; + piecemax[3] = 1+d*3+d*d*0; + for( i = 0; i <= 3; i++ )for( j = 0; j <= 0; j++ )for( k = 0; k <= 1; k++ ) p[4][i+d*(j+d*k)] = true; + cls[4] = 0; + piecemax[4] = 3+d*0+d*d*1; + for( i = 0; i <= 0; i++ )for( j = 0; j <= 1; j++ )for( k = 0; k <= 3; k++ ) p[5][i+d*(j+d*k)] = true; + cls[5] = 0; + piecemax[5] = 0+d*1+d*d*3; + for( i = 0; i <= 2; i++ )for( j = 0; j <= 0; j++ )for( k = 0; k <= 0; k++ ) p[6][i+d*(j+d*k)] = true; + cls[6] = 1; + piecemax[6] = 2+d*0+d*d*0; + for( i = 0; i <= 0; i++ )for( j = 0; j <= 2; j++ )for( k = 0; k <= 0; k++ ) p[7][i+d*(j+d*k)] = true; + cls[7] = 1; + piecemax[7] = 0+d*2+d*d*0; + for( i = 0; i <= 0; i++ )for( j = 0; j <= 0; j++ )for( k = 0; k <= 2; k++ ) p[8][i+d*(j+d*k)] = true; + cls[8] = 1; + piecemax[8] = 0+d*0+d*d*2; + for( i = 0; i <= 1; i++ )for( j = 0; j <= 1; j++ )for( k = 0; k <= 0; k++ ) p[9][i+d*(j+d*k)] = true; + cls[9] = 2; + piecemax[9] = 1+d*1+d*d*0; + for( i = 0; i <= 1; i++ )for( j = 0; j <= 0; j++ )for( k = 0; k <= 1; k++ ) p[10][i+d*(j+d*k)] = true; + cls[10] = 2; + piecemax[10] = 1+d*0+d*d*1; + for( i = 0; i <= 0; i++ )for( j = 0; j <= 1; j++ )for( k = 0; k <= 1; k++ ) p[11][i+d*(j+d*k)] = true; + cls[11] = 2; + piecemax[11] = 0+d*1+d*d*1; + for( i = 0; i <= 1; i++ )for( j = 0; j <= 1; j++ )for( k = 0; k <= 1; k++ ) p[12][i+d*(j+d*k)] = true; + cls[12] = 3; + piecemax[12] = 1+d*1+d*d*1; + piececount[0] = 13; + piececount[1] = 3; + piececount[2] = 1; + piececount[3] = 1; + m = 1+d*(1+d*1); + kount = 0; + if ( Fit(0, m) ) n = Place(0, m); + else error = 1; + if ( ! Trial(n) ) error = 2; + else if ( kount != 2005 ) error = 3; +} + // CHECKSTYLE.ON: .* + + @Benchmark + public void jmhTimePuzzle() { + Puzzle(); + } +} diff --git a/src/main/java/org/linaro/benchmarks/stanford/Queens.java b/src/main/java/org/linaro/benchmarks/stanford/Queens.java new file mode 100644 index 0000000..2da9f04 --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/stanford/Queens.java @@ -0,0 +1,80 @@ +/* Copied from https://llvm.org/svn/llvm-project/test-suite/tags/RELEASE_14/SingleSource/Benchmarks + * License: LLVM Release License. See Notice file + */ + +package org.linaro.benchmarks.stanford; + +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + +public class Queens { + + /* Since the original benchmark uses these to calculate indices, + * it is not appropriate to use pure booleans, and we use the constants below: + */ + private static final int FALSE = 0; + private static final int TRUE = 1; + + private boolean error; + private int q = FALSE; + + private int[] a = new int [9]; + private int[] b = new int[17]; + private int[] c = new int [15]; + private int[] x = new int [9]; + +// CHECKSTYLE.OFF: .* +void Try(int i, int a[], int b[], int c[], int x[]) { + int j; + j = 0; + q = FALSE; + while ( (q == FALSE) && (j != 8) ) { + j = j + 1; + q = FALSE; + if ( b[j] != FALSE && a[i+j] != FALSE && c[i-j+7] != FALSE ) { + x[i] = j; + b[j] = FALSE; + a[i+j] = FALSE; + c[i-j+7] = FALSE; + if ( i < 8 ) { + Try(i+1,a,b,c,x); + if ( q ==FALSE ) { + b[j] = TRUE; + a[i+j] = TRUE; + c[i-j+7] = TRUE; + } + } + else q = TRUE; + } + } +} + +void Doit () { + int i; + i = 0 - 7; + while ( i <= 16 ) { + if ( (i >= 1) && (i <= 8) ) a[i] = TRUE; + if ( i >= 2 ) b[i] = TRUE; + if ( i <= 7 ) c[i+7] = TRUE; + i = i + 1; + } + + Try(1, b, a, c, x); + if ( q == FALSE ) error = true; +} + +void Queens () { + int i; + for ( i = 1; i <= 50; i++ ) Doit(); +} + // CHECKSTYLE.ON: .* + + @Benchmark + public void jmhTimeQueens() { + Queens(); + } +} diff --git a/src/main/java/org/linaro/benchmarks/stanford/Quicksort.java b/src/main/java/org/linaro/benchmarks/stanford/Quicksort.java new file mode 100644 index 0000000..2232926 --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/stanford/Quicksort.java @@ -0,0 +1,87 @@ +/* Copied from https://llvm.org/svn/llvm-project/test-suite/tags/RELEASE_14/SingleSource/Benchmarks + * License: LLVM Release License. See Notice file + */ + +package org.linaro.benchmarks.stanford; + +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + +public class Quicksort { + + /* Bubble, Quick */ + private static final int sortelements = 5000; + private static final int srtelements = 500; + + private boolean error; + long seed; + + int[] sortlist = new int [sortelements + 1]; + int biggest; + int littlest; + int inttop; + +// CHECKSTYLE.OFF: .* +void Initrand () { + seed = 74755L; /* constant to long WR*/ +} + +int Rand () { + seed = (seed * 1309L + 13849L) & 65535L; /* constants to long WR*/ + return( (int)seed ); /* typecast back to int WR*/ +} + + /* Sorts an array using quicksort */ +void Initarr() { + int i; /* temp */ + long temp; /* made temp a long for 16 bit WR*/ + Initrand(); + biggest = 0; littlest = 0; + for ( i = 1; i <= sortelements; i++ ) { + temp = Rand(); + /* converted constants to long in next stmt, typecast back to int WR*/ + sortlist[i] = (int)(temp - (temp/100000L)*100000L - 50000L); + if ( sortlist[i] > biggest ) biggest = sortlist[i]; + else if ( sortlist[i] < littlest ) littlest = sortlist[i]; + } +} + +void Quicksort( int a[], int l, int r) { + /* quicksort the array A from start to finish */ + int i,j,x,w; + i=l; j=r; + x=a[(l+r) / 2]; + do { + while ( a[i]<x ) i = i+1; + while ( x<a[j] ) j = j-1; + if ( i<=j ) { + w = a[i]; + a[i] = a[j]; + a[j] = w; + i = i+1; j= j-1; + } + } while ( i<=j ); + if ( l <j ) Quicksort(a,l,j); + if ( i<r ) Quicksort(a,i,r); +} + +void Quick () { + Quicksort(sortlist,1,sortelements); + if ( (sortlist[1] != littlest) || (sortlist[sortelements] != biggest) ) error = true; +} + // CHECKSTYLE.ON: .* + + @Setup + public void setup() { + Initarr(); + } + + @Benchmark + public void jmhTimeQuicksort() { + Quick(); + } +} diff --git a/src/main/java/org/linaro/benchmarks/stanford/RealMM.java b/src/main/java/org/linaro/benchmarks/stanford/RealMM.java new file mode 100644 index 0000000..0f8e4fa --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/stanford/RealMM.java @@ -0,0 +1,68 @@ +/* Copied from https://llvm.org/svn/llvm-project/test-suite/tags/RELEASE_14/SingleSource/Benchmarks + * License: LLVM Release License. See Notice file + */ + +package org.linaro.benchmarks.stanford; + +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + +public class RealMM { + + private static final int rowsize = 40; + + private double[][] rma = new double [rowsize + 1][rowsize + 1]; + private double[][] rmb = new double [rowsize + 1][rowsize + 1]; + private double[][] rmr = new double [rowsize + 1][rowsize + 1]; + + long seed; + +// CHECKSTYLE.OFF: .* +void Initrand () { + seed = 74755L; /* constant to long WR*/ +} + +int Rand () { + seed = (seed * 1309L + 13849L) & 65535L; /* constants to long WR*/ + return( (int)seed ); /* typecast back to int WR*/ +} + + + /* Multiplies two real matrices. */ + +void rInitmatrix ( double m[][] ) { + int temp, i, j; + for ( i = 1; i <= rowsize; i++ ) + for ( j = 1; j <= rowsize; j++ ) { + temp = Rand(); + m[i][j] = (double)(temp - (temp/120)*120 - 60)/3; + } +} + +void rInnerproduct(double result[][], double a[][], double b[][], int row, int column) { + /* computes the inner product of A[row,*] and B[*,column] */ + int i; + result[row][column] = 0.0f; + for (i = 1; i<=rowsize; i++) result[row][column] = result[row][column]+a[row][i]*b[i][column]; +} + +void Mm () { + int i, j; + Initrand(); + rInitmatrix (rma); + rInitmatrix (rmb); + for ( i = 1; i <= rowsize; i++ ) + for ( j = 1; j <= rowsize; j++ ) + rInnerproduct(rmr,rma,rmb,i,j); +} + // CHECKSTYLE.ON: .* + + @Benchmark + public void jmhTimeRealMM() { + Mm(); + } +} diff --git a/src/main/java/org/linaro/benchmarks/stanford/Towers.java b/src/main/java/org/linaro/benchmarks/stanford/Towers.java new file mode 100644 index 0000000..0e57ea5 --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/stanford/Towers.java @@ -0,0 +1,128 @@ +/* Copied from https://llvm.org/svn/llvm-project/test-suite/tags/RELEASE_14/SingleSource/Benchmarks + * License: LLVM Release License. See Notice file + */ + +package org.linaro.benchmarks.stanford; + +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + +public class Towers { + + private static final int maxcells = 18; + + private static final int stackrange = 3; + + private boolean error; + + class Element { + int discsize; + int next; + } + + int[] stack = new int[stackrange + 1]; + Element[] cellspace = new Element[maxcells + 1]; + int freelist; + int movesdone; + + public Towers() { + for (int i = 0; i < cellspace.length; i++) { + cellspace[i] = new Element(); + } + } + +// CHECKSTYLE.OFF: .* +void Error (String emsg){ + error = true; +} + + +void Makenull (int s) { + stack[s]=0; +} + +int Getelement () { + int temp = 0; /* force init of temp WR*/ + if ( freelist>0 ) { + temp = freelist; + freelist = cellspace[freelist].next; + } else + Error("out of space "); + return (temp); +} + +void Push(int i, int s) { + boolean errorfound=false; + int localel; + if ( stack[s] > 0 ) + if ( cellspace[stack[s]].discsize<=i ) { + errorfound=true; + Error("disc size error"); + } + if ( ! errorfound ) { + localel=Getelement(); + cellspace[localel].next=stack[s]; + stack[s]=localel; + cellspace[localel].discsize=i; + } +} + +void Init (int s, int n) { + int discctr; + Makenull(s); + for ( discctr = n; discctr >= 1; discctr-- ) + Push(discctr,s); +} + +int Pop (int s) { + int temp, temp1; + if ( stack[s] > 0 ) { + temp1 = cellspace[stack[s]].discsize; + temp = cellspace[stack[s]].next; + cellspace[stack[s]].next=freelist; + freelist=stack[s]; + stack[s]=temp; + return (temp1); + } else + Error("nothing to pop "); + return 0; +} + +void Move (int s1, int s2) { + Push(Pop(s1),s2); + movesdone=movesdone+1; +} + +void tower(int i, int j, int k) { + int other; + if ( k==1 ) Move(i,j); + else { + other=6-i-j; + tower(i,other,k-1); + Move(i,j); + tower(other,j,k-1); + } +} + +void Towers () { /* Towers */ + int i; + for ( i=1; i <= maxcells; i++ ) cellspace[i].next=i-1; + freelist=maxcells; + Init(1,14); + Makenull(2); + Makenull(3); + movesdone=0; + tower(1,2,14); + if ( movesdone != 16383 ) error = true; +} /* Towers */ + // CHECKSTYLE.ON: .* + + @Benchmark + public void jmhTimeTowers() { + Towers(); + } +} diff --git a/src/main/java/org/linaro/benchmarks/stanford/Treesort.java b/src/main/java/org/linaro/benchmarks/stanford/Treesort.java new file mode 100644 index 0000000..e044926 --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/stanford/Treesort.java @@ -0,0 +1,108 @@ +/* Copied from https://llvm.org/svn/llvm-project/test-suite/tags/RELEASE_14/SingleSource/Benchmarks + * License: LLVM Release License. See Notice file + */ + +package org.linaro.benchmarks.stanford; + +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + +public class Treesort { + + private static final int sortelements = 5000; + private static final int srtelements = 500; + + private boolean error; + + private long seed; + + private int[] sortlist = new int [sortelements + 1]; + private int biggest; + private int littlest; + private int top; + + class Node { + Node left; + Node right; + int val; + } + + Node tree; + +// CHECKSTYLE.OFF: .* +void Initrand () { + seed = 74755L; /* constant to long WR*/ +} + +int Rand () { + seed = (seed * 1309L + 13849L) & 65535L; /* constants to long WR*/ + return( (int)seed ); /* typecast back to int WR*/ +} + + + + /* Sorts an array using treesort */ + +void tInitarr() { + int i; + long temp; /* converted temp to long for 16 bit WR*/ + Initrand(); + biggest = 0; littlest = 0; + for ( i = 1; i <= sortelements; i++ ) { + temp = Rand(); + /* converted constants to long in next stmt, typecast back to int WR*/ + sortlist[i] = (int)(temp - (temp/100000L)*100000L - 50000L); + if ( sortlist[i] > biggest ) biggest = sortlist[i]; + else if ( sortlist[i] < littlest ) littlest = sortlist[i]; + } +} + +void CreateNode (Node t, int n) { + t = new Node(); + t.val = n; +} + +void Insert(int n, Node t) { + /* insert n into tree */ + if ( n > t.val ) + if ( t.left == null ) CreateNode(t.left,n); + else Insert(n,t.left); + else if ( n < t.val ) + if ( t.right == null ) CreateNode(t.right,n); + else Insert(n,t.right); +} + + +boolean Checktree(Node p) { + /* check by inorder traversal */ + boolean result; + result = true; + if ( p.left != null ) + if ( p.left.val <= p.val ) result=false; + else result = Checktree(p.left) && result; + if ( p.right != null ) + if ( p.right.val >= p.val ) result = false; + else result = Checktree(p.right) && result; + return( result); +} /* checktree */ + +void Trees() { + int i; + tInitarr(); + tree = new Node(); + tree.left = null; tree.right=null; tree.val=sortlist[1]; + for ( i = 2; i <= sortelements; i++ ) + Insert(sortlist[i],tree); + if ( ! Checktree(tree) ) error = true; +} + // CHECKSTYLE.ON: .* + + @Benchmark + public void jmhTimeTreesort() { + Trees(); + } +} diff --git a/src/main/java/org/linaro/benchmarks/TestRGBToCmyk.java b/src/main/java/org/linaro/benchmarks/vector/TestRGBToCmyk.java index 71a93cd..e56a356 100644 --- a/src/main/java/org/linaro/benchmarks/TestRGBToCmyk.java +++ b/src/main/java/org/linaro/benchmarks/vector/TestRGBToCmyk.java @@ -15,7 +15,7 @@ * */ -package org.linaro.benchmarks; +package org.linaro.benchmarks.vector; import org.openjdk.jmh.annotations.*; import java.util.concurrent.TimeUnit; @@ -26,7 +26,8 @@ import java.util.concurrent.TimeUnit; public class TestRGBToCmyk { - static final int LENGTH = 256 * 1024; + static final int LENGTH = 1024; + static final int COUNT = 128; static byte input[] = new byte[LENGTH*3]; static byte output[] = new byte[LENGTH*4]; @@ -64,7 +65,9 @@ public class TestRGBToCmyk @Benchmark public void testRGBToCmyk() { - RGBToCmyk(input, output, LENGTH); + for (int i = 0; i < COUNT; i++) { + RGBToCmyk(input, output, LENGTH); + } } } diff --git a/src/main/java/org/linaro/benchmarks/TestReduceAdd.java b/src/main/java/org/linaro/benchmarks/vector/TestReduceAdd.java index 51e7181..679fac4 100644 --- a/src/main/java/org/linaro/benchmarks/TestReduceAdd.java +++ b/src/main/java/org/linaro/benchmarks/vector/TestReduceAdd.java @@ -14,7 +14,7 @@ * limitations under the License. * */ -package org.linaro.benchmarks; +package org.linaro.benchmarks.vector; import org.openjdk.jmh.annotations.*; import java.util.concurrent.TimeUnit; @@ -24,12 +24,13 @@ import java.util.concurrent.TimeUnit; @State(Scope.Benchmark) public class TestReduceAdd { - static final int LENGTH = 256 * 1024; + static final int LENGTH = 1024; + static final int COUNT = 2000; static int [] a = new int[LENGTH]; static int [] b = new int[LENGTH]; static short [] sa = new short[LENGTH]; static short [] sb = new short[LENGTH]; - + static int result = 0; public static void TestReduceAddInit() { for (int i = 0; i < LENGTH; i++) { a[i] = 2; @@ -103,18 +104,24 @@ public class TestReduceAdd { @Benchmark public void testReduceAddInt() { - int sum; - sum = reduceAddInt(a, b); - sum = reduceAddSumofSubInt(a, b); - sum = reduceAddSumofMulInt(a, b); + int sum = 0; + for (int i = 0; i < COUNT; i++) { + sum += reduceAddInt(a, b); + sum += reduceAddSumofSubInt(a, b); + sum += reduceAddSumofMulInt(a, b); + } + result += sum; } @Benchmark public void testReduceAddShort() { - int sum; - sum = reduceAddShort(sa, sb); - sum = reduceAddSumofSubShort(sa, sb); - sum = reduceAddSumofMulShort(sa, sb); + int sum = 0; + for (int i = 0; i < COUNT; i++) { + sum += reduceAddShort(sa, sb); + sum += reduceAddSumofSubShort(sa, sb); + sum += reduceAddSumofMulShort(sa, sb); + } + result += sum; } } diff --git a/src/main/java/org/linaro/benchmarks/TestSIMDAdd.java b/src/main/java/org/linaro/benchmarks/vector/TestSIMDAdd.java index 264458f..a7c69b4 100644 --- a/src/main/java/org/linaro/benchmarks/TestSIMDAdd.java +++ b/src/main/java/org/linaro/benchmarks/vector/TestSIMDAdd.java @@ -14,7 +14,7 @@ * limitations under the License. * */ -package org.linaro.benchmarks; +package org.linaro.benchmarks.vector; import org.openjdk.jmh.annotations.*; import java.util.concurrent.TimeUnit; @@ -24,7 +24,8 @@ import java.util.concurrent.TimeUnit; @State(Scope.Benchmark) public class TestSIMDAdd { - static final int LENGTH = 1024 * 256; + static final int LENGTH = 1024; + static final int COUNT = 128; static int [] a = new int[LENGTH]; static int [] b = new int[LENGTH]; static int [] c = new int[LENGTH]; @@ -34,6 +35,15 @@ public class TestSIMDAdd { static byte [] ba = new byte[LENGTH]; static byte [] bb = new byte[LENGTH]; static byte [] bc = new byte[LENGTH]; + static long [] la = new long[LENGTH]; + static long [] lb = new long[LENGTH]; + static long [] lc = new long[LENGTH]; + static float [] fa = new float[LENGTH]; + static float [] fb = new float[LENGTH]; + static float [] fc = new float[LENGTH]; + static double [] da = new double[LENGTH]; + static double [] db = new double[LENGTH]; + static double [] dc = new double[LENGTH]; public static void TestSIMDAddInit() { for (int i = 0; i < LENGTH; i++) { @@ -46,6 +56,15 @@ public class TestSIMDAdd { ba[i] = (byte)(i + 3); bb[i] = (byte)(i + 2); bc[i] = (byte)(i + 1); + la[i] = (long)(i + 3); + lb[i] = (long)(i + 2); + lc[i] = (long)(i + 1); + fa[i] = (float)(i + 3); + fb[i] = (float)(i + 2); + fc[i] = (float)(i + 1); + da[i] = (double)(i + 3); + db[i] = (double)(i + 2); + dc[i] = (double)(i + 1); } } @@ -67,6 +86,24 @@ public class TestSIMDAdd { } } + public static void vectAddLong() { + for (int i = 0; i < LENGTH; i++) { + lc[i] = la[i] + lb[i]; + } + } + + public static void vectAddFloat() { + for (int i = 0; i < LENGTH; i++) { + fc[i] = fa[i] + fb[i]; + } + } + + public static void vectAddDouble() { + for (int i = 0; i < LENGTH; i++) { + dc[i] = da[i] + db[i]; + } + } + @Setup public void setup() { @@ -75,17 +112,44 @@ public class TestSIMDAdd { @Benchmark public void testVectAddByte() { - vectAddByte(); + for (int i = 0; i < COUNT; i++) { + vectAddByte(); + } } @Benchmark public void testVectAddShort() { - vectAddShort(); + for (int i = 0; i < COUNT; i++) { + vectAddShort(); + } } @Benchmark public void testVectAddInt() { - vectAddInt(); + for (int i = 0; i < COUNT; i++) { + vectAddInt(); + } + } + + @Benchmark + public void testVectAddLong() { + for (int i = 0; i < COUNT; i++) { + vectAddLong(); + } + } + + @Benchmark + public void testVectAddFloat() { + for (int i = 0; i < COUNT; i++) { + vectAddFloat(); + } + } + + @Benchmark + public void testVectAddDouble() { + for (int i = 0; i < COUNT; i++) { + vectAddDouble(); + } } } diff --git a/src/main/java/org/linaro/benchmarks/TestSIMDCopy.java b/src/main/java/org/linaro/benchmarks/vector/TestSIMDCopy.java index 9e9aeee..8619ff4 100644 --- a/src/main/java/org/linaro/benchmarks/TestSIMDCopy.java +++ b/src/main/java/org/linaro/benchmarks/vector/TestSIMDCopy.java @@ -14,7 +14,7 @@ * limitations under the License. * */ -package org.linaro.benchmarks; +package org.linaro.benchmarks.vector; import org.openjdk.jmh.annotations.*; import java.util.concurrent.TimeUnit; @@ -24,13 +24,20 @@ import java.util.concurrent.TimeUnit; @State(Scope.Benchmark) public class TestSIMDCopy { - static final int LENGTH = 1024 * 256; + static final int LENGTH = 1024; + static final int COUNT = 128; static int [] a = new int[LENGTH]; static int [] c = new int[LENGTH]; static short [] sa = new short[LENGTH]; static short [] sc = new short[LENGTH]; static byte [] ba = new byte[LENGTH]; static byte [] bc = new byte[LENGTH]; + static long [] la = new long[LENGTH]; + static long [] lc = new long[LENGTH]; + static float [] fa = new float[LENGTH]; + static float [] fc = new float[LENGTH]; + static double [] da = new double[LENGTH]; + static double [] dc = new double[LENGTH]; public static void TestSIMDCopyInit() { for (int i = 0; i < LENGTH; i++) { @@ -40,6 +47,12 @@ public class TestSIMDCopy { sc[i] = (short)(i + 1); ba[i] = (byte)(i + 3); bc[i] = (byte)(i + 1); + la[i] = (long)(i + 3); + lc[i] = (long)(i + 1); + fa[i] = (float)(i + 3); + fc[i] = (float)(i + 1); + da[i] = (double)(i + 3); + dc[i] = (double)(i + 1); } } @@ -61,6 +74,24 @@ public class TestSIMDCopy { } } + public static void vectCopyLong() { + for (int i = 0; i < LENGTH; i++) { + lc[i] = la[i]; + } + } + + public static void vectCopyFloat() { + for (int i = 0; i < LENGTH; i++) { + fc[i] = fa[i]; + } + } + + public static void vectCopyDouble() { + for (int i = 0; i < LENGTH; i++) { + dc[i] = da[i]; + } + } + @Setup public void setup() { @@ -69,17 +100,43 @@ public class TestSIMDCopy { @Benchmark public void testVectCopyByte() { - vectCopyByte(); + for (int i = 0; i < COUNT; i++) { + vectCopyByte(); + } } @Benchmark public void testVectCopyShort() { - vectCopyShort(); + for (int i = 0; i < COUNT; i++) { + vectCopyShort(); + } } @Benchmark public void testVectCopyInt() { - vectCopyInt(); + for (int i = 0; i < COUNT; i++) { + vectCopyInt(); + } } + @Benchmark + public void testVectCopyLong() { + for (int i = 0; i < COUNT; i++) { + vectCopyLong(); + } + } + + @Benchmark + public void testVectCopyFloat() { + for (int i = 0; i < COUNT; i++) { + vectCopyFloat(); + } + } + + @Benchmark + public void testVectCopyDouble() { + for (int i = 0; i < COUNT; i++) { + vectCopyDouble(); + } + } } diff --git a/src/main/java/org/linaro/benchmarks/vector/TestSIMDFma.java b/src/main/java/org/linaro/benchmarks/vector/TestSIMDFma.java new file mode 100644 index 0000000..336ea87 --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/vector/TestSIMDFma.java @@ -0,0 +1,223 @@ +/* + * Copyright (C) 2017 Linaro Limited. All rights received. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ +package org.linaro.benchmarks.vector; + +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + +public class TestSIMDFma { + static final int LENGTH = 1024; + static final int COUNT = 128; + static float [] fa = new float[LENGTH]; + static float [] fb = new float[LENGTH]; + static float [] fc = new float[LENGTH]; + static double [] da = new double[LENGTH]; + static double [] db = new double[LENGTH]; + static double [] dc = new double[LENGTH]; + + public static void testSIMDFmaInit() { + for (int i = 0; i < LENGTH; i++) { + fa[i] = (float)(i + 3); + fb[i] = (float)(i + 2); + fc[i] = (float)(i + 1); + da[i] = (double)(i + 3); + db[i] = (double)(i + 2); + dc[i] = (double)(i + 1); + } + } + + public static void vecFusedMulAddFloat( + float[] a, + float[] b, + float[] c, + int loop) { + for (int i = 0; i < loop; i++) { + c[i] = Math.fma(a[i], b[i], c[i]); + } + } + + public static void vecFusedMulSub1Float( + float[] a, + float[] b, + float[] c, + int loop) { + for (int i = 0; i < loop; i++) { + c[i] = Math.fma(-a[i], b[i], c[i]); + } + } + + public static void vecFusedMulSub2Float( + float[] a, + float[] b, + float[] c, + int loop) { + for (int i = 0; i < loop; i++) { + c[i] = Math.fma(a[i], -b[i], c[i]); + } + } + + public static void vecNegFusedMulSubFloat( + float[] a, + float[] b, + float[] c, + int loop) { + for (int i = 0; i < loop; i++) { + c[i] = Math.fma(a[i], b[i], -c[i]); + } + } + + public static void vecNegFusedMulAddFloat( + float[] a, + float[] b, + float[] c, + int loop) { + for (int i = 0; i < loop; i++) { + c[i] = -(Math.fma(a[i], b[i], c[i])); + } + } + + public static void vecFusedMulAddDouble( + double[] a, + double[] b, + double[] c, + int loop) { + for (int i = 0; i < loop; i++) { + c[i] = Math.fma(a[i], b[i], c[i]); + } + } + + public static void vecFusedMulSub1Double( + double[] a, + double[] b, + double[] c, + int loop) { + for (int i = 0; i < loop; i++) { + c[i] = Math.fma(-a[i], b[i], c[i]); + } + } + + public static void vecFusedMulSub2Double( + double[] a, + double[] b, + double[] c, + int loop) { + for (int i = 0; i < loop; i++) { + c[i] = Math.fma(a[i], -b[i], c[i]); + } + } + + public static void vecNegFusedMulSubDouble( + double[] a, + double[] b, + double[] c, + int loop) { + for (int i = 0; i < loop; i++) { + c[i] = Math.fma(a[i], b[i], -c[i]); + } + } + + public static void vecNegFusedMulAddDouble( + double[] a, + double[] b, + double[] c, + int loop) { + for (int i = 0; i < loop; i++) { + c[i] = -(Math.fma(a[i], b[i], c[i])); + } + } + + @Setup + public void setup() + { + testSIMDFmaInit(); + } + + @Benchmark + public void testVecFusedMulAddFloat() { + for (int i = 0; i < COUNT; i++) { + vecFusedMulAddFloat(fa, fb, fc, LENGTH); + } + } + + @Benchmark + public void testVecFusedMulSub1Float() { + for (int i = 0; i < COUNT; i++) { + vecFusedMulSub1Float(fa, fb, fc, LENGTH); + } + } + + @Benchmark + public void testVecFusedMulSub2Float() { + for (int i = 0; i < COUNT; i++) { + vecFusedMulSub2Float(fa, fb, fc, LENGTH); + } + } + + @Benchmark + public void testVecNegFusedMulAddFloat() { + for (int i = 0; i < COUNT; i++) { + vecNegFusedMulAddFloat(fa, fb, fc, LENGTH); + } + } + + @Benchmark + public void testVecNegFusedMulSubFloat() { + for (int i = 0; i < COUNT; i++) { + vecNegFusedMulSubFloat(fa, fb, fc, LENGTH); + } + } + + @Benchmark + public void testVecFusedMulAddDouble() { + for (int i = 0; i < COUNT; i++) { + vecFusedMulAddDouble(da, db, dc, LENGTH); + } + } + + @Benchmark + public void testVecFusedMulSub1Double() { + for (int i = 0; i < COUNT; i++) { + vecFusedMulSub1Double(da, db, dc, LENGTH); + } + } + + @Benchmark + public void testVecFusedMulSub2Double() { + for (int i = 0; i < COUNT; i++) { + vecFusedMulSub2Double(da, db, dc, LENGTH); + } + } + + @Benchmark + public void testVecNegFusedMulAddDouble() { + for (int i = 0; i < COUNT; i++) { + vecNegFusedMulAddDouble(da, db, dc, LENGTH); + } + } + + @Benchmark + public void testVecNegFusedMulSubDouble() { + for (int i = 0; i < COUNT; i++) { + vecNegFusedMulSubDouble(da, db, dc, LENGTH); + } + } + +} diff --git a/src/main/java/org/linaro/benchmarks/TestSIMDLd2St2.java b/src/main/java/org/linaro/benchmarks/vector/TestSIMDLd2St2.java index 59af5c6..7e99698 100644 --- a/src/main/java/org/linaro/benchmarks/TestSIMDLd2St2.java +++ b/src/main/java/org/linaro/benchmarks/vector/TestSIMDLd2St2.java @@ -14,7 +14,7 @@ * limitations under the License. * */ -package org.linaro.benchmarks; +package org.linaro.benchmarks.vector; import org.openjdk.jmh.annotations.*; import java.util.concurrent.TimeUnit; @@ -24,7 +24,8 @@ import java.util.concurrent.TimeUnit; @State(Scope.Benchmark) public class TestSIMDLd2St2 { - static final int VECT_LENGTH = 256 * 1024; + static final int VECT_LENGTH = 1024; + static final int COUNT = 128; static final int DIM = 2; static final int LENGTH = VECT_LENGTH * DIM; static int [] in = new int[LENGTH]; @@ -102,10 +103,12 @@ public class TestSIMDLd2St2 { @Benchmark public void testVect2D() { - vect2DAddInt(out, in, c); - vect2DMulInt(out, in, c); - vect2DAddShort(sout, sin, sc); - vect2DMulShort(sout, sin, sc); + for (int i = 0; i < COUNT; i++) { + vect2DAddInt(out, in, c); + vect2DMulInt(out, in, c); + vect2DAddShort(sout, sin, sc); + vect2DMulShort(sout, sin, sc); + } } } diff --git a/src/main/java/org/linaro/benchmarks/TestSIMDLd3St3.java b/src/main/java/org/linaro/benchmarks/vector/TestSIMDLd3St3.java index c6d41c0..b2b6265 100644 --- a/src/main/java/org/linaro/benchmarks/TestSIMDLd3St3.java +++ b/src/main/java/org/linaro/benchmarks/vector/TestSIMDLd3St3.java @@ -14,7 +14,7 @@ * limitations under the License. * */ -package org.linaro.benchmarks; +package org.linaro.benchmarks.vector; import org.openjdk.jmh.annotations.*; import java.util.concurrent.TimeUnit; @@ -24,7 +24,8 @@ import java.util.concurrent.TimeUnit; @State(Scope.Benchmark) public class TestSIMDLd3St3 { - static final int VECT_LENGTH = 256 * 1024; + static final int VECT_LENGTH = 1024; + static final int COUNT = 128; static final int DIM = 3; static final int LENGTH = VECT_LENGTH * DIM; static int [] in = new int[LENGTH]; @@ -110,10 +111,12 @@ public class TestSIMDLd3St3 { @Benchmark public void testVect3D() { - vect3DAddInt(out, in, c); - vect3DMulInt(out, in, c); - vect3DAddShort(sout, sin, sc); - vect3DMulShort(sout, sin, sc); + for (int i = 0; i < COUNT; i++) { + vect3DAddInt(out, in, c); + vect3DMulInt(out, in, c); + vect3DAddShort(sout, sin, sc); + vect3DMulShort(sout, sin, sc); + } } } diff --git a/src/main/java/org/linaro/benchmarks/TestSIMDLd4St4.java b/src/main/java/org/linaro/benchmarks/vector/TestSIMDLd4St4.java index 01b7667..e53075c 100644 --- a/src/main/java/org/linaro/benchmarks/TestSIMDLd4St4.java +++ b/src/main/java/org/linaro/benchmarks/vector/TestSIMDLd4St4.java @@ -14,7 +14,7 @@ * limitations under the License. * */ -package org.linaro.benchmarks; +package org.linaro.benchmarks.vector; import org.openjdk.jmh.annotations.*; import java.util.concurrent.TimeUnit; @@ -24,7 +24,8 @@ import java.util.concurrent.TimeUnit; @State(Scope.Benchmark) public class TestSIMDLd4St4 { - static final int VECT_LENGTH = 256 * 1024; + static final int VECT_LENGTH = 1024; + static final int COUNT = 128; static final int DIM = 4; static final int LENGTH = VECT_LENGTH * DIM; static int [] in = new int[LENGTH]; @@ -118,10 +119,12 @@ public class TestSIMDLd4St4 { @Benchmark public void testVect4D() { - vect4DAddInt(out, in, c); - vect4DMulInt(out, in, c); - vect4DAddShort(sout, sin, sc); - vect4DMulShort(sout, sin, sc); + for (int i = 0; i < COUNT; i++) { + vect4DAddInt(out, in, c); + vect4DMulInt(out, in, c); + vect4DAddShort(sout, sin, sc); + vect4DMulShort(sout, sin, sc); + } } } diff --git a/src/main/java/org/linaro/benchmarks/TestSIMDMlaInt.java b/src/main/java/org/linaro/benchmarks/vector/TestSIMDMlaInt.java index 9532c93..08b1f22 100644 --- a/src/main/java/org/linaro/benchmarks/TestSIMDMlaInt.java +++ b/src/main/java/org/linaro/benchmarks/vector/TestSIMDMlaInt.java @@ -14,7 +14,7 @@ * limitations under the License. * */ -package org.linaro.benchmarks; +package org.linaro.benchmarks.vector; import org.openjdk.jmh.annotations.*; import java.util.concurrent.TimeUnit; @@ -24,7 +24,8 @@ import java.util.concurrent.TimeUnit; @State(Scope.Benchmark) public class TestSIMDMlaInt { - static final int LENGTH = 256 * 1024; + static final int LENGTH = 1024; + static final int COUNT = 128; static int [] a = new int[LENGTH]; static int [] b = new int[LENGTH]; static int [] c = new int[LENGTH]; @@ -86,19 +87,25 @@ public class TestSIMDMlaInt { @Benchmark public void testVectSumOfMulAdd1() { int sum = 0; - sum = vectSumOfMulAdd1(a, b, c, d); + for (int i = 0; i < COUNT; i++) { + sum += vectSumOfMulAdd1(a, b, c, d); + } } @Benchmark public void testVectSumOfMulAdd2() { int sum = 0; - sum = vectSumOfMulAdd2(a, b, c, d); + for (int i = 0; i < COUNT; i++) { + sum += vectSumOfMulAdd2(a, b, c, d); + } } @Benchmark public void testVectSumOfMulAdd3() { int sum = 0; - sum = vectSumOfMulAdd3(a, b, c, d); + for (int i = 0; i < COUNT; i++) { + sum += vectSumOfMulAdd3(a, b, c, d); + } } } diff --git a/src/main/java/org/linaro/benchmarks/TestSIMDMlaShort.java b/src/main/java/org/linaro/benchmarks/vector/TestSIMDMlaShort.java index 836595f..68e27d5 100644 --- a/src/main/java/org/linaro/benchmarks/TestSIMDMlaShort.java +++ b/src/main/java/org/linaro/benchmarks/vector/TestSIMDMlaShort.java @@ -14,7 +14,7 @@ * limitations under the License. * */ -package org.linaro.benchmarks; +package org.linaro.benchmarks.vector; import org.openjdk.jmh.annotations.*; import java.util.concurrent.TimeUnit; @@ -24,7 +24,8 @@ import java.util.concurrent.TimeUnit; @State(Scope.Benchmark) public class TestSIMDMlaShort { - static final int LENGTH = 256 * 1024; + static final int LENGTH = 1024; + static final int COUNT = 128; static short [] a = new short[LENGTH]; static short [] b = new short[LENGTH]; static short [] c = new short[LENGTH]; @@ -116,33 +117,45 @@ public class TestSIMDMlaShort { @Benchmark public void testVectSumOfMulAdd1() { int sum = 0; - sum = vectSumOfMulAdd1(a, b, c, d); + for (int i = 0; i < COUNT; i++) { + sum += vectSumOfMulAdd1(a, b, c, d); + } } @Benchmark public void testVectSumOfMulAdd2() { int sum = 0; - sum = vectSumOfMulAdd2(a, b, c, d); + for (int i = 0; i < COUNT; i++) { + sum += vectSumOfMulAdd2(a, b, c, d); + } } @Benchmark public void testVectSumOfMulAdd3() { int sum = 0; - sum = vectSumOfMulAdd3(a, b, c, d); + for (int i = 0; i < COUNT; i++) { + sum += vectSumOfMulAdd3(a, b, c, d); + } } @Benchmark public void testVectMulAdd1() { - vectMulAdd1(a, b, c, d); + for (int i = 0; i < COUNT; i++) { + vectMulAdd1(a, b, c, d); + } } @Benchmark public void testVectMulAdd2() { - vectMulAdd2(a, b, c, d); + for (int i = 0; i < COUNT; i++) { + vectMulAdd2(a, b, c, d); + } } @Benchmark public void testVectMulAdd3() { - vectMulAdd3(a, b, c, d); + for (int i = 0; i < COUNT; i++) { + vectMulAdd3(a, b, c, d); + } } } diff --git a/src/main/java/org/linaro/benchmarks/TestSIMDMul.java b/src/main/java/org/linaro/benchmarks/vector/TestSIMDMul.java index 37a16bc..3210e8d 100644 --- a/src/main/java/org/linaro/benchmarks/TestSIMDMul.java +++ b/src/main/java/org/linaro/benchmarks/vector/TestSIMDMul.java @@ -14,7 +14,7 @@ * limitations under the License. * */ -package org.linaro.benchmarks; +package org.linaro.benchmarks.vector; import org.openjdk.jmh.annotations.*; import java.util.concurrent.TimeUnit; @@ -24,7 +24,8 @@ import java.util.concurrent.TimeUnit; @State(Scope.Benchmark) public class TestSIMDMul { - static final int LENGTH = 1024 * 256; + static final int LENGTH = 1024; + static final int COUNT = 128; static int [] a = new int[LENGTH]; static int [] b = new int[LENGTH]; static int [] c = new int[LENGTH]; @@ -34,6 +35,15 @@ public class TestSIMDMul { static byte [] ba = new byte[LENGTH]; static byte [] bb = new byte[LENGTH]; static byte [] bc = new byte[LENGTH]; + static long [] la = new long[LENGTH]; + static long [] lb = new long[LENGTH]; + static long [] lc = new long[LENGTH]; + static float [] fa = new float[LENGTH]; + static float [] fb = new float[LENGTH]; + static float [] fc = new float[LENGTH]; + static double [] da = new double[LENGTH]; + static double [] db = new double[LENGTH]; + static double [] dc = new double[LENGTH]; public static void TestSIMDMulInit() { for (int i = 0; i < LENGTH; i++) { @@ -46,6 +56,15 @@ public class TestSIMDMul { ba[i] = (byte)(i + 3); bb[i] = (byte)(i + 2); bc[i] = (byte)(i + 1); + la[i] = (long)(i + 3); + lb[i] = (long)(i + 2); + lc[i] = (long)(i + 1); + fa[i] = (float)(i + 3); + fb[i] = (float)(i + 2); + fc[i] = (float)(i + 1); + da[i] = (double)(i + 3); + db[i] = (double)(i + 2); + dc[i] = (double)(i + 1); } } @@ -67,6 +86,24 @@ public class TestSIMDMul { } } + public static void vectMulLong() { + for (int i = 0; i < LENGTH; i++) { + lc[i] = la[i] * lb[i]; + } + } + + public static void vectMulFloat() { + for (int i = 0; i < LENGTH; i++) { + fc[i] = fa[i] * fb[i]; + } + } + + public static void vectMulDouble() { + for (int i = 0; i < LENGTH; i++) { + dc[i] = da[i] * db[i]; + } + } + @Setup public void setup() { @@ -75,17 +112,44 @@ public class TestSIMDMul { @Benchmark public void testVectMulByte() { - vectMulByte(); + for (int i = 0; i < COUNT; i++) { + vectMulByte(); + } } @Benchmark public void testVectMulShort() { - vectMulShort(); + for (int i = 0; i < COUNT; i++) { + vectMulShort(); + } } @Benchmark public void tesVectMulInt() { - vectMulInt(); + for (int i = 0; i < COUNT; i++) { + vectMulInt(); + } + } + + @Benchmark + public void testVectMulLong() { + for (int i = 0; i < COUNT; i++) { + vectMulLong(); + } + } + + @Benchmark + public void testVectMulFloat() { + for (int i = 0; i < COUNT; i++) { + vectMulFloat(); + } + } + + @Benchmark + public void testVectMulDouble() { + for (int i = 0; i < COUNT; i++) { + vectMulDouble(); + } } } diff --git a/src/main/java/org/linaro/benchmarks/vector/TestSIMDMulC.java b/src/main/java/org/linaro/benchmarks/vector/TestSIMDMulC.java new file mode 100644 index 0000000..1b75325 --- /dev/null +++ b/src/main/java/org/linaro/benchmarks/vector/TestSIMDMulC.java @@ -0,0 +1,85 @@ +/* + * Copyright (C) 2017 Linaro Limited. All rights received. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ +package org.linaro.benchmarks.vector; + +import org.openjdk.jmh.annotations.*; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) + +public class TestSIMDMulC { + static final int LENGTH = 1024; + static final int COUNT = 200; + static int [] a = new int[LENGTH]; + static int [] b = new int[LENGTH]; + static int [] c = new int[LENGTH]; + + public static void testSIMDMulCInit() { + for (int i = 0; i < LENGTH; i++) { + a[i] = i + 3; + b[i] = i + 2; + c[i] = i + 1; + } + } + + public static void mulCInt1( + int[] a, + int[] b, + int[] c, + int loop) { + for (int i = 0; i < loop; i++) { + int t0 = a[i] * 5; + int t1 = b[i] * 10; + c[i] = t0 + t1; + } + } + + public static void mulCInt2( + int[] a, + int[] b, + int[] c, + int loop) { + for (int i = 0; i < loop; i++) { + int t0 = a[i] * 9; + int t1 = b[i] * 17; + c[i] = t0 + t1; + } + } + + @Setup + public void setup() + { + testSIMDMulCInit(); + } + + @Benchmark + public void testSIMDMulCInt1() { + for (int i = 0; i < COUNT; i++) { + mulCInt1(a, b, c, LENGTH); + } + } + + @Benchmark + public void testSIMDMulCInt2() { + for (int i = 0; i < COUNT; i++) { + mulCInt2(a, b, c, LENGTH); + } + } + +} |