1 /* 2 * Copyright (C) 2016 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 "thread/Task.h" 20 #include "thread/TaskManager.h" 21 #include "thread/TaskProcessor.h" 22 23 #include <vector> 24 25 using namespace android; 26 using namespace android::uirenderer; 27 28 class TrivialTask : public Task<char> {}; 29 30 class TrivialProcessor : public TaskProcessor<char> { 31 public: TrivialProcessor(TaskManager * manager)32 explicit TrivialProcessor(TaskManager* manager) 33 : TaskProcessor(manager) {} ~TrivialProcessor()34 virtual ~TrivialProcessor() {} onProcess(const sp<Task<char>> & task)35 virtual void onProcess(const sp<Task<char> >& task) override { 36 TrivialTask* t = static_cast<TrivialTask*>(task.get()); 37 t->setResult(reinterpret_cast<intptr_t>(t) % 16 == 0 ? 'a' : 'b'); 38 } 39 }; 40 BM_TaskManager_allocateTask(benchmark::State & state)41void BM_TaskManager_allocateTask(benchmark::State& state) { 42 std::vector<sp<TrivialTask> > tasks; 43 tasks.reserve(state.max_iterations); 44 45 while (state.KeepRunning()) { 46 tasks.emplace_back(new TrivialTask); 47 benchmark::DoNotOptimize(tasks.back()); 48 } 49 } 50 BENCHMARK(BM_TaskManager_allocateTask); 51 BM_TaskManager_enqueueTask(benchmark::State & state)52void BM_TaskManager_enqueueTask(benchmark::State& state) { 53 TaskManager taskManager; 54 sp<TrivialProcessor> processor(new TrivialProcessor(&taskManager)); 55 std::vector<sp<TrivialTask> > tasks; 56 tasks.reserve(state.max_iterations); 57 58 while (state.KeepRunning()) { 59 tasks.emplace_back(new TrivialTask); 60 benchmark::DoNotOptimize(tasks.back()); 61 processor->add(tasks.back()); 62 } 63 64 for (sp<TrivialTask>& task : tasks) { 65 task->getResult(); 66 } 67 } 68 BENCHMARK(BM_TaskManager_enqueueTask); 69 BM_TaskManager_enqueueRunDeleteTask(benchmark::State & state)70void BM_TaskManager_enqueueRunDeleteTask(benchmark::State& state) { 71 TaskManager taskManager; 72 sp<TrivialProcessor> processor(new TrivialProcessor(&taskManager)); 73 std::vector<sp<TrivialTask> > tasks; 74 tasks.reserve(state.max_iterations); 75 76 while (state.KeepRunning()) { 77 tasks.emplace_back(new TrivialTask); 78 benchmark::DoNotOptimize(tasks.back()); 79 processor->add(tasks.back()); 80 } 81 state.ResumeTiming(); 82 for (sp<TrivialTask>& task : tasks) { 83 benchmark::DoNotOptimize(task->getResult()); 84 } 85 tasks.clear(); 86 state.PauseTiming(); 87 } 88 BENCHMARK(BM_TaskManager_enqueueRunDeleteTask); 89