1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
|
/*
* Copyright (C) 2012 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef RSD_CPU_CORE_H
#define RSD_CPU_CORE_H
#include "rsd_cpu.h"
#include "rsSignal.h"
#include "rsContext.h"
#include "rsCppUtils.h"
#include "rsElement.h"
#include "rsScriptC.h"
#include "rsCpuCoreRuntime.h"
namespace bcc {
class BCCContext;
class RSCompilerDriver;
class RSExecutable;
}
namespace android {
namespace renderscript {
extern bool gArchUseSIMD;
typedef void (* InvokeFunc_t)(void);
typedef void (* ForEachFunc_t)(void);
typedef void (*WorkerCallback_t)(void *usr, uint32_t idx);
class RsdCpuScriptImpl;
class RsdCpuReferenceImpl;
struct ScriptTLSStruct {
android::renderscript::Context * mContext;
const android::renderscript::Script * mScript;
RsdCpuScriptImpl *mImpl;
};
struct MTLaunchStruct {
RsExpandKernelDriverInfo fep;
RsdCpuReferenceImpl *rsc;
RsdCpuScriptImpl *script;
ForEachFunc_t kernel;
uint32_t sig;
const Allocation * ains[RS_KERNEL_INPUT_LIMIT];
Allocation * aout[RS_KERNEL_INPUT_LIMIT];
uint32_t mSliceSize;
volatile int mSliceNum;
bool isThreadable;
RsLaunchDimensions start;
RsLaunchDimensions end;
};
class RsdCpuReferenceImpl : public RsdCpuReference {
public:
~RsdCpuReferenceImpl() override;
RsdCpuReferenceImpl(Context *);
void lockMutex();
void unlockMutex();
bool init(uint32_t version_major, uint32_t version_minor, sym_lookup_t, script_lookup_t);
void setPriority(int32_t priority) override;
virtual void launchThreads(WorkerCallback_t cbk, void *data);
static void * helperThreadProc(void *vrsc);
RsdCpuScriptImpl * setTLS(RsdCpuScriptImpl *sc);
Context * getContext() {return mRSC;}
uint32_t getThreadCount() const {
return mWorkers.mCount + 1;
}
void launchThreads(const Allocation** ains, uint32_t inLen, Allocation* aout,
const RsScriptCall* sc, MTLaunchStruct* mtls);
CpuScript * createScript(const ScriptC *s, char const *resName, char const *cacheDir,
uint8_t const *bitcode, size_t bitcodeSize, uint32_t flags) override;
CpuScript * createIntrinsic(const Script *s, RsScriptIntrinsicID iid, Element *e) override;
void* createScriptGroup(const ScriptGroupBase *sg) override;
const RsdCpuReference::CpuSymbol *symLookup(const char *);
RsdCpuReference::CpuScript * lookupScript(const Script *s) {
return mScriptLookupFn(mRSC, s);
}
void setLinkRuntimeCallback(
bcc::RSLinkRuntimeCallback pLinkRuntimeCallback) {
mLinkRuntimeCallback = pLinkRuntimeCallback;
}
bcc::RSLinkRuntimeCallback getLinkRuntimeCallback() {
return mLinkRuntimeCallback;
}
void setSelectRTCallback(RSSelectRTCallback pSelectRTCallback) {
mSelectRTCallback = pSelectRTCallback;
}
RSSelectRTCallback getSelectRTCallback() {
return mSelectRTCallback;
}
#ifndef RS_COMPATIBILITY_LIB
void setSetupCompilerCallback(RSSetupCompilerCallback pSetupCompilerCallback) override {
mSetupCompilerCallback = pSetupCompilerCallback;
}
RSSetupCompilerCallback getSetupCompilerCallback() const override {
return mSetupCompilerCallback;
}
#endif
virtual void setBccPluginName(const char *name) {
mBccPluginName.setTo(name);
}
virtual const char *getBccPluginName() const {
return mBccPluginName.string();
}
bool getInForEach() override { return mInForEach; }
// Set to true if we should embed global variable information in the code.
void setEmbedGlobalInfo(bool v) override {
mEmbedGlobalInfo = v;
}
// Returns true if we should embed global variable information in the code.
bool getEmbedGlobalInfo() const override {
return mEmbedGlobalInfo;
}
// Set to true if we should skip constant (immutable) global variables when
// potentially embedding information about globals.
void setEmbedGlobalInfoSkipConstant(bool v) override {
mEmbedGlobalInfoSkipConstant = v;
}
// Returns true if we should skip constant (immutable) global variables when
// potentially embedding information about globals.
bool getEmbedGlobalInfoSkipConstant() const override {
return mEmbedGlobalInfoSkipConstant;
}
protected:
Context *mRSC;
uint32_t version_major;
uint32_t version_minor;
//bool mHasGraphics;
bool mInForEach;
struct Workers {
volatile int mRunningCount;
volatile int mLaunchCount;
uint32_t mCount;
pthread_t *mThreadId;
pid_t *mNativeThreadId;
Signal mCompleteSignal;
Signal *mLaunchSignals;
WorkerCallback_t mLaunchCallback;
void *mLaunchData;
};
Workers mWorkers;
bool mExit;
sym_lookup_t mSymLookupFn;
script_lookup_t mScriptLookupFn;
ScriptTLSStruct mTlsStruct;
bcc::RSLinkRuntimeCallback mLinkRuntimeCallback;
RSSelectRTCallback mSelectRTCallback;
RSSetupCompilerCallback mSetupCompilerCallback;
String8 mBccPluginName;
// Specifies whether we should embed global variable information in the
// code via special RS variables that can be examined later by the driver.
// Defaults to true.
bool mEmbedGlobalInfo;
// Specifies whether we should skip constant (immutable) global variables
// when potentially embedding information about globals.
// Defaults to true.
bool mEmbedGlobalInfoSkipConstant;
};
}
}
#endif
|
