summaryrefslogtreecommitdiff
path: root/libs
diff options
context:
space:
mode:
authorJohn Reck <jreck@google.com>2016-08-01 14:39:24 -0700
committerJohn Reck <jreck@google.com>2016-08-01 16:36:14 -0700
commit4387190d8ec9fe4e953fcfeb093a644b82cf85ed (patch)
treec717cbed2691386f68b6c97ba09d64ac85137871 /libs
parentfbd93027e4f8024642271652e490653a4d0c2b55 (diff)
downloadandroid-frameworks-base-4387190d8ec9fe4e953fcfeb093a644b82cf85ed.tar.gz
android-frameworks-base-4387190d8ec9fe4e953fcfeb093a644b82cf85ed.tar.xz
Eliminate recents upload jank
Bug: 30342017 Upload recents thumbnails in the dead gaps between frames instead of at the start of a frame. This eliminates jank caused by the large texture upload. Change-Id: I507cd286d199109c7a9a1511d68ba5ab5d28069f
Diffstat (limited to 'libs')
-rw-r--r--libs/hwui/TextureCache.cpp4
-rw-r--r--libs/hwui/TextureCache.h7
-rw-r--r--libs/hwui/renderthread/RenderProxy.cpp39
-rw-r--r--libs/hwui/renderthread/RenderProxy.h1
4 files changed, 51 insertions, 0 deletions
diff --git a/libs/hwui/TextureCache.cpp b/libs/hwui/TextureCache.cpp
index ade8600..523924a 100644
--- a/libs/hwui/TextureCache.cpp
+++ b/libs/hwui/TextureCache.cpp
@@ -167,6 +167,10 @@ bool TextureCache::prefetchAndMarkInUse(void* ownerToken, const SkBitmap* bitmap
return texture;
}
+bool TextureCache::prefetch(const SkBitmap* bitmap) {
+ return getCachedTexture(bitmap, AtlasUsageType::Use);
+}
+
Texture* TextureCache::get(const SkBitmap* bitmap, AtlasUsageType atlasUsageType) {
Texture* texture = getCachedTexture(bitmap, atlasUsageType);
diff --git a/libs/hwui/TextureCache.h b/libs/hwui/TextureCache.h
index a4317ce..0a61b6b 100644
--- a/libs/hwui/TextureCache.h
+++ b/libs/hwui/TextureCache.h
@@ -78,6 +78,13 @@ public:
bool prefetchAndMarkInUse(void* ownerToken, const SkBitmap* bitmap);
/**
+ * Attempts to precache the SkBitmap. Returns true if a Texture was successfully
+ * acquired for the bitmap, false otherwise. Does not mark the Texture
+ * as in use and won't update currently in-use Textures.
+ */
+ bool prefetch(const SkBitmap* bitmap);
+
+ /**
* Returns the texture associated with the specified bitmap from either within the cache, or
* the AssetAtlas. If the texture cannot be found in the cache, a new texture is generated.
*/
diff --git a/libs/hwui/renderthread/RenderProxy.cpp b/libs/hwui/renderthread/RenderProxy.cpp
index 06a24b2..fb1c896 100644
--- a/libs/hwui/renderthread/RenderProxy.cpp
+++ b/libs/hwui/renderthread/RenderProxy.cpp
@@ -22,9 +22,11 @@
#include "Readback.h"
#include "Rect.h"
#include "renderthread/CanvasContext.h"
+#include "renderthread/EglManager.h"
#include "renderthread/RenderTask.h"
#include "renderthread/RenderThread.h"
#include "utils/Macros.h"
+#include "utils/TimeUtils.h"
namespace android {
namespace uirenderer {
@@ -44,6 +46,8 @@ namespace renderthread {
typedef struct { \
a1; a2; a3; a4; a5; a6; a7; a8; \
} ARGS(name); \
+ static_assert(std::is_trivially_destructible<ARGS(name)>::value, \
+ "Error, ARGS must be trivially destructible!"); \
static void* Bridge_ ## name(ARGS(name)* args)
#define SETUP_TASK(method) \
@@ -636,6 +640,41 @@ int RenderProxy::copySurfaceInto(sp<Surface>& surface, SkBitmap* bitmap) {
reinterpret_cast<intptr_t>( staticPostAndWait(task) ));
}
+CREATE_BRIDGE2(prepareToDraw, RenderThread* thread, SkBitmap* bitmap) {
+ if (Caches::hasInstance() && args->thread->eglManager().hasEglContext()) {
+ ATRACE_NAME("Bitmap#prepareToDraw task");
+ Caches::getInstance().textureCache.prefetch(args->bitmap);
+ }
+ delete args->bitmap;
+ args->bitmap = nullptr;
+ return nullptr;
+}
+
+void RenderProxy::prepareToDraw(const SkBitmap& bitmap) {
+ // If we haven't spun up a hardware accelerated window yet, there's no
+ // point in precaching these bitmaps as it can't impact jank.
+ // We also don't know if we even will spin up a hardware-accelerated
+ // window or not.
+ if (!RenderThread::hasInstance()) return;
+ RenderThread* renderThread = &RenderThread::getInstance();
+ SETUP_TASK(prepareToDraw);
+ args->thread = renderThread;
+ args->bitmap = new SkBitmap(bitmap);
+ nsecs_t lastVsync = renderThread->timeLord().latestVsync();
+ nsecs_t estimatedNextVsync = lastVsync + renderThread->timeLord().frameIntervalNanos();
+ nsecs_t timeToNextVsync = estimatedNextVsync - systemTime(CLOCK_MONOTONIC);
+ // We expect the UI thread to take 4ms and for RT to be active from VSYNC+4ms to
+ // VSYNC+12ms or so, so aim for the gap during which RT is expected to
+ // be idle
+ // TODO: Make this concept a first-class supported thing? RT could use
+ // knowledge of pending draws to better schedule this task
+ if (timeToNextVsync > -6_ms && timeToNextVsync < 1_ms) {
+ renderThread->queueAt(task, estimatedNextVsync + 8_ms);
+ } else {
+ renderThread->queue(task);
+ }
+}
+
void RenderProxy::post(RenderTask* task) {
mRenderThread.queue(task);
}
diff --git a/libs/hwui/renderthread/RenderProxy.h b/libs/hwui/renderthread/RenderProxy.h
index e31062c..bb111bd 100644
--- a/libs/hwui/renderthread/RenderProxy.h
+++ b/libs/hwui/renderthread/RenderProxy.h
@@ -129,6 +129,7 @@ public:
ANDROID_API long getDroppedFrameReportCount();
ANDROID_API static int copySurfaceInto(sp<Surface>& surface, SkBitmap* bitmap);
+ ANDROID_API static void prepareToDraw(const SkBitmap& bitmap);
private:
RenderThread& mRenderThread;