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) {}
64     virtual void run() override;
65 
66 private:
67     RenderTask* mTask;
68     Mutex* mLock;
69     Condition* mSignal;
70 };
71 
72 typedef void* (*RunnableMethod)(void* data);
73 
74 class MethodInvokeRenderTask : public RenderTask {
75 public:
MethodInvokeRenderTask(RunnableMethod method)76     MethodInvokeRenderTask(RunnableMethod method)
77         : mMethod(method), mReturnPtr(nullptr) {}
78 
payload()79     void* payload() { return mData; }
setReturnPtr(void ** retptr)80     void setReturnPtr(void** retptr) { mReturnPtr = retptr; }
81 
run()82     virtual void run() override {
83         void* retval = mMethod(mData);
84         if (mReturnPtr) {
85             *mReturnPtr = retval;
86         }
87         // Commit suicide
88         delete this;
89     }
90 private:
91     RunnableMethod mMethod;
92     char mData[METHOD_INVOKE_PAYLOAD_SIZE];
93     void** mReturnPtr;
94 };
95 
96 } /* namespace renderthread */
97 } /* namespace uirenderer */
98 } /* namespace android */
99 #endif /* RENDERTASK_H_ */
100