diff options
17 files changed, 2873 insertions, 0 deletions
diff --git a/apct-tests/perftests/core/src/android/libcore/regression/AnnotatedElementPerfTest.java b/apct-tests/perftests/core/src/android/libcore/regression/AnnotatedElementPerfTest.java new file mode 100644 index 000000000000..d38d5197b937 --- /dev/null +++ b/apct-tests/perftests/core/src/android/libcore/regression/AnnotatedElementPerfTest.java @@ -0,0 +1,331 @@ +/* + * Copyright (C) 2022 The Android Open Source Project + * + * 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 android.libcore.regression; + +import android.perftests.utils.BenchmarkState; +import android.perftests.utils.PerfStatusReporter; +import android.test.suitebuilder.annotation.LargeTest; + +import androidx.test.runner.AndroidJUnit4; + +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; +import org.junit.runner.RunWith; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.reflect.Field; +import java.lang.reflect.Method; + +@RunWith(AndroidJUnit4.class) +@LargeTest +public class AnnotatedElementPerfTest { + @Rule public PerfStatusReporter mPerfStatusReporter = new PerfStatusReporter(); + + private Class<?> mType; + private Field mField; + private Method mMethod; + + @Before + public void setUp() throws Exception { + mType = Type.class; + mField = Type.class.getField("field"); + mMethod = Type.class.getMethod("method", String.class); + } + + // get annotations by member type and method + + @Test + public void timeGetTypeAnnotations() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + mType.getAnnotations(); + } + } + + @Test + public void timeGetFieldAnnotations() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + mField.getAnnotations(); + } + } + + @Test + public void timeGetMethodAnnotations() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + mMethod.getAnnotations(); + } + } + + @Test + public void timeGetParameterAnnotations() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + mMethod.getParameterAnnotations(); + } + } + + @Test + public void timeGetTypeAnnotation() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + mType.getAnnotation(Marker.class); + } + } + + @Test + public void timeGetFieldAnnotation() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + mField.getAnnotation(Marker.class); + } + } + + @Test + public void timeGetMethodAnnotation() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + mMethod.getAnnotation(Marker.class); + } + } + + @Test + public void timeIsTypeAnnotationPresent() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + mType.isAnnotationPresent(Marker.class); + } + } + + @Test + public void timeIsFieldAnnotationPresent() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + mField.isAnnotationPresent(Marker.class); + } + } + + @Test + public void timeIsMethodAnnotationPresent() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + mMethod.isAnnotationPresent(Marker.class); + } + } + + // get annotations by result size + + @Test + public void timeGetAllReturnsLargeAnnotation() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + HasLargeAnnotation.class.getAnnotations(); + } + } + + @Test + public void timeGetAllReturnsSmallAnnotation() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + HasSmallAnnotation.class.getAnnotations(); + } + } + + @Test + public void timeGetAllReturnsMarkerAnnotation() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + HasMarkerAnnotation.class.getAnnotations(); + } + } + + @Test + public void timeGetAllReturnsNoAnnotation() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + HasNoAnnotations.class.getAnnotations(); + } + } + + @Test + public void timeGetAllReturnsThreeAnnotations() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + HasThreeAnnotations.class.getAnnotations(); + } + } + + // get annotations with inheritance + + @Test + public void timeGetAnnotationsOnSubclass() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + ExtendsHasThreeAnnotations.class.getAnnotations(); + } + } + + @Test + public void timeGetDeclaredAnnotationsOnSubclass() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + ExtendsHasThreeAnnotations.class.getDeclaredAnnotations(); + } + } + + // get annotations with enclosing / inner classes + + @Test + public void timeGetDeclaredClasses() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + AnnotatedElementPerfTest.class.getDeclaredClasses(); + } + } + + @Test + public void timeGetDeclaringClass() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + HasSmallAnnotation.class.getDeclaringClass(); + } + } + + @Test + public void timeGetEnclosingClass() { + Object anonymousClass = new Object() {}; + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + anonymousClass.getClass().getEnclosingClass(); + } + } + + @Test + public void timeGetEnclosingConstructor() { + Object anonymousClass = new Object() {}; + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + anonymousClass.getClass().getEnclosingConstructor(); + } + } + + @Test + public void timeGetEnclosingMethod() { + Object anonymousClass = new Object() {}; + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + anonymousClass.getClass().getEnclosingMethod(); + } + } + + @Test + public void timeGetModifiers() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + HasSmallAnnotation.class.getModifiers(); + } + } + + @Test + public void timeGetSimpleName() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + HasSmallAnnotation.class.getSimpleName(); + } + } + + @Test + public void timeIsAnonymousClass() { + Object anonymousClass = new Object() {}; + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + anonymousClass.getClass().isAnonymousClass(); + } + } + + @Test + public void timeIsLocalClass() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + HasSmallAnnotation.class.isLocalClass(); + } + } + + // the annotated elements + + @Marker + public class Type { + @Marker public String field; + + @Marker + public void method(@Marker String parameter) {} + } + + @Large( + a = "on class", + b = {"A", "B", "C"}, + c = @Small(e = "E1", f = 1695938256, g = 7264081114510713000L), + d = {@Small(e = "E2", f = 1695938256, g = 7264081114510713000L)}) + public class HasLargeAnnotation {} + + @Small(e = "E1", f = 1695938256, g = 7264081114510713000L) + public class HasSmallAnnotation {} + + @Marker + public class HasMarkerAnnotation {} + + public class HasNoAnnotations {} + + @Large( + a = "on class", + b = {"A", "B", "C"}, + c = @Small(e = "E1", f = 1695938256, g = 7264081114510713000L), + d = {@Small(e = "E2", f = 1695938256, g = 7264081114510713000L)}) + @Small(e = "E1", f = 1695938256, g = 7264081114510713000L) + @Marker + public class HasThreeAnnotations {} + + public class ExtendsHasThreeAnnotations extends HasThreeAnnotations {} + + // the annotations + + @Retention(RetentionPolicy.RUNTIME) + public @interface Marker {} + + @Retention(RetentionPolicy.RUNTIME) + public @interface Large { + String a() default ""; + + String[] b() default {}; + + Small c() default @Small; + + Small[] d() default {}; + } + + @Retention(RetentionPolicy.RUNTIME) + public @interface Small { + String e() default ""; + + int f() default 0; + + long g() default 0L; + } +} diff --git a/apct-tests/perftests/core/src/android/libcore/regression/BidiPerfTest.java b/apct-tests/perftests/core/src/android/libcore/regression/BidiPerfTest.java new file mode 100644 index 000000000000..cc56868468e5 --- /dev/null +++ b/apct-tests/perftests/core/src/android/libcore/regression/BidiPerfTest.java @@ -0,0 +1,128 @@ +/* + * Copyright (C) 2015 The Android Open Source Project + * + * 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 android.libcore.regression; + +import android.perftests.utils.BenchmarkState; +import android.perftests.utils.PerfStatusReporter; +import android.test.suitebuilder.annotation.LargeTest; + +import androidx.test.runner.AndroidJUnit4; + +import org.junit.Rule; +import org.junit.Test; +import org.junit.runner.RunWith; + +import java.math.BigDecimal; +import java.text.AttributedCharacterIterator; +import java.text.Bidi; +import java.text.DecimalFormat; + +@RunWith(AndroidJUnit4.class) +@LargeTest +public class BidiPerfTest { + @Rule public PerfStatusReporter mPerfStatusReporter = new PerfStatusReporter(); + + private static final AttributedCharacterIterator CHAR_ITER = + DecimalFormat.getInstance().formatToCharacterIterator(new BigDecimal(Math.PI)); + + @Test + public void time_createBidiFromIter() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + Bidi bidi = new Bidi(CHAR_ITER); + } + } + + @Test + public void time_createBidiFromCharArray() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + Bidi bd = + new Bidi( + new char[] {'s', 's', 's'}, + 0, + new byte[] {(byte) 1, (byte) 2, (byte) 3}, + 0, + 3, + Bidi.DIRECTION_RIGHT_TO_LEFT); + } + } + + @Test + public void time_createBidiFromString() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + Bidi bidi = new Bidi("Hello", Bidi.DIRECTION_LEFT_TO_RIGHT); + } + } + + @Test + public void time_reorderVisually() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + Bidi.reorderVisually( + new byte[] {2, 1, 3, 0, 4}, 0, new String[] {"H", "e", "l", "l", "o"}, 0, 5); + } + } + + @Test + public void time_hebrewBidi() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + Bidi bd = + new Bidi( + new char[] {'\u05D0', '\u05D0', '\u05D0'}, + 0, + new byte[] {(byte) -1, (byte) -2, (byte) -3}, + 0, + 3, + Bidi.DIRECTION_DEFAULT_RIGHT_TO_LEFT); + bd = + new Bidi( + new char[] {'\u05D0', '\u05D0', '\u05D0'}, + 0, + new byte[] {(byte) -1, (byte) -2, (byte) -3}, + 0, + 3, + Bidi.DIRECTION_LEFT_TO_RIGHT); + } + } + + @Test + public void time_complicatedOverrideBidi() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + Bidi bd = + new Bidi( + "a\u05D0a\"a\u05D0\"\u05D0a".toCharArray(), + 0, + new byte[] {0, 0, 0, -3, -3, 2, 2, 0, 3}, + 0, + 9, + Bidi.DIRECTION_RIGHT_TO_LEFT); + } + } + + @Test + public void time_requiresBidi() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + Bidi.requiresBidi("\u05D0".toCharArray(), 1, 1); // false. + Bidi.requiresBidi("\u05D0".toCharArray(), 0, 1); // true. + } + } +} diff --git a/apct-tests/perftests/core/src/android/libcore/regression/BigIntegerPerfTest.java b/apct-tests/perftests/core/src/android/libcore/regression/BigIntegerPerfTest.java new file mode 100644 index 000000000000..662694b1b5d1 --- /dev/null +++ b/apct-tests/perftests/core/src/android/libcore/regression/BigIntegerPerfTest.java @@ -0,0 +1,69 @@ +/* + * Copyright (C) 2022 The Android Open Source Project + * + * 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 android.libcore.regression; + +import android.perftests.utils.BenchmarkState; +import android.perftests.utils.PerfStatusReporter; +import android.test.suitebuilder.annotation.LargeTest; + +import androidx.test.runner.AndroidJUnit4; + +import org.junit.Rule; +import org.junit.Test; +import org.junit.runner.RunWith; + +import java.math.BigInteger; +import java.util.Random; + +@RunWith(AndroidJUnit4.class) +@LargeTest +public class BigIntegerPerfTest { + @Rule public PerfStatusReporter mPerfStatusReporter = new PerfStatusReporter(); + + @Test + public void timeRandomDivision() throws Exception { + Random r = new Random(); + BigInteger x = new BigInteger(1024, r); + BigInteger y = new BigInteger(1024, r); + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + x.divide(y); + } + } + + @Test + public void timeRandomGcd() throws Exception { + Random r = new Random(); + BigInteger x = new BigInteger(1024, r); + BigInteger y = new BigInteger(1024, r); + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + x.gcd(y); + } + } + + @Test + public void timeRandomMultiplication() throws Exception { + Random r = new Random(); + BigInteger x = new BigInteger(1024, r); + BigInteger y = new BigInteger(1024, r); + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + x.multiply(y); + } + } +} diff --git a/apct-tests/perftests/core/src/android/libcore/regression/BitSetPerfTest.java b/apct-tests/perftests/core/src/android/libcore/regression/BitSetPerfTest.java new file mode 100644 index 000000000000..db5462cd69bf --- /dev/null +++ b/apct-tests/perftests/core/src/android/libcore/regression/BitSetPerfTest.java @@ -0,0 +1,115 @@ +/* + * Copyright (C) 2022 The Android Open Source Project + * + * 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 android.libcore.regression; + +import android.perftests.utils.BenchmarkState; +import android.perftests.utils.PerfStatusReporter; +import android.test.suitebuilder.annotation.LargeTest; + +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; +import org.junit.runners.Parameterized.Parameters; + +import java.util.Arrays; +import java.util.BitSet; +import java.util.Collection; + +@RunWith(Parameterized.class) +@LargeTest +public class BitSetPerfTest { + @Rule public PerfStatusReporter mPerfStatusReporter = new PerfStatusReporter(); + + @Parameters(name = "mSize={0}") + public static Collection<Object[]> data() { + return Arrays.asList(new Object[][] {{1000}, {10000}}); + } + + @Parameterized.Parameter(0) + public int mSize; + + private BitSet mBitSet; + + @Before + public void setUp() throws Exception { + mBitSet = new BitSet(mSize); + } + + @Test + public void timeIsEmptyTrue() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + if (!mBitSet.isEmpty()) throw new RuntimeException(); + } + } + + @Test + public void timeIsEmptyFalse() { + mBitSet.set(mBitSet.size() - 1); + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + if (mBitSet.isEmpty()) throw new RuntimeException(); + } + } + + @Test + public void timeGet() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + int i = 1; + while (state.keepRunning()) { + mBitSet.get(++i % mSize); + } + } + + @Test + public void timeClear() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + int i = 1; + while (state.keepRunning()) { + mBitSet.clear(++i % mSize); + } + } + + @Test + public void timeSet() { + int i = 1; + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + mBitSet.set(++i % mSize); + } + } + + @Test + public void timeSetOn() { + int i = 1; + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + mBitSet.set(++i % mSize, true); + } + } + + @Test + public void timeSetOff() { + int i = 1; + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + mBitSet.set(++i % mSize, false); + } + } +} diff --git a/apct-tests/perftests/core/src/android/libcore/regression/BreakIteratorPerfTest.java b/apct-tests/perftests/core/src/android/libcore/regression/BreakIteratorPerfTest.java new file mode 100644 index 000000000000..3952c12b3bfe --- /dev/null +++ b/apct-tests/perftests/core/src/android/libcore/regression/BreakIteratorPerfTest.java @@ -0,0 +1,193 @@ +/* + * Copyright (C) 2014 The Android Open Source Project + * + * 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 android.libcore.regression; + +import android.perftests.utils.BenchmarkState; +import android.perftests.utils.PerfStatusReporter; +import android.test.suitebuilder.annotation.LargeTest; + +import org.junit.Rule; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; +import org.junit.runners.Parameterized.Parameters; + +import java.text.BreakIterator; +import java.util.Arrays; +import java.util.Collection; +import java.util.Locale; + +@RunWith(Parameterized.class) +@LargeTest +public final class BreakIteratorPerfTest { + @Rule public PerfStatusReporter mPerfStatusReporter = new PerfStatusReporter(); + + public enum Text { + LIPSUM( + Locale.US, + "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Morbi mollis consequat" + + " nisl non pharetra. Praesent pretium vehicula odio sed ultrices. Aenean a" + + " felis libero. Vivamus sed commodo nibh. Pellentesque turpis lectus, euismod" + + " vel ante nec, cursus posuere orci. Suspendisse velit neque, fermentum" + + " luctus ultrices in, ultrices vitae arcu. Duis tincidunt cursus lorem. Nam" + + " ultricies accumsan quam vitae imperdiet. Pellentesque habitant morbi" + + " tristique senectus et netus et malesuada fames ac turpis egestas. Quisque" + + " aliquet pretium nisi, eget laoreet enim molestie sit amet. Class aptent" + + " taciti sociosqu ad litora torquent per conubia nostra, per inceptos" + + " himenaeos.\n" + + "Nam dapibus aliquam lacus ac suscipit. Proin in nibh sit amet purus congue" + + " laoreet eget quis nisl. Morbi gravida dignissim justo, a venenatis ante" + + " pulvinar at. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin" + + " ultrices vestibulum dui, vel aliquam lacus aliquam quis. Duis fringilla" + + " sapien ac lacus egestas, vel adipiscing elit euismod. Donec non tellus" + + " odio. Donec gravida eu massa ac feugiat. Aliquam erat volutpat. Praesent id" + + " adipiscing metus, nec laoreet enim. Aliquam vitae posuere turpis. Mauris ac" + + " pharetra sem. In at placerat tortor. Vivamus ac vehicula neque. Cras" + + " volutpat ullamcorper massa et varius. Praesent sagittis neque vitae nulla" + + " euismod pharetra.\n" + + "Sed placerat sapien non molestie sollicitudin. Nullam sit amet dictum quam." + + " Etiam tincidunt tortor vel pretium vehicula. Praesent fringilla ipsum vel" + + " velit luctus dignissim. Nulla massa ligula, mattis in enim et, mattis" + + " lacinia odio. Suspendisse tristique urna a orci commodo tempor. Duis" + + " lacinia egestas arcu a sollicitudin.\n" + + "In ac feugiat lacus. Nunc fermentum eu est at tristique. Pellentesque quis" + + " ligula et orci placerat lacinia. Maecenas quis mauris diam. Etiam mi ipsum," + + " tempus in purus quis, euismod faucibus orci. Nulla facilisi. Praesent sit" + + " amet sapien vel elit porta adipiscing. Phasellus sit amet volutpat diam.\n" + + "Proin bibendum elit non lacus pharetra, quis eleifend tellus placerat. Nulla" + + " facilisi. Maecenas ante diam, pellentesque mattis mattis in, porta ut" + + " lorem. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices" + + " posuere cubilia Curae; Nunc interdum tristique metus, in scelerisque odio" + + " fermentum eget. Cras nec venenatis lacus. Aenean euismod eget metus quis" + + " molestie. Cras tincidunt dolor ut massa ornare, in elementum lacus auctor." + + " Cras sodales nisl lacus, id ultrices ligula varius at. Sed tristique sit" + + " amet tellus vel mollis. Sed sed sollicitudin quam. Sed sed adipiscing" + + " risus, et dictum orci. Cras tempor pellentesque turpis et tempus."), + LONGPARA( + Locale.US, + "During dinner, Mr. Bennet scarcely spoke at all; but when the servants were" + + " withdrawn, he thought it time to have some conversation with his guest, and" + + " therefore started a subject in which he expected him to shine, by observing" + + " that he seemed very fortunate in his patroness. Lady Catherine de Bourgh's" + + " attention to his wishes, and consideration for his comfort, appeared very" + + " remarkable. Mr. Bennet could not have chosen better. Mr. Collins was" + + " eloquent in her praise. The subject elevated him to more than usual" + + " solemnity of manner, and with a most important aspect he protested that" + + " \"he had never in his life witnessed such behaviour in a person of" + + " rank--such affability and condescension, as he had himself experienced from" + + " Lady Catherine. She had been graciously pleased to approve of both of the" + + " discourses which he had already had the honour of preaching before her. She" + + " had also asked him twice to dine at Rosings, and had sent for him only the" + + " Saturday before, to make up her pool of quadrille in the evening. Lady" + + " Catherine was reckoned proud by many people he knew, but _he_ had never" + + " seen anything but affability in her. She had always spoken to him as she" + + " would to any other gentleman; she made not the smallest objection to his" + + " joining in the society of the neighbourhood nor to his leaving the parish" + + " occasionally for a week or two, to visit his relations. She had even" + + " condescended to advise him to marry as soon as he could, provided he chose" + + " with discretion; and had once paid him a visit in his humble parsonage," + + " where she had perfectly approved all the alterations he had been making," + + " and had even vouchsafed to suggest some herself--some shelves in the closet" + + " up stairs.\""), + GERMAN( + Locale.GERMANY, + "Aber dieser Freiheit setzte endlich der Winter ein Ziel. Draußen auf den Feldern" + + " und den hohen Bergen lag der Schnee und Peter wäre in seinem dünnen" + + " Leinwandjäckchen bald erfroren. Es war also seine einzige Freude, hinaus" + + " vor die Hütte zu treten und den Sperlingen Brotkrümchen zu streuen, was er" + + " sich jedesmal an seinem Frühstück absparte. Wenn nun die Vögel so lustig" + + " zwitscherten und um ihn herumflogen, da klopfte ihm das Herz vor Lust, und" + + " oft gab er ihnen sein ganzes Stück Schwarzbrot, ohne daran zu denken, daß" + + " er dafür alsdann selbst hungern müsse."), + THAI( + Locale.forLanguageTag("th-TH"), + "เป็นสำเนียงทางการของภาษาไทย" + + " เดิมทีเป็นการผสมผสานกันระหว่างสำเนียงอยุธยาและชาวไทยเชื้อสายจีนรุ่นหลังที่" + + "พูดไทยแทนกลุ่มภาษาจีน" + + " ลักษณะเด่นคือมีการออกเสียงที่ชัดเจนและแข็งกระด้างซึ่งได้รับอิทธิพลจากภาษาแต" + + "้จิ๋ว" + + " การออกเสียงพยัญชนะ สระ การผันวรรณยุกต์ที่ในภาษาไทยมาตรฐาน" + + " มาจากสำเนียงถิ่นนี้ในขณะที่ภาษาไทยสำเนียงอื่นล้วนเหน่อทั้งสิ้น" + + " คำศัพท์ที่ใช้ในสำเนียงกรุงเทพจำนวนมากได้รับมาจากกลุ่มภาษาจีนเช่นคำว่า โป๊," + + " เฮ็ง, อาหมวย, อาซิ่ม ซึ่งมาจากภาษาแต้จิ๋ว และจากภาษาจีนเช่น ถู(涂), ชิ่ว(去" + + " อ่านว่า\"ชู่\") และคำว่า ทาย(猜 อ่านว่า \"ชาย\") เป็นต้น" + + " เนื่องจากสำเนียงกรุงเทพได้รับอิทธิพลมาจากภาษาจีนดังนั้นตัวอักษร \"ร\"" + + " มักออกเสียงเหมารวมเป็น \"ล\" หรือคำควบกล่ำบางคำถูกละทิ้งไปด้วยเช่น รู้ เป็น" + + " ลู้, เรื่อง เป็น เลื่อง หรือ ประเทศ เป็น ปะเทศ" + + " เป็นต้นสร้างความลำบากให้แก่ต่างชาติที่ต้องการเรียนภาษาไทย" + + " แต่อย่างไรก็ตามผู้ที่พูดสำเนียงถิ่นนี้ก็สามารถออกอักขระภาษาไทยตามมาตรฐานได" + + "้อย่างถูกต้องเพียงแต่มักเผลอไม่ค่อยออกเสียง"), + THAI2(Locale.forLanguageTag("th-TH"), "this is the word browser in Thai: เบราว์เซอร์"), + TABS(Locale.US, "one\t\t\t\t\t\t\t\t\t\t\t\t\t\ttwo\n"), + ACCENT(Locale.US, "e\u0301\u00e9\nwhich is:\n\"e\\u0301\\u00e9\""), + EMOJI(Locale.US, ">>\ud83d\ude01<<\nwhich is:\n\">>\\ud83d\\ude01<<\""), + SPACES(Locale.US, " leading spaces and trailing ones too "), + EMPTY(Locale.US, ""), + NEWLINE(Locale.US, "\\n:\n"), + BIDI( + Locale.forLanguageTag("he-IL"), + "Sarah שרה is spelled sin ש resh ר heh ה from right to left."); + + final Locale mLocale; + final String mText; + + Text(Locale locale, String text) { + this.mText = text; + this.mLocale = locale; + } + } + + @Parameters(name = "mText={0}") + public static Collection<Object[]> data() { + return Arrays.asList( + new Object[][] { + {Text.ACCENT}, {Text.BIDI}, {Text.EMOJI}, {Text.EMPTY}, {Text.GERMAN}, + {Text.LIPSUM}, {Text.LONGPARA}, {Text.NEWLINE}, {Text.SPACES}, {Text.TABS}, + {Text.THAI}, {Text.THAI2} + }); + } + + @Parameterized.Parameter(0) + public Text mText; + + @Test + public void timeBreakIterator() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + BreakIterator it = BreakIterator.getLineInstance(mText.mLocale); + it.setText(mText.mText); + + while (it.next() != BreakIterator.DONE) { + // Keep iterating + } + } + } + + @Test + public void timeIcuBreakIterator() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + android.icu.text.BreakIterator it = + android.icu.text.BreakIterator.getLineInstance(mText.mLocale); + it.setText(mText.mText); + + while (it.next() != android.icu.text.BreakIterator.DONE) { + // Keep iterating + } + } + } +} diff --git a/apct-tests/perftests/core/src/android/libcore/regression/ByteBufferBulkPerfTest.java b/apct-tests/perftests/core/src/android/libcore/regression/ByteBufferBulkPerfTest.java new file mode 100644 index 000000000000..8e57b28a0550 --- /dev/null +++ b/apct-tests/perftests/core/src/android/libcore/regression/ByteBufferBulkPerfTest.java @@ -0,0 +1,139 @@ +/* + * Copyright (C) 2022 The Android Open Source Project. + * + * 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 android.libcore.regression; + +import android.perftests.utils.BenchmarkState; +import android.perftests.utils.PerfStatusReporter; +import android.test.suitebuilder.annotation.LargeTest; + +import org.junit.Rule; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; +import org.junit.runners.Parameterized.Parameters; + +import java.io.File; +import java.io.IOException; +import java.io.RandomAccessFile; +import java.nio.ByteBuffer; +import java.nio.channels.FileChannel; +import java.util.Arrays; +import java.util.Collection; + +@RunWith(Parameterized.class) +@LargeTest +public class ByteBufferBulkPerfTest { + @Rule public PerfStatusReporter mPerfStatusReporter = new PerfStatusReporter(); + + @Parameters(name = "mAligned({0}), mSrcBufferType({1}), mDataBufferType({2}), mBufferSize({3})") + public static Collection<Object[]> data() { + return Arrays.asList( + new Object[][] { + {true, MyBufferType.DIRECT, MyBufferType.DIRECT, 4096}, + {false, MyBufferType.DIRECT, MyBufferType.DIRECT, 4096}, + {true, MyBufferType.HEAP, MyBufferType.DIRECT, 4096}, + {false, MyBufferType.HEAP, MyBufferType.DIRECT, 4096}, + {true, MyBufferType.MAPPED, MyBufferType.DIRECT, 4096}, + {false, MyBufferType.MAPPED, MyBufferType.DIRECT, 4096}, + {true, MyBufferType.DIRECT, MyBufferType.HEAP, 4096}, + {false, MyBufferType.DIRECT, MyBufferType.HEAP, 4096}, + {true, MyBufferType.HEAP, MyBufferType.HEAP, 4096}, + {false, MyBufferType.HEAP, MyBufferType.HEAP, 4096}, + {true, MyBufferType.MAPPED, MyBufferType.HEAP, 4096}, + {false, MyBufferType.MAPPED, MyBufferType.HEAP, 4096}, + {true, MyBufferType.DIRECT, MyBufferType.MAPPED, 4096}, + {false, MyBufferType.DIRECT, MyBufferType.MAPPED, 4096}, + {true, MyBufferType.HEAP, MyBufferType.MAPPED, 4096}, + {false, MyBufferType.HEAP, MyBufferType.MAPPED, 4096}, + {true, MyBufferType.MAPPED, MyBufferType.MAPPED, 4096}, + {false, MyBufferType.MAPPED, MyBufferType.MAPPED, 4096}, + {true, MyBufferType.DIRECT, MyBufferType.DIRECT, 1232896}, + {false, MyBufferType.DIRECT, MyBufferType.DIRECT, 1232896}, + {true, MyBufferType.HEAP, MyBufferType.DIRECT, 1232896}, + {false, MyBufferType.HEAP, MyBufferType.DIRECT, 1232896}, + {true, MyBufferType.MAPPED, MyBufferType.DIRECT, 1232896}, + {false, MyBufferType.MAPPED, MyBufferType.DIRECT, 1232896}, + {true, MyBufferType.DIRECT, MyBufferType.HEAP, 1232896}, + {false, MyBufferType.DIRECT, MyBufferType.HEAP, 1232896}, + {true, MyBufferType.HEAP, MyBufferType.HEAP, 1232896}, + {false, MyBufferType.HEAP, MyBufferType.HEAP, 1232896}, + {true, MyBufferType.MAPPED, MyBufferType.HEAP, 1232896}, + {false, MyBufferType.MAPPED, MyBufferType.HEAP, 1232896}, + {true, MyBufferType.DIRECT, MyBufferType.MAPPED, 1232896}, + {false, MyBufferType.DIRECT, MyBufferType.MAPPED, 1232896}, + {true, MyBufferType.HEAP, MyBufferType.MAPPED, 1232896}, + {false, MyBufferType.HEAP, MyBufferType.MAPPED, 1232896}, + {true, MyBufferType.MAPPED, MyBufferType.MAPPED, 1232896}, + {false, MyBufferType.MAPPED, MyBufferType.MAPPED, 1232896}, + }); + } + + @Parameterized.Parameter(0) + public boolean mAligned; + + enum MyBufferType { + DIRECT, + HEAP, + MAPPED + } + + @Parameterized.Parameter(1) + public MyBufferType mSrcBufferType; + + @Parameterized.Parameter(2) + public MyBufferType mDataBufferType; + + @Parameterized.Parameter(3) + public int mBufferSize; + + public static ByteBuffer newBuffer(boolean aligned, MyBufferType bufferType, int bsize) + throws IOException { + int size = aligned ? bsize : bsize + 8 + 1; + ByteBuffer result = null; + switch (bufferType) { + case DIRECT: + result = ByteBuffer.allocateDirect(size); + break; + case HEAP: + result = ByteBuffer.allocate(size); + break; + case MAPPED: + File tmpFile = File.createTempFile("MappedByteBufferTest", ".tmp"); + tmpFile.createNewFile(); + tmpFile.deleteOnExit(); + RandomAccessFile raf = new RandomAccessFile(tmpFile, "rw"); + raf.setLength(size); + FileChannel fc = raf.getChannel(); + result = fc.map(FileChannel.MapMode.READ_WRITE, 0, fc.size()); + break; + } + result.position(aligned ? 0 : 1); + return result; + } + + @Test + public void timeByteBuffer_putByteBuffer() throws Exception { + ByteBuffer src = ByteBufferBulkPerfTest.newBuffer(mAligned, mSrcBufferType, mBufferSize); + ByteBuffer data = ByteBufferBulkPerfTest.newBuffer(mAligned, mDataBufferType, mBufferSize); + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + src.position(mAligned ? 0 : 1); + data.position(mAligned ? 0 : 1); + src.put(data); + } + } +} diff --git a/apct-tests/perftests/core/src/android/libcore/regression/ByteBufferPerfTest.java b/apct-tests/perftests/core/src/android/libcore/regression/ByteBufferPerfTest.java new file mode 100644 index 000000000000..4bd7c4e4fa82 --- /dev/null +++ b/apct-tests/perftests/core/src/android/libcore/regression/ByteBufferPerfTest.java @@ -0,0 +1,532 @@ +/* + * Copyright (C) 2022 The Android Open Source Project + * + * 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 android.libcore.regression; + +import android.perftests.utils.BenchmarkState; +import android.perftests.utils.PerfStatusReporter; +import android.test.suitebuilder.annotation.LargeTest; + +import org.junit.Rule; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; +import org.junit.runners.Parameterized.Parameters; + +import java.io.File; +import java.io.IOException; +import java.io.RandomAccessFile; +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.nio.CharBuffer; +import java.nio.DoubleBuffer; +import java.nio.FloatBuffer; +import java.nio.IntBuffer; +import java.nio.LongBuffer; +import java.nio.ShortBuffer; +import java.nio.channels.FileChannel; +import java.util.Arrays; +import java.util.Collection; + +@RunWith(Parameterized.class) +@LargeTest +public class ByteBufferPerfTest { + @Rule public PerfStatusReporter mPerfStatusReporter = new PerfStatusReporter(); + + public enum MyByteOrder { + BIG(ByteOrder.BIG_ENDIAN), + LITTLE(ByteOrder.LITTLE_ENDIAN); + final ByteOrder mByteOrder; + + MyByteOrder(ByteOrder mByteOrder) { + this.mByteOrder = mByteOrder; + } + } + + @Parameters(name = "mByteOrder={0}, mAligned={1}, mBufferType={2}") + public static Collection<Object[]> data() { + return Arrays.asList( + new Object[][] { + {MyByteOrder.BIG, true, MyBufferType.DIRECT}, + {MyByteOrder.LITTLE, true, MyBufferType.DIRECT}, + {MyByteOrder.BIG, false, MyBufferType.DIRECT}, + {MyByteOrder.LITTLE, false, MyBufferType.DIRECT}, + {MyByteOrder.BIG, true, MyBufferType.HEAP}, + {MyByteOrder.LITTLE, true, MyBufferType.HEAP}, + {MyByteOrder.BIG, false, MyBufferType.HEAP}, + {MyByteOrder.LITTLE, false, MyBufferType.HEAP}, + {MyByteOrder.BIG, true, MyBufferType.MAPPED}, + {MyByteOrder.LITTLE, true, MyBufferType.MAPPED}, + {MyByteOrder.BIG, false, MyBufferType.MAPPED}, + {MyByteOrder.LITTLE, false, MyBufferType.MAPPED} + }); + } + + @Parameterized.Parameter(0) + public MyByteOrder mByteOrder; + + @Parameterized.Parameter(1) + public boolean mAligned; + + enum MyBufferType { + DIRECT, + HEAP, + MAPPED; + } + + @Parameterized.Parameter(2) + public MyBufferType mBufferType; + + public static ByteBuffer newBuffer( + MyByteOrder byteOrder, boolean aligned, MyBufferType bufferType) throws IOException { + int size = aligned ? 8192 : 8192 + 8 + 1; + ByteBuffer result = null; + switch (bufferType) { + case DIRECT: + result = ByteBuffer.allocateDirect(size); + break; + case HEAP: + result = ByteBuffer.allocate(size); + break; + case MAPPED: + File tmpFile = new File("/sdcard/bm.tmp"); + if (new File("/tmp").isDirectory()) { + // We're running on the desktop. + tmpFile = File.createTempFile("MappedByteBufferTest", ".tmp"); + } + tmpFile.createNewFile(); + tmpFile.deleteOnExit(); + RandomAccessFile raf = new RandomAccessFile(tmpFile, "rw"); + raf.setLength(8192 * 8); + FileChannel fc = raf.getChannel(); + result = fc.map(FileChannel.MapMode.READ_WRITE, 0, fc.size()); + break; + } + result.order(byteOrder.mByteOrder); + result.position(aligned ? 0 : 1); + return result; + } + + // + // peeking + // + + @Test + public void timeByteBuffer_getByte() throws Exception { + ByteBuffer src = ByteBufferPerfTest.newBuffer(mByteOrder, mAligned, mBufferType); + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + src.position(mAligned ? 0 : 1); + for (int i = 0; i < 1024; ++i) { + src.get(); + } + } + } + + @Test + public void timeByteBuffer_getByteArray() throws Exception { + ByteBuffer src = ByteBufferPerfTest.newBuffer(mByteOrder, mAligned, mBufferType); + byte[] dst = new byte[1024]; + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + for (int i = 0; i < 1024; ++i) { + src.position(mAligned ? 0 : 1); + src.get(dst); + } + } + } + + @Test + public void timeByteBuffer_getByte_indexed() throws Exception { + ByteBuffer src = ByteBufferPerfTest.newBuffer(mByteOrder, mAligned, mBufferType); + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + src.position(mAligned ? 0 : 1); + for (int i = 0; i < 1024; ++i) { + src.get(i); + } + } + } + + @Test + public void timeByteBuffer_getChar() throws Exception { + ByteBuffer src = ByteBufferPerfTest.newBuffer(mByteOrder, mAligned, mBufferType); + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + src.position(mAligned ? 0 : 1); + for (int i = 0; i < 1024; ++i) { + src.getChar(); + } + } + } + + @Test + public void timeCharBuffer_getCharArray() throws Exception { + CharBuffer src = + ByteBufferPerfTest.newBuffer(mByteOrder, mAligned, mBufferType).asCharBuffer(); + char[] dst = new char[1024]; + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + for (int i = 0; i < 1024; ++i) { + src.position(0); + src.get(dst); + } + } + } + + @Test + public void timeByteBuffer_getChar_indexed() throws Exception { + ByteBuffer src = ByteBufferPerfTest.newBuffer(mByteOrder, mAligned, mBufferType); + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + src.position(mAligned ? 0 : 1); + for (int i = 0; i < 1024; ++i) { + src.getChar(i * 2); + } + } + } + + @Test + public void timeByteBuffer_getDouble() throws Exception { + ByteBuffer src = ByteBufferPerfTest.newBuffer(mByteOrder, mAligned, mBufferType); + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + src.position(mAligned ? 0 : 1); + for (int i = 0; i < 1024; ++i) { + src.getDouble(); + } + } + } + + @Test + public void timeDoubleBuffer_getDoubleArray() throws Exception { + DoubleBuffer src = + ByteBufferPerfTest.newBuffer(mByteOrder, mAligned, mBufferType).asDoubleBuffer(); + double[] dst = new double[1024]; + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + for (int i = 0; i < 1024; ++i) { + src.position(0); + src.get(dst); + } + } + } + + @Test + public void timeByteBuffer_getFloat() throws Exception { + ByteBuffer src = ByteBufferPerfTest.newBuffer(mByteOrder, mAligned, mBufferType); + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + src.position(mAligned ? 0 : 1); + for (int i = 0; i < 1024; ++i) { + src.getFloat(); + } + } + } + + @Test + public void timeFloatBuffer_getFloatArray() throws Exception { + FloatBuffer src = + ByteBufferPerfTest.newBuffer(mByteOrder, mAligned, mBufferType).asFloatBuffer(); + float[] dst = new float[1024]; + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + for (int i = 0; i < 1024; ++i) { + src.position(0); + src.get(dst); + } + } + } + + @Test + public void timeByteBuffer_getInt() throws Exception { + ByteBuffer src = ByteBufferPerfTest.newBuffer(mByteOrder, mAligned, mBufferType); + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + src.position(mAligned ? 0 : 1); + for (int i = 0; i < 1024; ++i) { + src.getInt(); + } + } + } + + @Test + public void timeIntBuffer_getIntArray() throws Exception { + IntBuffer src = + ByteBufferPerfTest.newBuffer(mByteOrder, mAligned, mBufferType).asIntBuffer(); + int[] dst = new int[1024]; + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + for (int i = 0; i < 1024; ++i) { + src.position(0); + src.get(dst); + } + } + } + + @Test + public void timeByteBuffer_getLong() throws Exception { + ByteBuffer src = ByteBufferPerfTest.newBuffer(mByteOrder, mAligned, mBufferType); + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + src.position(mAligned ? 0 : 1); + for (int i = 0; i < 1024; ++i) { + src.getLong(); + } + } + } + + @Test + public void timeLongBuffer_getLongArray() throws Exception { + LongBuffer src = + ByteBufferPerfTest.newBuffer(mByteOrder, mAligned, mBufferType).asLongBuffer(); + long[] dst = new long[1024]; + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + for (int i = 0; i < 1024; ++i) { + src.position(0); + src.get(dst); + } + } + } + + @Test + public void timeByteBuffer_getShort() throws Exception { + ByteBuffer src = ByteBufferPerfTest.newBuffer(mByteOrder, mAligned, mBufferType); + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + src.position(mAligned ? 0 : 1); + for (int i = 0; i < 1024; ++i) { + src.getShort(); + } + } + } + + @Test + public void timeShortBuffer_getShortArray() throws Exception { + ShortBuffer src = + ByteBufferPerfTest.newBuffer(mByteOrder, mAligned, mBufferType).asShortBuffer(); + short[] dst = new short[1024]; + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + for (int i = 0; i < 1024; ++i) { + src.position(0); + src.get(dst); + } + } + } + + // + // poking + // + + @Test + public void timeByteBuffer_putByte() throws Exception { + ByteBuffer src = ByteBufferPerfTest.newBuffer(mByteOrder, mAligned, mBufferType); + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + src.position(0); + for (int i = 0; i < 1024; ++i) { + src.put((byte) 0); + } + } + } + + @Test + public void timeByteBuffer_putByteArray() throws Exception { + ByteBuffer dst = ByteBufferPerfTest.newBuffer(mByteOrder, mAligned, mBufferType); + byte[] src = new byte[1024]; + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + for (int i = 0; i < 1024; ++i) { + dst.position(mAligned ? 0 : 1); + dst.put(src); + } + } + } + + @Test + public void timeByteBuffer_putChar() throws Exception { + ByteBuffer src = ByteBufferPerfTest.newBuffer(mByteOrder, mAligned, mBufferType); + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + src.position(mAligned ? 0 : 1); + for (int i = 0; i < 1024; ++i) { + src.putChar(' '); + } + } + } + + @Test + public void timeCharBuffer_putCharArray() throws Exception { + CharBuffer dst = + ByteBufferPerfTest.newBuffer(mByteOrder, mAligned, mBufferType).asCharBuffer(); + char[] src = new char[1024]; + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + for (int i = 0; i < 1024; ++i) { + dst.position(0); + dst.put(src); + } + } + } + + @Test + public void timeByteBuffer_putDouble() throws Exception { + ByteBuffer src = ByteBufferPerfTest.newBuffer(mByteOrder, mAligned, mBufferType); + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + src.position(mAligned ? 0 : 1); + for (int i = 0; i < 1024; ++i) { + src.putDouble(0.0); + } + } + } + + @Test + public void timeDoubleBuffer_putDoubleArray() throws Exception { + DoubleBuffer dst = + ByteBufferPerfTest.newBuffer(mByteOrder, mAligned, mBufferType).asDoubleBuffer(); + double[] src = new double[1024]; + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + for (int i = 0; i < 1024; ++i) { + dst.position(0); + dst.put(src); + } + } + } + + @Test + public void timeByteBuffer_putFloat() throws Exception { + ByteBuffer src = ByteBufferPerfTest.newBuffer(mByteOrder, mAligned, mBufferType); + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + src.position(mAligned ? 0 : 1); + for (int i = 0; i < 1024; ++i) { + src.putFloat(0.0f); + } + } + } + + @Test + public void timeFloatBuffer_putFloatArray() throws Exception { + FloatBuffer dst = + ByteBufferPerfTest.newBuffer(mByteOrder, mAligned, mBufferType).asFloatBuffer(); + float[] src = new float[1024]; + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + for (int i = 0; i < 1024; ++i) { + dst.position(0); + dst.put(src); + } + } + } + + @Test + public void timeByteBuffer_putInt() throws Exception { + ByteBuffer src = ByteBufferPerfTest.newBuffer(mByteOrder, mAligned, mBufferType); + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + src.position(mAligned ? 0 : 1); + for (int i = 0; i < 1024; ++i) { + src.putInt(0); + } + } + } + + @Test + public void timeIntBuffer_putIntArray() throws Exception { + IntBuffer dst = + ByteBufferPerfTest.newBuffer(mByteOrder, mAligned, mBufferType).asIntBuffer(); + int[] src = new int[1024]; + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + for (int i = 0; i < 1024; ++i) { + dst.position(0); + dst.put(src); + } + } + } + + @Test + public void timeByteBuffer_putLong() throws Exception { + ByteBuffer src = ByteBufferPerfTest.newBuffer(mByteOrder, mAligned, mBufferType); + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + src.position(mAligned ? 0 : 1); + for (int i = 0; i < 1024; ++i) { + src.putLong(0L); + } + } + } + + @Test + public void timeLongBuffer_putLongArray() throws Exception { + LongBuffer dst = + ByteBufferPerfTest.newBuffer(mByteOrder, mAligned, mBufferType).asLongBuffer(); + long[] src = new long[1024]; + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + for (int i = 0; i < 1024; ++i) { + dst.position(0); + dst.put(src); + } + } + } + + @Test + public void timeByteBuffer_putShort() throws Exception { + ByteBuffer src = ByteBufferPerfTest.newBuffer(mByteOrder, mAligned, mBufferType); + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + src.position(mAligned ? 0 : 1); + for (int i = 0; i < 1024; ++i) { + src.putShort((short) 0); + } + } + } + + @Test + public void timeShortBuffer_putShortArray() throws Exception { + ShortBuffer dst = + ByteBufferPerfTest.newBuffer(mByteOrder, mAligned, mBufferType).asShortBuffer(); + short[] src = new short[1024]; + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + for (int i = 0; i < 1024; ++i) { + dst.position(0); + dst.put(src); + } + } + } + + @Test + public void time_new_byteArray() throws Exception { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + byte[] bs = new byte[8192]; + } + } + + @Test + public void time_ByteBuffer_allocate() throws Exception { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + ByteBuffer bs = ByteBuffer.allocate(8192); + } + } +} diff --git a/apct-tests/perftests/core/src/android/libcore/regression/ByteBufferScalarVersusVectorPerfTest.java b/apct-tests/perftests/core/src/android/libcore/regression/ByteBufferScalarVersusVectorPerfTest.java new file mode 100644 index 000000000000..81f9e59f2423 --- /dev/null +++ b/apct-tests/perftests/core/src/android/libcore/regression/ByteBufferScalarVersusVectorPerfTest.java @@ -0,0 +1,149 @@ +/* + * Copyright (C) 2022 The Android Open Source Project. + * + * 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 android.libcore.regression; + +import android.perftests.utils.BenchmarkState; +import android.perftests.utils.PerfStatusReporter; +import android.test.suitebuilder.annotation.LargeTest; + +import org.junit.Rule; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; +import org.junit.runners.Parameterized.Parameters; + +import java.nio.ByteBuffer; +import java.util.Arrays; +import java.util.Collection; + +@RunWith(Parameterized.class) +@LargeTest +public class ByteBufferScalarVersusVectorPerfTest { + @Rule public PerfStatusReporter mPerfStatusReporter = new PerfStatusReporter(); + + @Parameters(name = "mByteOrder={0}, mAligned={1}, mBufferType={2}") + public static Collection<Object[]> data() { + return Arrays.asList( + new Object[][] { + { + ByteBufferPerfTest.MyByteOrder.BIG, + true, + ByteBufferPerfTest.MyBufferType.DIRECT + }, + { + ByteBufferPerfTest.MyByteOrder.LITTLE, + true, + ByteBufferPerfTest.MyBufferType.DIRECT + }, + { + ByteBufferPerfTest.MyByteOrder.BIG, + false, + ByteBufferPerfTest.MyBufferType.DIRECT + }, + { + ByteBufferPerfTest.MyByteOrder.LITTLE, + false, + ByteBufferPerfTest.MyBufferType.DIRECT + }, + { + ByteBufferPerfTest.MyByteOrder.BIG, + true, + ByteBufferPerfTest.MyBufferType.HEAP + }, + { + ByteBufferPerfTest.MyByteOrder.LITTLE, + true, + ByteBufferPerfTest.MyBufferType.HEAP + }, + { + ByteBufferPerfTest.MyByteOrder.BIG, + false, + ByteBufferPerfTest.MyBufferType.HEAP + }, + { + ByteBufferPerfTest.MyByteOrder.LITTLE, + false, + ByteBufferPerfTest.MyBufferType.HEAP + }, + { + ByteBufferPerfTest.MyByteOrder.BIG, + true, + ByteBufferPerfTest.MyBufferType.MAPPED + }, + { + ByteBufferPerfTest.MyByteOrder.LITTLE, + true, + ByteBufferPerfTest.MyBufferType.MAPPED + }, + { + ByteBufferPerfTest.MyByteOrder.BIG, + false, + ByteBufferPerfTest.MyBufferType.MAPPED + }, + { + ByteBufferPerfTest.MyByteOrder.LITTLE, + false, + ByteBufferPerfTest.MyBufferType.MAPPED + } + }); + } + + @Parameterized.Parameter(0) + public ByteBufferPerfTest.MyByteOrder mByteOrder; + + @Parameterized.Parameter(1) + public boolean mAligned; + + @Parameterized.Parameter(2) + public ByteBufferPerfTest.MyBufferType mBufferType; + + @Test + public void timeManualByteBufferCopy() throws Exception { + ByteBuffer src = ByteBufferPerfTest.newBuffer(mByteOrder, mAligned, mBufferType); + ByteBuffer dst = ByteBufferPerfTest.newBuffer(mByteOrder, mAligned, mBufferType); + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + src.position(0); + dst.position(0); + for (int i = 0; i < 8192; ++i) { + dst.put(src.get()); + } + } + } + + @Test + public void timeByteBufferBulkGet() throws Exception { + ByteBuffer src = ByteBuffer.allocate(mAligned ? 8192 : 8192 + 1); + byte[] dst = new byte[8192]; + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + src.position(mAligned ? 0 : 1); + src.get(dst, 0, dst.length); + } + } + + @Test + public void timeDirectByteBufferBulkGet() throws Exception { + ByteBuffer src = ByteBuffer.allocateDirect(mAligned ? 8192 : 8192 + 1); + byte[] dst = new byte[8192]; + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + src.position(mAligned ? 0 : 1); + src.get(dst, 0, dst.length); + } + } +} diff --git a/apct-tests/perftests/core/src/android/libcore/regression/CharacterPerfTest.java b/apct-tests/perftests/core/src/android/libcore/regression/CharacterPerfTest.java new file mode 100644 index 000000000000..28ec6ded3c86 --- /dev/null +++ b/apct-tests/perftests/core/src/android/libcore/regression/CharacterPerfTest.java @@ -0,0 +1,359 @@ +/* + * Copyright (C) 2022 The Android Open Source Project. + * + * 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 android.libcore.regression; + +import android.perftests.utils.BenchmarkState; +import android.perftests.utils.PerfStatusReporter; +import android.test.suitebuilder.annotation.LargeTest; + +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; +import org.junit.runners.Parameterized.Parameters; + +import java.util.Arrays; +import java.util.Collection; + +/** + * Tests various Character methods, intended for testing multiple implementations against each + * other. + */ +@RunWith(Parameterized.class) +@LargeTest +public class CharacterPerfTest { + @Rule public PerfStatusReporter mPerfStatusReporter = new PerfStatusReporter(); + + @Parameters(name = "mCharacterSet({0}), mOverload({1})") + public static Collection<Object[]> data() { + return Arrays.asList( + new Object[][] { + {CharacterSet.ASCII, Overload.CHAR}, + {CharacterSet.ASCII, Overload.INT}, + {CharacterSet.UNICODE, Overload.CHAR}, + {CharacterSet.UNICODE, Overload.INT} + }); + } + + @Parameterized.Parameter(0) + public CharacterSet mCharacterSet; + + @Parameterized.Parameter(1) + public Overload mOverload; + + private char[] mChars; + + @Before + public void setUp() throws Exception { + this.mChars = mCharacterSet.mChars; + } + + public enum Overload { + CHAR, + INT + } + + public double nanosToUnits(double nanos) { + return nanos / 65536; + } + + public enum CharacterSet { + ASCII(128), + UNICODE(65536); + final char[] mChars; + + CharacterSet(int size) { + this.mChars = new char[65536]; + for (int i = 0; i < 65536; ++i) { + mChars[i] = (char) (i % size); + } + } + } + + // A fake benchmark to give us a baseline. + @Test + public void timeIsSpace() { + boolean fake = false; + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + if (mOverload == Overload.CHAR) { + while (state.keepRunning()) { + for (int ch = 0; ch < 65536; ++ch) { + fake ^= ((char) ch == ' '); + } + } + } else { + while (state.keepRunning()) { + for (int ch = 0; ch < 65536; ++ch) { + fake ^= (ch == ' '); + } + } + } + } + + @Test + public void timeDigit() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + if (mOverload == Overload.CHAR) { + while (state.keepRunning()) { + for (int ch = 0; ch < 65536; ++ch) { + Character.digit(mChars[ch], 10); + } + } + } else { + while (state.keepRunning()) { + for (int ch = 0; ch < 65536; ++ch) { + Character.digit((int) mChars[ch], 10); + } + } + } + } + + @Test + public void timeGetNumericValue() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + if (mOverload == Overload.CHAR) { + while (state.keepRunning()) { + for (int ch = 0; ch < 65536; ++ch) { + Character.getNumericValue(mChars[ch]); + } + } + } else { + while (state.keepRunning()) { + for (int ch = 0; ch < 65536; ++ch) { + Character.getNumericValue((int) mChars[ch]); + } + } + } + } + + @Test + public void timeIsDigit() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + if (mOverload == Overload.CHAR) { + while (state.keepRunning()) { + for (int ch = 0; ch < 65536; ++ch) { + Character.isDigit(mChars[ch]); + } + } + } else { + while (state.keepRunning()) { + for (int ch = 0; ch < 65536; ++ch) { + Character.isDigit((int) mChars[ch]); + } + } + } + } + + @Test + public void timeIsIdentifierIgnorable() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + if (mOverload == Overload.CHAR) { + while (state.keepRunning()) { + for (int ch = 0; ch < 65536; ++ch) { + Character.isIdentifierIgnorable(mChars[ch]); + } + } + } else { + while (state.keepRunning()) { + for (int ch = 0; ch < 65536; ++ch) { + Character.isIdentifierIgnorable((int) mChars[ch]); + } + } + } + } + + @Test + public void timeIsJavaIdentifierPart() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + if (mOverload == Overload.CHAR) { + while (state.keepRunning()) { + for (int ch = 0; ch < 65536; ++ch) { + Character.isJavaIdentifierPart(mChars[ch]); + } + } + } else { + while (state.keepRunning()) { + for (int ch = 0; ch < 65536; ++ch) { + Character.isJavaIdentifierPart((int) mChars[ch]); + } + } + } + } + + @Test + public void timeIsJavaIdentifierStart() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + if (mOverload == Overload.CHAR) { + while (state.keepRunning()) { + for (int ch = 0; ch < 65536; ++ch) { + Character.isJavaIdentifierStart(mChars[ch]); + } + } + } else { + while (state.keepRunning()) { + for (int ch = 0; ch < 65536; ++ch) { + Character.isJavaIdentifierStart((int) mChars[ch]); + } + } + } + } + + @Test + public void timeIsLetter() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + if (mOverload == Overload.CHAR) { + while (state.keepRunning()) { + for (int ch = 0; ch < 65536; ++ch) { + Character.isLetter(mChars[ch]); + } + } + } else { + while (state.keepRunning()) { + for (int ch = 0; ch < 65536; ++ch) { + Character.isLetter((int) mChars[ch]); + } + } + } + } + + @Test + public void timeIsLetterOrDigit() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + if (mOverload == Overload.CHAR) { + while (state.keepRunning()) { + for (int ch = 0; ch < 65536; ++ch) { + Character.isLetterOrDigit(mChars[ch]); + } + } + } else { + while (state.keepRunning()) { + for (int ch = 0; ch < 65536; ++ch) { + Character.isLetterOrDigit((int) mChars[ch]); + } + } + } + } + + @Test + public void timeIsLowerCase() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + if (mOverload == Overload.CHAR) { + while (state.keepRunning()) { + for (int ch = 0; ch < 65536; ++ch) { + Character.isLowerCase(mChars[ch]); + } + } + } else { + while (state.keepRunning()) { + for (int ch = 0; ch < 65536; ++ch) { + Character.isLowerCase((int) mChars[ch]); + } + } + } + } + + @Test + public void timeIsSpaceChar() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + if (mOverload == Overload.CHAR) { + while (state.keepRunning()) { + for (int ch = 0; ch < 65536; ++ch) { + Character.isSpaceChar(mChars[ch]); + } + } + } else { + while (state.keepRunning()) { + for (int ch = 0; ch < 65536; ++ch) { + Character.isSpaceChar((int) mChars[ch]); + } + } + } + } + + @Test + public void timeIsUpperCase() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + if (mOverload == Overload.CHAR) { + while (state.keepRunning()) { + for (int ch = 0; ch < 65536; ++ch) { + Character.isUpperCase(mChars[ch]); + } + } + } else { + while (state.keepRunning()) { + for (int ch = 0; ch < 65536; ++ch) { + Character.isUpperCase((int) mChars[ch]); + } + } + } + } + + @Test + public void timeIsWhitespace() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + if (mOverload == Overload.CHAR) { + while (state.keepRunning()) { + for (int ch = 0; ch < 65536; ++ch) { + Character.isWhitespace(mChars[ch]); + } + } + } else { + while (state.keepRunning()) { + for (int ch = 0; ch < 65536; ++ch) { + Character.isWhitespace((int) mChars[ch]); + } + } + } + } + + @Test + public void timeToLowerCase() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + if (mOverload == Overload.CHAR) { + while (state.keepRunning()) { + for (int ch = 0; ch < 65536; ++ch) { + Character.toLowerCase(mChars[ch]); + } + } + } else { + while (state.keepRunning()) { + for (int ch = 0; ch < 65536; ++ch) { + Character.toLowerCase((int) mChars[ch]); + } + } + } + } + + @Test + public void timeToUpperCase() { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + if (mOverload == Overload.CHAR) { + while (state.keepRunning()) { + for (int ch = 0; ch < 65536; ++ch) { + Character.toUpperCase(mChars[ch]); + } + } + } else { + while (state.keepRunning()) { + for (int ch = 0; ch < 65536; ++ch) { + Character.toUpperCase((int) mChars[ch]); + } + } + } + } +} diff --git a/apct-tests/perftests/core/src/android/libcore/regression/CharsetForNamePerfTest.java b/apct-tests/perftests/core/src/android/libcore/regression/CharsetForNamePerfTest.java new file mode 100644 index 000000000000..603b182e7c36 --- /dev/null +++ b/apct-tests/perftests/core/src/android/libcore/regression/CharsetForNamePerfTest.java @@ -0,0 +1,63 @@ +/* + * Copyright (C) 2022 The Android Open Source Project + * + * 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 android.libcore.regression; + +import android.perftests.utils.BenchmarkState; +import android.perftests.utils.PerfStatusReporter; +import android.test.suitebuilder.annotation.LargeTest; + +import org.junit.Rule; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +import java.nio.charset.Charset; +import java.util.Arrays; +import java.util.Collection; + +@RunWith(Parameterized.class) +@LargeTest +public class CharsetForNamePerfTest { + @Rule public PerfStatusReporter mPerfStatusReporter = new PerfStatusReporter(); + + @Parameterized.Parameters(name = "mCharsetName({0})") + public static Collection<Object[]> data() { + return Arrays.asList( + new Object[][] { + {"UTF-16"}, + {"UTF-8"}, + {"UTF8"}, + {"ISO-8859-1"}, + {"8859_1"}, + {"ISO-8859-2"}, + {"8859_2"}, + {"US-ASCII"}, + {"ASCII"}, + }); + } + + @Parameterized.Parameter(0) + public String mCharsetName; + + @Test + public void timeCharsetForName() throws Exception { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + Charset.forName(mCharsetName); + } + } +} diff --git a/apct-tests/perftests/core/src/android/libcore/regression/CharsetPerfTest.java b/apct-tests/perftests/core/src/android/libcore/regression/CharsetPerfTest.java new file mode 100644 index 000000000000..437d186834e0 --- /dev/null +++ b/apct-tests/perftests/core/src/android/libcore/regression/CharsetPerfTest.java @@ -0,0 +1,146 @@ +/* + * Copyright (C) 2022 The Android Open Source Project. + * + * 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 android.libcore.regression; + +import android.perftests.utils.BenchmarkState; +import android.perftests.utils.PerfStatusReporter; +import android.test.suitebuilder.annotation.LargeTest; + +import org.junit.Rule; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; +import org.junit.runners.Parameterized.Parameters; + +import java.util.Arrays; +import java.util.Collection; + +@RunWith(Parameterized.class) +@LargeTest +public class CharsetPerfTest { + @Rule public PerfStatusReporter mPerfStatusReporter = new PerfStatusReporter(); + + @Parameters(name = "mLength({0}), mName({1})") + public static Collection<Object[]> data() { + return Arrays.asList( + new Object[][] { + {1, "UTF-16"}, + {1, "UTF-8"}, + {1, "UTF8"}, + {1, "ISO-8859-1"}, + {1, "8859_1"}, + {1, "ISO-8859-2"}, + {1, "8859_2"}, + {1, "US-ASCII"}, + {1, "ASCII"}, + {10, "UTF-16"}, + {10, "UTF-8"}, + {10, "UTF8"}, + {10, "ISO-8859-1"}, + {10, "8859_1"}, + {10, "ISO-8859-2"}, + {10, "8859_2"}, + {10, "US-ASCII"}, + {10, "ASCII"}, + {100, "UTF-16"}, + {100, "UTF-8"}, + {100, "UTF8"}, + {100, "ISO-8859-1"}, + {100, "8859_1"}, + {100, "ISO-8859-2"}, + {100, "8859_2"}, + {100, "US-ASCII"}, + {100, "ASCII"}, + {1000, "UTF-16"}, + {1000, "UTF-8"}, + {1000, "UTF8"}, + {1000, "ISO-8859-1"}, + {1000, "8859_1"}, + {1000, "ISO-8859-2"}, + {1000, "8859_2"}, + {1000, "US-ASCII"}, + {1000, "ASCII"}, + {10000, "UTF-16"}, + {10000, "UTF-8"}, + {10000, "UTF8"}, + {10000, "ISO-8859-1"}, + {10000, "8859_1"}, + {10000, "ISO-8859-2"}, + {10000, "8859_2"}, + {10000, "US-ASCII"}, + {10000, "ASCII"}, + }); + } + + @Parameterized.Parameter(0) + public int mLength; + + @Parameterized.Parameter(1) + public String mName; + + @Test + public void time_new_String_BString() throws Exception { + byte[] bytes = makeBytes(makeString(mLength)); + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + new String(bytes, mName); + } + } + + @Test + public void time_new_String_BII() throws Exception { + byte[] bytes = makeBytes(makeString(mLength)); + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + new String(bytes, 0, bytes.length); + } + } + + @Test + public void time_new_String_BIIString() throws Exception { + byte[] bytes = makeBytes(makeString(mLength)); + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + new String(bytes, 0, bytes.length, mName); + } + } + + @Test + public void time_String_getBytes() throws Exception { + String string = makeString(mLength); + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + string.getBytes(mName); + } + } + + private static String makeString(int length) { + StringBuilder result = new StringBuilder(length); + for (int i = 0; i < length; ++i) { + result.append('A' + (i % 26)); + } + return result.toString(); + } + + private static byte[] makeBytes(String s) { + try { + return s.getBytes("US-ASCII"); + } catch (Exception ex) { + throw new RuntimeException(ex); + } + } +} diff --git a/apct-tests/perftests/core/src/android/libcore/regression/CharsetUtf8PerfTest.java b/apct-tests/perftests/core/src/android/libcore/regression/CharsetUtf8PerfTest.java new file mode 100644 index 000000000000..f31e9c154f15 --- /dev/null +++ b/apct-tests/perftests/core/src/android/libcore/regression/CharsetUtf8PerfTest.java @@ -0,0 +1,82 @@ +/* + * Copyright (C) 2017 The Android Open Source Project + * + * 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 android.libcore.regression; + +import android.icu.lang.UCharacter; +import android.perftests.utils.BenchmarkState; +import android.perftests.utils.PerfStatusReporter; +import android.test.suitebuilder.annotation.LargeTest; + +import androidx.test.runner.AndroidJUnit4; + +import org.junit.Rule; +import org.junit.Test; +import org.junit.runner.RunWith; + +import java.nio.charset.Charset; + +/** + * Decode the same size of ASCII, BMP, Supplementary character using fast-path UTF-8 decoder. The + * fast-path code is in {@link StringFactory#newStringFromBytes(byte[], int, int, Charset)} + */ +@RunWith(AndroidJUnit4.class) +@LargeTest +public class CharsetUtf8PerfTest { + @Rule public PerfStatusReporter mPerfStatusReporter = new PerfStatusReporter(); + + private final int mNoOfBytes = 0x100; // 4MB + + private void makeUnicodeRange(int startingCodePoint, int endingCodePoint, int repeated) { + StringBuilder builder = new StringBuilder(); + for (int codePoint = startingCodePoint; codePoint <= endingCodePoint; codePoint++) { + if (codePoint < Character.MIN_SURROGATE || codePoint > Character.MAX_SURROGATE) { + builder.append(UCharacter.toString(codePoint)); + } + } + + String str = builder.toString(); + StringBuilder builder2 = new StringBuilder(); + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + for (int i = 0; i < repeated; i++) { + builder2.append(str); + } + } + } + + @Test + public void time_ascii() { + makeUnicodeRange(0, 0x7f, mNoOfBytes / 0x80); + } + + @Test + public void time_bmp2() { + makeUnicodeRange(0x0080, 0x07ff, mNoOfBytes / 2 / 0x780); + } + + @Test + public void time_bmp3() { + makeUnicodeRange( + 0x0800, + 0xffff, + mNoOfBytes / 3 / 0xf000 /* 0x10000 - 0x0800 - no of surrogate code points */); + } + + @Test + public void time_supplementary() { + makeUnicodeRange(0x10000, 0x10ffff, mNoOfBytes / 4 / 0x100000); + } +} diff --git a/apct-tests/perftests/core/src/android/libcore/regression/ChecksumPerfTest.java b/apct-tests/perftests/core/src/android/libcore/regression/ChecksumPerfTest.java new file mode 100644 index 000000000000..1d33fcb250b9 --- /dev/null +++ b/apct-tests/perftests/core/src/android/libcore/regression/ChecksumPerfTest.java @@ -0,0 +1,74 @@ +/* + * Copyright (C) 2022 The Android Open Source Project. + * + * 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 android.libcore.regression; + +import android.perftests.utils.BenchmarkState; +import android.perftests.utils.PerfStatusReporter; +import android.test.suitebuilder.annotation.LargeTest; + +import androidx.test.runner.AndroidJUnit4; + +import org.junit.Rule; +import org.junit.Test; +import org.junit.runner.RunWith; + +import java.util.zip.Adler32; +import java.util.zip.CRC32; + +@RunWith(AndroidJUnit4.class) +@LargeTest +public class ChecksumPerfTest { + @Rule public PerfStatusReporter mPerfStatusReporter = new PerfStatusReporter(); + + @Test + public void timeAdler_block() throws Exception { + byte[] bytes = new byte[10000]; + Adler32 adler = new Adler32(); + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + adler.update(bytes); + } + } + + @Test + public void timeAdler_byte() throws Exception { + Adler32 adler = new Adler32(); + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + adler.update(1); + } + } + + @Test + public void timeCrc_block() throws Exception { + byte[] bytes = new byte[10000]; + CRC32 crc = new CRC32(); + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + crc.update(bytes); + } + } + + @Test + public void timeCrc_byte() throws Exception { + CRC32 crc = new CRC32(); + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + crc.update(1); + } + } +} diff --git a/apct-tests/perftests/core/src/android/libcore/regression/CipherInputStreamPerfTest.java b/apct-tests/perftests/core/src/android/libcore/regression/CipherInputStreamPerfTest.java new file mode 100644 index 000000000000..35730ec753f1 --- /dev/null +++ b/apct-tests/perftests/core/src/android/libcore/regression/CipherInputStreamPerfTest.java @@ -0,0 +1,92 @@ +/* + * Copyright (C) 2022 The Android Open Source Project + * + * 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 android.libcore.regression; + +import android.perftests.utils.BenchmarkState; +import android.perftests.utils.PerfStatusReporter; +import android.test.suitebuilder.annotation.LargeTest; + +import androidx.test.runner.AndroidJUnit4; + +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; +import org.junit.runner.RunWith; + +import java.io.ByteArrayInputStream; +import java.io.InputStream; +import java.security.spec.AlgorithmParameterSpec; + +import javax.crypto.Cipher; +import javax.crypto.CipherInputStream; +import javax.crypto.KeyGenerator; +import javax.crypto.SecretKey; +import javax.crypto.spec.IvParameterSpec; + +/** CipherInputStream benchmark. */ +@RunWith(AndroidJUnit4.class) +@LargeTest +public class CipherInputStreamPerfTest { + @Rule public PerfStatusReporter mPerfStatusReporter = new PerfStatusReporter(); + + private static final int DATA_SIZE = 1024 * 1024; + private static final byte[] DATA = new byte[DATA_SIZE]; + + private static final int IV_SIZE = 16; + private static final byte[] IV = new byte[IV_SIZE]; + + static { + for (int i = 0; i < DATA_SIZE; i++) { + DATA[i] = (byte) i; + } + for (int i = 0; i < IV_SIZE; i++) { + IV[i] = (byte) i; + } + } + + private SecretKey mKey; + + private byte[] mOutput = new byte[8192]; + + private Cipher mCipherEncrypt; + + private AlgorithmParameterSpec mSpec; + + @Before + public void setUp() throws Exception { + KeyGenerator generator = KeyGenerator.getInstance("AES"); + generator.init(128); + mKey = generator.generateKey(); + + mSpec = new IvParameterSpec(IV); + + mCipherEncrypt = Cipher.getInstance("AES/CBC/PKCS5Padding"); + mCipherEncrypt.init(Cipher.ENCRYPT_MODE, mKey, mSpec); + } + + @Test + public void timeEncrypt() throws Exception { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + mCipherEncrypt.init(Cipher.ENCRYPT_MODE, mKey, mSpec); + InputStream is = new CipherInputStream(new ByteArrayInputStream(DATA), mCipherEncrypt); + while (is.read(mOutput) != -1) { + // Keep iterating + } + } + } +} diff --git a/apct-tests/perftests/core/src/android/libcore/regression/CipherPerfTest.java b/apct-tests/perftests/core/src/android/libcore/regression/CipherPerfTest.java new file mode 100644 index 000000000000..15c27f2366e1 --- /dev/null +++ b/apct-tests/perftests/core/src/android/libcore/regression/CipherPerfTest.java @@ -0,0 +1,210 @@ +/* + * Copyright (C) 2022 The Android Open Source Project. + * + * 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 android.libcore.regression; + +import android.perftests.utils.BenchmarkState; +import android.perftests.utils.PerfStatusReporter; +import android.test.suitebuilder.annotation.LargeTest; + +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +import java.security.spec.AlgorithmParameterSpec; +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import javax.crypto.Cipher; +import javax.crypto.KeyGenerator; +import javax.crypto.SecretKey; +import javax.crypto.spec.IvParameterSpec; + +/** + * Cipher benchmarks. Only runs on AES currently because of the combinatorial explosion of the test + * as it stands. + */ +@RunWith(Parameterized.class) +@LargeTest +public class CipherPerfTest { + @Rule public PerfStatusReporter mPerfStatusReporter = new PerfStatusReporter(); + + @Parameterized.Parameters( + name = + "mMode({0}), mPadding({1}), mKeySize({2}), mInputSize({3})," + + " mImplementation({4})") + public static Collection cases() { + int[] mKeySizes = new int[] {128, 192, 256}; + int[] inputSizes = new int[] {16, 32, 64, 128, 1024, 8192}; + final List<Object[]> params = new ArrayList<>(); + for (Mode mode : Mode.values()) { + for (Padding padding : Padding.values()) { + for (Implementation implementation : Implementation.values()) { + if ((mode == Mode.CBC + || mode == Mode.CFB + || mode == Mode.CTR + || mode == Mode.ECB + || mode == Mode.OFB) + && padding == Padding.PKCS1PADDING) { + continue; + } + if ((mode == Mode.CFB || mode == Mode.OFB) + && padding == Padding.NOPADDING + && implementation == Implementation.OpenSSL) { + continue; + } + for (int mKeySize : mKeySizes) { + for (int inputSize : inputSizes) { + params.add( + new Object[] { + mode, padding, mKeySize, inputSize, implementation + }); + } + } + } + } + } + return params; + } + + private static final int DATA_SIZE = 8192; + private static final byte[] DATA = new byte[DATA_SIZE]; + + private static final int IV_SIZE = 16; + + private static final byte[] IV = new byte[IV_SIZE]; + + static { + for (int i = 0; i < DATA_SIZE; i++) { + DATA[i] = (byte) i; + } + for (int i = 0; i < IV_SIZE; i++) { + IV[i] = (byte) i; + } + } + + public Algorithm mAlgorithm = Algorithm.AES; + + public enum Algorithm { + AES, + }; + + @Parameterized.Parameter(0) + public Mode mMode; + + public enum Mode { + CBC, + CFB, + CTR, + ECB, + OFB, + }; + + @Parameterized.Parameter(1) + public Padding mPadding; + + public enum Padding { + NOPADDING, + PKCS1PADDING, + }; + + @Parameterized.Parameter(2) + public int mKeySize; + + @Parameterized.Parameter(3) + public int mInputSize; + + @Parameterized.Parameter(4) + public Implementation mImplementation; + + public enum Implementation { + OpenSSL, + BouncyCastle + }; + + private String mProviderName; + + // Key generation isn't part of the benchmark so cache the results + private static Map<Integer, SecretKey> sKeySizes = new HashMap<Integer, SecretKey>(); + + private String mCipherAlgorithm; + private SecretKey mKey; + + private byte[] mOutput = new byte[DATA.length]; + + private Cipher mCipherEncrypt; + + private Cipher mCipherDecrypt; + + private AlgorithmParameterSpec mSpec; + + @Before + public void setUp() throws Exception { + mCipherAlgorithm = + mAlgorithm.toString() + "/" + mMode.toString() + "/" + mPadding.toString(); + + String mKeyAlgorithm = mAlgorithm.toString(); + mKey = sKeySizes.get(mKeySize); + if (mKey == null) { + KeyGenerator generator = KeyGenerator.getInstance(mKeyAlgorithm); + generator.init(mKeySize); + mKey = generator.generateKey(); + sKeySizes.put(mKeySize, mKey); + } + + switch (mImplementation) { + case OpenSSL: + mProviderName = "AndroidOpenSSL"; + break; + case BouncyCastle: + mProviderName = "BC"; + break; + default: + throw new RuntimeException(mImplementation.toString()); + } + + if (mMode != Mode.ECB) { + mSpec = new IvParameterSpec(IV); + } + + mCipherEncrypt = Cipher.getInstance(mCipherAlgorithm, mProviderName); + mCipherEncrypt.init(Cipher.ENCRYPT_MODE, mKey, mSpec); + + mCipherDecrypt = Cipher.getInstance(mCipherAlgorithm, mProviderName); + mCipherDecrypt.init(Cipher.DECRYPT_MODE, mKey, mSpec); + } + + @Test + public void timeEncrypt() throws Exception { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + mCipherEncrypt.doFinal(DATA, 0, mInputSize, mOutput); + } + } + + @Test + public void timeDecrypt() throws Exception { + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + mCipherDecrypt.doFinal(DATA, 0, mInputSize, mOutput); + } + } +} diff --git a/apct-tests/perftests/core/src/android/libcore/regression/CollatorPerfTest.java b/apct-tests/perftests/core/src/android/libcore/regression/CollatorPerfTest.java new file mode 100644 index 000000000000..6728e73d0c4b --- /dev/null +++ b/apct-tests/perftests/core/src/android/libcore/regression/CollatorPerfTest.java @@ -0,0 +1,84 @@ +/* + * Copyright (C) 2022 The Android Open Source Project + * + * 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 android.libcore.regression; + +import android.perftests.utils.BenchmarkState; +import android.perftests.utils.PerfStatusReporter; +import android.test.suitebuilder.annotation.LargeTest; + +import androidx.test.runner.AndroidJUnit4; + +import org.junit.Rule; +import org.junit.Test; +import org.junit.runner.RunWith; + +import java.text.Collator; +import java.text.RuleBasedCollator; +import java.util.Locale; + +@RunWith(AndroidJUnit4.class) +@LargeTest +public class CollatorPerfTest { + @Rule public PerfStatusReporter mPerfStatusReporter = new PerfStatusReporter(); + + private static final RuleBasedCollator COLLATOR = + (RuleBasedCollator) Collator.getInstance(Locale.US); + + @Test + public void timeCollatorPrimary() { + COLLATOR.setStrength(Collator.PRIMARY); + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + COLLATOR.compare("abcde", "abcdf"); + COLLATOR.compare("abcde", "abcde"); + COLLATOR.compare("abcdf", "abcde"); + } + } + + @Test + public void timeCollatorSecondary() { + COLLATOR.setStrength(Collator.SECONDARY); + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + COLLATOR.compare("abcdÂ", "abcdÄ"); + COLLATOR.compare("abcdÂ", "abcdÂ"); + COLLATOR.compare("abcdÄ", "abcdÂ"); + } + } + + @Test + public void timeCollatorTertiary() { + COLLATOR.setStrength(Collator.TERTIARY); + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + COLLATOR.compare("abcdE", "abcde"); + COLLATOR.compare("abcde", "abcde"); + COLLATOR.compare("abcde", "abcdE"); + } + } + + @Test + public void timeCollatorIdentical() { + COLLATOR.setStrength(Collator.IDENTICAL); + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + COLLATOR.compare("abcdȪ", "abcdȫ"); + COLLATOR.compare("abcdȪ", "abcdȪ"); + COLLATOR.compare("abcdȫ", "abcdȪ"); + } + } +} diff --git a/apct-tests/perftests/core/src/android/libcore/regression/CollectionsPerfTest.java b/apct-tests/perftests/core/src/android/libcore/regression/CollectionsPerfTest.java new file mode 100644 index 000000000000..a89efffcdd1f --- /dev/null +++ b/apct-tests/perftests/core/src/android/libcore/regression/CollectionsPerfTest.java @@ -0,0 +1,107 @@ +/* + * Copyright (C) 2014 The Android Open Source Project + * + * 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 android.libcore.regression; + +import android.perftests.utils.BenchmarkState; +import android.perftests.utils.PerfStatusReporter; +import android.test.suitebuilder.annotation.LargeTest; + +import org.junit.Rule; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; +import org.junit.runners.Parameterized.Parameters; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.Comparator; +import java.util.List; +import java.util.Random; +import java.util.Vector; + +@RunWith(Parameterized.class) +@LargeTest +public class CollectionsPerfTest { + @Rule public PerfStatusReporter mPerfStatusReporter = new PerfStatusReporter(); + + @Parameters(name = "mArrayListLength({0})") + public static Collection<Object[]> data() { + return Arrays.asList(new Object[][] {{4}, {16}, {64}, {256}, {1024}}); + } + + @Parameterized.Parameter(0) + public int arrayListLength; + + public static Comparator<Integer> REVERSE = + new Comparator<Integer>() { + @Override + public int compare(Integer lhs, Integer rhs) { + int lhsAsInt = lhs.intValue(); + int rhsAsInt = rhs.intValue(); + return rhsAsInt < lhsAsInt ? -1 : (lhsAsInt == rhsAsInt ? 0 : 1); + } + }; + + @Test + public void timeSort_arrayList() throws Exception { + List<Integer> input = buildList(arrayListLength, ArrayList.class); + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + Collections.sort(input); + } + } + + @Test + public void timeSortWithComparator_arrayList() throws Exception { + List<Integer> input = buildList(arrayListLength, ArrayList.class); + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + Collections.sort(input, REVERSE); + } + } + + @Test + public void timeSort_vector() throws Exception { + List<Integer> input = buildList(arrayListLength, Vector.class); + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + Collections.sort(input); + } + } + + @Test + public void timeSortWithComparator_vector() throws Exception { + List<Integer> input = buildList(arrayListLength, Vector.class); + BenchmarkState state = mPerfStatusReporter.getBenchmarkState(); + while (state.keepRunning()) { + Collections.sort(input, REVERSE); + } + } + + private static <T extends List<Integer>> List<Integer> buildList( + int arrayListLength, Class<T> listClass) throws Exception { + Random random = new Random(); + random.setSeed(0); + List<Integer> list = listClass.newInstance(); + for (int i = 0; i < arrayListLength; ++i) { + list.add(random.nextInt()); + } + return list; + } +} |