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 23namespace android { 24class Mutex; 25class Condition; 26namespace uirenderer { 27namespace 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 48class ANDROID_API RenderTask { 49public: 50 ANDROID_API RenderTask() : mNext(nullptr), mRunAt(0) {} 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 59class SignalingRenderTask : public RenderTask { 60public: 61 // Takes ownership of task, caller owns lock and signal 62 SignalingRenderTask(RenderTask* task, Mutex* lock, Condition* signal) 63 : mTask(task), mLock(lock), mSignal(signal) {} 64 virtual void run() override; 65 66private: 67 RenderTask* mTask; 68 Mutex* mLock; 69 Condition* mSignal; 70}; 71 72typedef void* (*RunnableMethod)(void* data); 73 74class MethodInvokeRenderTask : public RenderTask { 75public: 76 MethodInvokeRenderTask(RunnableMethod method) 77 : mMethod(method), mReturnPtr(nullptr) {} 78 79 void* payload() { return mData; } 80 void setReturnPtr(void** retptr) { mReturnPtr = retptr; } 81 82 virtual void run() override { 83 void* retval = mMethod(mData); 84 if (mReturnPtr) { 85 *mReturnPtr = retval; 86 } 87 // Commit suicide 88 delete this; 89 } 90private: 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