Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2009 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 | #include "rsContext.h" |
| 18 | #include "rsScriptC.h" |
| 19 | #include "rsMatrix.h" |
Anatol Pomazau | e7b4b86 | 2010-09-07 17:33:01 -0700 | [diff] [blame] | 20 | #include "../../compile/libbcc/include/bcc/bcc.h" |
Joe Onorato | 9c4e4ca | 2009-08-09 11:39:02 -0700 | [diff] [blame] | 21 | #include "utils/Timers.h" |
Alex Sakhartchouk | b26fb04 | 2010-09-24 15:18:12 -0700 | [diff] [blame] | 22 | #include "utils/StopWatch.h" |
Jack Palevich | 1ef8b80 | 2009-05-28 15:53:04 -0700 | [diff] [blame] | 23 | |
Jason Sams | 1aa5a4e | 2009-06-22 17:15:15 -0700 | [diff] [blame] | 24 | #include <GLES/gl.h> |
| 25 | #include <GLES/glext.h> |
| 26 | |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 27 | using namespace android; |
| 28 | using namespace android::renderscript; |
| 29 | |
Jason Sams | e576910 | 2009-06-19 16:03:18 -0700 | [diff] [blame] | 30 | #define GET_TLS() Context::ScriptTLSStruct * tls = \ |
| 31 | (Context::ScriptTLSStruct *)pthread_getspecific(Context::gThreadTLSKey); \ |
| 32 | Context * rsc = tls->mContext; \ |
| 33 | ScriptC * sc = (ScriptC *) tls->mScript |
| 34 | |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 35 | |
Jason Sams | e514b45 | 2009-09-25 14:51:22 -0700 | [diff] [blame] | 36 | ScriptC::ScriptC(Context *rsc) : Script(rsc) |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 37 | { |
Jason Sams | be36bf3 | 2010-05-11 14:03:58 -0700 | [diff] [blame] | 38 | mBccScript = NULL; |
Jason Sams | efb8de1 | 2009-06-08 15:20:31 -0700 | [diff] [blame] | 39 | memset(&mProgram, 0, sizeof(mProgram)); |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 40 | } |
| 41 | |
| 42 | ScriptC::~ScriptC() |
| 43 | { |
Jason Sams | be36bf3 | 2010-05-11 14:03:58 -0700 | [diff] [blame] | 44 | if (mBccScript) { |
| 45 | bccDeleteScript(mBccScript); |
Jack Palevich | 1ef8b80 | 2009-05-28 15:53:04 -0700 | [diff] [blame] | 46 | } |
Jason Sams | e402ed3 | 2009-11-03 11:25:42 -0800 | [diff] [blame] | 47 | free(mEnviroment.mScriptText); |
| 48 | mEnviroment.mScriptText = NULL; |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 49 | } |
| 50 | |
Jason Sams | c61346b | 2010-05-28 18:23:22 -0700 | [diff] [blame] | 51 | void ScriptC::setupScript(Context *rsc) |
Jason Sams | ada7f27 | 2009-09-24 14:55:38 -0700 | [diff] [blame] | 52 | { |
Jason Sams | c61346b | 2010-05-28 18:23:22 -0700 | [diff] [blame] | 53 | setupGLState(rsc); |
| 54 | mEnviroment.mStartTimeMillis |
| 55 | = nanoseconds_to_milliseconds(systemTime(SYSTEM_TIME_MONOTONIC)); |
| 56 | |
Jason Sams | be36bf3 | 2010-05-11 14:03:58 -0700 | [diff] [blame] | 57 | for (uint32_t ct=0; ct < mEnviroment.mFieldCount; ct++) { |
Jason Sams | 900f161 | 2010-09-16 18:18:29 -0700 | [diff] [blame] | 58 | if (mSlots[ct].get() && !mTypes[ct].get()) { |
| 59 | mTypes[ct].set(mSlots[ct]->getType()); |
| 60 | } |
| 61 | |
| 62 | if (!mTypes[ct].get()) |
Jason Sams | be36bf3 | 2010-05-11 14:03:58 -0700 | [diff] [blame] | 63 | continue; |
Jason Sams | 900f161 | 2010-09-16 18:18:29 -0700 | [diff] [blame] | 64 | void *ptr = NULL; |
| 65 | if (mSlots[ct].get()) { |
| 66 | ptr = mSlots[ct]->getPtr(); |
| 67 | } |
Jason Sams | be36bf3 | 2010-05-11 14:03:58 -0700 | [diff] [blame] | 68 | void **dest = ((void ***)mEnviroment.mFieldAddress)[ct]; |
Jason Sams | be36bf3 | 2010-05-11 14:03:58 -0700 | [diff] [blame] | 69 | |
Jason Sams | b9077f4 | 2010-09-22 15:57:41 -0700 | [diff] [blame] | 70 | if (rsc->props.mLogScripts) { |
| 71 | LOGV("%p ScriptC::setupScript slot=%i dst=%p src=%p type=%p", rsc, ct, dest, ptr, mSlots[ct]->getType()); |
| 72 | |
| 73 | //const uint32_t *p32 = (const uint32_t *)ptr; |
| 74 | //for (uint32_t ct2=0; ct2 < mSlots[ct]->getType()->getDimX(); ct2++) { |
| 75 | //LOGE(" %i = 0x%08x ", ct2, p32[ct2]); |
| 76 | //} |
| 77 | } |
Jason Sams | be36bf3 | 2010-05-11 14:03:58 -0700 | [diff] [blame] | 78 | |
| 79 | if (dest) { |
| 80 | *dest = ptr; |
| 81 | } else { |
Jason Sams | d7e5481 | 2010-10-10 17:58:25 -0700 | [diff] [blame] | 82 | if (rsc->props.mLogScripts) { |
| 83 | LOGV("ScriptC::setupScript, NULL var binding address."); |
| 84 | } |
Jason Sams | ada7f27 | 2009-09-24 14:55:38 -0700 | [diff] [blame] | 85 | } |
| 86 | } |
| 87 | } |
| 88 | |
Jason Sams | ce92d4b | 2010-05-17 14:55:34 -0700 | [diff] [blame] | 89 | const Allocation *ScriptC::ptrToAllocation(const void *ptr) const |
| 90 | { |
| 91 | if (!ptr) { |
| 92 | return NULL; |
| 93 | } |
| 94 | for (uint32_t ct=0; ct < mEnviroment.mFieldCount; ct++) { |
| 95 | if (!mSlots[ct].get()) |
| 96 | continue; |
| 97 | if (mSlots[ct]->getPtr() == ptr) { |
| 98 | return mSlots[ct].get(); |
| 99 | } |
| 100 | } |
| 101 | LOGE("ScriptC::ptrToAllocation, failed to find %p", ptr); |
| 102 | return NULL; |
| 103 | } |
| 104 | |
Jason Sams | c61346b | 2010-05-28 18:23:22 -0700 | [diff] [blame] | 105 | Script * ScriptC::setTLS(Script *sc) |
Jason Sams | 22fa371 | 2010-05-19 17:22:57 -0700 | [diff] [blame] | 106 | { |
| 107 | Context::ScriptTLSStruct * tls = (Context::ScriptTLSStruct *) |
| 108 | pthread_getspecific(Context::gThreadTLSKey); |
| 109 | rsAssert(tls); |
Jason Sams | c61346b | 2010-05-28 18:23:22 -0700 | [diff] [blame] | 110 | Script *old = tls->mScript; |
| 111 | tls->mScript = sc; |
| 112 | return old; |
Jason Sams | 22fa371 | 2010-05-19 17:22:57 -0700 | [diff] [blame] | 113 | } |
| 114 | |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 115 | |
Jason Sams | c61346b | 2010-05-28 18:23:22 -0700 | [diff] [blame] | 116 | void ScriptC::setupGLState(Context *rsc) |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 117 | { |
Jason Sams | a0a1b6f | 2009-06-10 15:04:38 -0700 | [diff] [blame] | 118 | if (mEnviroment.mFragmentStore.get()) { |
| 119 | rsc->setFragmentStore(mEnviroment.mFragmentStore.get()); |
| 120 | } |
| 121 | if (mEnviroment.mFragment.get()) { |
| 122 | rsc->setFragment(mEnviroment.mFragment.get()); |
| 123 | } |
Jason Sams | 8ce125b | 2009-06-17 16:52:59 -0700 | [diff] [blame] | 124 | if (mEnviroment.mVertex.get()) { |
| 125 | rsc->setVertex(mEnviroment.mVertex.get()); |
| 126 | } |
Jason Sams | b681c8a | 2009-09-28 18:12:56 -0700 | [diff] [blame] | 127 | if (mEnviroment.mRaster.get()) { |
| 128 | rsc->setRaster(mEnviroment.mRaster.get()); |
| 129 | } |
Jason Sams | c61346b | 2010-05-28 18:23:22 -0700 | [diff] [blame] | 130 | } |
Jason Sams | a0a1b6f | 2009-06-10 15:04:38 -0700 | [diff] [blame] | 131 | |
Jason Sams | c61346b | 2010-05-28 18:23:22 -0700 | [diff] [blame] | 132 | uint32_t ScriptC::run(Context *rsc) |
| 133 | { |
| 134 | if (mProgram.mRoot == NULL) { |
| 135 | rsc->setError(RS_ERROR_BAD_SCRIPT, "Attempted to run bad script"); |
| 136 | return 0; |
Joe Onorato | 9c4e4ca | 2009-08-09 11:39:02 -0700 | [diff] [blame] | 137 | } |
Jason Sams | c61346b | 2010-05-28 18:23:22 -0700 | [diff] [blame] | 138 | |
| 139 | setupScript(rsc); |
Jason Sams | 1d54f10 | 2009-09-03 15:43:13 -0700 | [diff] [blame] | 140 | |
Jason Sams | 2dca84d | 2009-12-09 11:05:45 -0800 | [diff] [blame] | 141 | uint32_t ret = 0; |
Jason Sams | c61346b | 2010-05-28 18:23:22 -0700 | [diff] [blame] | 142 | Script * oldTLS = setTLS(this); |
Jason Sams | b9077f4 | 2010-09-22 15:57:41 -0700 | [diff] [blame] | 143 | |
| 144 | if (rsc->props.mLogScripts) { |
| 145 | LOGV("%p ScriptC::run invoking root, ptr %p", rsc, mProgram.mRoot); |
| 146 | } |
| 147 | |
Jason Sams | be36bf3 | 2010-05-11 14:03:58 -0700 | [diff] [blame] | 148 | ret = mProgram.mRoot(); |
Jason Sams | b9077f4 | 2010-09-22 15:57:41 -0700 | [diff] [blame] | 149 | |
| 150 | if (rsc->props.mLogScripts) { |
| 151 | LOGV("%p ScriptC::run invoking complete, ret=%i", rsc, ret); |
| 152 | } |
| 153 | |
Jason Sams | c61346b | 2010-05-28 18:23:22 -0700 | [diff] [blame] | 154 | setTLS(oldTLS); |
Jason Sams | e45ac6e | 2009-07-20 14:31:06 -0700 | [diff] [blame] | 155 | return ret; |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 156 | } |
| 157 | |
Jason Sams | c61346b | 2010-05-28 18:23:22 -0700 | [diff] [blame] | 158 | |
Jason Sams | 7bf29dd | 2010-07-19 15:38:19 -0700 | [diff] [blame] | 159 | typedef struct { |
| 160 | Context *rsc; |
| 161 | ScriptC *script; |
| 162 | const Allocation * ain; |
| 163 | Allocation * aout; |
| 164 | const void * usr; |
| 165 | |
| 166 | uint32_t mSliceSize; |
| 167 | volatile int mSliceNum; |
| 168 | |
| 169 | const uint8_t *ptrIn; |
| 170 | uint32_t eStrideIn; |
| 171 | uint8_t *ptrOut; |
| 172 | uint32_t eStrideOut; |
| 173 | |
| 174 | uint32_t xStart; |
| 175 | uint32_t xEnd; |
| 176 | uint32_t yStart; |
| 177 | uint32_t yEnd; |
| 178 | uint32_t zStart; |
| 179 | uint32_t zEnd; |
| 180 | uint32_t arrayStart; |
| 181 | uint32_t arrayEnd; |
| 182 | |
| 183 | uint32_t dimX; |
| 184 | uint32_t dimY; |
| 185 | uint32_t dimZ; |
| 186 | uint32_t dimArray; |
| 187 | } MTLaunchStruct; |
| 188 | typedef int (*rs_t)(const void *, void *, const void *, uint32_t, uint32_t, uint32_t, uint32_t); |
| 189 | |
| 190 | static void wc_xy(void *usr, uint32_t idx) |
| 191 | { |
| 192 | MTLaunchStruct *mtls = (MTLaunchStruct *)usr; |
Jason Sams | 7bf29dd | 2010-07-19 15:38:19 -0700 | [diff] [blame] | 193 | |
| 194 | while (1) { |
| 195 | uint32_t slice = (uint32_t)android_atomic_inc(&mtls->mSliceNum); |
| 196 | uint32_t yStart = mtls->yStart + slice * mtls->mSliceSize; |
| 197 | uint32_t yEnd = yStart + mtls->mSliceSize; |
| 198 | yEnd = rsMin(yEnd, mtls->yEnd); |
| 199 | if (yEnd <= yStart) { |
| 200 | return; |
| 201 | } |
| 202 | |
| 203 | //LOGE("usr idx %i, x %i,%i y %i,%i", idx, mtls->xStart, mtls->xEnd, yStart, yEnd); |
Jason Sams | 8d957fa | 2010-09-28 14:41:22 -0700 | [diff] [blame] | 204 | //LOGE("usr ptr in %p, out %p", mtls->ptrIn, mtls->ptrOut); |
Jason Sams | 7bf29dd | 2010-07-19 15:38:19 -0700 | [diff] [blame] | 205 | for (uint32_t y = yStart; y < yEnd; y++) { |
| 206 | uint32_t offset = mtls->dimX * y; |
| 207 | uint8_t *xPtrOut = mtls->ptrOut + (mtls->eStrideOut * offset); |
| 208 | const uint8_t *xPtrIn = mtls->ptrIn + (mtls->eStrideIn * offset); |
| 209 | |
| 210 | for (uint32_t x = mtls->xStart; x < mtls->xEnd; x++) { |
| 211 | ((rs_t)mtls->script->mProgram.mRoot) (xPtrIn, xPtrOut, mtls->usr, x, y, 0, 0); |
| 212 | xPtrIn += mtls->eStrideIn; |
| 213 | xPtrOut += mtls->eStrideOut; |
| 214 | } |
| 215 | } |
| 216 | } |
| 217 | |
| 218 | } |
| 219 | |
Jason Sams | 177f844 | 2010-10-29 10:19:21 -0700 | [diff] [blame^] | 220 | static void wc_x(void *usr, uint32_t idx) |
| 221 | { |
| 222 | MTLaunchStruct *mtls = (MTLaunchStruct *)usr; |
| 223 | |
| 224 | while (1) { |
| 225 | uint32_t slice = (uint32_t)android_atomic_inc(&mtls->mSliceNum); |
| 226 | uint32_t xStart = mtls->xStart + slice * mtls->mSliceSize; |
| 227 | uint32_t xEnd = xStart + mtls->mSliceSize; |
| 228 | xEnd = rsMin(xEnd, mtls->xEnd); |
| 229 | if (xEnd <= xStart) { |
| 230 | return; |
| 231 | } |
| 232 | |
| 233 | //LOGE("usr idx %i, x %i,%i y %i,%i", idx, mtls->xStart, mtls->xEnd, yStart, yEnd); |
| 234 | //LOGE("usr ptr in %p, out %p", mtls->ptrIn, mtls->ptrOut); |
| 235 | uint8_t *xPtrOut = mtls->ptrOut + (mtls->eStrideOut * xStart); |
| 236 | const uint8_t *xPtrIn = mtls->ptrIn + (mtls->eStrideIn * xStart); |
| 237 | for (uint32_t x = xStart; x < xEnd; x++) { |
| 238 | ((rs_t)mtls->script->mProgram.mRoot) (xPtrIn, xPtrOut, mtls->usr, x, 0, 0, 0); |
| 239 | xPtrIn += mtls->eStrideIn; |
| 240 | xPtrOut += mtls->eStrideOut; |
| 241 | } |
| 242 | } |
| 243 | |
| 244 | } |
| 245 | |
Jason Sams | ace3e01 | 2010-07-15 17:11:13 -0700 | [diff] [blame] | 246 | void ScriptC::runForEach(Context *rsc, |
| 247 | const Allocation * ain, |
| 248 | Allocation * aout, |
| 249 | const void * usr, |
| 250 | const RsScriptCall *sc) |
Jason Sams | c61346b | 2010-05-28 18:23:22 -0700 | [diff] [blame] | 251 | { |
Jason Sams | 7bf29dd | 2010-07-19 15:38:19 -0700 | [diff] [blame] | 252 | MTLaunchStruct mtls; |
| 253 | memset(&mtls, 0, sizeof(mtls)); |
Jason Sams | c61346b | 2010-05-28 18:23:22 -0700 | [diff] [blame] | 254 | |
Jason Sams | 7bf29dd | 2010-07-19 15:38:19 -0700 | [diff] [blame] | 255 | if (ain) { |
| 256 | mtls.dimX = ain->getType()->getDimX(); |
| 257 | mtls.dimY = ain->getType()->getDimY(); |
| 258 | mtls.dimZ = ain->getType()->getDimZ(); |
| 259 | //mtls.dimArray = ain->getType()->getDimArray(); |
| 260 | } else if (aout) { |
| 261 | mtls.dimX = aout->getType()->getDimX(); |
| 262 | mtls.dimY = aout->getType()->getDimY(); |
| 263 | mtls.dimZ = aout->getType()->getDimZ(); |
| 264 | //mtls.dimArray = aout->getType()->getDimArray(); |
| 265 | } else { |
| 266 | rsc->setError(RS_ERROR_BAD_SCRIPT, "rsForEach called with null allocations"); |
| 267 | return; |
| 268 | } |
Jason Sams | ace3e01 | 2010-07-15 17:11:13 -0700 | [diff] [blame] | 269 | |
| 270 | if (!sc || (sc->xEnd == 0)) { |
Jason Sams | 7bf29dd | 2010-07-19 15:38:19 -0700 | [diff] [blame] | 271 | mtls.xEnd = mtls.dimX; |
Jason Sams | ace3e01 | 2010-07-15 17:11:13 -0700 | [diff] [blame] | 272 | } else { |
Jason Sams | 7bf29dd | 2010-07-19 15:38:19 -0700 | [diff] [blame] | 273 | rsAssert(sc->xStart < mtls.dimX); |
| 274 | rsAssert(sc->xEnd <= mtls.dimX); |
Jason Sams | ace3e01 | 2010-07-15 17:11:13 -0700 | [diff] [blame] | 275 | rsAssert(sc->xStart < sc->xEnd); |
Jason Sams | 7bf29dd | 2010-07-19 15:38:19 -0700 | [diff] [blame] | 276 | mtls.xStart = rsMin(mtls.dimX, sc->xStart); |
| 277 | mtls.xEnd = rsMin(mtls.dimX, sc->xEnd); |
| 278 | if (mtls.xStart >= mtls.xEnd) return; |
Jason Sams | ace3e01 | 2010-07-15 17:11:13 -0700 | [diff] [blame] | 279 | } |
| 280 | |
| 281 | if (!sc || (sc->yEnd == 0)) { |
Jason Sams | 7bf29dd | 2010-07-19 15:38:19 -0700 | [diff] [blame] | 282 | mtls.yEnd = mtls.dimY; |
Jason Sams | ace3e01 | 2010-07-15 17:11:13 -0700 | [diff] [blame] | 283 | } else { |
Jason Sams | 7bf29dd | 2010-07-19 15:38:19 -0700 | [diff] [blame] | 284 | rsAssert(sc->yStart < mtls.dimY); |
| 285 | rsAssert(sc->yEnd <= mtls.dimY); |
Jason Sams | ace3e01 | 2010-07-15 17:11:13 -0700 | [diff] [blame] | 286 | rsAssert(sc->yStart < sc->yEnd); |
Jason Sams | 7bf29dd | 2010-07-19 15:38:19 -0700 | [diff] [blame] | 287 | mtls.yStart = rsMin(mtls.dimY, sc->yStart); |
| 288 | mtls.yEnd = rsMin(mtls.dimY, sc->yEnd); |
| 289 | if (mtls.yStart >= mtls.yEnd) return; |
Jason Sams | ace3e01 | 2010-07-15 17:11:13 -0700 | [diff] [blame] | 290 | } |
| 291 | |
Jason Sams | 7bf29dd | 2010-07-19 15:38:19 -0700 | [diff] [blame] | 292 | mtls.xEnd = rsMax((uint32_t)1, mtls.xEnd); |
| 293 | mtls.yEnd = rsMax((uint32_t)1, mtls.yEnd); |
| 294 | mtls.zEnd = rsMax((uint32_t)1, mtls.zEnd); |
| 295 | mtls.arrayEnd = rsMax((uint32_t)1, mtls.arrayEnd); |
Jason Sams | ace3e01 | 2010-07-15 17:11:13 -0700 | [diff] [blame] | 296 | |
| 297 | rsAssert(ain->getType()->getDimZ() == 0); |
Jason Sams | c61346b | 2010-05-28 18:23:22 -0700 | [diff] [blame] | 298 | |
| 299 | setupScript(rsc); |
| 300 | Script * oldTLS = setTLS(this); |
| 301 | |
Jason Sams | ace3e01 | 2010-07-15 17:11:13 -0700 | [diff] [blame] | 302 | |
Jason Sams | 7bf29dd | 2010-07-19 15:38:19 -0700 | [diff] [blame] | 303 | mtls.rsc = rsc; |
| 304 | mtls.ain = ain; |
| 305 | mtls.aout = aout; |
| 306 | mtls.script = this; |
| 307 | mtls.usr = usr; |
| 308 | mtls.mSliceSize = 10; |
| 309 | mtls.mSliceNum = 0; |
Jason Sams | c61346b | 2010-05-28 18:23:22 -0700 | [diff] [blame] | 310 | |
Jason Sams | 7bf29dd | 2010-07-19 15:38:19 -0700 | [diff] [blame] | 311 | mtls.ptrIn = NULL; |
| 312 | mtls.eStrideIn = 0; |
| 313 | if (ain) { |
| 314 | mtls.ptrIn = (const uint8_t *)ain->getPtr(); |
| 315 | mtls.eStrideIn = ain->getType()->getElementSizeBytes(); |
Jason Sams | c61346b | 2010-05-28 18:23:22 -0700 | [diff] [blame] | 316 | } |
| 317 | |
Jason Sams | 7bf29dd | 2010-07-19 15:38:19 -0700 | [diff] [blame] | 318 | mtls.ptrOut = NULL; |
| 319 | mtls.eStrideOut = 0; |
| 320 | if (aout) { |
| 321 | mtls.ptrOut = (uint8_t *)aout->getPtr(); |
| 322 | mtls.eStrideOut = aout->getType()->getElementSizeBytes(); |
| 323 | } |
| 324 | |
Jason Sams | 177f844 | 2010-10-29 10:19:21 -0700 | [diff] [blame^] | 325 | if ((rsc->getWorkerPoolSize() > 1) && mEnviroment.mIsThreadable) { |
| 326 | if (mtls.dimY > 1) { |
| 327 | rsc->launchThreads(wc_xy, &mtls); |
| 328 | } else { |
| 329 | rsc->launchThreads(wc_x, &mtls); |
| 330 | } |
Jason Sams | 1813340 | 2010-07-20 15:09:00 -0700 | [diff] [blame] | 331 | |
| 332 | //LOGE("launch 1"); |
Jason Sams | 1813340 | 2010-07-20 15:09:00 -0700 | [diff] [blame] | 333 | } else { |
Jason Sams | 8d957fa | 2010-09-28 14:41:22 -0700 | [diff] [blame] | 334 | //LOGE("launch 3"); |
Jason Sams | 1813340 | 2010-07-20 15:09:00 -0700 | [diff] [blame] | 335 | for (uint32_t ar = mtls.arrayStart; ar < mtls.arrayEnd; ar++) { |
| 336 | for (uint32_t z = mtls.zStart; z < mtls.zEnd; z++) { |
| 337 | for (uint32_t y = mtls.yStart; y < mtls.yEnd; y++) { |
| 338 | uint32_t offset = mtls.dimX * mtls.dimY * mtls.dimZ * ar + |
| 339 | mtls.dimX * mtls.dimY * z + |
| 340 | mtls.dimX * y; |
| 341 | uint8_t *xPtrOut = mtls.ptrOut + (mtls.eStrideOut * offset); |
| 342 | const uint8_t *xPtrIn = mtls.ptrIn + (mtls.eStrideIn * offset); |
Jason Sams | 7bf29dd | 2010-07-19 15:38:19 -0700 | [diff] [blame] | 343 | |
Jason Sams | 1813340 | 2010-07-20 15:09:00 -0700 | [diff] [blame] | 344 | for (uint32_t x = mtls.xStart; x < mtls.xEnd; x++) { |
| 345 | ((rs_t)mProgram.mRoot) (xPtrIn, xPtrOut, usr, x, y, z, ar); |
| 346 | xPtrIn += mtls.eStrideIn; |
| 347 | xPtrOut += mtls.eStrideOut; |
| 348 | } |
Jason Sams | ace3e01 | 2010-07-15 17:11:13 -0700 | [diff] [blame] | 349 | } |
| 350 | } |
| 351 | } |
Jason Sams | c61346b | 2010-05-28 18:23:22 -0700 | [diff] [blame] | 352 | } |
Jason Sams | 1813340 | 2010-07-20 15:09:00 -0700 | [diff] [blame] | 353 | |
Jason Sams | c61346b | 2010-05-28 18:23:22 -0700 | [diff] [blame] | 354 | setTLS(oldTLS); |
| 355 | } |
| 356 | |
Jason Sams | 22fa371 | 2010-05-19 17:22:57 -0700 | [diff] [blame] | 357 | void ScriptC::Invoke(Context *rsc, uint32_t slot, const void *data, uint32_t len) |
| 358 | { |
| 359 | //LOGE("rsi_ScriptInvoke %i", slot); |
| 360 | if ((slot >= mEnviroment.mInvokeFunctionCount) || |
| 361 | (mEnviroment.mInvokeFunctions[slot] == NULL)) { |
| 362 | rsc->setError(RS_ERROR_BAD_SCRIPT, "Calling invoke on bad script"); |
| 363 | return; |
| 364 | } |
Jason Sams | c61346b | 2010-05-28 18:23:22 -0700 | [diff] [blame] | 365 | setupScript(rsc); |
| 366 | Script * oldTLS = setTLS(this); |
Jason Sams | 22fa371 | 2010-05-19 17:22:57 -0700 | [diff] [blame] | 367 | |
Jason Sams | b9077f4 | 2010-09-22 15:57:41 -0700 | [diff] [blame] | 368 | if (rsc->props.mLogScripts) { |
| 369 | LOGV("%p ScriptC::Invoke invoking slot %i, ptr %p", rsc, slot, mEnviroment.mInvokeFunctions[slot]); |
| 370 | } |
Jason Sams | 2a63bf6 | 2010-06-08 15:40:48 -0700 | [diff] [blame] | 371 | ((void (*)(const void *, uint32_t)) |
| 372 | mEnviroment.mInvokeFunctions[slot])(data, len); |
Jason Sams | b9077f4 | 2010-09-22 15:57:41 -0700 | [diff] [blame] | 373 | if (rsc->props.mLogScripts) { |
| 374 | LOGV("%p ScriptC::Invoke complete", rsc); |
| 375 | } |
Jason Sams | 2a63bf6 | 2010-06-08 15:40:48 -0700 | [diff] [blame] | 376 | |
Jason Sams | c61346b | 2010-05-28 18:23:22 -0700 | [diff] [blame] | 377 | setTLS(oldTLS); |
Jason Sams | 22fa371 | 2010-05-19 17:22:57 -0700 | [diff] [blame] | 378 | } |
| 379 | |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 380 | ScriptCState::ScriptCState() |
| 381 | { |
Stephen Hines | 01b7d29 | 2010-09-28 15:45:45 -0700 | [diff] [blame] | 382 | mScript.clear(); |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 383 | } |
| 384 | |
| 385 | ScriptCState::~ScriptCState() |
| 386 | { |
Stephen Hines | 01b7d29 | 2010-09-28 15:45:45 -0700 | [diff] [blame] | 387 | mScript.clear(); |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 388 | } |
| 389 | |
Stephen Hines | 01b7d29 | 2010-09-28 15:45:45 -0700 | [diff] [blame] | 390 | void ScriptCState::init(Context *rsc) |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 391 | { |
Stephen Hines | 01b7d29 | 2010-09-28 15:45:45 -0700 | [diff] [blame] | 392 | clear(rsc); |
| 393 | } |
| 394 | |
| 395 | void ScriptCState::clear(Context *rsc) |
| 396 | { |
| 397 | rsAssert(rsc); |
Stephen Hines | 01b7d29 | 2010-09-28 15:45:45 -0700 | [diff] [blame] | 398 | mScript.clear(); |
| 399 | mScript.set(new ScriptC(rsc)); |
Jason Sams | 1f52633 | 2009-06-05 17:35:09 -0700 | [diff] [blame] | 400 | } |
| 401 | |
Jason Sams | be36bf3 | 2010-05-11 14:03:58 -0700 | [diff] [blame] | 402 | static BCCvoid* symbolLookup(BCCvoid* pContext, const BCCchar* name) |
Jason Sams | 29df66f | 2009-07-16 15:08:06 -0700 | [diff] [blame] | 403 | { |
Jason Sams | aeb094b | 2010-05-18 13:35:45 -0700 | [diff] [blame] | 404 | const ScriptCState::SymbolTable_t *sym; |
Jason Sams | dd663fa | 2010-08-11 13:26:28 -0700 | [diff] [blame] | 405 | ScriptC *s = (ScriptC *)pContext; |
Jason Sams | aeb094b | 2010-05-18 13:35:45 -0700 | [diff] [blame] | 406 | sym = ScriptCState::lookupSymbol(name); |
| 407 | if (sym) { |
| 408 | return sym->mPtr; |
| 409 | } |
| 410 | sym = ScriptCState::lookupSymbolCL(name); |
| 411 | if (sym) { |
| 412 | return sym->mPtr; |
| 413 | } |
Jason Sams | 8d957fa | 2010-09-28 14:41:22 -0700 | [diff] [blame] | 414 | s->mEnviroment.mIsThreadable = false; |
Jason Sams | aeb094b | 2010-05-18 13:35:45 -0700 | [diff] [blame] | 415 | sym = ScriptCState::lookupSymbolGL(name); |
Jason Sams | 29df66f | 2009-07-16 15:08:06 -0700 | [diff] [blame] | 416 | if (sym) { |
| 417 | return sym->mPtr; |
| 418 | } |
Jason Sams | 29df66f | 2009-07-16 15:08:06 -0700 | [diff] [blame] | 419 | LOGE("ScriptC sym lookup failed for %s", name); |
Jason Sams | 29df66f | 2009-07-16 15:08:06 -0700 | [diff] [blame] | 420 | return NULL; |
| 421 | } |
Jason Sams | a4a54e4 | 2009-06-10 18:39:40 -0700 | [diff] [blame] | 422 | |
Shih-wei Liao | 1f9ba73 | 2010-10-23 02:15:57 -0700 | [diff] [blame] | 423 | extern const char rs_runtime_lib_bc[]; |
| 424 | extern unsigned rs_runtime_lib_bc_size; |
| 425 | |
Jason Sams | 8c6bc69 | 2009-09-16 15:04:38 -0700 | [diff] [blame] | 426 | void ScriptCState::runCompiler(Context *rsc, ScriptC *s) |
Jason Sams | 1f52633 | 2009-06-05 17:35:09 -0700 | [diff] [blame] | 427 | { |
Jason Sams | b9077f4 | 2010-09-22 15:57:41 -0700 | [diff] [blame] | 428 | LOGV("%p ScriptCState::runCompiler ", rsc); |
Alex Sakhartchouk | b26fb04 | 2010-09-24 15:18:12 -0700 | [diff] [blame] | 429 | { |
| 430 | StopWatch compileTimer("RenderScript compile time"); |
| 431 | s->mBccScript = bccCreateScript(); |
| 432 | s->mEnviroment.mIsThreadable = true; |
| 433 | bccScriptBitcode(s->mBccScript, s->mEnviroment.mScriptText, s->mEnviroment.mScriptTextLength); |
Shih-wei Liao | 1f9ba73 | 2010-10-23 02:15:57 -0700 | [diff] [blame] | 434 | //bccLinkBitcode(s->mBccScript, rs_runtime_lib_bc, rs_runtime_lib_bc_size); |
Alex Sakhartchouk | b26fb04 | 2010-09-24 15:18:12 -0700 | [diff] [blame] | 435 | bccRegisterSymbolCallback(s->mBccScript, symbolLookup, s); |
| 436 | bccCompileScript(s->mBccScript); |
| 437 | bccGetScriptLabel(s->mBccScript, "root", (BCCvoid**) &s->mProgram.mRoot); |
| 438 | bccGetScriptLabel(s->mBccScript, "init", (BCCvoid**) &s->mProgram.mInit); |
| 439 | } |
Jason Sams | b9077f4 | 2010-09-22 15:57:41 -0700 | [diff] [blame] | 440 | LOGV("%p ScriptCState::runCompiler root %p, init %p", rsc, s->mProgram.mRoot, s->mProgram.mInit); |
Jason Sams | f168504 | 2009-07-16 17:47:40 -0700 | [diff] [blame] | 441 | |
Jason Sams | 8c6bc69 | 2009-09-16 15:04:38 -0700 | [diff] [blame] | 442 | if (s->mProgram.mInit) { |
| 443 | s->mProgram.mInit(); |
Jason Sams | 1d54f10 | 2009-09-03 15:43:13 -0700 | [diff] [blame] | 444 | } |
| 445 | |
Jason Sams | 8c88090 | 2010-06-15 12:15:57 -0700 | [diff] [blame] | 446 | bccGetExportFuncs(s->mBccScript, (BCCsizei*) &s->mEnviroment.mInvokeFunctionCount, 0, NULL); |
| 447 | if(s->mEnviroment.mInvokeFunctionCount <= 0) |
| 448 | s->mEnviroment.mInvokeFunctions = NULL; |
| 449 | else { |
| 450 | s->mEnviroment.mInvokeFunctions = (Script::InvokeFunc_t*) calloc(s->mEnviroment.mInvokeFunctionCount, sizeof(Script::InvokeFunc_t)); |
| 451 | bccGetExportFuncs(s->mBccScript, NULL, s->mEnviroment.mInvokeFunctionCount, (BCCvoid **) s->mEnviroment.mInvokeFunctions); |
Jason Sams | 1d54f10 | 2009-09-03 15:43:13 -0700 | [diff] [blame] | 452 | } |
| 453 | |
Shih-wei Liao | a226b16 | 2010-07-20 16:43:25 -0700 | [diff] [blame] | 454 | bccGetExportVars(s->mBccScript, (BCCsizei*) &s->mEnviroment.mFieldCount, 0, NULL); |
| 455 | if(s->mEnviroment.mFieldCount <= 0) |
| 456 | s->mEnviroment.mFieldAddress = NULL; |
| 457 | else { |
| 458 | s->mEnviroment.mFieldAddress = (void **) calloc(s->mEnviroment.mFieldCount, sizeof(void *)); |
| 459 | bccGetExportVars(s->mBccScript, NULL, s->mEnviroment.mFieldCount, (BCCvoid **) s->mEnviroment.mFieldAddress); |
Alex Sakhartchouk | 700ba38 | 2010-10-08 15:00:05 -0700 | [diff] [blame] | 460 | s->initSlots(); |
Shih-wei Liao | a226b16 | 2010-07-20 16:43:25 -0700 | [diff] [blame] | 461 | } |
Jason Sams | a4a54e4 | 2009-06-10 18:39:40 -0700 | [diff] [blame] | 462 | |
Jason Sams | 8c6bc69 | 2009-09-16 15:04:38 -0700 | [diff] [blame] | 463 | s->mEnviroment.mFragment.set(rsc->getDefaultProgramFragment()); |
| 464 | s->mEnviroment.mVertex.set(rsc->getDefaultProgramVertex()); |
Jason Sams | ccc010b | 2010-05-13 18:30:11 -0700 | [diff] [blame] | 465 | s->mEnviroment.mFragmentStore.set(rsc->getDefaultProgramStore()); |
Jason Sams | b681c8a | 2009-09-28 18:12:56 -0700 | [diff] [blame] | 466 | s->mEnviroment.mRaster.set(rsc->getDefaultProgramRaster()); |
Jason Sams | 8c6bc69 | 2009-09-16 15:04:38 -0700 | [diff] [blame] | 467 | |
Jason Sams | be36bf3 | 2010-05-11 14:03:58 -0700 | [diff] [blame] | 468 | if (s->mProgram.mRoot) { |
Jason Sams | 1030893 | 2009-06-09 12:15:30 -0700 | [diff] [blame] | 469 | const static int pragmaMax = 16; |
Jason Sams | be36bf3 | 2010-05-11 14:03:58 -0700 | [diff] [blame] | 470 | BCCsizei pragmaCount; |
| 471 | BCCchar * str[pragmaMax]; |
| 472 | bccGetPragmas(s->mBccScript, &pragmaCount, pragmaMax, &str[0]); |
Jason Sams | 1030893 | 2009-06-09 12:15:30 -0700 | [diff] [blame] | 473 | |
Jason Sams | 1030893 | 2009-06-09 12:15:30 -0700 | [diff] [blame] | 474 | for (int ct=0; ct < pragmaCount; ct+=2) { |
Jason Sams | aeb094b | 2010-05-18 13:35:45 -0700 | [diff] [blame] | 475 | //LOGE("pragme %s %s", str[ct], str[ct+1]); |
Jason Sams | 1030893 | 2009-06-09 12:15:30 -0700 | [diff] [blame] | 476 | if (!strcmp(str[ct], "version")) { |
| 477 | continue; |
Jason Sams | 1030893 | 2009-06-09 12:15:30 -0700 | [diff] [blame] | 478 | } |
| 479 | |
Jason Sams | 1030893 | 2009-06-09 12:15:30 -0700 | [diff] [blame] | 480 | if (!strcmp(str[ct], "stateVertex")) { |
Jason Sams | 8ce125b | 2009-06-17 16:52:59 -0700 | [diff] [blame] | 481 | if (!strcmp(str[ct+1], "default")) { |
| 482 | continue; |
| 483 | } |
| 484 | if (!strcmp(str[ct+1], "parent")) { |
Jason Sams | 8c6bc69 | 2009-09-16 15:04:38 -0700 | [diff] [blame] | 485 | s->mEnviroment.mVertex.clear(); |
Jason Sams | 8ce125b | 2009-06-17 16:52:59 -0700 | [diff] [blame] | 486 | continue; |
| 487 | } |
Jason Sams | 1030893 | 2009-06-09 12:15:30 -0700 | [diff] [blame] | 488 | LOGE("Unreconized value %s passed to stateVertex", str[ct+1]); |
| 489 | } |
| 490 | |
| 491 | if (!strcmp(str[ct], "stateRaster")) { |
Jason Sams | b681c8a | 2009-09-28 18:12:56 -0700 | [diff] [blame] | 492 | if (!strcmp(str[ct+1], "default")) { |
| 493 | continue; |
| 494 | } |
| 495 | if (!strcmp(str[ct+1], "parent")) { |
| 496 | s->mEnviroment.mRaster.clear(); |
| 497 | continue; |
| 498 | } |
Jason Sams | 1030893 | 2009-06-09 12:15:30 -0700 | [diff] [blame] | 499 | LOGE("Unreconized value %s passed to stateRaster", str[ct+1]); |
| 500 | } |
| 501 | |
| 502 | if (!strcmp(str[ct], "stateFragment")) { |
Jason Sams | 8ce125b | 2009-06-17 16:52:59 -0700 | [diff] [blame] | 503 | if (!strcmp(str[ct+1], "default")) { |
| 504 | continue; |
| 505 | } |
| 506 | if (!strcmp(str[ct+1], "parent")) { |
Jason Sams | 8c6bc69 | 2009-09-16 15:04:38 -0700 | [diff] [blame] | 507 | s->mEnviroment.mFragment.clear(); |
Jason Sams | 8ce125b | 2009-06-17 16:52:59 -0700 | [diff] [blame] | 508 | continue; |
| 509 | } |
Jason Sams | 1030893 | 2009-06-09 12:15:30 -0700 | [diff] [blame] | 510 | LOGE("Unreconized value %s passed to stateFragment", str[ct+1]); |
| 511 | } |
| 512 | |
Jason Sams | b681c8a | 2009-09-28 18:12:56 -0700 | [diff] [blame] | 513 | if (!strcmp(str[ct], "stateStore")) { |
Jason Sams | 8ce125b | 2009-06-17 16:52:59 -0700 | [diff] [blame] | 514 | if (!strcmp(str[ct+1], "default")) { |
| 515 | continue; |
| 516 | } |
| 517 | if (!strcmp(str[ct+1], "parent")) { |
Jason Sams | 8c6bc69 | 2009-09-16 15:04:38 -0700 | [diff] [blame] | 518 | s->mEnviroment.mFragmentStore.clear(); |
Jason Sams | 8ce125b | 2009-06-17 16:52:59 -0700 | [diff] [blame] | 519 | continue; |
| 520 | } |
Jason Sams | b681c8a | 2009-09-28 18:12:56 -0700 | [diff] [blame] | 521 | LOGE("Unreconized value %s passed to stateStore", str[ct+1]); |
Jason Sams | 1030893 | 2009-06-09 12:15:30 -0700 | [diff] [blame] | 522 | } |
| 523 | |
| 524 | } |
| 525 | |
Jason Sams | d34b725 | 2009-08-04 16:58:20 -0700 | [diff] [blame] | 526 | |
Jason Sams | 1030893 | 2009-06-09 12:15:30 -0700 | [diff] [blame] | 527 | } else { |
| 528 | // Deal with an error. |
| 529 | } |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 530 | } |
| 531 | |
Jason Sams | 8b2c065 | 2009-08-12 17:54:11 -0700 | [diff] [blame] | 532 | |
Joe Onorato | 57b79ce | 2009-08-09 22:57:44 -0700 | [diff] [blame] | 533 | |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 534 | namespace android { |
| 535 | namespace renderscript { |
| 536 | |
| 537 | void rsi_ScriptCBegin(Context * rsc) |
| 538 | { |
| 539 | ScriptCState *ss = &rsc->mScriptC; |
Stephen Hines | 01b7d29 | 2010-09-28 15:45:45 -0700 | [diff] [blame] | 540 | ss->clear(rsc); |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 541 | } |
| 542 | |
Jason Sams | 1f52633 | 2009-06-05 17:35:09 -0700 | [diff] [blame] | 543 | void rsi_ScriptCSetText(Context *rsc, const char *text, uint32_t len) |
| 544 | { |
| 545 | ScriptCState *ss = &rsc->mScriptC; |
Jason Sams | e402ed3 | 2009-11-03 11:25:42 -0800 | [diff] [blame] | 546 | |
| 547 | char *t = (char *)malloc(len + 1); |
| 548 | memcpy(t, text, len); |
| 549 | t[len] = 0; |
| 550 | ss->mScript->mEnviroment.mScriptText = t; |
Jason Sams | 8c6bc69 | 2009-09-16 15:04:38 -0700 | [diff] [blame] | 551 | ss->mScript->mEnviroment.mScriptTextLength = len; |
Jason Sams | 1f52633 | 2009-06-05 17:35:09 -0700 | [diff] [blame] | 552 | } |
| 553 | |
| 554 | |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 555 | RsScript rsi_ScriptCCreate(Context * rsc) |
| 556 | { |
| 557 | ScriptCState *ss = &rsc->mScriptC; |
| 558 | |
Jason Sams | 225afd3 | 2010-10-21 14:06:55 -0700 | [diff] [blame] | 559 | ObjectBaseRef<ScriptC> s(ss->mScript); |
Stephen Hines | 01b7d29 | 2010-09-28 15:45:45 -0700 | [diff] [blame] | 560 | ss->mScript.clear(); |
Jason Sams | 225afd3 | 2010-10-21 14:06:55 -0700 | [diff] [blame] | 561 | s->incUserRef(); |
Jason Sams | 1f52633 | 2009-06-05 17:35:09 -0700 | [diff] [blame] | 562 | |
Stephen Hines | 01b7d29 | 2010-09-28 15:45:45 -0700 | [diff] [blame] | 563 | ss->runCompiler(rsc, s.get()); |
Stephen Hines | 01b7d29 | 2010-09-28 15:45:45 -0700 | [diff] [blame] | 564 | ss->clear(rsc); |
| 565 | return s.get(); |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 566 | } |
| 567 | |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 568 | } |
| 569 | } |