1 /*
2  * Copyright (C) 2013 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 RENDERTASK_H_
18 #define RENDERTASK_H_
19 
20 #include <cutils/compiler.h>
21 #include <utils/Timers.h>
22 
23 namespace android {
24 class Mutex;
25 class Condition;
26 namespace uirenderer {
27 namespace renderthread {
28 
29 #define METHOD_INVOKE_PAYLOAD_SIZE (8 * sizeof(void*))
30 
31 /*
32  * Notes about memory management
33  *
34  * RenderThread will only invoke RenderTask::run(). It is the responsibility
35  * of the RenderTask to know if it needs to suicide at the end of run() or
36  * if some other lifecycle is being used. As such, it is not valid to reference
37  * anything on RenderTask after the first call to run().
38  *
39  * For example SignalingRenderTask
40  * is expected to be stack allocated by the calling thread, so it does not
41  * suicide in run() but instead relies on the caller to destroy it.
42  *
43  * MethodInvokeRenderTask however is currently allocated with new, so it will
44  * suicide at the end of run(). TODO: Replace this with a small pool to avoid
45  * malloc/free churn of small objects?
46  */
47 
48 class ANDROID_API RenderTask {
49 public:
RenderTask()50     ANDROID_API RenderTask() : mNext(nullptr), mRunAt(0) {}
~RenderTask()51     ANDROID_API virtual ~RenderTask() {}
52 
53     ANDROID_API virtual void run() = 0;
54 
55     RenderTask* mNext;
56     nsecs_t mRunAt;  // nano-seconds on the SYSTEM_TIME_MONOTONIC clock
57 };
58 
59 class SignalingRenderTask : public RenderTask {
60 public:
61     // Takes ownership of task, caller owns lock and signal
SignalingRenderTask(RenderTask * task,Mutex * lock,Condition * signal)62     SignalingRenderTask(RenderTask* task, Mutex* lock, Condition* signal)
63             : mTask(task), mLock(lock), mSignal(signal), mHasRun(false) {}
64     virtual void run() override;
hasRun()65     bool hasRun() const { return mHasRun; }
66 
67 private:
68     RenderTask* mTask;
69     Mutex* mLock;
70     Condition* mSignal;
71     bool mHasRun;
72 };
73 
74 typedef void* (*RunnableMethod)(void* data);
75 
76 class MethodInvokeRenderTask : public RenderTask {
77 public:
MethodInvokeRenderTask(RunnableMethod method)78     explicit MethodInvokeRenderTask(RunnableMethod method) : mMethod(method), mReturnPtr(nullptr) {}
79 
payload()80     void* payload() { return mData; }
setReturnPtr(void ** retptr)81     void setReturnPtr(void** retptr) { mReturnPtr = retptr; }
82 
run()83     virtual void run() override {
84         void* retval = mMethod(mData);
85         if (mReturnPtr) {
86             *mReturnPtr = retval;
87         }
88         // Commit suicide
89         delete this;
90     }
91 
92 private:
93     RunnableMethod mMethod;
94     char mData[METHOD_INVOKE_PAYLOAD_SIZE];
95     void** mReturnPtr;
96 };
97 
98 } /* namespace renderthread */
99 } /* namespace uirenderer */
100 } /* namespace android */
101 #endif /* RENDERTASK_H_ */
102