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 #include "RenderThread.h" 18 19 #include "CanvasContext.h" 20 #include "DeviceInfo.h" 21 #include "EglManager.h" 22 #include "OpenGLReadback.h" 23 #include "RenderProxy.h" 24 #include "VulkanManager.h" 25 #include "hwui/Bitmap.h" 26 #include "pipeline/skia/SkiaOpenGLPipeline.h" 27 #include "pipeline/skia/SkiaOpenGLReadback.h" 28 #include "pipeline/skia/SkiaVulkanReadback.h" 29 #include "pipeline/skia/SkiaVulkanPipeline.h" 30 #include "renderstate/RenderState.h" 31 #include "renderthread/OpenGLPipeline.h" 32 #include "utils/FatVector.h" 33 #include "utils/TimeUtils.h" 34 35 #include <gui/DisplayEventReceiver.h> 36 #include <sys/resource.h> 37 #include <utils/Condition.h> 38 #include <utils/Log.h> 39 #include <utils/Mutex.h> 40 41 namespace android { 42 namespace uirenderer { 43 namespace renderthread { 44 45 // Number of events to read at a time from the DisplayEventReceiver pipe. 46 // The value should be large enough that we can quickly drain the pipe 47 // using just a few large reads. 48 static const size_t EVENT_BUFFER_SIZE = 100; 49 50 // Slight delay to give the UI time to push us a new frame before we replay 51 static const nsecs_t DISPATCH_FRAME_CALLBACKS_DELAY = milliseconds_to_nanoseconds(4); 52 53 static bool gHasRenderThreadInstance = false; 54 55 static void (*gOnStartHook)() = nullptr; 56 57 class DisplayEventReceiverWrapper : public VsyncSource { 58 public: 59 DisplayEventReceiverWrapper(std::unique_ptr<DisplayEventReceiver>&& receiver) 60 : mDisplayEventReceiver(std::move(receiver)) {} 61 62 virtual void requestNextVsync() override { 63 status_t status = mDisplayEventReceiver->requestNextVsync(); 64 LOG_ALWAYS_FATAL_IF(status != NO_ERROR, "requestNextVsync failed with status: %d", status); 65 } 66 67 virtual nsecs_t latestVsyncEvent() override { 68 DisplayEventReceiver::Event buf[EVENT_BUFFER_SIZE]; 69 nsecs_t latest = 0; 70 ssize_t n; 71 while ((n = mDisplayEventReceiver->getEvents(buf, EVENT_BUFFER_SIZE)) > 0) { 72 for (ssize_t i = 0; i < n; i++) { 73 const DisplayEventReceiver::Event& ev = buf[i]; 74 switch (ev.header.type) { 75 case DisplayEventReceiver::DISPLAY_EVENT_VSYNC: 76 latest = ev.header.timestamp; 77 break; 78 } 79 } 80 } 81 if (n < 0) { 82 ALOGW("Failed to get events from display event receiver, status=%d", status_t(n)); 83 } 84 return latest; 85 } 86 87 private: 88 std::unique_ptr<DisplayEventReceiver> mDisplayEventReceiver; 89 }; 90 91 class DummyVsyncSource : public VsyncSource { 92 public: 93 DummyVsyncSource(RenderThread* renderThread) : mRenderThread(renderThread) {} 94 95 virtual void requestNextVsync() override { 96 mRenderThread->queue().postDelayed(16_ms, [this]() { 97 mRenderThread->drainDisplayEventQueue(); 98 }); 99 } 100 101 virtual nsecs_t latestVsyncEvent() override { 102 return systemTime(CLOCK_MONOTONIC); 103 } 104 105 private: 106 RenderThread* mRenderThread; 107 }; 108 109 bool RenderThread::hasInstance() { 110 return gHasRenderThreadInstance; 111 } 112 113 void RenderThread::setOnStartHook(void (*onStartHook)()) { 114 LOG_ALWAYS_FATAL_IF(hasInstance(), "can't set an onStartHook after we've started..."); 115 gOnStartHook = onStartHook; 116 } 117 118 RenderThread& RenderThread::getInstance() { 119 // This is a pointer because otherwise __cxa_finalize 120 // will try to delete it like a Good Citizen but that causes us to crash 121 // because we don't want to delete the RenderThread normally. 122 static RenderThread* sInstance = new RenderThread(); 123 gHasRenderThreadInstance = true; 124 return *sInstance; 125 } 126 127 RenderThread::RenderThread() 128 : ThreadBase() 129 , mVsyncSource(nullptr) 130 , mVsyncRequested(false) 131 , mFrameCallbackTaskPending(false) 132 , mRenderState(nullptr) 133 , mEglManager(nullptr) 134 , mVkManager(nullptr) { 135 Properties::load(); 136 start("RenderThread"); 137 } 138 139 RenderThread::~RenderThread() { 140 LOG_ALWAYS_FATAL("Can't destroy the render thread"); 141 } 142 143 void RenderThread::initializeDisplayEventReceiver() { 144 LOG_ALWAYS_FATAL_IF(mVsyncSource, "Initializing a second DisplayEventReceiver?"); 145 146 if (!Properties::isolatedProcess) { 147 auto receiver = std::make_unique<DisplayEventReceiver>(); 148 status_t status = receiver->initCheck(); 149 LOG_ALWAYS_FATAL_IF(status != NO_ERROR, 150 "Initialization of DisplayEventReceiver " 151 "failed with status: %d", 152 status); 153 154 // Register the FD 155 mLooper->addFd(receiver->getFd(), 0, Looper::EVENT_INPUT, 156 RenderThread::displayEventReceiverCallback, this); 157 mVsyncSource = new DisplayEventReceiverWrapper(std::move(receiver)); 158 } else { 159 mVsyncSource = new DummyVsyncSource(this); 160 } 161 } 162 163 void RenderThread::initThreadLocals() { 164 mDisplayInfo = DeviceInfo::queryDisplayInfo(); 165 nsecs_t frameIntervalNanos = static_cast<nsecs_t>(1000000000 / mDisplayInfo.fps); 166 mTimeLord.setFrameInterval(frameIntervalNanos); 167 initializeDisplayEventReceiver(); 168 mEglManager = new EglManager(*this); 169 mRenderState = new RenderState(*this); 170 mVkManager = new VulkanManager(*this); 171 mCacheManager = new CacheManager(mDisplayInfo); 172 } 173 174 void RenderThread::dumpGraphicsMemory(int fd) { 175 globalProfileData()->dump(fd); 176 177 String8 cachesOutput; 178 String8 pipeline; 179 auto renderType = Properties::getRenderPipelineType(); 180 switch (renderType) { 181 case RenderPipelineType::OpenGL: { 182 if (Caches::hasInstance()) { 183 cachesOutput.appendFormat("Caches:\n"); 184 Caches::getInstance().dumpMemoryUsage(cachesOutput); 185 } else { 186 cachesOutput.appendFormat("No caches instance."); 187 } 188 pipeline.appendFormat("FrameBuilder"); 189 break; 190 } 191 case RenderPipelineType::SkiaGL: { 192 mCacheManager->dumpMemoryUsage(cachesOutput, mRenderState); 193 pipeline.appendFormat("Skia (OpenGL)"); 194 break; 195 } 196 case RenderPipelineType::SkiaVulkan: { 197 mCacheManager->dumpMemoryUsage(cachesOutput, mRenderState); 198 pipeline.appendFormat("Skia (Vulkan)"); 199 break; 200 } 201 default: 202 LOG_ALWAYS_FATAL("canvas context type %d not supported", (int32_t)renderType); 203 break; 204 } 205 206 dprintf(fd, "\n%s\n", cachesOutput.string()); 207 dprintf(fd, "\nPipeline=%s\n", pipeline.string()); 208 } 209 210 Readback& RenderThread::readback() { 211 if (!mReadback) { 212 auto renderType = Properties::getRenderPipelineType(); 213 switch (renderType) { 214 case RenderPipelineType::OpenGL: 215 mReadback = new OpenGLReadbackImpl(*this); 216 break; 217 case RenderPipelineType::SkiaGL: 218 mReadback = new skiapipeline::SkiaOpenGLReadback(*this); 219 break; 220 case RenderPipelineType::SkiaVulkan: 221 mReadback = new skiapipeline::SkiaVulkanReadback(*this); 222 break; 223 default: 224 LOG_ALWAYS_FATAL("canvas context type %d not supported", (int32_t)renderType); 225 break; 226 } 227 } 228 229 return *mReadback; 230 } 231 232 void RenderThread::setGrContext(sk_sp<GrContext> context) { 233 mCacheManager->reset(context); 234 if (mGrContext) { 235 mGrContext->releaseResourcesAndAbandonContext(); 236 } 237 mGrContext = std::move(context); 238 } 239 240 int RenderThread::displayEventReceiverCallback(int fd, int events, void* data) { 241 if (events & (Looper::EVENT_ERROR | Looper::EVENT_HANGUP)) { 242 ALOGE("Display event receiver pipe was closed or an error occurred. " 243 "events=0x%x", 244 events); 245 return 0; // remove the callback 246 } 247 248 if (!(events & Looper::EVENT_INPUT)) { 249 ALOGW("Received spurious callback for unhandled poll event. " 250 "events=0x%x", 251 events); 252 return 1; // keep the callback 253 } 254 255 reinterpret_cast<RenderThread*>(data)->drainDisplayEventQueue(); 256 257 return 1; // keep the callback 258 } 259 260 void RenderThread::drainDisplayEventQueue() { 261 ATRACE_CALL(); 262 nsecs_t vsyncEvent = mVsyncSource->latestVsyncEvent(); 263 if (vsyncEvent > 0) { 264 mVsyncRequested = false; 265 if (mTimeLord.vsyncReceived(vsyncEvent) && !mFrameCallbackTaskPending) { 266 ATRACE_NAME("queue mFrameCallbackTask"); 267 mFrameCallbackTaskPending = true; 268 nsecs_t runAt = (vsyncEvent + DISPATCH_FRAME_CALLBACKS_DELAY); 269 queue().postAt(runAt, [this]() { dispatchFrameCallbacks(); }); 270 } 271 } 272 } 273 274 void RenderThread::dispatchFrameCallbacks() { 275 ATRACE_CALL(); 276 mFrameCallbackTaskPending = false; 277 278 std::set<IFrameCallback*> callbacks; 279 mFrameCallbacks.swap(callbacks); 280 281 if (callbacks.size()) { 282 // Assume one of them will probably animate again so preemptively 283 // request the next vsync in case it occurs mid-frame 284 requestVsync(); 285 for (std::set<IFrameCallback*>::iterator it = callbacks.begin(); it != callbacks.end(); 286 it++) { 287 (*it)->doFrame(); 288 } 289 } 290 } 291 292 void RenderThread::requestVsync() { 293 if (!mVsyncRequested) { 294 mVsyncRequested = true; 295 mVsyncSource->requestNextVsync(); 296 } 297 } 298 299 bool RenderThread::threadLoop() { 300 setpriority(PRIO_PROCESS, 0, PRIORITY_DISPLAY); 301 if (gOnStartHook) { 302 gOnStartHook(); 303 } 304 initThreadLocals(); 305 306 while (true) { 307 waitForWork(); 308 processQueue(); 309 310 if (mPendingRegistrationFrameCallbacks.size() && !mFrameCallbackTaskPending) { 311 drainDisplayEventQueue(); 312 mFrameCallbacks.insert(mPendingRegistrationFrameCallbacks.begin(), 313 mPendingRegistrationFrameCallbacks.end()); 314 mPendingRegistrationFrameCallbacks.clear(); 315 requestVsync(); 316 } 317 318 if (!mFrameCallbackTaskPending && !mVsyncRequested && mFrameCallbacks.size()) { 319 // TODO: Clean this up. This is working around an issue where a combination 320 // of bad timing and slow drawing can result in dropping a stale vsync 321 // on the floor (correct!) but fails to schedule to listen for the 322 // next vsync (oops), so none of the callbacks are run. 323 requestVsync(); 324 } 325 } 326 327 return false; 328 } 329 330 void RenderThread::postFrameCallback(IFrameCallback* callback) { 331 mPendingRegistrationFrameCallbacks.insert(callback); 332 } 333 334 bool RenderThread::removeFrameCallback(IFrameCallback* callback) { 335 size_t erased; 336 erased = mFrameCallbacks.erase(callback); 337 erased |= mPendingRegistrationFrameCallbacks.erase(callback); 338 return erased; 339 } 340 341 void RenderThread::pushBackFrameCallback(IFrameCallback* callback) { 342 if (mFrameCallbacks.erase(callback)) { 343 mPendingRegistrationFrameCallbacks.insert(callback); 344 } 345 } 346 347 sk_sp<Bitmap> RenderThread::allocateHardwareBitmap(SkBitmap& skBitmap) { 348 auto renderType = Properties::getRenderPipelineType(); 349 switch (renderType) { 350 case RenderPipelineType::OpenGL: 351 return OpenGLPipeline::allocateHardwareBitmap(*this, skBitmap); 352 case RenderPipelineType::SkiaGL: 353 return skiapipeline::SkiaOpenGLPipeline::allocateHardwareBitmap(*this, skBitmap); 354 case RenderPipelineType::SkiaVulkan: 355 return skiapipeline::SkiaVulkanPipeline::allocateHardwareBitmap(*this, skBitmap); 356 default: 357 LOG_ALWAYS_FATAL("canvas context type %d not supported", (int32_t)renderType); 358 break; 359 } 360 return nullptr; 361 } 362 363 bool RenderThread::isCurrent() { 364 return gettid() == getInstance().getTid(); 365 } 366 367 } /* namespace renderthread */ 368 } /* namespace uirenderer */ 369 } /* namespace android */ 370