rsClosure.cpp revision ff2bb54ebf593b1d19d3a2e4cfa70a8ea4432c0d 
1#include "rsClosure.h"
2
3#include "cpu_ref/rsCpuCore.h"
4#include "rsContext.h" // XXX: necessary to avoid compiler error on rsScript.h below
5#include "rsScript.h"
6#include "rsType.h"
7
8namespace android {
9namespace renderscript {
10
11RsClosure rsi_ClosureCreate(Context* context, RsScriptKernelID kernelID,
12                            RsAllocation returnValue,
13                            RsScriptFieldID* fieldIDs, size_t fieldIDs_length,
14                            uintptr_t* values, size_t values_length,
15                            size_t* sizes, size_t sizes_length,
16                            RsClosure* depClosures, size_t depClosures_length,
17                            RsScriptFieldID* depFieldIDs,
18                            size_t depFieldIDs_length) {
19    rsAssert(fieldIDs_length == values_length && values_length == sizes_length &&
20             sizes_length == depClosures_length &&
21             depClosures_length == depFieldIDs_length);
22
23    return (RsClosure)(new Closure(
24        context, (const ScriptKernelID*)kernelID, (Allocation*)returnValue,
25        fieldIDs_length, (const ScriptFieldID**)fieldIDs, (const void**)values,
26        sizes, (const Closure**)depClosures,
27        (const ScriptFieldID**)depFieldIDs));
28}
29
30RsClosure rsi_InvokeClosureCreate(Context* context, RsScriptInvokeID invokeID,
31                                  const void* params, const size_t paramLength,
32                                  const RsScriptFieldID* fieldIDs, const size_t fieldIDs_length,
33                                  const uintptr_t* values, const size_t values_length,
34                                  const size_t* sizes, const size_t sizes_length) {
35    rsAssert(fieldIDs_length == values_length && values_length == sizes_length);
36    return (RsClosure)(new Closure(
37        context, (const ScriptInvokeID*)invokeID, params, paramLength,
38        fieldIDs_length, (const ScriptFieldID**)fieldIDs, (const void**)values,
39        sizes));
40}
41
42#if 0
43void rsi_ClosureEval(Context* rsc, RsClosure closure) {
44    ((Closure*)closure)->eval();
45}
46#endif
47
48void rsi_ClosureSetArg(Context* rsc, RsClosure closure, uint32_t index,
49                       uintptr_t value, size_t size) {
50    ((Closure*)closure)->setArg(index, (const void*)value, size);
51}
52
53void rsi_ClosureSetGlobal(Context* rsc, RsClosure closure,
54                          RsScriptFieldID fieldID, uintptr_t value,
55                          size_t size) {
56    ((Closure*)closure)->setGlobal((const ScriptFieldID*)fieldID,
57                                   (const void*)value, size);
58}
59
60Closure::Closure(Context* context,
61                 const ScriptKernelID* kernelID,
62                 Allocation* returnValue,
63                 const int numValues,
64                 const ScriptFieldID** fieldIDs,
65                 const void** values,
66                 const size_t* sizes,
67                 const Closure** depClosures,
68                 const ScriptFieldID** depFieldIDs) :
69    ObjectBase(context), mContext(context), mKernelID((ScriptKernelID*)kernelID),
70    mInvokeID(nullptr), mReturnValue(returnValue), mParams(nullptr),
71    mParamLength(0) {
72    size_t i;
73
74    for (i = 0; i < (size_t)numValues && fieldIDs[i] == nullptr; i++);
75
76    mNumArg = i;
77    mArgs = new const void*[mNumArg];
78    memcpy(mArgs, values, sizeof(const void*) * mNumArg);
79
80    for (; i < (size_t)numValues; i++) {
81        rsAssert(fieldIDs[i] != nullptr);
82        mGlobals[fieldIDs[i]] = make_pair(values[i], sizes[i]);
83        ALOGV("Creating closure %p, binding field %p (Script %p, slot: %d)",
84              this, fieldIDs[i], fieldIDs[i]->mScript, fieldIDs[i]->mSlot);
85    }
86
87    size_t j = mNumArg;
88    for (const auto& p : mGlobals) {
89        rsAssert(p.first == fieldIDs[j]);
90        rsAssert(p.second.first == values[j]);
91        rsAssert(p.second.second == sizes[j]);
92        j++;
93    }
94
95    // mDependences.insert(depClosures, depClosures + numValues);
96
97    for (i = 0; i < mNumArg; i++) {
98        const Closure* dep = depClosures[i];
99        if (dep != nullptr) {
100            auto mapping = mArgDeps[dep];
101            if (mapping == nullptr) {
102                mapping = new Map<int, const ObjectBaseRef<ScriptFieldID>*>();
103                mArgDeps[dep] = mapping;
104            }
105            (*mapping)[i] = new ObjectBaseRef<ScriptFieldID>(
106                const_cast<ScriptFieldID*>(depFieldIDs[i]));
107        }
108    }
109
110    for (; i < (size_t)numValues; i++) {
111        const Closure* dep = depClosures[i];
112        if (dep != nullptr) {
113            auto mapping = mGlobalDeps[dep];
114            if (mapping == nullptr) {
115                mapping = new Map<const ObjectBaseRef<ScriptFieldID>*,
116                                  const ObjectBaseRef<ScriptFieldID>*>();
117                mGlobalDeps[dep] = mapping;
118            }
119            (*mapping)[new ObjectBaseRef<ScriptFieldID>(
120                const_cast<ScriptFieldID*>(fieldIDs[i]))] =
121                    new ObjectBaseRef<ScriptFieldID>(
122                        const_cast<ScriptFieldID*>(depFieldIDs[i]));
123        }
124    }
125}
126
127Closure::Closure(Context* context, const ScriptInvokeID* invokeID,
128                 const void* params, const size_t paramLength,
129                 const size_t numValues, const ScriptFieldID** fieldIDs,
130                 const void** values, const size_t* sizes) :
131    ObjectBase(context), mContext(context), mKernelID(nullptr), mInvokeID(invokeID),
132    mReturnValue(nullptr), mParams(params), mParamLength(paramLength) {
133    for (size_t i = 0; i < numValues; i++) {
134        mGlobals[fieldIDs[i]] = make_pair(values[i], sizes[i]);
135    }
136}
137
138Closure::~Closure() {
139    for (const auto& p : mArgDeps) {
140        auto map = p.second;
141        for (const auto& p1 : *map) {
142            delete p1.second;
143        }
144        delete p.second;
145    }
146
147    for (const auto& p : mGlobalDeps) {
148        auto map = p.second;
149        for (const auto& p1 : *map) {
150            delete p1.first;
151            delete p1.second;
152        }
153        delete p.second;
154    }
155
156    delete[] mArgs;
157}
158
159void Closure::setArg(const uint32_t index, const void* value, const size_t size) {
160    mArgs[index] = value;
161}
162
163void Closure::setGlobal(const ScriptFieldID* fieldID, const void* value,
164                        const size_t size) {
165    mGlobals[fieldID] = make_pair(value, size);
166}
167
168}  // namespace renderscript
169}  // namespace android
170