1 /* 2 * Copyright (C) 2015 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #include <benchmark/benchmark.h> 18 19 #include "DisplayList.h" 20 #if HWUI_NEW_OPS 21 #include "RecordingCanvas.h" 22 #else 23 #include "DisplayListCanvas.h" 24 #endif 25 #include "tests/common/TestUtils.h" 26 27 using namespace android; 28 using namespace android::uirenderer; 29 30 #if HWUI_NEW_OPS 31 typedef RecordingCanvas TestCanvas; 32 #else 33 typedef DisplayListCanvas TestCanvas; 34 #endif 35 36 void BM_DisplayList_alloc(benchmark::State& benchState) { 37 while (benchState.KeepRunning()) { 38 auto displayList = new DisplayList(); 39 benchmark::DoNotOptimize(displayList); 40 delete displayList; 41 } 42 } 43 BENCHMARK(BM_DisplayList_alloc); 44 45 void BM_DisplayList_alloc_theoretical(benchmark::State& benchState) { 46 while (benchState.KeepRunning()) { 47 auto displayList = new char[sizeof(DisplayList)]; 48 benchmark::DoNotOptimize(displayList); 49 delete[] displayList; 50 } 51 } 52 BENCHMARK(BM_DisplayList_alloc_theoretical); 53 54 void BM_DisplayListCanvas_record_empty(benchmark::State& benchState) { 55 TestCanvas canvas(100, 100); 56 delete canvas.finishRecording(); 57 58 while (benchState.KeepRunning()) { 59 canvas.resetRecording(100, 100); 60 benchmark::DoNotOptimize(&canvas); 61 delete canvas.finishRecording(); 62 } 63 } 64 BENCHMARK(BM_DisplayListCanvas_record_empty); 65 66 void BM_DisplayListCanvas_record_saverestore(benchmark::State& benchState) { 67 TestCanvas canvas(100, 100); 68 delete canvas.finishRecording(); 69 70 while (benchState.KeepRunning()) { 71 canvas.resetRecording(100, 100); 72 canvas.save(SaveFlags::MatrixClip); 73 canvas.save(SaveFlags::MatrixClip); 74 benchmark::DoNotOptimize(&canvas); 75 canvas.restore(); 76 canvas.restore(); 77 delete canvas.finishRecording(); 78 } 79 } 80 BENCHMARK(BM_DisplayListCanvas_record_saverestore); 81 82 void BM_DisplayListCanvas_record_translate(benchmark::State& benchState) { 83 TestCanvas canvas(100, 100); 84 delete canvas.finishRecording(); 85 86 while (benchState.KeepRunning()) { 87 canvas.resetRecording(100, 100); 88 canvas.scale(10, 10); 89 benchmark::DoNotOptimize(&canvas); 90 delete canvas.finishRecording(); 91 } 92 } 93 BENCHMARK(BM_DisplayListCanvas_record_translate); 94 95 /** 96 * Simulate a simple view drawing a background, overlapped by an image. 97 * 98 * Note that the recording commands are intentionally not perfectly efficient, as the 99 * View system frequently produces unneeded save/restores. 100 */ 101 void BM_DisplayListCanvas_record_simpleBitmapView(benchmark::State& benchState) { 102 TestCanvas canvas(100, 100); 103 delete canvas.finishRecording(); 104 105 SkPaint rectPaint; 106 SkBitmap iconBitmap = TestUtils::createSkBitmap(80, 80); 107 108 while (benchState.KeepRunning()) { 109 canvas.resetRecording(100, 100); 110 { 111 canvas.save(SaveFlags::MatrixClip); 112 canvas.drawRect(0, 0, 100, 100, rectPaint); 113 canvas.restore(); 114 } 115 { 116 canvas.save(SaveFlags::MatrixClip); 117 canvas.translate(10, 10); 118 canvas.drawBitmap(iconBitmap, 0, 0, nullptr); 119 canvas.restore(); 120 } 121 benchmark::DoNotOptimize(&canvas); 122 delete canvas.finishRecording(); 123 } 124 } 125 BENCHMARK(BM_DisplayListCanvas_record_simpleBitmapView); 126 127 class NullClient: public CanvasStateClient { 128 void onViewportInitialized() override {} 129 void onSnapshotRestored(const Snapshot& removed, const Snapshot& restored) {} 130 GLuint getTargetFbo() const override { return 0; } 131 }; 132 133 void BM_CanvasState_saverestore(benchmark::State& benchState) { 134 NullClient client; 135 CanvasState state(client); 136 state.initializeSaveStack(100, 100, 0, 0, 100, 100, Vector3()); 137 138 while (benchState.KeepRunning()) { 139 state.save(SaveFlags::MatrixClip); 140 state.save(SaveFlags::MatrixClip); 141 benchmark::DoNotOptimize(&state); 142 state.restore(); 143 state.restore(); 144 } 145 } 146 BENCHMARK(BM_CanvasState_saverestore); 147 148 void BM_CanvasState_init(benchmark::State& benchState) { 149 NullClient client; 150 CanvasState state(client); 151 state.initializeSaveStack(100, 100, 0, 0, 100, 100, Vector3()); 152 153 while (benchState.KeepRunning()) { 154 state.initializeSaveStack(100, 100, 0, 0, 100, 100, Vector3()); 155 benchmark::DoNotOptimize(&state); 156 } 157 } 158 BENCHMARK(BM_CanvasState_init); 159 160 void BM_CanvasState_translate(benchmark::State& benchState) { 161 NullClient client; 162 CanvasState state(client); 163 state.initializeSaveStack(100, 100, 0, 0, 100, 100, Vector3()); 164 165 while (benchState.KeepRunning()) { 166 state.translate(5, 5, 0); 167 benchmark::DoNotOptimize(&state); 168 state.translate(-5, -5, 0); 169 } 170 } 171 BENCHMARK(BM_CanvasState_translate); 172
