TaskManagerBench.cpp revision d53e3bed1ca4a14b2a86d53eaef6969bd043176e 
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
25using namespace android;
26using namespace android::uirenderer;
27
28class TrivialTask : public Task<char> {};
29
30class TrivialProcessor : public TaskProcessor<char> {
31public:
32    explicit TrivialProcessor(TaskManager* manager)
33            : TaskProcessor(manager) {}
34    virtual ~TrivialProcessor() {}
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
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}
50BENCHMARK(BM_TaskManager_allocateTask);
51
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}
68BENCHMARK(BM_TaskManager_enqueueTask);
69
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}
88BENCHMARK(BM_TaskManager_enqueueRunDeleteTask);
89