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