Home | History | Annotate | Download | only in renderthread 
      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:
     50     ANDROID_API RenderTask() : mNext(0), 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 
     59 class SignalingRenderTask : public RenderTask {
     60 public:
     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();
     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:
     76     MethodInvokeRenderTask(RunnableMethod method)
     77         : mMethod(method), mReturnPtr(0) {}
     78 
     79     void* payload() { return mData; }
     80     void setReturnPtr(void** retptr) { mReturnPtr = retptr; }
     81 
     82     virtual void run() {
     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