rsContext.cpp revision cf912de17f1e086ccea707d8607a3d2eda56b98f
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 "rsDevice.h" 18#include "rsContext.h" 19#include "rsThreadIO.h" 20#include <ui/FramebufferNativeWindow.h> 21#include <ui/PixelFormat.h> 22#include <ui/EGLUtils.h> 23#include <ui/egl/android_natives.h> 24 25#include <sys/types.h> 26#include <sys/resource.h> 27#include <sched.h> 28 29#include <cutils/properties.h> 30 31#include <GLES/gl.h> 32#include <GLES/glext.h> 33#include <GLES2/gl2.h> 34#include <GLES2/gl2ext.h> 35 36#include <cutils/sched_policy.h> 37#include <sys/syscall.h> 38#include <string.h> 39 40using namespace android; 41using namespace android::renderscript; 42 43pthread_key_t Context::gThreadTLSKey = 0; 44uint32_t Context::gThreadTLSKeyCount = 0; 45uint32_t Context::gGLContextCount = 0; 46pthread_mutex_t Context::gInitMutex = PTHREAD_MUTEX_INITIALIZER; 47 48static void checkEglError(const char* op, EGLBoolean returnVal = EGL_TRUE) { 49 if (returnVal != EGL_TRUE) { 50 fprintf(stderr, "%s() returned %d\n", op, returnVal); 51 } 52 53 for (EGLint error = eglGetError(); error != EGL_SUCCESS; error 54 = eglGetError()) { 55 fprintf(stderr, "after %s() eglError %s (0x%x)\n", op, EGLUtils::strerror(error), 56 error); 57 } 58} 59 60void printEGLConfiguration(EGLDisplay dpy, EGLConfig config) { 61 62#define X(VAL) {VAL, #VAL} 63 struct {EGLint attribute; const char* name;} names[] = { 64 X(EGL_BUFFER_SIZE), 65 X(EGL_ALPHA_SIZE), 66 X(EGL_BLUE_SIZE), 67 X(EGL_GREEN_SIZE), 68 X(EGL_RED_SIZE), 69 X(EGL_DEPTH_SIZE), 70 X(EGL_STENCIL_SIZE), 71 X(EGL_CONFIG_CAVEAT), 72 X(EGL_CONFIG_ID), 73 X(EGL_LEVEL), 74 X(EGL_MAX_PBUFFER_HEIGHT), 75 X(EGL_MAX_PBUFFER_PIXELS), 76 X(EGL_MAX_PBUFFER_WIDTH), 77 X(EGL_NATIVE_RENDERABLE), 78 X(EGL_NATIVE_VISUAL_ID), 79 X(EGL_NATIVE_VISUAL_TYPE), 80 X(EGL_SAMPLES), 81 X(EGL_SAMPLE_BUFFERS), 82 X(EGL_SURFACE_TYPE), 83 X(EGL_TRANSPARENT_TYPE), 84 X(EGL_TRANSPARENT_RED_VALUE), 85 X(EGL_TRANSPARENT_GREEN_VALUE), 86 X(EGL_TRANSPARENT_BLUE_VALUE), 87 X(EGL_BIND_TO_TEXTURE_RGB), 88 X(EGL_BIND_TO_TEXTURE_RGBA), 89 X(EGL_MIN_SWAP_INTERVAL), 90 X(EGL_MAX_SWAP_INTERVAL), 91 X(EGL_LUMINANCE_SIZE), 92 X(EGL_ALPHA_MASK_SIZE), 93 X(EGL_COLOR_BUFFER_TYPE), 94 X(EGL_RENDERABLE_TYPE), 95 X(EGL_CONFORMANT), 96 }; 97#undef X 98 99 for (size_t j = 0; j < sizeof(names) / sizeof(names[0]); j++) { 100 EGLint value = -1; 101 EGLint returnVal = eglGetConfigAttrib(dpy, config, names[j].attribute, &value); 102 EGLint error = eglGetError(); 103 if (returnVal && error == EGL_SUCCESS) { 104 LOGV(" %s: %d (0x%x)", names[j].name, value, value); 105 } 106 } 107} 108 109 110bool Context::initGLThread() { 111 pthread_mutex_lock(&gInitMutex); 112 LOGV("initGLThread start %p", this); 113 114 mEGL.mNumConfigs = -1; 115 EGLint configAttribs[128]; 116 EGLint *configAttribsPtr = configAttribs; 117 EGLint context_attribs2[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE }; 118 119 memset(configAttribs, 0, sizeof(configAttribs)); 120 121 configAttribsPtr[0] = EGL_SURFACE_TYPE; 122 configAttribsPtr[1] = EGL_WINDOW_BIT; 123 configAttribsPtr += 2; 124 125 configAttribsPtr[0] = EGL_RENDERABLE_TYPE; 126 configAttribsPtr[1] = EGL_OPENGL_ES2_BIT; 127 configAttribsPtr += 2; 128 129 if (mUserSurfaceConfig.depthMin > 0) { 130 configAttribsPtr[0] = EGL_DEPTH_SIZE; 131 configAttribsPtr[1] = mUserSurfaceConfig.depthMin; 132 configAttribsPtr += 2; 133 } 134 135 if (mDev->mForceSW) { 136 configAttribsPtr[0] = EGL_CONFIG_CAVEAT; 137 configAttribsPtr[1] = EGL_SLOW_CONFIG; 138 configAttribsPtr += 2; 139 } 140 141 configAttribsPtr[0] = EGL_NONE; 142 rsAssert(configAttribsPtr < (configAttribs + (sizeof(configAttribs) / sizeof(EGLint)))); 143 144 LOGV("%p initEGL start", this); 145 mEGL.mDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY); 146 checkEglError("eglGetDisplay"); 147 148 eglInitialize(mEGL.mDisplay, &mEGL.mMajorVersion, &mEGL.mMinorVersion); 149 checkEglError("eglInitialize"); 150 151#if 1 152 PixelFormat pf = PIXEL_FORMAT_RGBA_8888; 153 if (mUserSurfaceConfig.alphaMin == 0) { 154 pf = PIXEL_FORMAT_RGBX_8888; 155 } 156 157 status_t err = EGLUtils::selectConfigForPixelFormat(mEGL.mDisplay, configAttribs, pf, &mEGL.mConfig); 158 if (err) { 159 LOGE("%p, couldn't find an EGLConfig matching the screen format\n", this); 160 } 161 if (props.mLogVisual) { 162 printEGLConfiguration(mEGL.mDisplay, mEGL.mConfig); 163 } 164#else 165 eglChooseConfig(mEGL.mDisplay, configAttribs, &mEGL.mConfig, 1, &mEGL.mNumConfigs); 166#endif 167 168 mEGL.mContext = eglCreateContext(mEGL.mDisplay, mEGL.mConfig, EGL_NO_CONTEXT, context_attribs2); 169 checkEglError("eglCreateContext"); 170 if (mEGL.mContext == EGL_NO_CONTEXT) { 171 pthread_mutex_unlock(&gInitMutex); 172 LOGE("%p, eglCreateContext returned EGL_NO_CONTEXT", this); 173 return false; 174 } 175 gGLContextCount++; 176 177 178 EGLint pbuffer_attribs[] = { EGL_WIDTH, 1, EGL_HEIGHT, 1, EGL_NONE }; 179 mEGL.mSurfaceDefault = eglCreatePbufferSurface(mEGL.mDisplay, mEGL.mConfig, pbuffer_attribs); 180 checkEglError("eglCreatePbufferSurface"); 181 if (mEGL.mSurfaceDefault == EGL_NO_SURFACE) { 182 LOGE("eglCreatePbufferSurface returned EGL_NO_SURFACE"); 183 pthread_mutex_unlock(&gInitMutex); 184 deinitEGL(); 185 return false; 186 } 187 188 EGLBoolean ret = eglMakeCurrent(mEGL.mDisplay, mEGL.mSurfaceDefault, mEGL.mSurfaceDefault, mEGL.mContext); 189 if (ret == EGL_FALSE) { 190 LOGE("eglMakeCurrent returned EGL_FALSE"); 191 checkEglError("eglMakeCurrent", ret); 192 pthread_mutex_unlock(&gInitMutex); 193 deinitEGL(); 194 return false; 195 } 196 197 mGL.mVersion = glGetString(GL_VERSION); 198 mGL.mVendor = glGetString(GL_VENDOR); 199 mGL.mRenderer = glGetString(GL_RENDERER); 200 mGL.mExtensions = glGetString(GL_EXTENSIONS); 201 202 //LOGV("EGL Version %i %i", mEGL.mMajorVersion, mEGL.mMinorVersion); 203 LOGV("GL Version %s", mGL.mVersion); 204 //LOGV("GL Vendor %s", mGL.mVendor); 205 LOGV("GL Renderer %s", mGL.mRenderer); 206 //LOGV("GL Extensions %s", mGL.mExtensions); 207 208 const char *verptr = NULL; 209 if (strlen((const char *)mGL.mVersion) > 9) { 210 if (!memcmp(mGL.mVersion, "OpenGL ES-CM", 12)) { 211 verptr = (const char *)mGL.mVersion + 12; 212 } 213 if (!memcmp(mGL.mVersion, "OpenGL ES ", 10)) { 214 verptr = (const char *)mGL.mVersion + 9; 215 } 216 } 217 218 if (!verptr) { 219 LOGE("Error, OpenGL ES Lite not supported"); 220 pthread_mutex_unlock(&gInitMutex); 221 deinitEGL(); 222 return false; 223 } else { 224 sscanf(verptr, " %i.%i", &mGL.mMajorVersion, &mGL.mMinorVersion); 225 } 226 227 glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &mGL.mMaxVertexAttribs); 228 glGetIntegerv(GL_MAX_VERTEX_UNIFORM_VECTORS, &mGL.mMaxVertexUniformVectors); 229 glGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, &mGL.mMaxVertexTextureUnits); 230 231 glGetIntegerv(GL_MAX_VARYING_VECTORS, &mGL.mMaxVaryingVectors); 232 glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &mGL.mMaxTextureImageUnits); 233 234 glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &mGL.mMaxFragmentTextureImageUnits); 235 glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_VECTORS, &mGL.mMaxFragmentUniformVectors); 236 237 mGL.OES_texture_npot = NULL != strstr((const char *)mGL.mExtensions, "GL_OES_texture_npot"); 238 mGL.GL_NV_texture_npot_2D_mipmap = NULL != strstr((const char *)mGL.mExtensions, "GL_NV_texture_npot_2D_mipmap"); 239 mGL.EXT_texture_max_aniso = 1.0f; 240 bool hasAniso = NULL != strstr((const char *)mGL.mExtensions, "GL_EXT_texture_filter_anisotropic"); 241 if (hasAniso) { 242 glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &mGL.EXT_texture_max_aniso); 243 } 244 245 LOGV("initGLThread end %p", this); 246 pthread_mutex_unlock(&gInitMutex); 247 return true; 248} 249 250void Context::deinitEGL() { 251 LOGV("%p, deinitEGL", this); 252 253 if (mEGL.mContext != EGL_NO_CONTEXT) { 254 eglMakeCurrent(mEGL.mDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, mEGL.mContext); 255 eglDestroyContext(mEGL.mDisplay, mEGL.mContext); 256 checkEglError("eglDestroyContext"); 257 } 258 259 gGLContextCount--; 260 if (!gGLContextCount) { 261 eglTerminate(mEGL.mDisplay); 262 } 263} 264 265Context::PushState::PushState(Context *con) { 266 mRsc = con; 267 mFragment.set(con->getProgramFragment()); 268 mVertex.set(con->getProgramVertex()); 269 mStore.set(con->getProgramStore()); 270 mRaster.set(con->getProgramRaster()); 271 mFont.set(con->getFont()); 272} 273 274Context::PushState::~PushState() { 275 mRsc->setProgramFragment(mFragment.get()); 276 mRsc->setProgramVertex(mVertex.get()); 277 mRsc->setProgramStore(mStore.get()); 278 mRsc->setProgramRaster(mRaster.get()); 279 mRsc->setFont(mFont.get()); 280} 281 282 283uint32_t Context::runScript(Script *s) { 284 PushState(this); 285 286 uint32_t ret = s->run(this); 287 return ret; 288} 289 290void Context::checkError(const char *msg, bool isFatal) const { 291 292 GLenum err = glGetError(); 293 if (err != GL_NO_ERROR) { 294 char buf[1024]; 295 snprintf(buf, sizeof(buf), "GL Error = 0x%08x, from: %s", err, msg); 296 297 if (isFatal) { 298 setError(RS_ERROR_FATAL_DRIVER, buf); 299 } else { 300 switch (err) { 301 case GL_OUT_OF_MEMORY: 302 setError(RS_ERROR_OUT_OF_MEMORY, buf); 303 break; 304 default: 305 setError(RS_ERROR_DRIVER, buf); 306 break; 307 } 308 } 309 310 LOGE("%p, %s", this, buf); 311 } 312} 313 314uint32_t Context::runRootScript() { 315 glViewport(0, 0, mWidth, mHeight); 316 317 timerSet(RS_TIMER_SCRIPT); 318 mStateFragmentStore.mLast.clear(); 319 uint32_t ret = runScript(mRootScript.get()); 320 321 checkError("runRootScript"); 322 return ret; 323} 324 325uint64_t Context::getTime() const { 326 struct timespec t; 327 clock_gettime(CLOCK_MONOTONIC, &t); 328 return t.tv_nsec + ((uint64_t)t.tv_sec * 1000 * 1000 * 1000); 329} 330 331void Context::timerReset() { 332 for (int ct=0; ct < _RS_TIMER_TOTAL; ct++) { 333 mTimers[ct] = 0; 334 } 335} 336 337void Context::timerInit() { 338 mTimeLast = getTime(); 339 mTimeFrame = mTimeLast; 340 mTimeLastFrame = mTimeLast; 341 mTimerActive = RS_TIMER_INTERNAL; 342 mAverageFPSFrameCount = 0; 343 mAverageFPSStartTime = mTimeLast; 344 mAverageFPS = 0; 345 timerReset(); 346} 347 348void Context::timerFrame() { 349 mTimeLastFrame = mTimeFrame; 350 mTimeFrame = getTime(); 351 // Update average fps 352 const uint64_t averageFramerateInterval = 1000 * 1000000; 353 mAverageFPSFrameCount ++; 354 uint64_t inverval = mTimeFrame - mAverageFPSStartTime; 355 if (inverval >= averageFramerateInterval) { 356 inverval = inverval / 1000000; 357 mAverageFPS = (mAverageFPSFrameCount * 1000) / inverval; 358 mAverageFPSFrameCount = 0; 359 mAverageFPSStartTime = mTimeFrame; 360 } 361} 362 363void Context::timerSet(Timers tm) { 364 uint64_t last = mTimeLast; 365 mTimeLast = getTime(); 366 mTimers[mTimerActive] += mTimeLast - last; 367 mTimerActive = tm; 368} 369 370void Context::timerPrint() { 371 double total = 0; 372 for (int ct = 0; ct < _RS_TIMER_TOTAL; ct++) { 373 total += mTimers[ct]; 374 } 375 uint64_t frame = mTimeFrame - mTimeLastFrame; 376 mTimeMSLastFrame = frame / 1000000; 377 mTimeMSLastScript = mTimers[RS_TIMER_SCRIPT] / 1000000; 378 mTimeMSLastSwap = mTimers[RS_TIMER_CLEAR_SWAP] / 1000000; 379 380 381 if (props.mLogTimes) { 382 LOGV("RS: Frame (%i), Script %2.1f%% (%i), Swap %2.1f%% (%i), Idle %2.1f%% (%lli), Internal %2.1f%% (%lli), Avg fps: %u", 383 mTimeMSLastFrame, 384 100.0 * mTimers[RS_TIMER_SCRIPT] / total, mTimeMSLastScript, 385 100.0 * mTimers[RS_TIMER_CLEAR_SWAP] / total, mTimeMSLastSwap, 386 100.0 * mTimers[RS_TIMER_IDLE] / total, mTimers[RS_TIMER_IDLE] / 1000000, 387 100.0 * mTimers[RS_TIMER_INTERNAL] / total, mTimers[RS_TIMER_INTERNAL] / 1000000, 388 mAverageFPS); 389 } 390} 391 392bool Context::setupCheck() { 393 if (!mShaderCache.lookup(this, mVertex.get(), mFragment.get())) { 394 LOGE("Context::setupCheck() 1 fail"); 395 return false; 396 } 397 398 mFragmentStore->setupGL2(this, &mStateFragmentStore); 399 mFragment->setupGL2(this, &mStateFragment, &mShaderCache); 400 mRaster->setupGL2(this, &mStateRaster); 401 mVertex->setupGL2(this, &mStateVertex, &mShaderCache); 402 return true; 403} 404 405void Context::setupProgramStore() { 406 mFragmentStore->setupGL2(this, &mStateFragmentStore); 407} 408 409static bool getProp(const char *str) { 410 char buf[PROPERTY_VALUE_MAX]; 411 property_get(str, buf, "0"); 412 return 0 != strcmp(buf, "0"); 413} 414 415void Context::displayDebugStats() { 416 char buffer[128]; 417 sprintf(buffer, "Avg fps %u, Frame %i ms, Script %i ms", mAverageFPS, mTimeMSLastFrame, mTimeMSLastScript); 418 float oldR, oldG, oldB, oldA; 419 mStateFont.getFontColor(&oldR, &oldG, &oldB, &oldA); 420 uint32_t bufferLen = strlen(buffer); 421 422 float shadowCol = 0.1f; 423 mStateFont.setFontColor(shadowCol, shadowCol, shadowCol, 1.0f); 424 mStateFont.renderText(buffer, bufferLen, 5, getHeight() - 6); 425 426 mStateFont.setFontColor(1.0f, 0.7f, 0.0f, 1.0f); 427 mStateFont.renderText(buffer, bufferLen, 4, getHeight() - 7); 428 429 mStateFont.setFontColor(oldR, oldG, oldB, oldA); 430} 431 432void * Context::threadProc(void *vrsc) { 433 Context *rsc = static_cast<Context *>(vrsc); 434 rsc->mNativeThreadId = gettid(); 435 436 setpriority(PRIO_PROCESS, rsc->mNativeThreadId, ANDROID_PRIORITY_DISPLAY); 437 rsc->mThreadPriority = ANDROID_PRIORITY_DISPLAY; 438 439 rsc->props.mLogTimes = getProp("debug.rs.profile"); 440 rsc->props.mLogScripts = getProp("debug.rs.script"); 441 rsc->props.mLogObjects = getProp("debug.rs.object"); 442 rsc->props.mLogShaders = getProp("debug.rs.shader"); 443 rsc->props.mLogShadersAttr = getProp("debug.rs.shader.attributes"); 444 rsc->props.mLogShadersUniforms = getProp("debug.rs.shader.uniforms"); 445 rsc->props.mLogVisual = getProp("debug.rs.visual"); 446 447 rsc->mTlsStruct = new ScriptTLSStruct; 448 if (!rsc->mTlsStruct) { 449 LOGE("Error allocating tls storage"); 450 rsc->setError(RS_ERROR_OUT_OF_MEMORY, "Failed allocation for TLS"); 451 return NULL; 452 } 453 rsc->mTlsStruct->mContext = rsc; 454 rsc->mTlsStruct->mScript = NULL; 455 int status = pthread_setspecific(rsc->gThreadTLSKey, rsc->mTlsStruct); 456 if (status) { 457 LOGE("pthread_setspecific %i", status); 458 } 459 460 if (!rsc->initGLThread()) { 461 rsc->setError(RS_ERROR_OUT_OF_MEMORY, "Failed initializing GL"); 462 return NULL; 463 } 464 465 rsc->mScriptC.init(rsc); 466 if (rsc->mIsGraphicsContext) { 467 rsc->mStateRaster.init(rsc); 468 rsc->setProgramRaster(NULL); 469 rsc->mStateVertex.init(rsc); 470 rsc->setProgramVertex(NULL); 471 rsc->mStateFragment.init(rsc); 472 rsc->setProgramFragment(NULL); 473 rsc->mStateFragmentStore.init(rsc); 474 rsc->setProgramStore(NULL); 475 rsc->mStateFont.init(rsc); 476 rsc->setFont(NULL); 477 rsc->mStateVertexArray.init(rsc); 478 } 479 480 rsc->mRunning = true; 481 bool mDraw = true; 482 while (!rsc->mExit) { 483 mDraw |= rsc->mIO.playCoreCommands(rsc, !mDraw); 484 mDraw &= (rsc->mRootScript.get() != NULL); 485 mDraw &= (rsc->mWndSurface != NULL); 486 487 uint32_t targetTime = 0; 488 if (mDraw && rsc->mIsGraphicsContext) { 489 targetTime = rsc->runRootScript(); 490 491 if (rsc->props.mLogVisual) { 492 rsc->displayDebugStats(); 493 } 494 495 mDraw = targetTime && !rsc->mPaused; 496 rsc->timerSet(RS_TIMER_CLEAR_SWAP); 497 eglSwapBuffers(rsc->mEGL.mDisplay, rsc->mEGL.mSurface); 498 rsc->timerFrame(); 499 rsc->timerSet(RS_TIMER_INTERNAL); 500 rsc->timerPrint(); 501 rsc->timerReset(); 502 } 503 if (targetTime > 1) { 504 int32_t t = (targetTime - (int32_t)(rsc->mTimeMSLastScript + rsc->mTimeMSLastSwap)) * 1000; 505 if (t > 0) { 506 usleep(t); 507 } 508 } 509 } 510 511 LOGV("%p, RS Thread exiting", rsc); 512 513 if (rsc->mIsGraphicsContext) { 514 pthread_mutex_lock(&gInitMutex); 515 rsc->deinitEGL(); 516 pthread_mutex_unlock(&gInitMutex); 517 } 518 delete rsc->mTlsStruct; 519 520 LOGV("%p, RS Thread exited", rsc); 521 return NULL; 522} 523 524void Context::destroyWorkerThreadResources() { 525 LOGV("destroyWorkerThreadResources 1"); 526 if (mIsGraphicsContext) { 527 mRaster.clear(); 528 mFragment.clear(); 529 mVertex.clear(); 530 mFragmentStore.clear(); 531 mFont.clear(); 532 mRootScript.clear(); 533 mStateRaster.deinit(this); 534 mStateVertex.deinit(this); 535 mStateFragment.deinit(this); 536 mStateFragmentStore.deinit(this); 537 mStateFont.deinit(this); 538 mShaderCache.cleanupAll(); 539 } 540 ObjectBase::zeroAllUserRef(this); 541 LOGV("destroyWorkerThreadResources 2"); 542 mExit = true; 543} 544 545void * Context::helperThreadProc(void *vrsc) { 546 Context *rsc = static_cast<Context *>(vrsc); 547 uint32_t idx = (uint32_t)android_atomic_inc(&rsc->mWorkers.mLaunchCount); 548 549 LOGV("RS helperThread starting %p idx=%i", rsc, idx); 550 551 rsc->mWorkers.mLaunchSignals[idx].init(); 552 rsc->mWorkers.mNativeThreadId[idx] = gettid(); 553 554#if 0 555 typedef struct {uint64_t bits[1024 / 64]; } cpu_set_t; 556 cpu_set_t cpuset; 557 memset(&cpuset, 0, sizeof(cpuset)); 558 cpuset.bits[idx / 64] |= 1ULL << (idx % 64); 559 int ret = syscall(241, rsc->mWorkers.mNativeThreadId[idx], 560 sizeof(cpuset), &cpuset); 561 LOGE("SETAFFINITY ret = %i %s", ret, EGLUtils::strerror(ret)); 562#endif 563 564 setpriority(PRIO_PROCESS, rsc->mWorkers.mNativeThreadId[idx], rsc->mThreadPriority); 565 int status = pthread_setspecific(rsc->gThreadTLSKey, rsc->mTlsStruct); 566 if (status) { 567 LOGE("pthread_setspecific %i", status); 568 } 569 570 while (rsc->mRunning) { 571 rsc->mWorkers.mLaunchSignals[idx].wait(); 572 if (rsc->mWorkers.mLaunchCallback) { 573 rsc->mWorkers.mLaunchCallback(rsc->mWorkers.mLaunchData, idx); 574 } 575 android_atomic_dec(&rsc->mWorkers.mRunningCount); 576 rsc->mWorkers.mCompleteSignal.set(); 577 } 578 579 LOGV("RS helperThread exiting %p idx=%i", rsc, idx); 580 return NULL; 581} 582 583void Context::launchThreads(WorkerCallback_t cbk, void *data) { 584 mWorkers.mLaunchData = data; 585 mWorkers.mLaunchCallback = cbk; 586 mWorkers.mRunningCount = (int)mWorkers.mCount; 587 for (uint32_t ct = 0; ct < mWorkers.mCount; ct++) { 588 mWorkers.mLaunchSignals[ct].set(); 589 } 590 while (mWorkers.mRunningCount) { 591 mWorkers.mCompleteSignal.wait(); 592 } 593} 594 595void Context::setPriority(int32_t p) { 596 // Note: If we put this in the proper "background" policy 597 // the wallpapers can become completly unresponsive at times. 598 // This is probably not what we want for something the user is actively 599 // looking at. 600 mThreadPriority = p; 601#if 0 602 SchedPolicy pol = SP_FOREGROUND; 603 if (p > 0) { 604 pol = SP_BACKGROUND; 605 } 606 if (!set_sched_policy(mNativeThreadId, pol)) { 607 // success; reset the priority as well 608 } 609#else 610 setpriority(PRIO_PROCESS, mNativeThreadId, p); 611 for (uint32_t ct=0; ct < mWorkers.mCount; ct++) { 612 setpriority(PRIO_PROCESS, mWorkers.mNativeThreadId[ct], p); 613 } 614#endif 615} 616 617Context::Context() { 618 mDev = NULL; 619 mRunning = false; 620 mExit = false; 621 mPaused = false; 622 mObjHead = NULL; 623 mError = RS_ERROR_NONE; 624} 625 626Context * Context::createContext(Device *dev, const RsSurfaceConfig *sc) { 627 Context * rsc = new Context(); 628 if (!rsc->initContext(dev, sc)) { 629 delete rsc; 630 return NULL; 631 } 632 return rsc; 633} 634 635bool Context::initContext(Device *dev, const RsSurfaceConfig *sc) { 636 pthread_mutex_lock(&gInitMutex); 637 638 dev->addContext(this); 639 mDev = dev; 640 if (sc) { 641 mUserSurfaceConfig = *sc; 642 } else { 643 memset(&mUserSurfaceConfig, 0, sizeof(mUserSurfaceConfig)); 644 } 645 646 memset(&mEGL, 0, sizeof(mEGL)); 647 memset(&mGL, 0, sizeof(mGL)); 648 mIsGraphicsContext = sc != NULL; 649 650 int status; 651 pthread_attr_t threadAttr; 652 653 if (!gThreadTLSKeyCount) { 654 status = pthread_key_create(&gThreadTLSKey, NULL); 655 if (status) { 656 LOGE("Failed to init thread tls key."); 657 pthread_mutex_unlock(&gInitMutex); 658 return false; 659 } 660 } 661 gThreadTLSKeyCount++; 662 663 pthread_mutex_unlock(&gInitMutex); 664 665 // Global init done at this point. 666 667 status = pthread_attr_init(&threadAttr); 668 if (status) { 669 LOGE("Failed to init thread attribute."); 670 return false; 671 } 672 673 mWndSurface = NULL; 674 675 timerInit(); 676 timerSet(RS_TIMER_INTERNAL); 677 678 int cpu = sysconf(_SC_NPROCESSORS_ONLN); 679 LOGV("RS Launching thread(s), reported CPU count %i", cpu); 680 if (cpu < 2) cpu = 0; 681 682 mWorkers.mCount = (uint32_t)cpu; 683 mWorkers.mThreadId = (pthread_t *) calloc(mWorkers.mCount, sizeof(pthread_t)); 684 mWorkers.mNativeThreadId = (pid_t *) calloc(mWorkers.mCount, sizeof(pid_t)); 685 mWorkers.mLaunchSignals = new Signal[mWorkers.mCount]; 686 mWorkers.mLaunchCallback = NULL; 687 status = pthread_create(&mThreadId, &threadAttr, threadProc, this); 688 if (status) { 689 LOGE("Failed to start rs context thread."); 690 return false; 691 } 692 while (!mRunning && (mError == RS_ERROR_NONE)) { 693 usleep(100); 694 } 695 696 if (mError != RS_ERROR_NONE) { 697 return false; 698 } 699 700 mWorkers.mCompleteSignal.init(); 701 mWorkers.mRunningCount = 0; 702 mWorkers.mLaunchCount = 0; 703 for (uint32_t ct=0; ct < mWorkers.mCount; ct++) { 704 status = pthread_create(&mWorkers.mThreadId[ct], &threadAttr, helperThreadProc, this); 705 if (status) { 706 mWorkers.mCount = ct; 707 LOGE("Created fewer than expected number of RS threads."); 708 break; 709 } 710 } 711 pthread_attr_destroy(&threadAttr); 712 return true; 713} 714 715Context::~Context() { 716 LOGV("Context::~Context"); 717 718 mIO.mToCore.flush(); 719 rsAssert(mExit); 720 mExit = true; 721 mPaused = false; 722 void *res; 723 724 mIO.shutdown(); 725 int status = pthread_join(mThreadId, &res); 726 727 // Global structure cleanup. 728 pthread_mutex_lock(&gInitMutex); 729 if (mDev) { 730 mDev->removeContext(this); 731 --gThreadTLSKeyCount; 732 if (!gThreadTLSKeyCount) { 733 pthread_key_delete(gThreadTLSKey); 734 } 735 mDev = NULL; 736 } 737 pthread_mutex_unlock(&gInitMutex); 738 LOGV("Context::~Context done"); 739} 740 741void Context::setSurface(uint32_t w, uint32_t h, ANativeWindow *sur) { 742 rsAssert(mIsGraphicsContext); 743 744 EGLBoolean ret; 745 if (mEGL.mSurface != NULL) { 746 ret = eglMakeCurrent(mEGL.mDisplay, mEGL.mSurfaceDefault, mEGL.mSurfaceDefault, mEGL.mContext); 747 checkEglError("eglMakeCurrent", ret); 748 749 ret = eglDestroySurface(mEGL.mDisplay, mEGL.mSurface); 750 checkEglError("eglDestroySurface", ret); 751 752 mEGL.mSurface = NULL; 753 mWidth = 1; 754 mHeight = 1; 755 } 756 757 mWndSurface = sur; 758 if (mWndSurface != NULL) { 759 mWidth = w; 760 mHeight = h; 761 762 mEGL.mSurface = eglCreateWindowSurface(mEGL.mDisplay, mEGL.mConfig, mWndSurface, NULL); 763 checkEglError("eglCreateWindowSurface"); 764 if (mEGL.mSurface == EGL_NO_SURFACE) { 765 LOGE("eglCreateWindowSurface returned EGL_NO_SURFACE"); 766 } 767 768 ret = eglMakeCurrent(mEGL.mDisplay, mEGL.mSurface, mEGL.mSurface, mEGL.mContext); 769 checkEglError("eglMakeCurrent", ret); 770 771 mStateVertex.updateSize(this); 772 } 773} 774 775void Context::pause() { 776 rsAssert(mIsGraphicsContext); 777 mPaused = true; 778} 779 780void Context::resume() { 781 rsAssert(mIsGraphicsContext); 782 mPaused = false; 783} 784 785void Context::setRootScript(Script *s) { 786 rsAssert(mIsGraphicsContext); 787 mRootScript.set(s); 788} 789 790void Context::setProgramStore(ProgramStore *pfs) { 791 rsAssert(mIsGraphicsContext); 792 if (pfs == NULL) { 793 mFragmentStore.set(mStateFragmentStore.mDefault); 794 } else { 795 mFragmentStore.set(pfs); 796 } 797} 798 799void Context::setProgramFragment(ProgramFragment *pf) { 800 rsAssert(mIsGraphicsContext); 801 if (pf == NULL) { 802 mFragment.set(mStateFragment.mDefault); 803 } else { 804 mFragment.set(pf); 805 } 806} 807 808void Context::setProgramRaster(ProgramRaster *pr) { 809 rsAssert(mIsGraphicsContext); 810 if (pr == NULL) { 811 mRaster.set(mStateRaster.mDefault); 812 } else { 813 mRaster.set(pr); 814 } 815} 816 817void Context::setProgramVertex(ProgramVertex *pv) { 818 rsAssert(mIsGraphicsContext); 819 if (pv == NULL) { 820 mVertex.set(mStateVertex.mDefault); 821 } else { 822 mVertex.set(pv); 823 } 824} 825 826void Context::setFont(Font *f) { 827 rsAssert(mIsGraphicsContext); 828 if (f == NULL) { 829 mFont.set(mStateFont.mDefault); 830 } else { 831 mFont.set(f); 832 } 833} 834 835void Context::assignName(ObjectBase *obj, const char *name, uint32_t len) { 836 rsAssert(!obj->getName()); 837 obj->setName(name, len); 838 mNames.add(obj); 839} 840 841void Context::removeName(ObjectBase *obj) { 842 for (size_t ct=0; ct < mNames.size(); ct++) { 843 if (obj == mNames[ct]) { 844 mNames.removeAt(ct); 845 return; 846 } 847 } 848} 849 850RsMessageToClientType Context::peekMessageToClient(size_t *receiveLen, uint32_t *subID, bool wait) { 851 *receiveLen = 0; 852 if (!wait && mIO.mToClient.isEmpty()) { 853 return RS_MESSAGE_TO_CLIENT_NONE; 854 } 855 856 uint32_t bytesData = 0; 857 uint32_t commandID = 0; 858 const uint32_t *d = (const uint32_t *)mIO.mToClient.get(&commandID, &bytesData); 859 *receiveLen = bytesData - sizeof(uint32_t); 860 if (bytesData) { 861 *subID = d[0]; 862 } 863 return (RsMessageToClientType)commandID; 864} 865 866RsMessageToClientType Context::getMessageToClient(void *data, size_t *receiveLen, uint32_t *subID, size_t bufferLen, bool wait) { 867 //LOGE("getMessageToClient %i %i", bufferLen, wait); 868 *receiveLen = 0; 869 if (!wait && mIO.mToClient.isEmpty()) { 870 return RS_MESSAGE_TO_CLIENT_NONE; 871 } 872 873 //LOGE("getMessageToClient 2 con=%p", this); 874 uint32_t bytesData = 0; 875 uint32_t commandID = 0; 876 const uint32_t *d = (const uint32_t *)mIO.mToClient.get(&commandID, &bytesData); 877 //LOGE("getMessageToClient 3 %i %i", commandID, bytesData); 878 879 *receiveLen = bytesData - sizeof(uint32_t); 880 *subID = d[0]; 881 882 //LOGE("getMessageToClient %i %i", commandID, *subID); 883 if (bufferLen >= bytesData) { 884 memcpy(data, d+1, *receiveLen); 885 mIO.mToClient.next(); 886 return (RsMessageToClientType)commandID; 887 } 888 return RS_MESSAGE_TO_CLIENT_RESIZE; 889} 890 891bool Context::sendMessageToClient(const void *data, RsMessageToClientType cmdID, 892 uint32_t subID, size_t len, bool waitForSpace) const { 893 //LOGE("sendMessageToClient %i %i %i %i", cmdID, subID, len, waitForSpace); 894 if (cmdID == 0) { 895 LOGE("Attempting to send invalid command 0 to client."); 896 return false; 897 } 898 if (!waitForSpace) { 899 if (!mIO.mToClient.makeSpaceNonBlocking(len + 12)) { 900 // Not enough room, and not waiting. 901 return false; 902 } 903 } 904 //LOGE("sendMessageToClient 2"); 905 uint32_t *p = (uint32_t *)mIO.mToClient.reserve(len + sizeof(subID)); 906 p[0] = subID; 907 if (len > 0) { 908 memcpy(p+1, data, len); 909 } 910 mIO.mToClient.commit(cmdID, len + sizeof(subID)); 911 //LOGE("sendMessageToClient 3"); 912 return true; 913} 914 915void Context::initToClient() { 916 while (!mRunning) { 917 usleep(100); 918 } 919} 920 921void Context::deinitToClient() { 922 mIO.mToClient.shutdown(); 923} 924 925void Context::setError(RsError e, const char *msg) const { 926 mError = e; 927 sendMessageToClient(msg, RS_MESSAGE_TO_CLIENT_ERROR, e, strlen(msg) + 1, true); 928} 929 930 931void Context::dumpDebug() const { 932 LOGE("RS Context debug %p", this); 933 LOGE("RS Context debug"); 934 935 LOGE(" EGL ver %i %i", mEGL.mMajorVersion, mEGL.mMinorVersion); 936 LOGE(" EGL context %p surface %p, Display=%p", mEGL.mContext, mEGL.mSurface, mEGL.mDisplay); 937 LOGE(" GL vendor: %s", mGL.mVendor); 938 LOGE(" GL renderer: %s", mGL.mRenderer); 939 LOGE(" GL Version: %s", mGL.mVersion); 940 LOGE(" GL Extensions: %s", mGL.mExtensions); 941 LOGE(" GL int Versions %i %i", mGL.mMajorVersion, mGL.mMinorVersion); 942 LOGE(" RS width %i, height %i", mWidth, mHeight); 943 LOGE(" RS running %i, exit %i, paused %i", mRunning, mExit, mPaused); 944 LOGE(" RS pThreadID %li, nativeThreadID %i", mThreadId, mNativeThreadId); 945 946 LOGV("MAX Textures %i, %i %i", mGL.mMaxVertexTextureUnits, mGL.mMaxFragmentTextureImageUnits, mGL.mMaxTextureImageUnits); 947 LOGV("MAX Attribs %i", mGL.mMaxVertexAttribs); 948 LOGV("MAX Uniforms %i, %i", mGL.mMaxVertexUniformVectors, mGL.mMaxFragmentUniformVectors); 949 LOGV("MAX Varyings %i", mGL.mMaxVaryingVectors); 950} 951 952/////////////////////////////////////////////////////////////////////////////////////////// 953// 954 955namespace android { 956namespace renderscript { 957 958void rsi_ContextFinish(Context *rsc) { 959} 960 961void rsi_ContextBindRootScript(Context *rsc, RsScript vs) { 962 Script *s = static_cast<Script *>(vs); 963 rsc->setRootScript(s); 964} 965 966void rsi_ContextBindSampler(Context *rsc, uint32_t slot, RsSampler vs) { 967 Sampler *s = static_cast<Sampler *>(vs); 968 969 if (slot > RS_MAX_SAMPLER_SLOT) { 970 LOGE("Invalid sampler slot"); 971 return; 972 } 973 974 s->bindToContext(&rsc->mStateSampler, slot); 975} 976 977void rsi_ContextBindProgramStore(Context *rsc, RsProgramStore vpfs) { 978 ProgramStore *pfs = static_cast<ProgramStore *>(vpfs); 979 rsc->setProgramStore(pfs); 980} 981 982void rsi_ContextBindProgramFragment(Context *rsc, RsProgramFragment vpf) { 983 ProgramFragment *pf = static_cast<ProgramFragment *>(vpf); 984 rsc->setProgramFragment(pf); 985} 986 987void rsi_ContextBindProgramRaster(Context *rsc, RsProgramRaster vpr) { 988 ProgramRaster *pr = static_cast<ProgramRaster *>(vpr); 989 rsc->setProgramRaster(pr); 990} 991 992void rsi_ContextBindProgramVertex(Context *rsc, RsProgramVertex vpv) { 993 ProgramVertex *pv = static_cast<ProgramVertex *>(vpv); 994 rsc->setProgramVertex(pv); 995} 996 997void rsi_ContextBindFont(Context *rsc, RsFont vfont) { 998 Font *font = static_cast<Font *>(vfont); 999 rsc->setFont(font); 1000} 1001 1002void rsi_AssignName(Context *rsc, void * obj, const char *name, uint32_t len) { 1003 ObjectBase *ob = static_cast<ObjectBase *>(obj); 1004 rsc->assignName(ob, name, len); 1005} 1006 1007void rsi_ObjDestroy(Context *rsc, void *optr) { 1008 ObjectBase *ob = static_cast<ObjectBase *>(optr); 1009 rsc->removeName(ob); 1010 ob->decUserRef(); 1011} 1012 1013void rsi_ContextPause(Context *rsc) { 1014 rsc->pause(); 1015} 1016 1017void rsi_ContextResume(Context *rsc) { 1018 rsc->resume(); 1019} 1020 1021void rsi_ContextSetSurface(Context *rsc, uint32_t w, uint32_t h, ANativeWindow *sur) { 1022 rsc->setSurface(w, h, sur); 1023} 1024 1025void rsi_ContextSetPriority(Context *rsc, int32_t p) { 1026 rsc->setPriority(p); 1027} 1028 1029void rsi_ContextDump(Context *rsc, int32_t bits) { 1030 ObjectBase::dumpAll(rsc); 1031} 1032 1033void rsi_ContextDestroyWorker(Context *rsc) { 1034 LOGE("rsi_ContextDestroyWorker 1"); 1035 rsc->destroyWorkerThreadResources();; 1036 LOGE("rsi_ContextDestroyWorker 2"); 1037} 1038 1039} 1040} 1041 1042void rsContextDestroy(RsContext vcon) { 1043 LOGV("rsContextDestroy %p", vcon); 1044 Context *rsc = static_cast<Context *>(vcon); 1045 rsContextDestroyWorker(rsc); 1046 delete rsc; 1047 LOGV("rsContextDestroy 2 %p", vcon); 1048} 1049 1050RsContext rsContextCreate(RsDevice vdev, uint32_t version) { 1051 LOGV("rsContextCreate %p", vdev); 1052 Device * dev = static_cast<Device *>(vdev); 1053 Context *rsc = Context::createContext(dev, NULL); 1054 return rsc; 1055} 1056 1057RsContext rsContextCreateGL(RsDevice vdev, uint32_t version, RsSurfaceConfig sc) { 1058 LOGV("rsContextCreateGL %p", vdev); 1059 Device * dev = static_cast<Device *>(vdev); 1060 Context *rsc = Context::createContext(dev, &sc); 1061 LOGV("rsContextCreateGL ret %p ", rsc); 1062 return rsc; 1063} 1064 1065RsMessageToClientType rsContextPeekMessage(RsContext vrsc, size_t *receiveLen, uint32_t *subID, bool wait) { 1066 Context * rsc = static_cast<Context *>(vrsc); 1067 return rsc->peekMessageToClient(receiveLen, subID, wait); 1068} 1069 1070RsMessageToClientType rsContextGetMessage(RsContext vrsc, void *data, size_t *receiveLen, uint32_t *subID, size_t bufferLen, bool wait) { 1071 Context * rsc = static_cast<Context *>(vrsc); 1072 return rsc->getMessageToClient(data, receiveLen, subID, bufferLen, wait); 1073} 1074 1075void rsContextInitToClient(RsContext vrsc) { 1076 Context * rsc = static_cast<Context *>(vrsc); 1077 rsc->initToClient(); 1078} 1079 1080void rsContextDeinitToClient(RsContext vrsc) { 1081 Context * rsc = static_cast<Context *>(vrsc); 1082 rsc->deinitToClient(); 1083} 1084 1085// Only to be called at a3d load time, before object is visible to user 1086// not thread safe 1087void rsaGetName(RsContext con, void * obj, const char **name) { 1088 ObjectBase *ob = static_cast<ObjectBase *>(obj); 1089 (*name) = ob->getName(); 1090} 1091