1 /*
2  * Copyright (C) 2017 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 #ifndef HWUI_WORKQUEUE_H
18 #define HWUI_WORKQUEUE_H
19 
20 #include "utils/Macros.h"
21 
22 #include <log/log.h>
23 #include <utils/Timers.h>
24 
25 #include <condition_variable>
26 #include <functional>
27 #include <future>
28 #include <mutex>
29 #include <vector>
30 
31 namespace android::uirenderer {
32 
33 struct MonotonicClock {
nowMonotonicClock34     static nsecs_t now() { return systemTime(CLOCK_MONOTONIC); }
35 };
36 
37 class WorkQueue {
38     PREVENT_COPY_AND_ASSIGN(WorkQueue);
39 
40 public:
41     using clock = MonotonicClock;
42 
43 private:
44     struct WorkItem {
45         WorkItem() = delete;
46         WorkItem(const WorkItem& other) = delete;
47         WorkItem& operator=(const WorkItem& other) = delete;
48         WorkItem(WorkItem&& other) = default;
49         WorkItem& operator=(WorkItem&& other) = default;
50 
WorkItemWorkItem51         WorkItem(nsecs_t runAt, std::function<void()>&& work)
52                 : runAt(runAt), work(std::move(work)) {}
53 
54         nsecs_t runAt;
55         std::function<void()> work;
56     };
57 
58 public:
WorkQueue(std::function<void ()> && wakeFunc,std::mutex & lock)59     WorkQueue(std::function<void()>&& wakeFunc, std::mutex& lock)
60             : mWakeFunc(move(wakeFunc)), mLock(lock) {}
61 
process()62     void process() {
63         auto now = clock::now();
64         std::vector<WorkItem> toProcess;
65         {
66             std::unique_lock _lock{mLock};
67             if (mWorkQueue.empty()) return;
68             toProcess = std::move(mWorkQueue);
69             auto moveBack = find_if(std::begin(toProcess), std::end(toProcess),
70                                     [&now](WorkItem& item) { return item.runAt > now; });
71             if (moveBack != std::end(toProcess)) {
72                 mWorkQueue.reserve(std::distance(moveBack, std::end(toProcess)) + 5);
73                 std::move(moveBack, std::end(toProcess), std::back_inserter(mWorkQueue));
74                 toProcess.erase(moveBack, std::end(toProcess));
75             }
76         }
77         for (auto& item : toProcess) {
78             item.work();
79         }
80     }
81 
82     template <class F>
postAt(nsecs_t time,F && func)83     void postAt(nsecs_t time, F&& func) {
84         enqueue(WorkItem{time, std::function<void()>(std::forward<F>(func))});
85     }
86 
87     template <class F>
postDelayed(nsecs_t delay,F && func)88     void postDelayed(nsecs_t delay, F&& func) {
89         enqueue(WorkItem{clock::now() + delay, std::function<void()>(std::forward<F>(func))});
90     }
91 
92     template <class F>
post(F && func)93     void post(F&& func) {
94         postAt(0, std::forward<F>(func));
95     }
96 
97     template <class F>
98     auto async(F&& func) -> std::future<decltype(func())> {
99         typedef std::packaged_task<decltype(func())()> task_t;
100         auto task = std::make_shared<task_t>(std::forward<F>(func));
101         post([task]() { std::invoke(*task); });
102         return task->get_future();
103     }
104 
105     template <class F>
106     auto runSync(F&& func) -> decltype(func()) {
107         std::packaged_task<decltype(func())()> task{std::forward<F>(func)};
108         post([&task]() { std::invoke(task); });
109         return task.get_future().get();
110     };
111 
nextWakeup(std::unique_lock<std::mutex> & lock)112     nsecs_t nextWakeup(std::unique_lock<std::mutex>& lock) {
113         if (mWorkQueue.empty()) {
114             return std::numeric_limits<nsecs_t>::max();
115         } else {
116             return std::begin(mWorkQueue)->runAt;
117         }
118     }
119 
120 private:
enqueue(WorkItem && item)121     void enqueue(WorkItem&& item) {
122         bool needsWakeup;
123         {
124             std::unique_lock _lock{mLock};
125             auto insertAt = std::find_if(
126                     std::begin(mWorkQueue), std::end(mWorkQueue),
127                     [time = item.runAt](WorkItem & item) { return item.runAt > time; });
128             needsWakeup = std::begin(mWorkQueue) == insertAt;
129             mWorkQueue.emplace(insertAt, std::move(item));
130         }
131         if (needsWakeup) {
132             mWakeFunc();
133         }
134     }
135 
136     std::function<void()> mWakeFunc;
137 
138     std::mutex& mLock;
139     std::vector<WorkItem> mWorkQueue;
140 };
141 
142 }  // namespace android::uirenderer
143 
144 #endif  // HWUI_WORKQUEUE_H
145