T-527 (R8) / T-511 DONE: the WebGL cube at 25-28 fps on the card — the card redraws only what changed, a tall band surface (engine 0063); the PDK adapter builds again

The 480 px spinning cube, the sensors running: 25.3-28.0 fps on the card (was 16.6-22.0), 360 px 28.9-29.9, 240 px 29.4-30.0 (the page's own ~30); verify with a ticker beside the canvas and the cube stopped 0 rows wrong. - The frame trailer's dirty words (render/browserserver/Src/JihadFrameWindow.h): before each msgPainted the daemon writes the rect that differs from the frame published before it and both frames' numbers — the union of every composite's change since, at that frame's geometry; a forgotten job, popups, a software frame or an earlier-posted job not yet polled make it whole (BrowserPageGoanna pubDirtyAdd/pubDirtyTake, publishWindow; JIHAD_GPU_NO_DIRTY=1 off). The adapter, showing that base frame at the same geometry, zoom and scroll, invalidates only the rect (BrowserAdapter::msgPainted, BrowserOffscreen::dirtyRect). The YAP messages and the header are unchanged; docs/IPC-CONTRACT.md now describes the trailer. - Engine patch 0063 (bda31412): a change too tall for the 256-row band surface takes a 512-row band surface (JIHAD_GPU_BAND_TALL) instead of the frame-sized target; frames are packed for the band surface first, so desktop Wikipedia's pan frames stay where they were (its pan unchanged). Pins moved; 63 patches reproduce. - The PDK adapter had not built since T-540: YapProxy.h's member initializer (m_sendFailed) is C++11 and the PDK's gcc 4.3.3 refuses it; initialized in the constructor. The YAP contract check passes. - The pan's 56 ms+ gaps traced: tools/host/gap-trace.py, and with JIHAD_GPU_TIMELINE=1 the express lane notes why it made no frame and every trailer is logged. Desktop Wikipedia's 10 s pan: 24 gaps, all the compositor job's (a whole read after a tree change, the copy from the base, a job behind the page's tile uploads). - default-check.sh reads across the daemon log's 2 MB rotation; gpu-spike-collect.sh removes the frame dumps. - Kit R8's 24 fps criterion ticked, R3's gap criterion annotated; T-511 DONE; notes, README knobs, ENGINE-SOURCE 0063, PICKUP. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-25 22:04:28 -04:00
1 parent 911034810b
commit d5f50632e3
@@ -0,0 +1,276 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: NotAlexNoyle <alexnoyle@icloud.com>
+Date: Sun, 25 Oct 2026 22:02:16 -0400
+Subject: [PATCH] gpu-compositor: a tall band surface for a change that does
+ not fit the band surface
+
+cavekit-gpu-rendering.md R8 / T-527. A frame whose change does not fit the 256-row band surface took the
+whole path: the frame-sized target (768x1224) cleared, drawn and resolved on the Adreno 220 every frame, and
+the read waited for all of it. A 480 px WebGL canvas changes 354-482 rows a frame, so every frame of the
+spinning cube went that way (the job ~45 ms, the card 16.6-22.0 fps while the page drew 22-24). A second,
+taller band surface (JIHAD_GPU_BAND_TALL rows, default 512, 0 off; its own pbuffer and target, freed with
+the context like the band surface's) takes such a frame; frames are packed for the band surface first, so
+one that fits it never pays the tall one (desktop Wikipedia's chunked pan frames stay where they were). The
+cube's job 15-30 ms; with the daemon's partial invalidation the card shows 25.3-28.0 fps at 480 px.
+
+Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
+---
+ gfx/gl/GLContextEGL.h                     |  6 +++-
+ gfx/gl/GLContextProviderEGL.cpp           | 33 +++++++++++--------
+ gfx/layers/ipc/CompositorBridgeParent.cpp | 28 ++++++++++++++--
+ gfx/layers/opengl/CompositorOGL.cpp       | 40 +++++++++++++++--------
+ gfx/layers/opengl/CompositorOGL.h         | 19 +++++++++--
+ 5 files changed, 92 insertions(+), 34 deletions(-)
+
+diff --git a/gfx/gl/GLContextEGL.h b/gfx/gl/GLContextEGL.h
+index 13459d1f5b..7d1268821e 100644
+--- a/gfx/gl/GLContextEGL.h
+++ b/gfx/gl/GLContextEGL.h
+@@ -96,10 +96,14 @@ public:
+     EGLSurface mJihadPbOverride = nullptr;
+     // Round 106: a band-sized pbuffer made current for the band composites of a scroll-only
+     // frame, then the frame's pbuffer again. false when the band pbuffer cannot be made.
+-    bool JihadUseBandPBuffer(int aWidth, int aHeight);
+    // T-527: aTall picks a second pbuffer of its own (the tall band surface), so a frame that needs
+    // the tall one and the next that needs the short one do not remake either
+    bool JihadUseBandPBuffer(int aWidth, int aHeight, bool aTall = false);
+     void JihadUseFramePBuffer();
+     EGLSurface mJihadBandPb = nullptr;
+     int mJihadBandPbW = 0, mJihadBandPbH = 0;
+    EGLSurface mJihadBandPbTall = nullptr;
+    int mJihadBandPbTallW = 0, mJihadBandPbTallH = 0;
+ 
+     virtual bool MakeCurrentImpl(bool aForce) override;
+ 
+diff --git a/gfx/gl/GLContextProviderEGL.cpp b/gfx/gl/GLContextProviderEGL.cpp
+index eb00bc01f0..58329c0236 100644
+--- a/gfx/gl/GLContextProviderEGL.cpp
+++ b/gfx/gl/GLContextProviderEGL.cpp
+@@ -261,8 +261,10 @@ GLContextEGL::~GLContextEGL()
+ 
+     // Jihad (T-513 review): the frame-sized and the band pbuffers made for this context
+     if (mJihadBandPb && mJihadBandPb != mSurface) DestroySurface(mJihadBandPb);
+-    if (mJihadPbOverride && mJihadPbOverride != mSurface && mJihadPbOverride != mJihadBandPb) DestroySurface(mJihadPbOverride);
+-    mJihadBandPb = mJihadPbOverride = nullptr;
+    if (mJihadBandPbTall && mJihadBandPbTall != mSurface) DestroySurface(mJihadBandPbTall);   // T-527
+    if (mJihadPbOverride && mJihadPbOverride != mSurface && mJihadPbOverride != mJihadBandPb &&
+        mJihadPbOverride != mJihadBandPbTall) DestroySurface(mJihadPbOverride);
+    mJihadBandPb = mJihadBandPbTall = mJihadPbOverride = nullptr;
+     DestroySurface(mSurface);
+ }
+ 
+@@ -373,25 +375,28 @@ GLContextEGL::JihadUsePBufferOfSize(int aWidth, int aHeight)
+ }
+ 
+ bool
+-GLContextEGL::JihadUseBandPBuffer(int aWidth, int aHeight)
+GLContextEGL::JihadUseBandPBuffer(int aWidth, int aHeight, bool aTall)
+ {
+-    if (!mJihadBandPb || mJihadBandPbW != aWidth || mJihadBandPbH != aHeight) {
+-        if (mJihadBandPb) {
+-            if (mSurfaceOverride == mJihadBandPb) JihadUseFramePBuffer();
+-            sEGLLibrary.fDestroySurface(EGL_DISPLAY(), mJihadBandPb);
+-            mJihadBandPb = nullptr;
+    EGLSurface& pb = aTall ? mJihadBandPbTall : mJihadBandPb;
+    int& pbW = aTall ? mJihadBandPbTallW : mJihadBandPbW;
+    int& pbH = aTall ? mJihadBandPbTallH : mJihadBandPbH;
+    if (!pb || pbW != aWidth || pbH != aHeight) {
+        if (pb) {
+            if (mSurfaceOverride == pb) JihadUseFramePBuffer();
+            sEGLLibrary.fDestroySurface(EGL_DISPLAY(), pb);
+            pb = nullptr;
+         }
+         const EGLint attrs[] = { LOCAL_EGL_WIDTH, aWidth, LOCAL_EGL_HEIGHT, aHeight, LOCAL_EGL_NONE };
+-        mJihadBandPb = sEGLLibrary.fCreatePbufferSurface(EGL_DISPLAY(), mConfig, attrs);
+-        if (!mJihadBandPb) {
+        pb = sEGLLibrary.fCreatePbufferSurface(EGL_DISPLAY(), mConfig, attrs);
+        if (!pb) {
+             fprintf(stderr, "[jihad-gpu] a %dx%d band pbuffer could not be made (0x%x)\n", aWidth, aHeight, sEGLLibrary.fGetError());
+             return false;
+         }
+-        mJihadBandPbW = aWidth; mJihadBandPbH = aHeight;
+-        JIHAD_GPU_LOG("[jihad-gpu] band pbuffer %dx%d made\n", aWidth, aHeight);
+        pbW = aWidth; pbH = aHeight;
+        JIHAD_GPU_LOG("[jihad-gpu] band pbuffer %dx%d made%s\n", aWidth, aHeight, aTall ? " (the tall one)" : "");
+     }
+-    if (mSurfaceOverride != mJihadBandPb) {
+-        mSurfaceOverride = mJihadBandPb;
+    if (mSurfaceOverride != pb) {
+        mSurfaceOverride = pb;
+         MakeCurrent(true);
+     }
+     return true;
+diff --git a/gfx/layers/ipc/CompositorBridgeParent.cpp b/gfx/layers/ipc/CompositorBridgeParent.cpp
+index 4650113654..7478575b87 100644
+--- a/gfx/layers/ipc/CompositorBridgeParent.cpp
+++ b/gfx/layers/ipc/CompositorBridgeParent.cpp
+@@ -1921,7 +1921,19 @@ CompositorBridgeParent::JihadComposeAndRead(JihadFrameRequest* aReq, float aScal
+         int dfNChunks = 0;
+         dfSpan = JihadPackColumns(dfCols, dfNCols, total, ogl->JihadBandRows(), aWidth, dfChunks, &dfNChunks);   // round 142
+       }
+-      if (total > 0 && dfSpan >= 0 && total + dfSpan <= ogl->JihadBandRows()) {
+      // T-527: packed for the band surface first; a frame that does not fit it takes the tall one
+      bool dfFits = total > 0 && dfSpan >= 0 && total + dfSpan <= ogl->JihadBandRows();
+      const int dfTall = ogl->JihadBandTallRows();
+      if (!dfFits && dfTall > 0 && total > 0) {
+        int span2 = 0;
+        if (JihadFixedCols()) {
+          JihadChunk dfChunks2[12];
+          int dfNChunks2 = 0;
+          span2 = JihadPackColumns(dfCols, dfNCols, total, dfTall, aWidth, dfChunks2, &dfNChunks2);
+        }
+        if (span2 >= 0 && total + span2 <= dfTall) { dfSpan = span2; dfFits = true; }
+      }
+      if (dfFits) {
+         aReq->lo = iv[0][0]; aReq->hi = iv[0][1];
+         aReq->lo2 = n > 1 ? iv[1][0] : 0; aReq->hi2 = n > 1 ? iv[1][1] : 0;
+         aReq->nCols = dfNCols;
+@@ -1968,7 +1980,17 @@ CompositorBridgeParent::JihadComposeAndRead(JihadFrameRequest* aReq, float aScal
+     const int fullAsked = (b1 ? std::min(aHeight, aReq->hi) - std::max(0, aReq->lo) : 0) + (b2 ? std::min(aHeight, aReq->hi2) - std::max(0, aReq->lo2) : 0);
+     JihadChunk chunks[12];
+     int nChunks = 0;
+-    const int chunkRows = JihadPackColumns(aReq->cols, aReq->nCols, fullAsked, ogl->JihadBandRows(), aWidth, chunks, &nChunks);
+    int chunkRows = JihadPackColumns(aReq->cols, aReq->nCols, fullAsked, ogl->JihadBandRows(), aWidth, chunks, &nChunks);
+    // T-527: packed for the band surface first; the tall one's rows only when that does not fit
+    if (!(chunkRows >= 0 && fullAsked + chunkRows <= ogl->JihadBandRows()) && ogl->JihadBandTallRows() > 0) {
+      JihadChunk chunks2[12];
+      int nChunks2 = 0;
+      const int cr2 = JihadPackColumns(aReq->cols, aReq->nCols, fullAsked, ogl->JihadBandTallRows(), aWidth, chunks2, &nChunks2);
+      if (cr2 >= 0 && fullAsked + cr2 <= ogl->JihadBandTallRows()) {
+        chunkRows = cr2; nChunks = nChunks2;
+        for (int c = 0; c < nChunks2; c++) chunks[c] = chunks2[c];
+      }
+    }
+     // T-513 (review): the regions of one composite are at most 12, bands included: chunks past that
+     // would be read without being composed, so such a frame does not fit
+     const bool fits = chunkRows >= 0 && fullAsked + chunkRows <= bandMax && nChunks + (b1 ? 1 : 0) + (b2 ? 1 : 0) <= 12;
+@@ -1985,7 +2007,7 @@ CompositorBridgeParent::JihadComposeAndRead(JihadFrameRequest* aReq, float aScal
+       // the band pass: its own small surface and target when available (round 106), else the
+       // stack at the top of the frame-sized target (round 105)
+       const TimeStamp tp0 = TimeStamp::Now();
+-      const int passRows = (top > 0 && top <= ogl->JihadBandRows()) ? ogl->JihadBeginBandPass(aWidth) : 0;
+      const int passRows = top > 0 ? ogl->JihadBeginBandPass(aWidth, top) : 0;   // T-527: the band surface or the tall one
+       if (!passRows) {
+         // T-513 (review): stacked at the top of the frame-sized target, so the frame's own surface
+         // current (a band frame before this one left the band pbuffer current, and on the Adreno 220
+diff --git a/gfx/layers/opengl/CompositorOGL.cpp b/gfx/layers/opengl/CompositorOGL.cpp
+index 21dd27b6fe..ed16534208 100644
+--- a/gfx/layers/opengl/CompositorOGL.cpp
+++ b/gfx/layers/opengl/CompositorOGL.cpp
+@@ -261,6 +261,9 @@ CompositorOGL::CleanupResources()
+   if (mJihadBandFBO) mGLContext->fDeleteFramebuffers(1, &mJihadBandFBO);
+   if (mJihadBandRB) mGLContext->fDeleteRenderbuffers(1, &mJihadBandRB);
+   mJihadBandFBO = mJihadBandRB = 0;
+  if (mJihadBandTallFBO) mGLContext->fDeleteFramebuffers(1, &mJihadBandTallFBO);   // T-527
+  if (mJihadBandTallRB) mGLContext->fDeleteRenderbuffers(1, &mJihadBandTallRB);
+  mJihadBandTallFBO = mJihadBandTallRB = 0;
+   if (mJihadReadFBO) mGLContext->fDeleteFramebuffers(1, &mJihadReadFBO);
+   if (mJihadReadRB) mGLContext->fDeleteRenderbuffers(1, &mJihadReadRB);
+   mJihadReadFBO = mJihadReadRB = 0;
+@@ -2329,35 +2332,44 @@ CompositorOGL::JihadEnsureTargetSize(int aWidth, int aHeight)
+ }
+ 
+ int
+-CompositorOGL::JihadBeginBandPass(int aWidth)
+CompositorOGL::JihadBeginBandPass(int aWidth, int aRows)
+ {
+   static const bool sOff = getenv("JIHAD_GPU_BAND_SURFACE") && !strcmp(getenv("JIHAD_GPU_BAND_SURFACE"), "0");
+   if (sOff || aWidth <= 0 || mGLContext->GetContextType() != GLContextType::EGL) {
+     return 0;
+   }
+  // T-527: the band surface, or the tall one when the pass needs more rows than the band surface has
+  const bool tall = aRows > JihadBandRows();
+  const int rows = tall ? JihadBandTallRows() : JihadBandRows();
+  if (rows <= 0 || aRows > rows) {
+    return 0;
+  }
+  GLuint& rb = tall ? mJihadBandTallRB : mJihadBandRB;
+  GLuint& fbo = tall ? mJihadBandTallFBO : mJihadBandFBO;
+  int& w = tall ? mJihadBandTallW : mJihadBandW;
+   GLContextEGL* egl = static_cast<GLContextEGL*>(mGLContext.get());
+-  if (!egl->JihadUseBandPBuffer(aWidth, JihadBandRows())) {
+  if (!egl->JihadUseBandPBuffer(aWidth, rows, tall)) {
+     return 0;
+   }
+-  if (!mJihadBandFBO || mJihadBandW != aWidth) {
+-    if (!mJihadBandRB) mGLContext->fGenRenderbuffers(1, &mJihadBandRB);
+-    mGLContext->fBindRenderbuffer(LOCAL_GL_RENDERBUFFER, mJihadBandRB);
+-    mGLContext->fRenderbufferStorage(LOCAL_GL_RENDERBUFFER, 0x8058 /* GL_RGBA8_OES */, aWidth, JihadBandRows());
+  if (!fbo || w != aWidth) {
+    if (!rb) mGLContext->fGenRenderbuffers(1, &rb);
+    mGLContext->fBindRenderbuffer(LOCAL_GL_RENDERBUFFER, rb);
+    mGLContext->fRenderbufferStorage(LOCAL_GL_RENDERBUFFER, 0x8058 /* GL_RGBA8_OES */, aWidth, rows);
+     mGLContext->fBindRenderbuffer(LOCAL_GL_RENDERBUFFER, 0);
+-    if (!mJihadBandFBO) mGLContext->fGenFramebuffers(1, &mJihadBandFBO);
+-    mGLContext->fBindFramebuffer(LOCAL_GL_FRAMEBUFFER, mJihadBandFBO);
+-    mGLContext->fFramebufferRenderbuffer(LOCAL_GL_FRAMEBUFFER, LOCAL_GL_COLOR_ATTACHMENT0, LOCAL_GL_RENDERBUFFER, mJihadBandRB);
+    if (!fbo) mGLContext->fGenFramebuffers(1, &fbo);
+    mGLContext->fBindFramebuffer(LOCAL_GL_FRAMEBUFFER, fbo);
+    mGLContext->fFramebufferRenderbuffer(LOCAL_GL_FRAMEBUFFER, LOCAL_GL_COLOR_ATTACHMENT0, LOCAL_GL_RENDERBUFFER, rb);
+     const GLenum st = mGLContext->fCheckFramebufferStatus(LOCAL_GL_FRAMEBUFFER);
+     if (st != LOCAL_GL_FRAMEBUFFER_COMPLETE) {
+-      fprintf(stderr, "[jihad-gpu] band target %dx%d incomplete (0x%x)\n", aWidth, JihadBandRows(), st);
+      fprintf(stderr, "[jihad-gpu] band target %dx%d incomplete (0x%x)\n", aWidth, rows, st);
+       egl->JihadUseFramePBuffer();
+       return 0;
+     }
+-    mJihadBandW = aWidth;
+-    JIHAD_GPU_LOG("[jihad-gpu] band target %dx%d: FBO %u on its own pbuffer\n", aWidth, JihadBandRows(), mJihadBandFBO);
+    w = aWidth;
+    JIHAD_GPU_LOG("[jihad-gpu] band target %dx%d: FBO %u on its own pbuffer%s\n", aWidth, rows, fbo, tall ? " (the tall one)" : "");
+   }
+-  mJihadWindowFBO = mJihadBandFBO;
+-  return JihadBandRows();
+  mJihadWindowFBO = fbo;
+  return rows;
+ }
+ 
+ void
+diff --git a/gfx/layers/opengl/CompositorOGL.h b/gfx/layers/opengl/CompositorOGL.h
+index a4c738dc47..0c27bb890a 100644
+--- a/gfx/layers/opengl/CompositorOGL.h
+++ b/gfx/layers/opengl/CompositorOGL.h
+@@ -242,12 +242,13 @@ public:
+   // A separate band-sized FBO broke on the Adreno 220: the driver bins an FBO render by the EGL
+   // surface's size, so any target or viewport smaller than the surface lost rows (round 104).
+   // 0 rows when off (JIHAD_GPU_NO_BAND_TARGET=1).
+-  int JihadBandMaxRows() const { static const bool sOff = getenv("JIHAD_GPU_NO_BAND_TARGET") != nullptr; return sOff ? 0 : (JihadBandRows() > 320 ? JihadBandRows() : 320); }
+  int JihadBandMaxRows() const { static const bool sOff = getenv("JIHAD_GPU_NO_BAND_TARGET") != nullptr; const int m = JihadBandRows() > JihadBandTallRows() ? JihadBandRows() : JihadBandTallRows(); return sOff ? 0 : (m > 320 ? m : 320); }
+   // Round 106: the band pass on its own surface (JIHAD_GPU_BAND_SURFACE=0 keeps the stack in the
+   // frame-sized target): a 256-row pbuffer and an FBO of the same size are made current, so the
+   // composite costs the band, not the frame; JihadEndBandPass puts the frame's surface and
+   // target back. Returns the band target's rows, 0 when the band pass is not available.
+-  int JihadBeginBandPass(int aWidth);
+  // T-527: aRows the pass needs: the band surface when they fit it, else the tall one when they fit that
+  int JihadBeginBandPass(int aWidth, int aRows);
+   void JihadEndBandPass();
+   void JihadUseFrameSurface();   // the frame's pbuffer current again (before a whole composite)
+   // T-513 (review): the reads that follow belong to a request the daemon may give up while the GPU
+@@ -255,6 +256,8 @@ public:
+   void JihadSetCancel(const mozilla::Atomic<bool>* aCancel) { mJihadCancel = aCancel; }
+   GLuint mJihadBandRB = 0, mJihadBandFBO = 0;
+   int mJihadBandW = 0;
+  GLuint mJihadBandTallRB = 0, mJihadBandTallFBO = 0;   // T-527: the tall band surface's target
+  int mJihadBandTallW = 0;
+   // the band surface's rows: JIHAD_GPU_BAND_ROWS (64..942, default 256; round 137)
+   static int JihadBandRows() {
+     static const int sRows = [] {
+@@ -264,6 +267,18 @@ public:
+     }();
+     return sRows;
+   }
+  // T-527: a second, taller band surface for a frame whose change does not fit the band surface (a
+  // 480 px WebGL canvas changes 354-482 rows a frame and took the whole frame-sized target, 768x1224
+  // cleared, drawn and resolved every frame): JIHAD_GPU_BAND_TALL (default 512, 0 off). Frames are
+  // packed for the band surface first, so a frame that fits it never pays the tall one.
+  static int JihadBandTallRows() {
+    static const int sRows = [] {
+      const char* e = getenv("JIHAD_GPU_BAND_TALL");
+      const int r = e ? atoi(e) : 512;
+      return r <= JihadBandRows() ? 0 : (r > 942 ? 942 : r);
+    }();
+    return sRows;
+  }
+   void JihadShiftRowsNow(JihadFrameRequest* aReq);
+   uint8_t* JihadBandScratch(size_t aBytes);   // the stacked bands' read, at least aBytes
+   bool JihadReadAsync(JihadFrameRequest* aReq);
@@ -9,7 +9,7 @@ UXP_BASE=5f290d1097a8350b56ce2092aa9d5fc9147c6661
 # The tip of our engine branch (NotAlexNoyle/UXP-Jihad, jihad/uxp-<UXP_TAG>: one commit per patch
 # in build/desktop/patches) the build uses. The third_party/uxp gitlink and the OE recipe's SRCREV
 # must both be this commit.
-UXP_PIN=63c20e39deda564931abc70cc08da7c54cfcb750
+UXP_PIN=bda3141209f1e97571e6e0879d85c51bb1386df1
 # What the user agent and the start pages say: Goanna version and the short UPSTREAM base.
 GOANNA_VERSION=6.9
 UXP_SHORT=5f290d1
@@ -34,7 +34,7 @@ COMPATIBLE_MACHINE = "(tenderloin|opal)"
 # for real (build/engine/patch-queue.sh --check proves it reproduces SRCREV's tree):
 #   SRC_URI = "git://repo.palemoon.org/MoonchildProductions/UXP.git;protocol=https;tag=<UXP_TAG>"
 SRC_URI = "git://${JIHAD_REPO}/third_party/uxp;protocol=file;nobranch=1"
-SRCREV = "63c20e39deda564931abc70cc08da7c54cfcb750"
+SRCREV = "bda3141209f1e97571e6e0879d85c51bb1386df1"
 S = "${WORKDIR}/git"

 # Modern C++14 toolchain (device-build R1) — the stock dylan/device gcc cannot build UXP.
@@ -26,3 +26,4 @@ Build site: context/plans/build-site.md
 | T-513 | DONE | 2026-10-19/24. Two inspectors (Codex out of credits) on Tier 87, twelve findings fixed; Codex by direct invocation on the fixes, T-499 and T-487 on 2026-10-24, nine more fixed: `context/impl/impl-review-findings-gpu-2.md`. Engine 0058 (`gfx/layers/opengl/CompositorOGL.{h,cpp}`, `GLContextProviderEGL.cpp`, `AsyncCompositionManager.{h,cpp}`, `CompositorBridgeParent.cpp`, `TextureHostOGL.cpp`, `PuppetWidget.cpp`); the daemon's `BrowserPageGoanna.{h,cpp}` (the shown buffer never composed into, the express jobs forgotten on a fallback, a job of another frame height given up, the verify reference posted behind its job from a static pool), `GoannaRenderPage.{h,cpp}` (`DocumentKey`/`ResetLayoutSize`), `JihadBrowserServer.{h,cpp}` (inject `target focus|last`, the inject threads reaped), `render/adapter/BrowserOffscreen.cpp` (the window bound). R2's fast flick and two cards (40 + 22 verified frames, 0 rows wrong), R10's twenty card cycles (+76 KB). Round notes `docs/rounds/t513-2026-10-19/`. |
 | T-519 | DONE | 2026-10-24. `docs/rounds/t519-2026-10-24/` (14 pan logs, the dumps). New `render/goanna/test/jihad-fixed-both.html`; `tools/device/t502/pan-run.sh` (`ROUND_DIR`), `tools/device/t502/README.md` (the verify mode's two limits: an animating layer's rows, and its frame rates). Kit: R2 lines 2-3 and R4's four `[x]`, R2's first `[~]` (the animated block under verify), R3's GPU-against-software `[x]`; the table in `docs/RENDERING-OPTIONS.md`. Open: the verify reference's animation time pinned to its job's (engine). |
 | T-527 | PARTIAL | 2026-10-25 night: the zoom's sharp frame. `render/goanna/GoannaRenderPage.{h,cpp}` (`SetGpuDpCritical`, `GpuResolutionFor`/`GpuResolutionChanges`/`GpuResolutionNow`, `JIHAD_GPU_CRIT_MARGIN`), `render/goanna/BrowserPageGoanna.{h,cpp}` (`gpuCriticalEnd`, the express lane publishing a main-lane frame composed while the main thread is away, the express thread kicked by a main-lane post, the hold ended at the express post, `mXTreeRes`: no frame drawing the tiles at under half their size, `JIHAD_GPU_ZOOM_DUMP_SEQ`), engine 0062 (`63c20e39`: the root's displayport base kept by the paint), `tools/device/t502/finger-zoom.sh`. First painted frame at a new zoom 513-669 ms (was 746-2212); pans unchanged or better; verify 0 structurally wrong. `docs/rounds/t527-2026-10-25/notes.txt` |
+| T-527 | PARTIAL | 2026-10-25 later: R8 met. `render/browserserver/Src/JihadFrameWindow.h` (the dirty words), `render/goanna/BrowserPageGoanna.{h,cpp}` (`pubDirtyAdd`/`pubDirtyTake`, `publishWindow` writes the rect changed since the frame before or none; `jihadXNote`: the express lane's idle reasons on the timeline), `render/adapter/BrowserOffscreen.{h,cpp}` (`frameSeq`, `dirtyRect`), `render/adapter/BrowserAdapter.{h,cpp}` (msgPainted invalidates only the rect when it shows the base frame at the same geometry, zoom and scroll), `render/browserserver/Yap/YapProxy.{h,cpp}` (the PDK build: no member initializer), engine 0063 (`bda31412`: the tall band surface), `tools/host/gap-trace.py`, `tools/device/t502/default-check.sh` (the log rotation), `gpu-spike-collect.sh` (dumps removed). The 480 px cube 25.3-28.0 fps on the card |
@@ -296,3 +296,4 @@ Build site: context/plans/build-site.md

 ### Iteration 19 — 2026-10-25 (night)
 - T-527: the zoom's sharp frame (R6) — PARTIAL. Critical displayport (what the card shows first, margins after), express lane publishes main-lane frames composed while the main thread is away, hold ends at the express post, no minified frame for a big zoom out, engine 0062 (root displayport base kept by the paint: PaintFrame's DecideScrollableLayer replaced it every paint). First painted frame 513-669 ms by finger on desktop Wikipedia (was 746-2212). Files: render/goanna/{BrowserPageGoanna,GoannaRenderPage}.{h,cpp}, engine 0062, tools/device/t502/finger-zoom*.sh, docs/rounds/t527-2026-10-25/. Build P, patch-queue --check P (62), pans P (long 29.5-35.4, wiki 22.3-28.5), verify 0 structural. Next: T-527 — the pan's 56 ms+ gaps, WebGL 24 fps, pool size.
+- T-527 (same night): R8 met — dirty rect through the frame trailer + adapter partial invalidation, tall band surface (engine 0063); 480 px cube 25.3-28.0 fps card (was 16.6-22.0); PDK adapter build fixed (YapProxy m_sendFailed, broken since T-540); pan gaps traced (gap-trace.py, express idle notes): 24 in 10 s, compositor-job bound. T-511 DONE. Build P, patch-queue P (63), Enyo default-check P, verify 0 wrong. Next: T-527 — the read/copy floor, Wikipedia 24 fps with sensors, dtap-out first frame.
@@ -59,7 +59,7 @@ Hacker News 36-37, desktop Wikipedia 13-14 (software 9-12.4).
 **Acceptance Criteria:**
 - [~] The scripted pan (0 → 3000 card px in 10 s, `tools/device/t502/pan-run.sh`) runs at 24 fps or better on `jihad-long-static.html` and on desktop en.wikipedia.org after its load *(2026-10-24, T-527, the owner's lever 3b: the bench's `sensord` takes ~30% of a core at idle (load 3.5). With it and `atlas-sensord` stopped the Wikipedia pan ran 25.0 / 27.5 / 27.4 fps against 21.4 / 20.9 / 22.4 with them running, the long page 33-36.5 against 30-35; both restored after. The floor is met on the bench without the sensors; with them it is 21-22, so the compositor thread stays the product's lever. 2026-10-19, T-515: the test page 30-35 fps; desktop Wikipedia 19-21 fps in 2 s windows, median frame gap 45 ms, with the frames made off the main thread. The page's script no longer gaps them (its 2.2 s restyle ran under frames every ~45 ms); the floor is the compositor thread's ~45 ms a Wikipedia frame, whichever lane asks for it: T-517. A page whose script holds the main thread 600 ms in every 700 pans at 26-32 fps (2.4-3.8 without the express lane).)*
 - [x] On every page measured, the GPU path's pan is at least as fast as the software path's on the same pan (`NOGPU=1`), and the table in `docs/RENDERING-OPTIONS.md` says so per page *(2026-10-24, T-519, the same 10 s pan on each page both ways on engine 0058, the pan's 2 s windows: long static 30.4-33.3 against 10.8-12.5 fps, fixed header and footer 26.4-27.9 against 10.9-12.7, sticky-mix 16.5-19.0 against 8.6-10.0, the animation page panned 14.5-24.4 against 11.4-23.6, the self-scrolling page 22.8-27.7 against 10.5-11.4, Hacker News 37.5-48.0 against 6.3-10.2 (the pan overshoots its 1249 px, the last frames are past the page), desktop Wikipedia 18.5-25.9 against 2.7-2.9 (the 18.5 window is the first scroll's restyle). The table is in `docs/RENDERING-OPTIONS.md`; logs `docs/rounds/t519-2026-10-24/pan-*-gpu2-*` and `pan-*-sw-*`.)*
- [ ] Frame gaps of 56 ms or more during a pan are accounted for (traced to their source) and the avoidable ones removed *(2026-10-18, traced: desktop Wikipedia's pan has 3-13 a 2 s window. The stall sampler resolves them to the page's own restyle on the first scroll (955 ms, 36% selector matching: its sticky header), the layer paints of the displayport moves (58-121 ms: display list, glyphs, regions), and short misc events. None is the daemon's own work; the anchor distance does not change them (0.125 and 0.4 heights measured). What would remove them from the frames is the frames made off the main thread: T-515. 2026-10-19: done (T-515, the express lane): the main thread's stalls are covered by frames composed and published from a thread of their own; the gaps left are the compositor's own (T-517).)*
+- [ ] Frame gaps of 56 ms or more during a pan are accounted for (traced to their source) and the avoidable ones removed *(2026-10-25, T-527: traced per gap with `tools/host/gap-trace.py` on the timeline (the express lane now notes why it made no frame): desktop Wikipedia's 10 s pan, 24 gaps in 252 frames — an express job of 50-100 ms (a frame whose tree changed: a whole read; the copy from the base with a stuck header) while the two-deep pipeline waits, a job queued 25-88 ms behind the page's tile-upload transaction, once all three buffers held by the card; none is the main thread any more. Removing them is the compositor job's floor (the read, the copy), still open. 2026-10-18, traced: desktop Wikipedia's pan has 3-13 a 2 s window. The stall sampler resolves them to the page's own restyle on the first scroll (955 ms, 36% selector matching: its sticky header), the layer paints of the displayport moves (58-121 ms: display list, glyphs, regions), and short misc events. None is the daemon's own work; the anchor distance does not change them (0.125 and 0.4 heights measured). What would remove them from the frames is the frames made off the main thread: T-515. 2026-10-19: done (T-515, the express lane): the main thread's stalls are covered by frames composed and published from a thread of their own; the gaps left are the compositor's own (T-517).)*
 - [x] During a pan the card has content past the view's edges, as the software path's frames have: a gap between frames or a busy main thread shows the page, not grey *(added 2026-10-18 from the owner's "areas turn grey": the GPU frame carries 0.15 of the card's height above and below the view (engine 0046, `JIHAD_GPU_OVERSCAN`); verify 0 structurally wrong rows with it on the test page, sticky-mix, desktop Wikipedia and Hacker News; frame dumps looked at)*
 **Dependencies:** R2

@@ -101,7 +101,7 @@ Hacker News 36-37, desktop Wikipedia 13-14 (software 9-12.4).
 **Description:** WebGL 1 contexts are created on the device's GPU and composited without a CPU round trip per WebGL frame.
 **Acceptance Criteria:**
 - [x] On the GPU path `canvas.getContext("webgl")` succeeds on the bench; on the software path WebGL stays off *(2026-10-19, T-511, engine 0051: WebGL asks EGL on the GPU path and is not blocklisted there; `NOGPU=1`: getContext null, "Refused to create native OpenGL context" (rounds 281-313, `docs/rounds/t502-2026-10-17/webgl-r281-313.txt`))*
- [ ] A WebGL test page (a spinning textured cube, `render/goanna/test/`) renders correctly and runs at 24 fps or better *(2026-10-24, the emulated finger (T-524): the cube stays drawn and sharp through a pinch out and a drag over the canvas and after the card is closed and opened three times, the page's counter 19.7-21.8 fps (14.8 at 360 px). 2026-10-19, T-511, `render/goanna/test/jihad-webgl-cube.html`: renders correctly (screenshots r288, r305, r310). On the card: a 240 px cube 26.5-26.9 fps, 360 px 21.5-22.8, 480 px 18-20.5 (the page's own rate 21.5-25 at 480). The canvas reaches the compositor with no copy (one share group); what is left is the compositor job's ~45 ms for 482 rows, the same floor as Wikipedia's pan frames: carried by T-517)*
+- [x] A WebGL test page (a spinning textured cube, `render/goanna/test/`) renders correctly and runs at 24 fps or better *(2026-10-25, T-527, the sensors running (`docs/rounds/t527-2026-10-25/notes.txt`): the 480 px cube 25.3-28.0 fps on the card (the page 28.5-30), 360 px 28.9-29.9, 240 px 29.4-30.0; verify with a ticker beside the canvas and the cube stopped 0 rows wrong over 24 frames, the screenshot shows the cube and the ticker. What it took: the card redraws only the rect that changed (the daemon's dirty words in the frame trailer, the adapter's partial invalidation) and a change that does not fit the 256-row band surface takes a 512-row one (engine 0063) instead of the frame-sized target. 2026-10-24, the emulated finger (T-524): the cube stays drawn and sharp through a pinch out and a drag over the canvas and after the card is closed and opened three times, the page's counter 19.7-21.8 fps (14.8 at 360 px). 2026-10-19, T-511, `render/goanna/test/jihad-webgl-cube.html`: renders correctly (screenshots r288, r305, r310). On the card: a 240 px cube 26.5-26.9 fps, 360 px 21.5-22.8, 480 px 18-20.5 (the page's own rate 21.5-25 at 480). The canvas reaches the compositor with no copy (one share group); what is left is the compositor job's ~45 ms for 482 rows, the same floor as Wikipedia's pan frames: carried by T-517)*
 - [x] Context loss (the card closed, the GPU reset) is handled without a daemon crash; a WebGL page cannot wedge the GPU path (R1's bound) *(2026-10-19, T-511: the second WebGL page closed faulted in libGLESv2 until a context was released from its thread before its destruction (engine 0051); 8 open/close cycles of the card on the cube, no fault; `WEBGL_lose_context` lose and restore (`?lose=1`): the page rebuilds and draws on; the cube's compose jobs run under R1's job bound like any other)*
 - [x] WebGL conformance spot checks (the basic ones a page needs: textures, framebuffers, shaders) pass, and what does not is listed *(2026-10-19, T-511: the test page's checks: shaders, a texture upload, a framebuffer object, readPixels of what was drawn: ok; MAX_TEXTURE_SIZE 4096; 14 extensions; missing against desktop WebGL 1: ANGLE_instanced_arrays, WEBGL_compressed_texture_s3tc, EXT_blend_minmax, EXT_shader_texture_lod (not offered by the GLES 2.0 driver))*
 **Dependencies:** R1
@@ -150,3 +150,4 @@ Hacker News 36-37, desktop Wikipedia 13-14 (software 9-12.4).
 - 2026-10-18: R6 gains the sharpness criterion (the zoom's resolution) after T-504's rounds 162-186.
 - 2026-10-18: R3 gains the overscan criterion (content past the view's edges during a pan) after T-505's rounds 187-201.
 - 2026-10-25: R6's zoom criterion annotated with T-527's first round (the critical displayport, the express lane publishing the main lane's frame, engine 0062).
+- 2026-10-25: R8's 24 fps criterion met (the partial redraw through the frame trailer, the tall band surface, engine 0063); R3's gap criterion annotated with the trace.
@@ -520,7 +520,7 @@ Codex was out of usage (468k tokens of grepping, no report); the path was read f
 | T-524 | The finger round, part 1: the GPU path on real pages in the three interfaces under the timeline and the dumps; cavekit-gpu-rendering R6 and R12 closed; T-514's items | cavekit-finger-emulation.md | R3 | T-523 | yes | L | DONE 2026-10-24 (the scrolling and gesture items of `docs/FINGER-TESTS.md` run in all three with the emulated finger, `docs/rounds/finger-2026-10-24/zoom-grey.txt`: the owner's grey found and fixed — the smart zoom's block rule and the viewport's default maximum (daemon), the root's displayport base and clip divided by the resolution (engine c79d16f8, patch 0059), the GPU-path hit test's mapping, the resolution set before the displayport, the displayport re-set at a zoom; a GPU maximum-scale of 4000 / the declared viewport's larger side. Dispositioned to T-527: the flick's coast gap (blank lower card and header for ~0.5 s), the first frame at a new zoom (1.6-2.9 s on desktop Wikipedia), the clip above ~2.9 on a wide page and the untagged page's maximum. Dev copies on the device: libxul 4d753b8f, daemon 7c29035a on all three, originals as .orig) |
 | T-525 | The finger round, part 2: chrome and shells (settings and personas flicks, addons lists, the long-press menus, the padlock, Mojo pinch; rotation a person's) | cavekit-finger-emulation.md | R3 | T-523 | yes | L | DONE 2026-10-24 (the chrome buttons of all three, the long-press menus of all three, the drop-down and the certificate dialog, the preferences tabs and controls, Mojo's settings values and address search, a Persona worn and taken off, the add-ons panes and plugin menu, the add-on site's nav and search — each on its item in `docs/FINGER-TESTS.md`. Open from it: Mojo's link hold offers the text commands only (mojo-ui R6), the extension row's buttons take no tap at the fit zoom (chrome-look R2), the about:addons search filter not judged. Rotation stays a person's.) |
 | T-526 | The finger round, part 3: keyboard and text, plugins and media; what stays a person's said so | cavekit-finger-emulation.md | R3 | T-523 | yes | L | DONE 2026-10-24 (every keyboard, text, plugin and media item a finger reaches run — see `docs/FINGER-TESTS.md`; Mochi's Paste found and fixed (the sheet blurred the field; a click first), Mojo's link hold fixed with it (T-525); a person's: hearing (Flash and HTML audio), a physical keyboard, a framed field (no test page), another app's link; open: the about:addons extension row's buttons at the fit zoom) |
-| T-527 | The GPU floor with the owner's levers: the bench without `sensord`/`atlas-sensord`, then the compositor-thread floor in the engine (T-505/T-511/T-517 re-opened under it) | cavekit-gpu-rendering.md | R3, R8 | T-524 | yes | XL | IN PROGRESS 2026-10-25 (the sensor bench done: desktop Wikipedia 21-22 fps with sensord/atlas-sensord, 25-27.5 without; the long page 30-35 / 33-37; sensors restored. 2026-10-25 night, the zoom's sharp frame (R6): the first frame painted at a new zoom's resolution 513-669 ms on desktop Wikipedia by finger, was 746-2212 — the critical displayport, the express lane publishing the main lane's frame, the hold ended at the express post, no minified frame for a big zoom out, engine 0062 (the root's displayport base kept by the paint); pans unchanged or better, verify 0 structurally wrong (`docs/rounds/t527-2026-10-25/notes.txt`). Next: the pan's 56 ms+ gaps traced, the WebGL cube at 24 fps, the tile texture pool size (160 cut a zoom's transaction by 70-110 ms)) |
+| T-527 | The GPU floor with the owner's levers: the bench without `sensord`/`atlas-sensord`, then the compositor-thread floor in the engine (T-505/T-511/T-517 re-opened under it) | cavekit-gpu-rendering.md | R3, R8 | T-524 | yes | XL | IN PROGRESS 2026-10-25 (the sensor bench done: desktop Wikipedia 21-22 fps with sensord/atlas-sensord, 25-27.5 without; the long page 30-35 / 33-37; sensors restored. 2026-10-25 night, the zoom's sharp frame (R6): the first frame painted at a new zoom's resolution 513-669 ms on desktop Wikipedia by finger, was 746-2212 — the critical displayport, the express lane publishing the main lane's frame, the hold ended at the express post, no minified frame for a big zoom out, engine 0062 (the root's displayport base kept by the paint); pans unchanged or better, verify 0 structurally wrong (`docs/rounds/t527-2026-10-25/notes.txt`). 2026-10-25 later: R8 met — the 480 px WebGL cube 25.3-28.0 fps on the card (was 16.6-22.0): the daemon writes the rect changed since the frame before into the frame trailer and the adapter redraws only that, and a change too tall for the band surface takes a 512-row one (engine 0063); the PDK adapter builds again (YapProxy's member initializer, T-540); the pan's 56 ms+ gaps traced (`tools/host/gap-trace.py`, the express lane's idle notes). Next: the gaps' sources (the read, the copy from the base), desktop Wikipedia ≥ 24 fps with the sensors, the double tap out's first frame, the tile texture pool size) |

 ## Tier 88 — Closing the kits' open criteria on the current build (2026-10-24; added to the site, not a regeneration)

@@ -573,7 +573,7 @@ the mid-pan dumps, never by a screenshot. No device run while the owner is at th
 | T-508 | Video and Flash on the GPU path: `<video>` (VP8, Theora, H.264) to the end, styled video (rounded, fade, under a modal), Flash draw/animate/input | cavekit-gpu-rendering.md | R7 | T-502 | yes | L | DONE 2026-10-19 (rounds 213-228: VP8, Theora, VP9 and H.264 to the end on the GPU path, at the clips' rates; styled video (rounded, fade, modal); Flash draws, animates and takes keys; `push-engine-update.sh` now carries FFmpeg's libavcodec/libavutil, which a device updated by it lacked (H.264, AAC and MP3 were refused on both paths); new pages `jihad-video-styled.html`, `jihad-anim-opacity.html`, `jihad-canplay.html`) |
 | T-509 | Safety and fit: bounded GPU waits with a fallback to the software path, a simulated EGL failure, memory and GPU memory against the software path, three daemons at once, idle CPU | cavekit-gpu-rendering.md | R1, R10 | T-502 | yes | M | DONE 2026-10-19 (rounds 229-232: the daemon gives the GPU path up for its life after three failed or refused frames or a frame not composed in 3 s, and renders in software (`gpuFallBack`); engine 0047 (a forgotten frame writes nothing; `JIHAD_GPU_TEST_NO_EGL`, `JIHAD_GPU_TEST_STALL`); memory and idle CPU measured against the software path, three GPU daemons at once) |
 | T-510 | The default: the GPU path on in all three event.d jobs with `JIHAD_GPU_COMPOSITOR=0` and a pref to force software; Mochi and Mojo load, pan, zoom and close on it; the startup report | cavekit-gpu-rendering.md | R1 | T-503, T-507, T-509, T-515 | yes | M | DONE 2026-10-19 (blocked by T-504 until then so the owner's zoom complaint would not ship; the express lane (T-515) closed it. The generated upstart jobs start the GPU path with the express lane; `JIHAD_GPU_COMPOSITOR=0` or the pref `jihad.gpu.enabled=false` (read before the engine starts) give the software path, and the log names the path taken; all three interfaces load, pan, zoom and close Wikipedia on their default daemons (`default-check.sh`), the pref and the env override checked on the bench) |
-| T-511 | WebGL through EGL: contexts on the device's GPU on the GPU path, a spinning-cube test page ≥ 24 fps, context loss, spot conformance | cavekit-gpu-rendering.md | R8 | T-510 | yes | L | PARTIAL 2026-10-19 (rounds 281-313, `docs/rounds/t502-2026-10-17/webgl-r281-313.txt`; engine 0051 (WebGL on EGL on the GPU path, the stencil back mask, one share group so the canvas's texture is composited with no copy, a context released before its destruction), 0052 (the column read); the daemon's own-slot base judged by the recent changes. Met: contexts on the GPU path and none on the software path; the cube renders correctly; 8 open/close cycles and a lose/restore without a fault; the spot checks and the missing extensions listed. Open: the 480 px cube 18-20.5 fps on the card (240 px 26.5-26.9, 360 px 21.5-22.8): the compositor job's ~45 ms, carried by T-517; 2026-10-19 evening (round 358): the 480 px cube 19.5-20.9 fps on the card, the page's own rate 23.8-25.1; the card cannot pass the page's rate. BLOCKED with T-517's floor) |
+| T-511 | WebGL through EGL: contexts on the device's GPU on the GPU path, a spinning-cube test page ≥ 24 fps, context loss, spot conformance | cavekit-gpu-rendering.md | R8 | T-510 | yes | L | DONE 2026-10-25 (T-527: the 480 px cube 25.3-28.0 fps on the card, 360 px 28.9-29.9, 240 px 29.4-30; the partial redraw through the frame trailer and the tall band surface, engine 0063; earlier: PARTIAL 2026-10-19 (rounds 281-313, `docs/rounds/t502-2026-10-17/webgl-r281-313.txt`; engine 0051 (WebGL on EGL on the GPU path, the stencil back mask, one share group so the canvas's texture is composited with no copy, a context released before its destruction), 0052 (the column read); the daemon's own-slot base judged by the recent changes. Met: contexts on the GPU path and none on the software path; the cube renders correctly; 8 open/close cycles and a lose/restore without a fault; the spot checks and the missing extensions listed. Open: the 480 px cube 18-20.5 fps on the card (240 px 26.5-26.9, 360 px 21.5-22.8): the compositor job's ~45 ms, carried by T-517; 2026-10-19 evening (round 358): the 480 px cube 19.5-20.9 fps on the card, the page's own rate 23.8-25.1; the card cannot pass the page's rate. BLOCKED with T-517's floor)) |
 | T-512 | Fit to keep: diagnostics pruned and bounded, the knobs listed, the engine work folded into the patch queue, the docs and README | cavekit-gpu-rendering.md | R11 | T-503…T-511, T-517 | no | M | DONE 2026-10-19 (`e8b0e425`: the `[jihad-gpu]` diagnostics behind one gate each in the engine (0057, `mozilla/gfx/JihadGpuLog.h`) and the daemon (`render/goanna/JihadGpuLog.h`), three startup lines in a shipped daemon, the default checks of all three interfaces pass; every switch in `tools/device/t502/README.md`; the 57 patches reproduce the pin and each has its ENGINE-SOURCE row; RENDERING-OPTIONS, the README and PICKUP carry the evening's numbers. The review (R11's third) is T-513) |
 | T-513 | Review of Tier 87 (Codex by direct invocation, the inspector as backup) and fixes | cavekit-gpu-rendering.md | R11 | T-512 | no | M | DONE 2026-10-19 (Codex out of credits: two inspectors, 12 findings, all fixed, `context/impl/impl-review-findings-gpu-2.md`; twenty card cycles flat (R10); a fast flick and two cards in turn pass the verify mode once its reference is composed behind the job (R2); the three default checks on the bench) |
 | T-514 | [OWNER] Finger round on the GPU path in all three interfaces: pan, flick, pinch, double-tap | cavekit-gpu-rendering.md | R12 | T-513 | yes | S | DONE 2026-10-24 by the emulated finger (T-524; R12 at [~]: "finds it smooth" stays the owner's word) |
@@ -85,6 +85,7 @@ modifications; the same changes are the commits of `jihad/uxp-RB_20261006`, one
 | `0060-security-the-built-in-roots-rolled-forward-to-UXP-re.patch` | `security/nss/lib/ckfw/builtins/certdata.txt` | T-529 (cavekit-certificate-trust R2): the built-in roots are UXP release's of 2026-10-24 (037cc5f614c8): 24 roots Mozilla removed dropped (Entrust, AffirmTrust, CommScope, Trustwave, emSign …), 19 current ones added; `ROOTS_SHA256` in `engine-version.env` |
 | `0061-security-a-certificate-error-is-not-TLS-intolerance-.patch` | `security/manager/ssl/nsNSSIOLayer.cpp` | T-534: a SEC_ERROR_* / mozilla::pkix / bad-cert-domain failure is never retried at a lower TLS version (the retry tripped a TLS 1.3 server's downgrade sentinel and a revoked certificate read "SSL_ERROR_RX_MALFORMED_SERVER_HELLO") |
 | `0062-layout-the-GPU-path-s-root-displayport-base-is-the-d.patch` | `layout/base/nsLayoutUtils.{h,cpp}`, `layout/generic/nsGfxScrollFrame.cpp` | T-527: on the GPU path the root's displayport base set by the daemon (0059's `jihad_layout_set_displayport2`) is kept by the paint (`nsLayoutUtils::JihadKeepsDisplayPortBase`): `nsLayoutUtils::PaintFrame`'s `DecideScrollableLayer` replaced it on every paint with the composition size at the origin in CSS px, and a zoomed-in card's first paint without margins covered 660 of the 531..861 CSS px shown (`docs/rounds/t527-2026-10-25/notes.txt`) |
+| `0063-gpu-compositor-a-tall-band-surface-for-a-change-that.patch` | `gfx/gl/GLContextEGL.h`, `gfx/gl/GLContextProviderEGL.cpp`, `gfx/layers/ipc/CompositorBridgeParent.cpp`, `gfx/layers/opengl/CompositorOGL.{h,cpp}` | T-527 (R8): a change that does not fit the 256-row band surface takes a second, 512-row band surface (`JIHAD_GPU_BAND_TALL`, its own pbuffer and target) instead of the frame-sized target; frames are packed for the band surface first. The 480 px WebGL cube's job 15-30 ms where it took ~45 |
 | `0054-gpu-compositor-kept-rects-all-saved-before-any-is-wr.patch` | `gfx/layers/opengl/CompositorOGL.cpp`, `widget/PuppetWidget.cpp`, `dom/canvas/WebGLContext.cpp`, `widget/headless/GfxInfo.cpp` | T-517/T-511 review: a window-moved shift saves every kept rect before writing any; `jihad_offscreen_gpu_given_up()` / `jihad_gpu_compositor_on()`, so WebGL makes no EGL contexts once the daemon has given the GPU path up |
 | `0053-gpu-compositor-a-shift-that-is-the-daemon-s-window-m.patch` | `gfx/layers/opengl/CompositorOGL.{h,cpp}`, `widget/PuppetWidget.cpp` | T-517: a compose job's shift may be the daemon's move of the frame's window in its segment (flag 8): the rows are in place, only the kept rects are copied from where they were |
 | `0052-gpu-compositor-the-frame-s-bands-read-as-one-column-.patch` | `widget/PuppetWidget.{h,cpp}`, `gfx/layers/ipc/CompositorBridgeParent.cpp`, `gfx/layers/opengl/CompositorOGL.{h,cpp}` | T-511: a compose job may give its bands' stale columns (flag 4); with no shift, kept rows or fixed columns, the bands are read as the one column the change and they span when it is under three quarters of the width; the poll reports the change's columns (twelve ints); `JIHAD_GPU_NO_COLUMN_READ=1` reads whole rows |
@@ -58,6 +58,15 @@ What a regeneration owes the contract: `context/kits/cavekit-ipc-contract.md` R1
 - `freeze`/`thaw` detach/reattach the buffers for backgrounded cards (memory
  reclaim). `setWindowSize` / `setVirtualWindowSize` resize the surface and the
  content viewport respectively.
+- **Jihad's segment trailer** (not a message; the messages and `BrowserOffscreenInfo`
+  are unchanged): the last 64 bytes of each segment, past the pixel rows the adapter
+  uses, are `JihadFrameTrailer` (`render/browserserver/Src/JihadFrameWindow.h`). An
+  adapter that made the segment marks it (`adapterCaps`); the daemon then writes,
+  before each `msgPainted`, where in the pixels the frame starts (T-517, the frame
+  window) and the rect that differs from the frame published before it, with both
+  frames' numbers (T-527, the dirty words: the adapter showing that frame may redraw
+  only the rect). Either side from before ignores or leaves the trailer zero, and a
+  zero trailer means the frame starts at the pixels' start and is new everywhere.


 ## Sync command (adapter → server, blocks for reply)
@@ -52,7 +52,7 @@ Jihad Browser, and it starts when Jihad Browser is finished.
 Memory: `global-jihad-project.md`. The workspace `CLAUDE.md` carries the pointer and the corrected
 target line (both webOS 3.0.5 and CE 3.1.0).

-## 2026-10-25 (night) — T-527: the zoom's sharp frame 3-4x sooner; engine patch 0062 (READ FIRST)
+## 2026-10-25 (night) — T-527: the zoom's sharp frame 3-4x sooner (engine 0062); WebGL at 24+ fps (engine 0063) (READ FIRST)

 **Measured by the emulated finger on desktop Wikipedia, sensors running** (`docs/rounds/t527-2026-10-25/notes.txt`,
 `tools/device/t502/finger-zoom.sh`): the first frame painted at a new zoom's resolution now comes 593 ms after a
@@ -78,14 +78,27 @@ mid-pan dumps looked at; verify without the express lane 0 rows wrong / 0 struct
 long page's frames differ below the threshold in most frames where T-519 found none — the head binaries do the same,
 not this change. Measured, not changed: `JIHAD_GPU_TEX_POOL=160` cut a zoom's transaction 70-110 ms (+28 MB GPU at most).

-**Device state:** Enyo runs DEV COPIES — daemon `786f520c` and libxul `f25bb166` (63c20e39 stripped) in its
-`deviceroot/hl`, the originals kept as `jihad-browserserver.orig` / `libxul.so.orig` (47a68434 / 161d7a88) and the
-new libxul also as `libxul.so.t527`. Mochi and Mojo are the packages. A packaged build (`build-all-device.sh`) after
-the commits is the clean way to ship them. The sensors run. Pushes: the owner's, `push.sh` needs the engine fork's
-new head `63c20e39` too.
+**Pushes:** the owner's; `push.sh` pushes the engine fork's branch (now at `bda31412`) and main.

-**Next (T-527):** the pan's 56 ms+ gaps traced and the avoidable removed (R3), the 480 px WebGL cube at 24 fps (R8),
-desktop Wikipedia ≥ 24 fps with the sensors (R3), the double tap out's first frame (R6), the pool size.
+**Later the same night — R8 met, T-511 DONE.** The 480 px WebGL cube 25.3-28.0 fps on the card with the sensors
+running (was 16.6-22.0; 360 px 28.9-29.9, 240 px 29.4-30 — the page's own ~30): (1) the daemon writes the rect that
+changed since the frame before into the segment's trailer (`JihadFrameWindow.h` dirty words, with both frames' numbers)
+and the adapter redraws only that rect when it shows that frame at the same geometry, zoom and scroll
+(`BrowserAdapter::msgPainted`; `JIHAD_GPU_NO_DIRTY=1` off); (2) engine **0063** (`bda31412`): a change too tall for the
+256-row band surface takes a 512-row band surface instead of the frame-sized target (`JIHAD_GPU_BAND_TALL`). Verify 0
+rows wrong, the cube and a ticker drawn right; Wikipedia's pan unchanged. **The PDK adapter had not built since T-540**
+(`YapProxy.h`'s member initializer; PDK gcc 4.3.3): fixed — a package build from c0aee8d0/ef9691ec would have failed.
+The pan's ≥56 ms gaps are traced (`tools/host/gap-trace.py`, the express lane's `express idle:` notes): 24 in a 10 s
+Wikipedia pan, all the compositor job's (a 50-100 ms whole read after a tree change, the copy from the base, a job
+queued behind the page's tile uploads), none the main thread's. `docs/IPC-CONTRACT.md` now describes the trailer.
+
+**Device state (end of the night):** Enyo runs DEV COPIES — daemon `b79f1c1f`, libxul `d69e0fd0` (bda31412 stripped),
+the adapter `d4325248` in `/usr/lib/jihad/enyo/` (rootfs; LunaSysMgr restarted) — originals as `.orig` (47a68434,
+161d7a88, a312e864). Mochi and Mojo: the packages (their adapters the old ones). The upstart Enyo job runs; the Enyo
+default check passes. A packaged build of all three after the commits ships the adapters together (`build-all-device.sh`).
+
+**Next (T-527):** the compositor job's floor behind the pan's gaps (the read, the copy from the base), desktop Wikipedia
+≥ 24 fps with the sensors (R3), the double tap out's first frame (R6), the tile texture pool size.

 ## 2026-10-25 — the certificate-trust kit (Tier 90) done on the device; a TLS floor and a tighter Trust dialog (READ FIRST)

@@ -69,3 +69,39 @@ paragraphs 9 -> 17 -> 25, Wikipedia's panels in place). Verify without the expre
 frames, 0 rows wrong, 0 structurally wrong. The long page's frames now differ below the threshold in most
 frames (53 of 59) where T-519 found none; the head binaries do the same (pan-v4-long-old: 54 of 61), so it is
 not this change (the larger displayport of T-541 or the shipped followOverflow the run used).
+
+
+WebGL, the 480 px cube (R8): 24 fps on the card
+-----------------------------------------------
+Baseline (pan-w1-cube480): the card 16.6-22.0 fps, the page's own 22.0-23.5. Each frame the main lane composed the
+canvas's 354-row change in the frame-sized target (it did not fit the 256-row band surface): compose 2-5 ms, then the
+read of 354 rows x 456 columns waited 32-52 ms for the GPU (the whole 768x1224 target cleared, drawn and resolved).
+1. The card redraws only what changed (r304's measured option, now with a side channel): the daemon writes the rect
+   that differs from the frame published before into the segment's trailer (JihadFrameWindow.h: dirtyMagic,
+   dirtyLeft..dirtyBottom, dirtySeq, dirtyBase; the union of every composite's change since that frame, at its
+   geometry; anything unknown, a forgotten job, popups, a software frame, an earlier-posted job not yet polled, makes
+   it whole), and the adapter invalidates only that rect when it shows frame dirtyBase at the same geometry and
+   zoom and its own scroll has not moved (BrowserAdapter::msgPainted). Proven end to end (pan-w3, the adapter's paint
+   log on for the run): 515 partial invalidations against 24 whole, the rect x 105..457 rows 231..585. The card
+   alone: 18-22 fps (the daemon's job was the bound).
+2. A tall band surface (engine 0063, JIHAD_GPU_BAND_TALL, 512 rows): a change that does not fit the band surface
+   takes a 512-row band pass instead of the frame-sized target; frames are packed for the 256-row surface first.
+   The cube's job 15-30 ms (pan-w4 with JIHAD_GPU_BAND_ROWS=512 first, then pan-w5 with the tall surface).
+After both, the sensors running (pan-w5, pan-w6): 480 px 25.3-28.0 fps on the card (the page 28.5-30), 360 px
+28.9-29.9 (one 13.5 window), 240 px 29.4-30.0 (the page's own ~30). Verify with a ticker beside the canvas and the cube
+stopped (pan-v5-cube480): 24 frames, 0 rows wrong; the screenshot shows the cube and the ticker (pan-v5-cube480.jpg).
+Desktop Wikipedia's pan with the tall surface (pan-t1-wiki): 20.5 (the first scroll's restyle), 27.0, 27.0 fps; with
+JIHAD_GPU_BAND_ROWS=512 instead (pan-b512-wiki) 21.2/22.0/26.0 — the reason the band surface stays 256.
+Found on the way: the PDK adapter had not built since T-540 (YapProxy.h's member initializer m_sendFailed, which the
+PDK's gcc 4.3.3 rejects): the shipped adapters predate T-540, and a fresh package build would have failed.
+
+The pan's 56 ms+ gaps (R3): traced
+----------------------------------
+tools/host/gap-trace.py <log> on a JIHAD_GPU_TIMELINE=1 pan (the express lane now notes why it made no frame:
+"express idle: ..."). Desktop Wikipedia, 10 s pan, sensors running (pan-g2-wiki): 24 gaps of 56 ms or more in 252
+frames. Their sources: an express job of 50-100 ms on the compositor loop while the two-deep pipeline waits for it
+(the frame whose tree changed: a whole read of 300-1200 rows, 35-73 ms of it the read; the band frame's copy from
+the base 10-14 ms when the page has a stuck header); a job queued 25-88 ms behind the page's own layer transaction
+(the tile uploads of a displayport move); once, 166 ms with all three buffers held by the card ("no slot: in flight
+111"). The steady frame is ~30 ms (compose ~8, copy from the base 10-14, read 7-12). With the tall band surface the
+count is the same (pan-g3-wiki: 19). None of them is the daemon waiting on its own main thread any more.
@@ -0,0 +1,807 @@
+=== LOG BEGIN
+[jihad-bs] variant=enyo (JIHAD_BS_NAME=jihad-browser) state=/var/palm/jihad/enyo
+[jihad-bs] rendering: the GPU path (the job's JIHAD_GPU_COMPOSITOR)
+[jihad-bs] plugin search path: /media/cryptofs/apps/usr/palm/applications/net.riverstonerelay.jihad-browser/profile/plugins:/media/cryptofs/apps/usr/lib/BrowserServerPlugins:/media/cryptofs/apps/usr/palm/applications/net.riverstonerelay.jihad-browser/deviceroot/hl/plugins
+[jihad-bs] child process loader: /media/cryptofs/apps/usr/palm/applications/net.riverstonerelay.jihad-browser/deviceroot/hl/ld-2.23.so (library-path /media/cryptofs/apps/usr/palm/applications/net.riverstonerelay.jihad-browser/deviceroot/hl)
+[jihad-bs] init: resolving greDir
+[jihad-bs] init: resolving the profile + cache dirs
+[jihad-bs] profile ProfD=/media/cryptofs/apps/usr/palm/applications/net.riverstonerelay.jihad-browser/profile ProfLD=/media/cryptofs/apps/usr/palm/applications/net.riverstonerelay.jihad-browser/cache
+[jihad-bs] init: checking the startup cache against the bundle
+[jihad-bs] startup cache: bundle unchanged (id 69e40158df028bba0d26d32f5d17dd74, 75 files, 7e279f72a0c8f574, 28 ms) — kept
+[jihad-bs] init: XRE_InitEmbedding2
+[jihad-bs] appinfo: registered early (before app-startup JS)
+[jihad-bs] init: XRE_InitEmbedding2 OK
+[jihad-bs] engine: optional export jihad_layout_set_displayport is MISSING from libxul (its fallback is in use)
+[jihad-bs] engine: 24 of 25 optional jihad_* exports present
+[jihad-bs] init: InstallDialogService
+[jihad-bs] init: InstallDownloadService
+[jihad-bs] init: InstallAppInfoService (nsIXULAppInfo/nsIXULRuntime)
+[jihad-bs] appinfo[late-backstop]: id={4534aac8-d8c8-4765-95ee-7f61fd0b762d} version=1.0 platform=6.9.0
+[jihad-bs] widget-probe @mozilla.org/chrome/chrome-native-theme;1      ABSENT
+[jihad-bs] widget-probe @mozilla.org/widget/dragservice;1              ABSENT
+[jihad-bs] widget-probe @mozilla.org/widget/clipboard;1                ABSENT
+[jihad-bs] widget-probe @mozilla.org/widget/lookandfeel;1              ABSENT
+[jihad-bs] widget-probe @mozilla.org/widget/idleservice;1              ABSENT
+[jihad-bs] widget-probe @mozilla.org/widget/appshell/headless;1        PRESENT
+[jihad-bs] widget-probe @mozilla.org/gfx/screenmanager;1               PRESENT
+[jihad-bs] js-console bridge on (chrome/resource/about only)
+[jihad-bs] clipboardhelper: registered (headless widget module does not provide one)
+[jihad-bs] init: XRE_NotifyProfile (DoStartup: prefs + addons + profile-after-change)
+[jihad-bs] init: XRE_NotifyProfile returned
+[jihad-bs] init: preferences-service
+[jihad-bs] init: general.useragent.override
+[jihad-bs] init: menu highlight sheet
+[jihad-bs] menu highlight sheet: /var/palm/jihad/enyo/jihad-menu.css rv=0x0
+[jihad-bs] init: registering the per-domain UA observer
+[jihad-bs] prefs check: surfacecache.max_size_kb=32768 (goanna.js low-RAM block ACTIVE)
+[jihad-bs] prefs check: layers.enable-tiles=1
+[jihad-bs] init: engine init complete
+[jihad-bs] self-drive inject channel ENABLED: /var/palm/jihad/enyo/inject.cmd
+[jihad-bs] tick period 8 ms with a card, 1000 ms idle
+[jihad-bs] GPU compose jobs wake the loop when done (pipe 19)
+[jihad-bs] luna: serving palm://net.riverstonerelay.jihadBrowser/ — public{clearCache,clearCookies,notifications,getFlash,enableFlash,disableFlash,saveThumbnail,deleteThumbnail,clearThumbnails,findPrinters,printPage,pageCertificate,getTheme} private{clearCache,clearCookies,getChromePrefs,getFlash,getTheme,notifications} (toast channel ON)
+[jihad-bs] engine up; serving YAP 'jihad-browser' (waiting for BrowserAdapter)
+[jihad-bs] proxy: webOS's setting read (39 bytes)
+[jihad-bs] js-console (no source):0:0 bundled add-ons: the add-on manager is ready (attempt 0, 4864 ms after start)
+[jihad-bs] js-console (no source):0:0 bundled add-ons: palefill@addons.martoks-place.de: already installed, 1.30 (5260 ms)
+[jihad-bs] js-console (no source):0:0 identity: ready: 1 learned site(s), 1 site rule(s)
+[jihad-bs] js-console (no source):0:0 compat: ready: shims on
+[jihad-bs] luna: getTheme (none)
+Connecting to browser-adapter (client) socket: /tmp/yapserver.jihad-browser19319-8 ...
+Connected to client socket
+[jihad-bs] client connected
+[jihad-bs] connect 960x1400 keys=0x1d67000b,0x1d67800c sz=12582944 id=0
+[jihad-bs] cert: certificate files -> /var/palm/jihad/enyo/certs (/var/ssl not writable by us)
+[jihad-gpu] daemon frame path: compositor (jihad_offscreen_compose present, OMTC on)
+[jihad-widget] create type=0 popup=0 hint=0 parent=(nil) bounds=0,0 960x1400
+[jihad-bs] tick: card connected — 8 ms
+[jihad-bs] extra buffer key=0x1d68000d sz=12582944
+[jihad-bs] extra buffer ACCEPTED: 3-buffer rotation active (key 0x1d68000d)
+[jihad-bs] focus: Luna requests are now answered for the card that just said it has the focus
+[jihad-bs] setEnableJavaScript 1
+[jihad-bs] setBlockPopups 1
+[jihad-bs] setAcceptCookies 1
+[jihad-bs] setZoomAndScroll zoom=1.0000 (was -1.0000) scroll=0,0
+[jihad-gpu] view: scale 1.0000 offset 0.0,0.0
+[jihad-gpu] viewport: scale 1.0000 (compositor), displayport NOT set (code 1, what the card shows, margins 0x0 CSS px, shift 0,0)
+[jihad-gpu] view: scale 1.0000 offset 0.0,0.0
+[jihad-gpu] viewport: scale 1.0000 (compositor), displayport NOT set (code 1, panning, margins 0x768 CSS px, shift 0,0)
+[jihad-widget] create type=3 popup=0 hint=0 parent=0x38e8d800 bounds=0,0 1024x768
+[jihad-gpu] share root made: the compositor's and WebGL's contexts share textures
+[jihad-gpu] pbuffer context 1100x1400: created 
+[jihad-gpu] renderbuffer window targets 1100x1400: FBO 1 and one more, read by a thread of their own
+[jihad-gpu] compositor created for 1024x768 (compositor backend 2)
+[jihad-gpu] scroll anchor moved to 0,0 (wanted 0,0)
+[jihad-gpu] view: scale 1.0000 offset 0.0,0.0
+[jihad-gpu] viewport: scale 1.0000 (compositor), displayport NOT set (code 2, panning, margins 0x768 CSS px, shift 0,0)
+[jihad-gpu] displayport shifted to 0,0 from the engine's 0,0
+[jihad-gpu] view: scale 1.0000 offset 0.0,0.0
+[jihad-bs] setMinFontSize 2
+[jihad-bs] setEnableJavaScript 1
+[jihad-bs] setBlockPopups 1
+[jihad-bs] setAcceptCookies 1
+[jihad-bs] setBlockPopups 1
+[jihad-bs] setAcceptCookies 1
+[jihad-bs] setEnableJavaScript 1
+[jihad-bs] setMinFontSize 2
+[jihad-page] docshell active (was active; timers and animation frames at full rate)
+[jihad-bs] extra buffer key=0x1d68000d sz=12582944
+[jihad-bs] extra buffer ACCEPTED: 3-buffer rotation active (key 0x1d68000d)
+[jihad-gpu] view: scale 1.0000 offset 0.0,0.0
+[jihad-gpu] viewport: scale 1.0000 (compositor), displayport NOT set (code 2, panning, margins 0x942 CSS px, shift 0,0)
+[jihad-gpu] scroll anchor moved to 0,0 (wanted 0,0)
+[jihad-gpu] view: scale 1.0000 offset 0.0,0.0
+[jihad-gpu] viewport: scale 1.0000 (compositor), displayport NOT set (code 2, panning, margins 0x942 CSS px, shift 0,0)
+[jihad-gpu] displayport shifted to 0,0 from the engine's 0,0
+[jihad-gpu] view: scale 1.0000 offset 0.0,0.0
+[jihad-bs] openUrl http://192.168.1.245:8077/jihad-webgl-cube.html?size=480&ticker=1&stop=4
+[jihad-bs] InitializeNSS OK
+[jihad-bs] jihad_init_nss(ssl provider): main=1 rv=0x0 got=0x42bff300
+[jihad-bs] state top f=0x10001 doc=0 win=0 net=0 START status=0x0
+[jihad-bs] state top f=0x10010 doc=0 win=0 net=0 STOP status=0x804b0002
+[jihad-bs] state top f=0xf0001 doc=1 win=1 net=1 START status=0x0
+[jihad-gpu] view: scale 1.0000 offset 0.0,0.0
+[jihad-gpu] viewport: scale 1.0000 (compositor), displayport NOT set (code 2, panning, margins 0x942 CSS px, shift 0,0)
+[jihad-gpu] scroll anchor moved to 0,0 (wanted 0,0)
+[jihad-gpu] view: scale 1.0000 offset 0.0,0.0
+[jihad-gpu] displayport shifted to 0,0 from the engine's 0,0
+[jihad-gpu] view: scale 1.0000 offset 0.0,0.0
+[jihad-gpu] view: scale 1.0000 offset 0.0,0.0
+[jihad-gpu] scroll anchor moved to 0,0 (wanted 0,0)
+[jihad-gpu] view: scale 1.0000 offset 0.0,0.0
+[jihad-gpu] displayport shifted to 0,0 from the engine's 0,0
+[jihad-bs] proxy: webOS's setting read (39 bytes)
+[jihad-bs] js-console (no source):0:0 blocker: cache: EasyList 202610241635, EasyPrivacy 202610241641 - hosts 95044, third-party 5370, typed 199, path 5600, exceptions 5+1079, generichide 158, selectors 13079 (less 0), site selectors 7871 (less 301, per document), bad selectors 220, skipped 13063, 10644 ms
+[jihad-bs] js-console (no source):0:0 blocker: hiding on (13079 generic selectors)
+[jihad-bs] js-console (no source):0:0 blocker: excepted generic selectors, per document: 268; generic-hide sites 154 and 4 address prefixes
+[jihad-bs] js-console (no source):0:0 OpenGL compositor Initialized Succesfully.
+Version: OpenGL ES 2.0 1566933
+Vendor: Qualcomm
+Renderer: Adreno (TM) 220
+FBO Texture Target: TEXTURE_2D
+[jihad-bs] shm 493289483 attached write-through
+[jihad-gpu] overscan: 141 card rows each side, the clip widened 142 CSS px each way (code 2)
+[jihad-gpu] slot 0 read whole: valid=0 x 0/0 y -141/0 zoom 1.0000/1.0000 w 768/0 h 1224/0 fixed 0..0
+[jihad-gpu] frame 0: layers 4.2 ms
+[jihad-gpu] activity: docshell active, pres shell active, document visible, frame requests full rate, painted-pres-shell 0, window foreground
+[jihad-bs] clock hold on: the floor goes to 1188000 kHz while the engine has work (governor ondemandtcl, floor 192000 kHz otherwise)
+[jihad-bs] clock hold: held
+[jihad-bs] js-console (no source):0:0 certs: built-in roots: 169 certificates, 118 trusted for sites, 0 on Mozilla's removed report
+[jihad-gpu] window targets re-sized to 768x1224 (were 1100x1400); the pbuffer too
+[jihad-gpu] async scroll: the root layer 0x33723c00 has no metadata (card scroll valid 1 want 0.0,0.0)
+[jihad-gpu] BeginFrame 1: render bounds 0,0 768x1224, target 768x1224, clip 0,0 768x1224, widget 768x1224, window fbo 1
+[jihad-gpu] glFinish 0.0 ms, glReadPixels 1224 rows 51.7 ms, CPU swizzle+flip 7.4 ms
+[jihad-gpu] read: shift 0 rows 0.0 ms, band 0..1224 59.2 ms, band 0..0 0.0 ms
+[jihad-gpu] compositor thread: compose 0.8 ms, handoff 59.3 ms (frame 0, rows 0..1224 and 0..0 of 1224, x 0..768, 0 columns, 0 kept, changed 0..1224 x 0..768, fixed 0..0, tree changed, started=1)
+[jihad-gpu] job 1: queued 0.7 ms on the compositor loop, composed in 87.7 ms
+[jihad-bs] blocker installed: heap purged (jemalloc dirty pages returned)
+[jihad-gpu] compositor scroll off (the pan settled, the engine moved there) at 0,0
+[jihad-gpu] job done 433 ms after its start, 0 pending polls, read 0..1224 and 0..0, changed 0..1224, fixed 0..0, nb=0, 0 still in flight
+[jihad-bs] painted shmid=0x1d67000b bytes=0 (768x1224 top=-141 band=0 left=0) mZoom=1.0000 contentZoom=1.0000 ms=434 rows new=0 copied=0
+[jihad-gpu] daemon frame: before read 0 ms, read (compose) 434 ms, between 0 ms, popups+publish 0 ms
+[jihad-gpu] publish: 1 ms from the frame's arrival to the message, msgPainted 5 ms
+[jihad-bs] shm 493322252 attached write-through
+[jihad-gpu] slot 1 from the newest slot 0 (y -141 -> -141, shift 0); bands 0..0 and 0..0
+[jihad-gpu] frame 1: layers 0.3 ms
+[jihad-bs] js-console (no source):0:0 certs: webOS: 190 distinct certificate(s) in 3 store(s); trusting 0; skipped {"stock":63,"removed":12,"builtin":115,"expired":0,"notCA":0,"notRoot":0,"siteLike":0,"noCertSign":0,"accepted":0,"already":0,"relay":0,"unreadable":0}
+[jihad-gpu] diff first: changed 141..1083, shift 0 (none), fixed 0..0 -> 942 rows, the whole path
+[jihad-gpu] glFinish 0.0 ms, glReadPixels 942 rows 20.8 ms, CPU swizzle+flip 5.4 ms
+[jihad-gpu] read: shift 0 rows 30.8 ms, band 141..1083 26.3 ms, band 0..0 0.0 ms
+[jihad-gpu] compositor thread: compose 0.4 ms, handoff 57.3 ms (frame 1, rows 141..1083 and 0..0 of 1224, x 0..768, 0 columns, 0 kept, changed 141..1083 x 0..768, fixed 0..0, tree changed, started=1)
+[jihad-gpu] job 2: queued 18.4 ms on the compositor loop, composed in 58.2 ms
+[jihad-gpu] glFinish 0.0 ms, glReadPixels 1224 rows 21.4 ms, CPU swizzle+flip 9.4 ms
+[jihad-gpu] read: shift 0 rows 0.0 ms, band 0..1224 30.9 ms, band 0..0 0.0 ms
+[jihad-gpu] compositor thread: compose 0.3 ms, handoff 31.0 ms (frame 2, rows 0..1224 and 0..0 of 1224, x 0..768, 0 columns, 0 kept, changed 0..0 x 0..0, fixed 0..0, started=1)
+[jihad-gpu] job 3: queued 64.7 ms on the compositor loop, composed in 31.4 ms
+[jihad-bs] state top f=0x10001 doc=0 win=0 net=0 START status=0x0
+[jihad-bs] state top f=0x10010 doc=0 win=0 net=0 STOP status=0x0
+[jihad-widget] create type=3 popup=0 hint=0 parent=0x38e8d800 bounds=0,0 768x942
+[jihad-bs] state top f=0x10001 doc=0 win=0 net=0 START status=0x0
+[jihad-gpu] job done 178 ms after its start, 1 pending polls, read 141..1083 and 0..0, changed 141..1083, fixed 0..0, nb=1, 0 still in flight
+[jihad-gpu] verify slot 1 (y -141, shift 0, bands 0..0 0..0): 0 rows differ in 0 runs:; 0 rows wrong:; 0 rows structurally wrong:
+[jihad-bs] painted shmid=0x1d67800c bytes=1 (768x1224 top=-141 band=0 left=0) mZoom=1.0000 contentZoom=1.0000 ms=278 rows new=0 copied=0
+[jihad-gpu] publish: 100 ms from the frame's arrival to the message, msgPainted 1 ms
+[jihad-bs] shm 493355021 attached write-through
+[jihad-gpu] slot 2 from the newest slot 1 (y -141 -> -141, shift 0); bands 0..0 and 0..0
+[jihad-gpu] painted layers: tiled
+[jihad-gpu] frame 2: layers 3.2 ms
+[jihad-gpu] async scroll: layer 0x33723c00 has 1 metadata (first: root content 1, id 0, offset 0.0,0.0), card scroll valid 0 want 0.0,0.0, controller 0
+[jihad-gpu] diff first: changed 141..1083, shift 0 (none), fixed 0..0 -> 942 rows, the whole path
+[jihad-gpu] tick: loop gap 0 ms before it, pump 153 ms, paint 127 ms
+[jihad-gpu] maybePaint +128 ms (1 jobs, needsPaint 1, dirtyPending 0, seq 3/2)
+[jihad-bs] emitGeometry contentSize=768x942 win=768x942 mZoom=1.0000
+[jihad-gpu] maybePaint +8 ms (1 jobs, needsPaint 1, dirtyPending 0, seq 3/3)
+[jihad-gpu] tick: loop gap 1 ms before it, pump 8 ms, paint 0 ms
+[jihad-gpu] glFinish 0.0 ms, glReadPixels 942 rows 22.0 ms, CPU swizzle+flip 6.5 ms
+[jihad-gpu] read: shift 0 rows 35.8 ms, band 141..1083 28.7 ms, band 0..0 0.0 ms
+[jihad-gpu] compositor thread: compose 0.7 ms, handoff 64.6 ms (frame 3, rows 141..1083 and 0..0 of 1224, x 0..768, 0 columns, 0 kept, changed 141..1083 x 0..768, fixed 0..0, tree changed, started=1)
+[jihad-gpu] job 4: queued 0.2 ms on the compositor loop, composed in 65.8 ms
+[jihad-gpu] glFinish 0.0 ms, glReadPixels 1224 rows 30.9 ms, CPU swizzle+flip 7.1 ms
+[jihad-gpu] read: shift 0 rows 0.0 ms, band 0..1224 38.2 ms, band 0..0 0.0 ms
+[jihad-gpu] compositor thread: compose 0.5 ms, handoff 38.3 ms (frame 4, rows 0..1224 and 0..0 of 1224, x 0..768, 0 columns, 0 kept, changed 0..0 x 0..0, fixed 0..0, started=1)
+[jihad-gpu] job 5: queued 49.1 ms on the compositor loop, composed in 38.9 ms
+[jihad-gpu] maybePaint +235 ms (1 jobs, needsPaint 1, dirtyPending 0, seq 3/3)
+[jihad-gpu] tick: loop gap 0 ms before it, pump 235 ms, paint 0 ms
+[jihad-gpu] scroll anchor moved to 0,0 (wanted 0,0)
+[jihad-gpu] displayport shifted to 0,0 from the engine's 0,0
+[jihad-bs] state top f=0x10001 doc=0 win=0 net=0 START status=0x0
+[jihad-bs] state top f=0x10010 doc=0 win=0 net=0 STOP status=0x804b0002
+[jihad-bs] state top f=0x10010 doc=0 win=0 net=0 STOP status=0x804b0002
+[jihad-bs] state top f=0x10010 doc=0 win=0 net=0 STOP status=0x804b0002
+[jihad-bs] state top f=0x20010 doc=1 win=0 net=0 STOP status=0x804b0002
+[jihad-bs] state top f=0xc0010 doc=0 win=1 net=1 STOP status=0x804b0002
+[jihad-bs] state top f=0xf0001 doc=1 win=1 net=1 START status=0x0
+[jihad-gpu] maybePaint +164 ms (1 jobs, needsPaint 1, dirtyPending 0, seq 3/3)
+[jihad-gpu] tick: loop gap 4 ms before it, pump 160 ms, paint 0 ms
+[jihad-bs] layout viewport 980x1202 (card 768x942)
+[jihad-bs] emitGeometry contentSize=980x1202 win=768x942 mZoom=1.0000
+[jihad-gpu] maybePaint +66 ms (1 jobs, needsPaint 1, dirtyPending 0, seq 4/4)
+[jihad-bs] first paint released — repainting the whole page
+[jihad-gpu] job done 479 ms after its start, 0 pending polls, read 141..1083 and 0..0, changed 141..1083, fixed 0..0, nb=1, 0 still in flight
+[jihad-gpu] verify slot 2 (y -141, shift 0, bands 0..0 0..0): 0 rows differ in 0 runs:; 0 rows wrong:; 0 rows structurally wrong:
+[jihad-bs] painted shmid=0x1d68000d bytes=1 (768x1224 top=-141 band=0 left=0) mZoom=1.0000 contentZoom=1.0000 ms=593 rows new=0 copied=0
+[jihad-gpu] publish: 115 ms from the frame's arrival to the message, msgPainted 0 ms
+[jihad-gpu] frame 3: layers 1.3 ms
+[jihad-gpu] diff first: changed 141..1224, shift 0 (none), fixed 0..0 -> 1083 rows, the whole path
+[jihad-gpu] tick: loop gap 0 ms before it, pump 66 ms, paint 123 ms
+[jihad-bs] setZoomAndScroll zoom=0.7837 (was 1.0000) scroll=0,0
+[jihad-gpu] displayport: scroll port 980x1202 CSS px, shown 980x1202 at +0,0, resolution 1.0000, margins 1202 up and down, 0 sideways (CSS px)
+[jihad-gpu] viewport: scale 0.7837 (compositor), displayport set (code 0, panning, margins 0x1202 CSS px, shift 0,0)
+[jihad-gpu] scroll anchor moved to 0,0 (wanted 0,0)
+[jihad-gpu] displayport: scroll port 980x1202 CSS px, shown 980x1202 at +0,0, resolution 1.0000, margins 1202 up and down, 0 sideways (CSS px)
+[jihad-gpu] displayport shifted to 0,0 from the engine's 0,0
+[jihad-gpu] maybePaint +125 ms (1 jobs, needsPaint 1, dirtyPending 0, seq 5/4)
+[jihad-gpu] overscan: 141 card rows each side, the clip widened 181 CSS px each way (code 0)
+[jihad-gpu] frame 4: layers 1.8 ms
+[jihad-gpu] glFinish 0.0 ms, glReadPixels 1083 rows 28.4 ms, CPU swizzle+flip 9.3 ms
+[jihad-gpu] read: shift 0 rows 0.0 ms, band 141..1224 37.9 ms, band 0..0 0.0 ms
+[jihad-gpu] compositor thread: compose 0.8 ms, handoff 38.0 ms (frame 5, rows 141..1224 and 0..0 of 1224, x 0..768, 0 columns, 0 kept, changed 141..1224 x 0..768, fixed 0..0, tree changed, started=1)
+[jihad-gpu] job 6: queued 0.3 ms on the compositor loop, composed in 39.5 ms
+[jihad-gpu] maybePaint +38 ms (2 jobs, needsPaint 1, dirtyPending 0, seq 5/5)
+[jihad-gpu] job done 47 ms after its start, 1 pending polls, read 141..1224 and 0..0, changed 141..1224, fixed 0..0, nb=1, 1 still in flight
+[jihad-gpu] glFinish 0.0 ms, glReadPixels 1224 rows 32.2 ms, CPU swizzle+flip 7.2 ms
+[jihad-gpu] read: shift 0 rows 0.0 ms, band 0..1224 39.5 ms, band 0..0 0.0 ms
+[jihad-gpu] compositor thread: compose 0.6 ms, handoff 39.6 ms (frame 6, rows 0..1224 and 0..0 of 1224, x 0..768, 0 columns, 0 kept, changed 0..0 x 0..0, fixed 0..0, started=1)
+[jihad-gpu] job 7: queued 37.9 ms on the compositor loop, composed in 40.3 ms
+[jihad-gpu] async scroll: want 0.0,0.0, painted at 0.0,0.0, zoom 1.0000 x 1.0000 -> translation -0.0,-0.0 on layer 0x33724400 (parent 0x33723c00, id 2)
+[jihad-gpu] async scroll: want 0.0,0.0, painted at 0.0,0.0, zoom 1.0000 x 1.0000 -> translation -0.0,-0.0 on layer 0x33727000 (parent 0x33723c00, id 2)
+[jihad-gpu] glFinish 0.0 ms, glReadPixels 1224 rows 22.8 ms, CPU swizzle+flip 10.9 ms
+[jihad-gpu] read: shift 0 rows 6.6 ms, band 0..1224 33.8 ms, band 0..0 0.0 ms
+[jihad-gpu] compositor thread: compose 0.9 ms, handoff 40.5 ms (frame 7, rows 0..1224 and 0..0 of 1224, x 0..768, 0 columns, 0 kept, changed 0..1224 x 0..768, fixed 0..0, tree changed, started=1)
+[jihad-gpu] job 8: queued 74.1 ms on the compositor loop, composed in 41.5 ms
+[jihad-gpu] async scroll: want 0.0,0.0, painted at 0.0,0.0, zoom 1.0000 x 1.0000 -> translation -0.0,-0.0 on layer 0x33724400 (parent 0x33723c00, id 2)
+[jihad-gpu] async scroll: want 0.0,0.0, painted at 0.0,0.0, zoom 1.0000 x 1.0000 -> translation -0.0,-0.0 on layer 0x33727000 (parent 0x33723c00, id 2)
+[jihad-gpu] glFinish 0.0 ms, glReadPixels 1224 rows 22.1 ms, CPU swizzle+flip 6.8 ms
+[jihad-gpu] read: shift 0 rows 0.0 ms, band 0..1224 29.1 ms, band 0..0 0.0 ms
+[jihad-gpu] compositor thread: compose 3.8 ms, handoff 29.2 ms (frame 8, rows 0..1224 and 0..0 of 1224, x 0..768, 0 columns, 0 kept, changed 0..0 x 0..0, fixed 0..0, started=1)
+[jihad-gpu] job 9: queued 94.3 ms on the compositor loop, composed in 33.0 ms
+[jihad-gpu] verify slot 0 (y -141, shift 0, bands 141..1083 0..0): 0 rows differ in 0 runs:; 0 rows wrong:; 0 rows structurally wrong:
+[jihad-bs] painted shmid=0x1d67000b bytes=1 (768x1224 top=-141 band=0 left=0) mZoom=0.7837 contentZoom=1.0000 ms=187 rows new=0 copied=0
+[jihad-gpu] publish: 140 ms from the frame's arrival to the message, msgPainted 0 ms
+[jihad-gpu] job done 188 ms after its start, 0 pending polls, read 0..1224 and 0..0, changed 0..1224, fixed 0..0, nb=0, 0 still in flight
+[jihad-gpu] verify slot 1 (y -141, shift 0, bands 141..1224 0..0): 0 rows differ in 0 runs:; 0 rows wrong:; 0 rows structurally wrong:
+[jihad-bs] painted shmid=0x1d67800c bytes=0 (768x1224 top=-141 band=0 left=0) mZoom=0.7837 contentZoom=0.7837 ms=279 rows new=0 copied=0
+[jihad-gpu] tick: loop gap 26 ms before it, pump 14 ms, paint 244 ms
+[jihad-gpu] maybePaint +245 ms (0 jobs, needsPaint 1, dirtyPending 0, seq 6/5)
+[jihad-gpu] compositor scroll off (the pan settled, the engine moved there) at 0,0
+[jihad-gpu] maybePaint +33 ms (0 jobs, needsPaint 1, dirtyPending 0, seq 6/6)
+[jihad-gpu] tick: loop gap 1 ms before it, pump 33 ms, paint 0 ms
+[jihad-bs] js-console (no source):0:0 compat: 192.168.1.245: CSSStyleSheet.replace, reportError, Intl.ListFormat, Element.checkVisibility, AbortSignal.any, URLSearchParams.size, Array.fromAsync, inert, popover, Blob.text/arrayBuffer, Response.json, Promise.try, Set methods, iterator helpers, ReadableStream iteration, crypto.randomUUID, scheduler.postTask, requestVideoFrameCallback, canvas.roundRect
+[jihad-gpu] maybePaint +9 ms (0 jobs, needsPaint 1, dirtyPending 0, seq 6/6)
+[jihad-gpu] tick: loop gap 0 ms before it, pump 8 ms, paint 1 ms
+[jihad-gpu] maybePaint +4 ms (0 jobs, needsPaint 1, dirtyPending 0, seq 6/6)
+[jihad-gpu] maybePaint +17 ms (0 jobs, needsPaint 1, dirtyPending 0, seq 6/6)
+[jihad-gpu] tick: loop gap 5 ms before it, pump 11 ms, paint 1 ms
+[jihad-gpu] maybePaint +5 ms (0 jobs, needsPaint 1, dirtyPending 0, seq 6/6)
+[jihad-gpu] maybePaint +15 ms (0 jobs, needsPaint 1, dirtyPending 0, seq 6/6)
+[jihad-gpu] tick: loop gap 4 ms before it, pump 11 ms, paint 0 ms
+[jihad-bs] state top f=0x10001 doc=0 win=0 net=0 START status=0x0
+[jihad-bs] state top f=0x10010 doc=0 win=0 net=0 STOP status=0x0
+[jihad-widget] create type=3 popup=0 hint=0 parent=0x38e8d800 bounds=0,0 980x1202
+[jihad-bs] state top f=0x10001 doc=0 win=0 net=0 START status=0x0
+[jihad-gpu] maybePaint +28 ms (0 jobs, needsPaint 1, dirtyPending 0, seq 6/6)
+[jihad-gpu] slot 1 read whole: valid=0 x 0/0 y -141/-141 zoom 0.7837/0.7837 w 768/768 h 1224/1224 fixed 0..0
+[jihad-gpu] frame 5: layers 0.3 ms
+[jihad-gpu] activity: docshell active, pres shell active, document visible, frame requests full rate, painted-pres-shell 0, window foreground
+[jihad-gpu] tick: loop gap 0 ms before it, pump 28 ms, paint 0 ms
+[jihad-gpu] diff first: changed 141..1083, shift 0 (none), fixed 0..0 -> 1224 rows, the whole path
+[jihad-bs] layout viewport back to the card 768x942 (a new document)
+[jihad-gpu] maybePaint +20 ms (1 jobs, needsPaint 1, dirtyPending 0, seq 7/7)
+[jihad-gpu] frame 6: layers 0.3 ms
+[jihad-gpu] tick: loop gap 0 ms before it, pump 20 ms, paint 1 ms
+[jihad-gpu] maybePaint +7 ms (2 jobs, needsPaint 1, dirtyPending 0, seq 7/7)
+[jihad-gpu] tick: loop gap 0 ms before it, pump 6 ms, paint 0 ms
+[jihad-gpu] glFinish 0.0 ms, glReadPixels 1224 rows 25.2 ms, CPU swizzle+flip 6.8 ms
+[jihad-gpu] read: shift 0 rows 0.0 ms, band 0..1224 32.2 ms, band 0..0 0.0 ms
+[jihad-gpu] compositor thread: compose 0.3 ms, handoff 32.2 ms (frame 9, rows 0..1224 and 0..0 of 1224, x 0..768, 0 columns, 0 kept, changed 141..1083 x 0..768, fixed 0..0, tree changed, started=1)
+[jihad-gpu] job 10: queued 0.0 ms on the compositor loop, composed in 32.8 ms
+[jihad-gpu] diff first: changed 141..1083, shift 0 (none), fixed 0..0 -> 942 rows, the whole path
+[jihad-gpu] glFinish 0.0 ms, glReadPixels 942 rows 19.3 ms, CPU swizzle+flip 5.4 ms
+[jihad-gpu] read: shift 0 rows 9.1 ms, band 141..1083 24.9 ms, band 0..0 0.0 ms
+[jihad-gpu] compositor thread: compose 0.3 ms, handoff 34.0 ms (frame 10, rows 141..1083 and 0..0 of 1224, x 0..768, 0 columns, 0 kept, changed 141..1083 x 0..768, fixed 0..0, tree changed, started=1)
+[jihad-gpu] job 11: queued 12.7 ms on the compositor loop, composed in 34.5 ms
+[jihad-gpu] glFinish 0.0 ms, glReadPixels 1224 rows 21.1 ms, CPU swizzle+flip 9.5 ms
+[jihad-gpu] read: shift 0 rows 0.0 ms, band 0..1224 30.8 ms, band 0..0 0.0 ms
+[jihad-gpu] compositor thread: compose 0.3 ms, handoff 30.9 ms (frame 11, rows 0..1224 and 0..0 of 1224, x 0..768, 0 columns, 0 kept, changed 0..0 x 0..0, fixed 0..0, started=1)
+[jihad-gpu] job 12: queued 47.3 ms on the compositor loop, composed in 31.3 ms
+[jihad-bs] emitGeometry contentSize=768x942 win=768x942 mZoom=0.7837
+[jihad-bs] metaViewport -> card: initial=1.0000 min=0.1000 max=4.0000 768x942 userScalable=1
+[jihad-gpu] maybePaint +272 ms (2 jobs, needsPaint 1, dirtyPending 0, seq 8/8)
+[jihad-gpu] tick: loop gap 2 ms before it, pump 270 ms, paint 0 ms
+[jihad-bs]   tick period ms min=6 avg=99 max=450 | work avg=110 max=449 (pump avg=81 paint avg=29) | n=18
+[jihad-bs] state top f=0x10010 doc=0 win=0 net=0 STOP status=0x0
+[jihad-gpu] maybePaint +6 ms (2 jobs, needsPaint 1, dirtyPending 0, seq 8/8)
+[jihad-gpu] tick: loop gap 0 ms before it, pump 6 ms, paint 0 ms
+[jihad-bs] js-console (no source):0:0 compat: 192.168.1.245: CSSStyleSheet.replace, reportError, Intl.ListFormat, Element.checkVisibility, AbortSignal.any, URLSearchParams.size, Array.fromAsync, inert, popover, Blob.text/arrayBuffer, Response.json, Promise.try, Set methods, iterator helpers, ReadableStream iteration, crypto.randomUUID, scheduler.postTask, requestVideoFrameCallback, canvas.roundRect
+[jihad-gpu] maybePaint +10 ms (2 jobs, needsPaint 1, dirtyPending 0, seq 8/8)
+[jihad-gpu] tick: loop gap 0 ms before it, pump 10 ms, paint 0 ms
+[jihad-bs] setZoomAndScroll zoom=1.0000 (was 0.7837) scroll=0,0
+[jihad-gpu] maybePaint +6 ms (2 jobs, needsPaint 1, dirtyPending 0, seq 8/8)
+[jihad-bs] first paint released — repainting the whole page
+[jihad-bs] paint pipeline: wanted=18 deferred=0 done=5 in 2058ms (2.4 fps)
+[jihad-bs]   partial=0 (full: nodmg=12 force=0 slot=2 geom=0 small=0) ticks=18 dirty=4 | frame gap ms min=97 avg=296 max=614
+[jihad-bs]   gap hist ms <16=0 16-23=0 24-31=0 32-39=0 40-55=0 56+=4
+[jihad-gpu] overscan: 141 card rows each side, the clip widened 142 CSS px each way (code 0)
+[jihad-gpu] job done 327 ms after its start, 2 pending polls, read 0..1224 and 0..0, changed 141..1083, fixed 0..0, nb=0, 1 still in flight
+[jihad-bs] painted shmid=0x1d67800c bytes=0 (768x1224 top=-141 band=0 left=0) mZoom=1.0000 contentZoom=0.7837 ms=328 rows new=0 copied=0
+[jihad-gpu] tick: loop gap 1 ms before it, pump 5 ms, paint 7 ms
+[jihad-gpu] canvas layer: a shared surface (zero copy)
+[jihad-gpu] maybePaint +105 ms (1 jobs, needsPaint 1, dirtyPending 0, seq 8/8)
+[jihad-gpu] texture pool: 0 taken from the pool, 1 new (0 converted, 0.0 ms each), 0 kept, 0 deleted (pool full), 0 in the pool
+[jihad-gpu] tick: loop gap 0 ms before it, pump 98 ms, paint 0 ms
+[jihad-gpu] texture conversion: framebuffer status 0x8cd5
+[jihad-gpu] upload call 256x256 format 0x80e1 type 0x1401 init 1: 0.5 ms
+[jihad-gpu] texture source update: make current 0.0 ms, texture created 2.5 ms, upload 0.7 ms (all 3.2)
+[jihad-gpu] texture pool: 0 taken from the pool, 2 new (1 converted, 2.2 ms each), 0 kept, 0 deleted (pool full), 0 in the pool
+[jihad-gpu] upload call 256x256 format 0x80e1 type 0x1401 init 1: 0.7 ms
+[jihad-gpu] texture source update: make current 0.0 ms, texture created 0.8 ms, upload 0.9 ms (all 1.7)
+[jihad-gpu] texture pool: 0 taken from the pool, 3 new (2 converted, 1.5 ms each), 0 kept, 0 deleted (pool full), 0 in the pool
+[jihad-gpu] upload call 256x256 format 0x80e1 type 0x1401 init 1: 0.8 ms
+[jihad-gpu] texture source update: make current 0.0 ms, texture created 0.8 ms, upload 0.9 ms (all 1.7)
+[jihad-gpu] texture pool: 0 taken from the pool, 4 new (3 converted, 1.2 ms each), 0 kept, 0 deleted (pool full), 0 in the pool
+[jihad-gpu] upload call 256x256 format 0x80e1 type 0x1401 init 1: 0.7 ms
+[jihad-gpu] texture source update: make current 0.0 ms, texture created 0.8 ms, upload 0.9 ms (all 1.7)
+[jihad-gpu] upload call 256x256 format 0x80e1 type 0x1401 init 1: 0.8 ms
+[jihad-gpu] texture source update: make current 0.0 ms, texture created 0.7 ms, upload 0.9 ms (all 1.7)
+[jihad-gpu] upload call 256x256 format 0x80e1 type 0x1401 init 1: 0.8 ms
+[jihad-gpu] texture source update: make current 0.0 ms, texture created 0.8 ms, upload 0.9 ms (all 1.8)
+[jihad-gpu] upload call 256x256 format 0x80e1 type 0x1401 init 1: 0.8 ms
+[jihad-gpu] texture source update: make current 0.0 ms, texture created 0.8 ms, upload 1.0 ms (all 1.8)
+[jihad-gpu] upload call 256x256 format 0x80e1 type 0x1401 init 1: 0.8 ms
+[jihad-gpu] texture source update: make current 0.0 ms, texture created 0.8 ms, upload 0.9 ms (all 1.7)
+[jihad-gpu] upload call 256x256 format 0x80e1 type 0x1401 init 1: 0.8 ms
+[jihad-gpu] texture source update: make current 0.0 ms, texture created 0.8 ms, upload 0.9 ms (all 1.7)
+[jihad-gpu] upload call 256x256 format 0x80e1 type 0x1401 init 1: 0.8 ms
+[jihad-gpu] texture source update: make current 0.0 ms, texture created 0.7 ms, upload 0.9 ms (all 1.7)
+[jihad-gpu] upload call 256x256 format 0x80e1 type 0x1401 init 1: 0.8 ms
+[jihad-gpu] texture source update: make current 0.0 ms, texture created 0.8 ms, upload 1.0 ms (all 1.7)
+[jihad-gpu] upload call 256x256 format 0x80e1 type 0x1401 init 1: 0.7 ms
+[jihad-gpu] texture source update: make current 0.0 ms, texture created 0.7 ms, upload 0.8 ms (all 1.6)
+[jihad-gpu] maybePaint +24 ms (1 jobs, needsPaint 1, dirtyPending 0, seq 9/9)
+[jihad-gpu] jobs drained: 1 in flight, every slot's record dropped
+[jihad-gpu] frame 7: layers 0.1 ms
+[jihad-gpu] tick: loop gap 1 ms before it, pump 22 ms, paint 1 ms
+[jihad-bs] state top f=0x10010 doc=0 win=0 net=0 STOP status=0x0
+[jihad-bs] state top f=0x20010 doc=1 win=0 net=0 STOP status=0x0
+[jihad-bs] state top f=0xc0010 doc=0 win=1 net=1 STOP status=0x0
+[jihad-bs] load done uri=http://192.168.1.245:8077/jihad-webgl-cube.html?size=480&ticker=1&stop=4
+[jihad-bs] loaderr failed=0 code=0x0 certErr=0 chost= ccode=0x0
+[jihad-bs] titleAndUrl title=[webgl: context made (Mozilla)] uri=http://192.168.1.245:8077/jihad-webgl-cube.html?size=480&ticker=1&stop=4 back=0 fwd=0
+[jihad-gpu] displayport: scroll port 768x942 CSS px, shown 768x942 at +0,0, resolution 1.0000, margins 942 up and down, 0 sideways (CSS px)
+[jihad-gpu] maybePaint +17 ms (1 jobs, needsPaint 1, dirtyPending 0, seq 9/9)
+[jihad-gpu] tick: loop gap 0 ms before it, pump 17 ms, paint 0 ms
+[jihad-gpu] maybePaint +61 ms (1 jobs, needsPaint 1, dirtyPending 0, seq 9/9)
+[jihad-gpu] tick: loop gap 1 ms before it, pump 60 ms, paint 1 ms
+[jihad-gpu] upload call 256x256 format 0x80e1 type 0x1401 init 0: 1.0 ms
+[jihad-gpu] upload call 224x256 format 0x80e1 type 0x1401 init 0: 1.4 ms
+[jihad-gpu] upload call 256x224 format 0x80e1 type 0x1401 init 0: 1.2 ms
+[jihad-gpu] upload call 224x224 format 0x80e1 type 0x1401 init 0: 0.9 ms
+[jihad-gpu] texture source update: make current 0.0 ms, texture created 0.2 ms, upload 5.3 ms (all 5.5)
+[jihad-gpu] maybePaint +20 ms (1 jobs, needsPaint 1, dirtyPending 0, seq 9/9)
+[jihad-gpu] tick: loop gap 0 ms before it, pump 19 ms, paint 0 ms
+[jihad-gpu] maybePaint +1 ms (1 jobs, needsPaint 1, dirtyPending 0, seq 9/9)
+[jihad-gpu] maybePaint +8 ms (1 jobs, needsPaint 1, dirtyPending 0, seq 9/9)
+[jihad-gpu] maybePaint +9 ms (1 jobs, needsPaint 1, dirtyPending 0, seq 9/9)
+[jihad-gpu] maybePaint +8 ms (1 jobs, needsPaint 1, dirtyPending 0, seq 9/9)
+[jihad-gpu] maybePaint +24 ms (1 jobs, needsPaint 1, dirtyPending 0, seq 9/9)
+[jihad-gpu] frame 8: layers 0.1 ms
+[jihad-gpu] tick: loop gap 9 ms before it, pump 15 ms, paint 0 ms
+[jihad-gpu] maybePaint +1 ms (2 jobs, needsPaint 1, dirtyPending 0, seq 9/9)
+[jihad-gpu] maybePaint +8 ms (2 jobs, needsPaint 1, dirtyPending 0, seq 9/9)
+[jihad-gpu] maybePaint +37 ms (2 jobs, needsPaint 1, dirtyPending 0, seq 9/9)
+[jihad-gpu] tick: loop gap 12 ms before it, pump 25 ms, paint 0 ms
+[jihad-gpu] maybePaint +5 ms (2 jobs, needsPaint 1, dirtyPending 0, seq 9/9)
+[jihad-gpu] maybePaint +3 ms (2 jobs, needsPaint 1, dirtyPending 0, seq 9/9)
+[jihad-gpu] compositor thread: compose 147.1 ms, handoff 64.8 ms (frame 12, rows 0..1224 and 0..0 of 1224, x 0..768, 0 columns, 0 kept, changed 0..1224 x 0..768, fixed 0..0, tree changed, started=1)
+[jihad-gpu] job 13: queued 0.1 ms on the compositor loop, composed in 212.0 ms
+[jihad-gpu] async scroll: want 0.0,0.0, painted at 0.0,0.0, zoom 1.0000 x 1.0000 -> translation -0.0,-0.0 on layer 0x33726400 (parent 0x33723c00, id 3)
+[jihad-gpu] async scroll: want 0.0,0.0, painted at 0.0,0.0, zoom 1.0000 x 1.0000 -> translation -0.0,-0.0 on layer 0x33724400 (parent 0x33723c00, id 3)
+[jihad-gpu] diff first: changed 141..1083, shift 0 (none), fixed 0..0 -> 1224 rows, the whole path
+[jihad-gpu] async scroll: want 0.0,0.0, painted at 0.0,0.0, zoom 1.0000 x 1.0000 -> translation -0.0,-0.0 on layer 0x33726400 (parent 0x33723c00, id 3)
+[jihad-gpu] async scroll: want 0.0,0.0, painted at 0.0,0.0, zoom 1.0000 x 1.0000 -> translation -0.0,-0.0 on layer 0x33724400 (parent 0x33723c00, id 3)
+[jihad-gpu] frame dumped: /tmp/frame.raw (768x1224 BGRA, first with content)
+[jihad-gpu] compositor thread: compose 68.4 ms, handoff 58.1 ms (frame 13, rows 0..1224 and 0..0 of 1224, x 0..768, 0 columns, 0 kept, changed 141..1083 x 0..768, fixed 0..0, tree changed, started=1)
+[jihad-gpu] job 14: queued 68.7 ms on the compositor loop, composed in 127.3 ms
+[jihad-gpu] seq frame 1: content rows 144..1080 cols 0..764 (of 768x1224) px(100,100)=ffffff px(700,900)=222222
+[jihad-gpu] job done 351 ms after its start, 12 pending polls, read 0..1224 and 0..0, changed 0..1224, fixed 0..0, nb=724992, 1 still in flight
+[jihad-bs] painted shmid=0x1d67800c bytes=724992 (768x1224 top=-141 band=0 left=0) mZoom=1.0000 contentZoom=1.0000 ms=351 rows new=0 copied=0
+[jihad-gpu] publish: 0 ms from the frame's arrival to the message, msgPainted 2 ms
+[jihad-gpu] zoom 1.0000: the displayport and the anchor follow, 487 ms after the zoom (the first frame at the new zoom is out)
+[jihad-gpu] displayport: scroll port 768x942 CSS px, shown 768x942 at +0,0, resolution 1.0000, margins 942 up and down, 0 sideways (CSS px)
+[jihad-gpu] scroll anchor moved to 0,0 (wanted 0,0)
+[jihad-gpu] displayport: scroll port 768x942 CSS px, shown 768x942 at +0,0, resolution 1.0000, margins 942 up and down, 0 sideways (CSS px)
+[jihad-gpu] displayport shifted to 0,0 from the engine's 0,0
+[jihad-gpu] seq frame 2: content rows 144..1080 cols 0..764 (of 768x1224) px(100,100)=ffffff px(700,900)=222222
+[jihad-gpu] job done 253 ms after its start, 0 pending polls, read 0..1224 and 0..0, changed 141..1083, fixed 0..0, nb=724992, 0 still in flight
+[jihad-bs] painted shmid=0x1d68000d bytes=724992 (768x1224 top=-141 band=0 left=0) mZoom=1.0000 contentZoom=1.0000 ms=254 rows new=0 copied=0
+[jihad-gpu] publish: 1 ms from the frame's arrival to the message, msgPainted 15 ms
+[jihad-gpu] tick: loop gap 3 ms before it, pump 0 ms, paint 215 ms
+[jihad-gpu] compositor scroll off (the pan settled, the engine moved there) at 0,0
+[jihad-gpu] maybePaint +235 ms (0 jobs, needsPaint 1, dirtyPending 0, seq 14/14)
+[jihad-gpu] tick: loop gap 0 ms before it, pump 19 ms, paint 0 ms
+[jihad-gpu] maybePaint +0 ms (0 jobs, needsPaint 1, dirtyPending 0, seq 14/14)
+[jihad-gpu] slot 0 from the newest slot 2 (y -141 -> -141, shift 0); bands 0..0 and 0..0
+[jihad-gpu] frame 9: layers 0.1 ms
+[jihad-gpu] diff first: changed 141..1083, shift 0 (none), fixed 0..0 -> 942 rows, the whole path
+[jihad-gpu] maybePaint +11 ms (1 jobs, needsPaint 1, dirtyPending 0, seq 14/14)
+[jihad-gpu] frame 10: layers 0.1 ms
+[jihad-gpu] compositor thread: compose 1.4 ms, handoff 50.0 ms (frame 14, rows 141..1083 and 0..0 of 1224, x 0..768, 0 columns, 0 kept, changed 141..1083 x 0..768, fixed 0..0, tree changed, started=1)
+[jihad-gpu] job 15: queued 0.1 ms on the compositor loop, composed in 52.8 ms
+[jihad-gpu] maybePaint +45 ms (2 jobs, needsPaint 1, dirtyPending 0, seq 14/14)
+[jihad-gpu] compositor thread: compose 7.1 ms, handoff 53.6 ms (frame 15, rows 0..1224 and 0..0 of 1224, x 0..768, 0 columns, 0 kept, changed 0..0 x 0..0, fixed 0..0, started=1)
+[jihad-gpu] job 16: queued 51.6 ms on the compositor loop, composed in 60.9 ms
+[jihad-gpu] seq frame 3: content rows 144..1080 cols 0..764 (of 768x1224) px(100,100)=ffffff px(700,900)=222222
+[jihad-gpu] job done 134 ms after its start, 1 pending polls, read 141..1083 and 0..0, changed 141..1083, fixed 0..0, nb=724992, 1 still in flight
+[jihad-gpu] compositor thread: compose 1.5 ms, handoff 58.6 ms (frame 16, rows 141..1083 and 0..0 of 1224, x 0..768, 0 columns, 0 kept, changed 0..0 x 0..0, fixed 0..0, started=1)
+[jihad-gpu] job 17: queued 111.7 ms on the compositor loop, composed in 60.3 ms
+[jihad-gpu] seq frame 4: content rows 144..1080 cols 0..764 (of 768x1224) px(100,100)=ffffff px(700,900)=222222
+[jihad-gpu] compositor thread: compose 1.4 ms, handoff 57.5 ms (frame 17, rows 0..1224 and 0..0 of 1224, x 0..768, 0 columns, 0 kept, changed 0..0 x 0..0, fixed 0..0, started=1)
+[jihad-gpu] job 18: queued 154.4 ms on the compositor loop, composed in 59.0 ms
+[jihad-gpu] upload call 256x256 format 0x80e1 type 0x1401 init 0: 5.8 ms
+[jihad-gpu] texture source update: make current 0.0 ms, texture kept 0.0 ms, upload 5.9 ms (all 5.9)
+[jihad-gpu] verify slot 0 (y -141, shift 0, bands 0..0 0..0): 0 rows differ in 0 runs:; 0 rows wrong:; 0 rows structurally wrong:
+[jihad-bs] painted shmid=0x1d67000b bytes=724992 (768x1224 top=-141 band=0 left=0) mZoom=1.0000 contentZoom=1.0000 ms=318 rows new=0 copied=0
+[jihad-gpu] publish: 184 ms from the frame's arrival to the message, msgPainted 2 ms
+[jihad-gpu] seq frame 5: content rows 144..1080 cols 0..764 (of 768x1224) px(100,100)=ffffff px(700,900)=222222
+[jihad-gpu] job done 371 ms after its start, 0 pending polls, read 141..1083 and 0..0, changed 0..0, fixed 0..0, nb=724992, 0 still in flight
+[jihad-gpu] seq frame 6: content rows 144..1080 cols 0..764 (of 768x1224) px(100,100)=ffffff px(700,900)=222222
+[jihad-gpu] verify slot 1 (y -141, shift 0, bands 141..1083 0..0): 0 rows differ in 0 runs:; 0 rows wrong:; 0 rows structurally wrong:
+[jihad-bs] painted shmid=0x1d67800c bytes=724992 (768x1224 top=-141 band=0 left=0) mZoom=1.0000 contentZoom=1.0000 ms=510 rows new=0 copied=0
+[jihad-gpu] publish: 139 ms from the frame's arrival to the message, msgPainted 1 ms
+[jihad-gpu] tick: loop gap 30 ms before it, pump 27 ms, paint 466 ms
+[jihad-gpu] maybePaint +473 ms (0 jobs, needsPaint 1, dirtyPending 0, seq 16/16)
+[jihad-gpu] tick: loop gap 1 ms before it, pump 6 ms, paint 0 ms
+[jihad-gpu] maybePaint +0 ms (0 jobs, needsPaint 1, dirtyPending 0, seq 16/16)
+[jihad-gpu] frame 11: layers 0.1 ms
+[jihad-gpu] diff first: changed 189..671, shift 0 (none), fixed 0..0 -> 942 rows, the whole path
+[jihad-gpu] maybePaint +3 ms (1 jobs, needsPaint 1, dirtyPending 0, seq 16/16)
+[jihad-gpu] frame 12: layers 0.1 ms
+[jihad-gpu] compositor thread: compose 1.5 ms, handoff 31.2 ms (frame 18, rows 141..1083 and 0..0 of 1224, x 0..768, 0 columns, 0 kept, changed 189..671 x 144..761, fixed 0..0, tree changed, started=1)
+[jihad-gpu] job 19: queued 0.1 ms on the compositor loop, composed in 33.1 ms
+[jihad-gpu] maybePaint +32 ms (2 jobs, needsPaint 1, dirtyPending 0, seq 16/16)
+[jihad-gpu] seq frame 7: content rows 144..1080 cols 0..764 (of 768x1224) px(100,100)=ffffff px(700,900)=222222
+[jihad-gpu] job done 161 ms after its start, 1 pending polls, read 141..1083 and 0..0, changed 189..671, fixed 0..0, nb=724992, 1 still in flight
+[jihad-gpu] compositor thread: compose 10.2 ms, handoff 151.2 ms (frame 19, rows 0..1224 and 0..0 of 1224, x 0..768, 0 columns, 0 kept, changed 0..0 x 0..0, fixed 0..0, started=1)
+[jihad-gpu] job 20: queued 31.0 ms on the compositor loop, composed in 161.5 ms
+[jihad-gpu] seq frame 8: content rows 144..1080 cols 0..764 (of 768x1224) px(100,100)=ffffff px(700,900)=222222
+[jihad-gpu] job 21: queued 190.6 ms on the compositor loop, composed in 132.5 ms
+[jihad-gpu] verify slot 2 (y -141, shift 0, bands 141..1083 0..0): 0 rows differ in 0 runs:; 0 rows wrong:; 0 rows structurally wrong:
+[jihad-bs] painted shmid=0x1d68000d bytes=724992 (768x1224 top=-141 band=0 left=0) mZoom=1.0000 contentZoom=1.0000 ms=367 rows new=0 copied=0
+[jihad-gpu] publish: 206 ms from the frame's arrival to the message, msgPainted 0 ms
+[jihad-gpu] seq frame 9: content rows 144..1080 cols 0..764 (of 768x1224) px(100,100)=ffffff px(700,900)=222222
+[jihad-gpu] job done 408 ms after its start, 0 pending polls, read 189..671 and 0..0, changed 0..0, fixed 0..0, nb=724992, 0 still in flight
+[jihad-gpu] job 22: queued 323.3 ms on the compositor loop, composed in 105.2 ms
+[jihad-gpu] upload call 256x256 format 0x80e1 type 0x1401 init 0: 1.4 ms
+[jihad-gpu] texture source update: make current 0.0 ms, texture kept 0.0 ms, upload 1.6 ms (all 1.6)
+[jihad-gpu] seq frame 10: content rows 144..1080 cols 0..764 (of 768x1224) px(100,100)=ffffff px(700,900)=222222
+[jihad-gpu] verify slot 0 (y -141, shift 0, bands 189..671 0..0): 0 rows differ in 0 runs:; 0 rows wrong:; 0 rows structurally wrong:
+[jihad-bs] painted shmid=0x1d67000b bytes=724992 (768x1224 top=-141 band=0 left=0) mZoom=1.0000 contentZoom=1.0000 ms=587 rows new=0 copied=0
+[jihad-gpu] publish: 180 ms from the frame's arrival to the message, msgPainted 0 ms
+[jihad-gpu] tick: loop gap 5 ms before it, pump 30 ms, paint 558 ms
+[jihad-gpu] maybePaint +568 ms (0 jobs, needsPaint 1, dirtyPending 0, seq 18/18)
+[jihad-gpu] tick: loop gap 0 ms before it, pump 10 ms, paint 0 ms
+[jihad-gpu] maybePaint +0 ms (0 jobs, needsPaint 1, dirtyPending 0, seq 18/18)
+[jihad-gpu] frame 13: layers 0.2 ms
+[jihad-gpu] diff first: changed 189..671, shift 0 (none), fixed 0..0 -> 482 rows, the band pass
+[jihad-gpu] band pbuffer 768x512 made (the tall one)
+[jihad-gpu] maybePaint +8 ms (1 jobs, needsPaint 1, dirtyPending 0, seq 18/18)
+[jihad-gpu] band target 768x512: FBO 9 on its own pbuffer (the tall one)
+[jihad-gpu] BeginFrame 23: render bounds 0,0 768x512, target 768x512, clip 0,0 768x482, widget 768x512, window fbo 9
+[jihad-gpu] maybePaint +16 ms (1 jobs, needsPaint 1, dirtyPending 0, seq 18/18)
+[jihad-gpu] tick: loop gap 9 ms before it, pump 15 ms, paint 1 ms
+[jihad-bs] js-console (no source):0:0 blocker: memory after install: resident 143.2 MB, heap-allocated 55.3 MB, JS GC heap 10.0 MB, JS temporary peak 1.3 MB, JS compartments 56+7
+[jihad-gpu] maybePaint +63 ms (1 jobs, needsPaint 1, dirtyPending 0, seq 18/18)
+[jihad-gpu] tick: loop gap 0 ms before it, pump 62 ms, paint 0 ms
+[jihad-gpu] compositor thread: band frame 0: rows 189..671 and 0..0, x 0..768, 0 columns in 0 chunks (0 rows), 0 kept, entry 0.4 ms, surface in 20.5 ms, compose 2.0 ms, shift 0.0 ms, read 71.5 ms, surface out 0.0 ms, all 94.5 ms, ok=1
+[jihad-gpu] job 23: queued 0.1 ms on the compositor loop, composed in 94.7 ms
+[jihad-gpu] BeginFrame 24: render bounds 0,0 768x1224, target 768x1224, clip 0,0 768x1224, widget 768x1224, window fbo 1
+[jihad-gpu] maybePaint +46 ms (1 jobs, needsPaint 1, dirtyPending 0, seq 18/18)
+[jihad-gpu] seq frame 11: content rows 144..1080 cols 0..764 (of 768x1224) px(100,100)=ffffff px(700,900)=222222
+[jihad-gpu] job done 162 ms after its start, 3 pending polls, read 189..671 and 0..0, changed 189..671, fixed 0..0, nb=724992, 0 still in flight
+[jihad-gpu] job 24: queued 87.9 ms on the compositor loop, composed in 102.1 ms
+[jihad-gpu] upload call 256x256 format 0x80e1 type 0x1401 init 0: 1.7 ms
+[jihad-gpu] texture source update: make current 0.0 ms, texture kept 0.0 ms, upload 1.9 ms (all 2.0)
+[jihad-gpu] seq frame 12: content rows 144..1080 cols 0..764 (of 768x1224) px(100,100)=ffffff px(700,900)=222222
+[jihad-gpu] verify slot 1 (y -141, shift 0, bands 189..671 0..0): 17 rows differ in 1 runs: 653..670; 0 rows wrong:; 0 rows structurally wrong:
+[jihad-bs] painted shmid=0x1d67800c bytes=724992 (768x1224 top=-141 band=0 left=0) mZoom=1.0000 contentZoom=1.0000 ms=330 rows new=0 copied=0
+[jihad-gpu] publish: 168 ms from the frame's arrival to the message, msgPainted 0 ms
+[jihad-gpu] tick: loop gap 7 ms before it, pump 39 ms, paint 205 ms
+[jihad-bs]   tick period ms min=4 avg=80 max=588 | work avg=74 max=588 (pump avg=18 paint avg=56) | n=26
+[jihad-bs] emitGeometry contentSize=1049x942 win=768x942 mZoom=1.0000
+[jihad-gpu] maybePaint +261 ms (0 jobs, needsPaint 1, dirtyPending 0, seq 20/20)
+[jihad-bs] paint pipeline: wanted=30 deferred=3 done=8 in 2092ms (3.8 fps)
+[jihad-bs]   partial=0 (full: nodmg=29 force=0 slot=0 geom=0 small=0) ticks=30 dirty=0 | frame gap ms min=51 avg=308 max=473
+[jihad-bs]   gap hist ms <16=0 16-23=0 24-31=0 32-39=0 40-55=1 56+=7
+[jihad-gpu] frame 14: layers 0.2 ms
+[jihad-gpu] tick: loop gap 0 ms before it, pump 56 ms, paint 1 ms
+[jihad-gpu] upload call 256x256 format 0x80e1 type 0x1401 init 0: 6.1 ms
+[jihad-gpu] texture source update: make current 0.0 ms, texture kept 0.0 ms, upload 6.4 ms (all 6.4)
+[jihad-gpu] upload call 256x256 format 0x80e1 type 0x1401 init 0: 3.1 ms
+[jihad-gpu] texture source update: make current 0.0 ms, texture kept 0.0 ms, upload 3.3 ms (all 3.4)
+[jihad-bs] title changed by the page: [webgl fps=6.3 shaders=ok texture=ok framebuffer=ok readPixels=ok maxtex=4096 ext=14 missing=ANGLE_instanced_arrays,WEBGL]
+[jihad-gpu] maybePaint +18 ms (1 jobs, needsPaint 1, dirtyPending 0, seq 20/20)
+[jihad-gpu] tick: loop gap 0 ms before it, pump 17 ms, paint 0 ms
+[jihad-gpu] maybePaint +0 ms (1 jobs, needsPaint 1, dirtyPending 0, seq 20/20)
+[jihad-bs] setZoomAndScroll zoom=0.7321 (was 1.0000) scroll=0,0
+[jihad-gpu] upload call 256x256 format 0x80e1 type 0x1401 init 0: 15.8 ms
+[jihad-gpu] upload steps: make current 0.0 ms, bind 0.0 ms, the rest 20.5 ms (all 20.5)
+[jihad-gpu] texture source update: make current 0.0 ms, texture kept 0.0 ms, upload 20.6 ms (all 20.7)
+[jihad-gpu] maybePaint +23 ms (1 jobs, needsPaint 1, dirtyPending 0, seq 20/20)
+[jihad-gpu] overscan: 141 card rows each side, the clip widened 194 CSS px each way (code 0)
+[jihad-gpu] tick: loop gap 1 ms before it, pump 22 ms, paint 0 ms
+[jihad-gpu] upload call 256x256 format 0x80e1 type 0x1401 init 0: 27.8 ms
+[jihad-gpu] upload steps: make current 0.0 ms, bind 0.0 ms, the rest 28.0 ms (all 28.1)
+[jihad-gpu] texture source update: make current 0.0 ms, texture kept 0.0 ms, upload 28.1 ms (all 28.1)
+[jihad-gpu] upload call 256x256 format 0x80e1 type 0x1401 init 0: 8.2 ms
+[jihad-gpu] upload steps: make current 0.0 ms, bind 0.0 ms, the rest 8.5 ms (all 8.5)
+[jihad-gpu] texture source update: make current 0.0 ms, texture kept 0.0 ms, upload 8.6 ms (all 8.6)
+[jihad-gpu] upload call 256x256 format 0x80e1 type 0x1401 init 0: 5.1 ms
+[jihad-gpu] texture source update: make current 0.0 ms, texture kept 0.0 ms, upload 5.4 ms (all 5.4)
+[jihad-gpu] upload call 256x256 format 0x80e1 type 0x1401 init 1: 0.6 ms
+[jihad-gpu] texture source update: make current 0.0 ms, texture created 15.6 ms, upload 1.0 ms (all 16.6)
+[jihad-gpu] upload call 256x256 format 0x80e1 type 0x1401 init 1: 0.8 ms
+[jihad-gpu] texture source update: make current 0.1 ms, texture created 15.3 ms, upload 0.9 ms (all 16.3)
+[jihad-gpu] upload call 256x256 format 0x80e1 type 0x1401 init 1: 0.8 ms
+[jihad-gpu] texture source update: make current 0.0 ms, texture created 1.5 ms, upload 1.0 ms (all 2.5)
+[jihad-gpu] upload call 256x256 format 0x80e1 type 0x1401 init 1: 0.9 ms
+[jihad-gpu] texture source update: make current 0.0 ms, texture created 0.8 ms, upload 1.0 ms (all 1.9)
+[jihad-gpu] diff first: changed 149..747, shift 0 (none), fixed 0..0 -> 598 rows, the whole path
+[jihad-gpu] job 25: queued 108.7 ms on the compositor loop, composed in 28.0 ms
+[jihad-gpu] job 26: queued 136.9 ms on the compositor loop, composed in 41.7 ms
+[jihad-gpu] upload call 256x256 format 0x80e1 type 0x1401 init 0: 0.7 ms
+[jihad-gpu] texture source update: make current 0.0 ms, texture kept 0.0 ms, upload 0.9 ms (all 0.9)
+[jihad-gpu] maybePaint +140 ms (1 jobs, needsPaint 1, dirtyPending 0, seq 23/23)
+[jihad-gpu] job done 182 ms after its start, 3 pending polls, read 149..747 and 0..0, changed 149..747, fixed 0..0, nb=724992, 0 still in flight
+[jihad-gpu] verify slot 2 (y -141, shift 0, bands 189..671 0..0): 0 rows differ in 0 runs:; 0 rows wrong:; 0 rows structurally wrong:
+[jihad-bs] painted shmid=0x1d68000d bytes=724992 (768x1224 top=-141 band=0 left=0) mZoom=0.7321 contentZoom=1.0000 ms=276 rows new=0 copied=0
+[jihad-gpu] publish: 94 ms from the frame's arrival to the message, msgPainted 2 ms
+[jihad-gpu] slot 0 read whole: valid=1 x 0/0 y -141/-141 zoom 0.7321/1.0000 w 768/768 h 1224/1224 fixed 0..0
+[jihad-gpu] frame 15: layers 0.1 ms
+[jihad-gpu] async scroll: want 0.0,0.0, painted at 0.0,0.0, zoom 1.0000 x 1.0000 -> translation -0.0,-0.0 on layer 0x33726400 (parent 0x33723c00, id 3)
+[jihad-gpu] async scroll: want 0.0,0.0, painted at 0.0,0.0, zoom 1.0000 x 1.0000 -> translation -0.0,-0.0 on layer 0x33724400 (parent 0x33723c00, id 3)
+[jihad-gpu] tick: loop gap 0 ms before it, pump 138 ms, paint 107 ms
+[jihad-gpu] maybePaint +108 ms (1 jobs, needsPaint 1, dirtyPending 0, seq 23/23)
+[jihad-gpu] frame 16: layers 0.2 ms
+[jihad-gpu] maybePaint +40 ms (2 jobs, needsPaint 1, dirtyPending 0, seq 23/23)
+[jihad-gpu] tick: loop gap 2 ms before it, pump 39 ms, paint 0 ms
+[jihad-gpu] job 27: queued 0.1 ms on the compositor loop, composed in 55.9 ms
+[jihad-gpu] maybePaint +7 ms (2 jobs, needsPaint 1, dirtyPending 0, seq 23/23)
+[jihad-gpu] job done 49 ms after its start, 2 pending polls, read 0..1224 and 0..0, changed 0..1224, fixed 0..0, nb=390784, 1 still in flight
+[jihad-bs] painted shmid=0x1d67000b bytes=390784 (768x1224 top=-141 band=0 left=0) mZoom=0.7321 contentZoom=0.7321 ms=51 rows new=0 copied=0
+[jihad-gpu] publish: 3 ms from the frame's arrival to the message, msgPainted 4 ms
+[jihad-gpu] zoom 0.7321: the displayport and the anchor follow, 325 ms after the zoom (the first frame at the new zoom is out)
+[jihad-gpu] displayport: scroll port 768x942 CSS px, shown 1049x1287 at +0,0, resolution 1.0000, margins 1287 up and down, 0 sideways (CSS px)
+[jihad-gpu] scroll anchor moved to 0,0 (wanted 0,0)
+[jihad-gpu] displayport: scroll port 768x942 CSS px, shown 1049x1287 at +0,0, resolution 1.0000, margins 1287 up and down, 0 sideways (CSS px)
+[jihad-gpu] displayport shifted to 0,0 from the engine's 0,0
+[jihad-gpu] second frame not started: no slot 0, adapter holds it 1, no buffer 0, too small 0, start failed 0
+[jihad-gpu] tick: loop gap 0 ms before it, pump 7 ms, paint 26 ms
+[jihad-gpu] maybePaint +30 ms (1 jobs, needsPaint 1, dirtyPending 0, seq 23/23)
+[jihad-gpu] frame 17: layers 14.1 ms
+[jihad-gpu] compositor scroll off (the pan settled, the engine moved there) at 0,0
+[jihad-gpu] maybePaint +24 ms (2 jobs, needsPaint 1, dirtyPending 0, seq 23/23)
+[jihad-gpu] tick: loop gap 19 ms before it, pump 9 ms, paint 0 ms
+[jihad-gpu] maybePaint +1 ms (2 jobs, needsPaint 1, dirtyPending 0, seq 23/23)
+[jihad-gpu] maybePaint +0 ms (2 jobs, needsPaint 1, dirtyPending 0, seq 23/23)
+[jihad-gpu] job 28: queued 45.2 ms on the compositor loop, composed in 58.3 ms
+[jihad-gpu] maybePaint +3 ms (2 jobs, needsPaint 1, dirtyPending 0, seq 25/25)
+[jihad-gpu] job done 106 ms after its start, 5 pending polls, read 0..1224 and 0..0, changed 0..0, fixed 0..0, nb=390784, 1 still in flight
+[jihad-bs] painted shmid=0x1d67800c bytes=390784 (768x1224 top=-141 band=0 left=0) mZoom=0.7321 contentZoom=0.7321 ms=107 rows new=0 copied=0
+[jihad-gpu] upload call 256x256 format 0x80e1 type 0x1401 init 1: 0.8 ms
+[jihad-gpu] texture source update: make current 0.0 ms, texture created 2.2 ms, upload 1.0 ms (all 3.2)
+[jihad-gpu] publish: 1 ms from the frame's arrival to the message, msgPainted 1 ms
+[jihad-gpu] maybePaint +5 ms (1 jobs, needsPaint 1, dirtyPending 0, seq 25/25)
+[jihad-gpu] upload call 256x256 format 0x80e1 type 0x1401 init 1: 0.8 ms
+[jihad-gpu] texture source update: make current 0.0 ms, texture created 0.9 ms, upload 0.9 ms (all 1.8)
+[jihad-gpu] maybePaint +1 ms (1 jobs, needsPaint 1, dirtyPending 0, seq 25/25)
+[jihad-gpu] upload call 256x256 format 0x80e1 type 0x1401 init 1: 1.0 ms
+[jihad-gpu] texture source update: make current 0.0 ms, texture created 0.8 ms, upload 1.1 ms (all 1.9)
+[jihad-gpu] upload call 256x256 format 0x80e1 type 0x1401 init 1: 0.8 ms
+[jihad-gpu] diff first: changed 0..1224, shift 0 (none), fixed 0..0 -> 1224 rows, the whole path
+[jihad-gpu] async scroll: layer 0x33724400 has 1 metadata (first: root content 1, id 3, offset 0.0,0.0), card scroll valid 1 want 0.0,0.0, controller 0
+[jihad-gpu] maybePaint +9 ms (1 jobs, needsPaint 1, dirtyPending 0, seq 26/26)
+[jihad-gpu] maybePaint +11 ms (1 jobs, needsPaint 1, dirtyPending 0, seq 26/26)
+[jihad-gpu] maybePaint +36 ms (1 jobs, needsPaint 1, dirtyPending 0, seq 26/26)
+[jihad-gpu] frame 18: layers 0.1 ms
+[jihad-gpu] tick: loop gap 6 ms before it, pump 30 ms, paint 0 ms
+[jihad-gpu] maybePaint +0 ms (2 jobs, needsPaint 1, dirtyPending 0, seq 26/26)
+[jihad-gpu] maybePaint +7 ms (2 jobs, needsPaint 1, dirtyPending 0, seq 26/26)
+[jihad-gpu] job done 84 ms after its start, 7 pending polls, read 0..1224 and 0..0, changed 0..1224, fixed 0..0, nb=528384, 1 still in flight
+[jihad-gpu] job 29: queued 23.6 ms on the compositor loop, composed in 61.0 ms
+[jihad-gpu] job 30: queued 84.7 ms on the compositor loop, composed in 36.7 ms
+[jihad-gpu] upload call 256x256 format 0x80e1 type 0x1401 init 0: 0.8 ms
+[jihad-gpu] diff first: changed 141..831, shift 0 (none), fixed 0..0 -> 1224 rows, the whole path
+[jihad-gpu] verify slot 2 (y -141, shift 0, bands 0..0 0..0): 0 rows differ in 0 runs:; 0 rows wrong:; 0 rows structurally wrong:
+[jihad-bs] painted shmid=0x1d68000d bytes=528384 (768x1224 top=-141 band=0 left=0) mZoom=0.7321 contentZoom=0.7321 ms=195 rows new=0 copied=0
+[jihad-gpu] publish: 111 ms from the frame's arrival to the message, msgPainted 0 ms
+[jihad-gpu] job done 120 ms after its start, 0 pending polls, read 0..1224 and 0..0, changed 141..831, fixed 0..0, nb=528384, 0 still in flight
+[jihad-bs] painted shmid=0x1d67000b bytes=528384 (768x1224 top=-141 band=0 left=0) mZoom=0.7321 contentZoom=0.7321 ms=121 rows new=0 copied=0
+[jihad-gpu] publish: 1 ms from the frame's arrival to the message, msgPainted 0 ms
+[jihad-gpu] tick: loop gap 7 ms before it, pump 0 ms, paint 114 ms
+[jihad-gpu] maybePaint +115 ms (0 jobs, needsPaint 1, dirtyPending 0, seq 28/26)
+[jihad-gpu] frame 19: layers 0.3 ms
+[jihad-gpu] maybePaint +58 ms (1 jobs, needsPaint 1, dirtyPending 0, seq 28/28)
+[jihad-gpu] job done 56 ms after its start, 0 pending polls, read 0..1224 and 0..0, changed 0..0, fixed 0..0, nb=528384, 0 still in flight
+[jihad-bs] painted shmid=0x1d67800c bytes=528384 (768x1224 top=-141 band=0 left=0) mZoom=0.7321 contentZoom=0.7321 ms=59 rows new=0 copied=0
+[jihad-gpu] publish: 3 ms from the frame's arrival to the message, msgPainted 0 ms
+[jihad-gpu] tick: loop gap 5 ms before it, pump 54 ms, paint 5 ms
+[jihad-gpu] maybePaint +18 ms (0 jobs, needsPaint 1, dirtyPending 0, seq 30/29)
+[jihad-gpu] tick: loop gap 0 ms before it, pump 13 ms, paint 0 ms
+[jihad-gpu] maybePaint +1 ms (0 jobs, needsPaint 1, dirtyPending 0, seq 30/29)
+[jihad-gpu] maybePaint +0 ms (1 jobs, needsPaint 1, dirtyPending 0, seq 30/29)
+[jihad-gpu] maybePaint +1 ms (1 jobs, needsPaint 1, dirtyPending 1, seq 30/30)
+[jihad-gpu] maybePaint +1 ms (1 jobs, needsPaint 1, dirtyPending 1, seq 30/30)
+[jihad-gpu] maybePaint +7 ms (1 jobs, needsPaint 1, dirtyPending 0, seq 30/30)
+[jihad-gpu] maybePaint +17 ms (2 jobs, needsPaint 1, dirtyPending 0, seq 30/30)
+[jihad-gpu] tick: loop gap 8 ms before it, pump 8 ms, paint 0 ms
+[jihad-gpu] maybePaint +1 ms (2 jobs, needsPaint 1, dirtyPending 0, seq 30/30)
+[jihad-gpu] job done 39 ms after its start, 7 pending polls, read 141..831 and 0..0, changed 231..585, fixed 0..0, nb=528384, 1 still in flight
+[jihad-gpu] verify slot 2 (y -141, shift 0, bands 141..831 0..0): 0 rows differ in 0 runs:; 0 rows wrong:; 0 rows structurally wrong:
+[jihad-bs] painted shmid=0x1d68000d bytes=528384 (768x1224 top=-141 band=0 left=0) mZoom=0.7321 contentZoom=0.7321 ms=155 rows new=0 copied=0
+[jihad-gpu] publish: 116 ms from the frame's arrival to the message, msgPainted 0 ms
+[jihad-gpu] job done 147 ms after its start, 0 pending polls, read 231..585 and 0..0, changed 0..0, fixed 0..0, nb=528384, 0 still in flight
+[jihad-gpu] verify slot 0 (y -141, shift 0, bands 231..585 0..0): 0 rows differ in 0 runs:; 0 rows wrong:; 0 rows structurally wrong:
+[jihad-bs] painted shmid=0x1d67000b bytes=528384 (768x1224 top=-141 band=0 left=0) mZoom=0.7321 contentZoom=0.7321 ms=226 rows new=0 copied=0
+[jihad-gpu] publish: 79 ms from the frame's arrival to the message, msgPainted 0 ms
+[jihad-gpu] tick: loop gap 1 ms before it, pump 0 ms, paint 200 ms
+[jihad-gpu] tick: loop gap 0 ms before it, pump 5 ms, paint 1 ms
+[jihad-gpu] BeginFrame 37: render bounds 0,0 768x512, target 768x512, clip 0,0 768x354, widget 768x512, window fbo 9
+[jihad-gpu] column read x 104..464, rows 231..585 (target rows from 0 of 512): glReadPixels 9.5 ms, swizzle+copy 2.8 ms
+[jihad-gpu] compositor thread: band frame 1: rows 231..585 and 0..0, x 104..464, 0 columns in 0 chunks (0 rows), 0 kept, entry 0.2 ms, surface in 1.4 ms, compose 2.1 ms, shift 0.0 ms, read 12.5 ms, surface out 0.0 ms, all 16.3 ms, ok=1
+[jihad-gpu] job done 19 ms after its start, 2 pending polls, read 231..585 and 0..0, changed 231..585, fixed 0..0, nb=528384, 0 still in flight
+[jihad-gpu] BeginFrame 38: render bounds 0,0 768x1224, target 768x1224, clip 0,0 768x1224, widget 768x1224, window fbo 1
+[jihad-gpu] upload call 256x256 format 0x80e1 type 0x1401 init 0: 0.9 ms
+[jihad-gpu] verify slot 1 (y -141, shift 0, bands 231..585 0..0): 0 rows differ in 0 runs:; 0 rows wrong:; 0 rows structurally wrong:
+[jihad-bs] painted shmid=0x1d67800c bytes=528384 (768x1224 top=-141 band=0 left=0) mZoom=0.7321 contentZoom=0.7321 ms=121 rows new=0 copied=0
+[jihad-gpu] publish: 103 ms from the frame's arrival to the message, msgPainted 0 ms
+[jihad-gpu] BeginFrame 39: render bounds 0,0 768x512, target 768x512, clip 0,0 768x354, widget 768x512, window fbo 9
+[jihad-gpu] tick: loop gap 3 ms before it, pump 14 ms, paint 108 ms
+[jihad-gpu] column read x 104..560, rows 231..585 (target rows from 0 of 512): glReadPixels 14.5 ms, swizzle+copy 5.0 ms
+[jihad-gpu] compositor thread: band frame 2: rows 231..585 and 0..0, x 104..560, 0 columns in 0 chunks (0 rows), 0 kept, entry 0.2 ms, surface in 0.5 ms, compose 2.4 ms, shift 0.0 ms, read 20.1 ms, surface out 0.0 ms, all 23.4 ms, ok=1
+[jihad-gpu] job done 31 ms after its start, 1 pending polls, read 231..585 and 0..0, changed 231..585, fixed 0..0, nb=528384, 0 still in flight
+[jihad-gpu] BeginFrame 40: render bounds 0,0 768x1224, target 768x1224, clip 0,0 768x1224, widget 768x1224, window fbo 1
+[jihad-gpu] verify slot 2 (y -141, shift 0, bands 231..585 0..0): 0 rows differ in 0 runs:; 0 rows wrong:; 0 rows structurally wrong:
+[jihad-bs] painted shmid=0x1d68000d bytes=528384 (768x1224 top=-141 band=0 left=0) mZoom=0.7321 contentZoom=0.7321 ms=136 rows new=0 copied=0
+[jihad-gpu] publish: 105 ms from the frame's arrival to the message, msgPainted 1 ms
+[jihad-gpu] tick: loop gap 1 ms before it, pump 28 ms, paint 108 ms
+[jihad-gpu] tick: loop gap 0 ms before it, pump 10 ms, paint 1 ms
+[jihad-gpu] BeginFrame 41: render bounds 0,0 768x512, target 768x512, clip 0,0 768x354, widget 768x512, window fbo 9
+[jihad-gpu] tick: loop gap 0 ms before it, pump 15 ms, paint 0 ms
+[jihad-gpu] column read x 104..560, rows 231..585 (target rows from 0 of 512): glReadPixels 9.9 ms, swizzle+copy 2.5 ms
+[jihad-gpu] compositor thread: band frame 3: rows 231..585 and 0..0, x 104..560, 0 columns in 0 chunks (0 rows), 0 kept, entry 0.3 ms, surface in 13.9 ms, compose 3.9 ms, shift 0.0 ms, read 12.6 ms, surface out 0.0 ms, all 30.7 ms, ok=1
+[jihad-gpu] job done 34 ms after its start, 4 pending polls, read 231..585 and 0..0, changed 231..585, fixed 0..0, nb=528384, 0 still in flight
+[jihad-gpu] BeginFrame 42: render bounds 0,0 768x1224, target 768x1224, clip 0,0 768x1224, widget 768x1224, window fbo 1
+[jihad-gpu] verify slot 0 (y -141, shift 0, bands 231..585 0..0): 0 rows differ in 0 runs:; 0 rows wrong:; 0 rows structurally wrong:
+[jihad-bs] painted shmid=0x1d67000b bytes=528384 (768x1224 top=-141 band=0 left=0) mZoom=0.7321 contentZoom=0.7321 ms=133 rows new=0 copied=0
+[jihad-gpu] publish: 99 ms from the frame's arrival to the message, msgPainted 0 ms
+[jihad-gpu] tick: loop gap 8 ms before it, pump 8 ms, paint 101 ms
+[jihad-gpu] tick: loop gap 0 ms before it, pump 7 ms, paint 0 ms
+[jihad-gpu] BeginFrame 43: render bounds 0,0 768x512, target 768x512, clip 0,0 768x354, widget 768x512, window fbo 9
+[jihad-gpu] column read x 104..560, rows 231..585 (target rows from 0 of 512): glReadPixels 9.5 ms, swizzle+copy 2.4 ms
+[jihad-gpu] compositor thread: band frame 4: rows 231..585 and 0..0, x 104..560, 0 columns in 0 chunks (0 rows), 0 kept, entry 2.0 ms, surface in 13.6 ms, compose 2.6 ms, shift 0.0 ms, read 12.2 ms, surface out 0.0 ms, all 30.6 ms, ok=1
+[jihad-gpu] BeginFrame 44: render bounds 0,0 768x1224, target 768x1224, clip 0,0 768x1224, widget 768x1224, window fbo 1
+[jihad-gpu] job done 40 ms after its start, 5 pending polls, read 231..585 and 0..0, changed 231..585, fixed 0..0, nb=528384, 0 still in flight
+[jihad-gpu] upload call 256x256 format 0x80e1 type 0x1401 init 0: 1.0 ms
+[jihad-gpu] verify slot 1 (y -141, shift 0, bands 231..585 0..0): 0 rows differ in 0 runs:; 0 rows wrong:; 0 rows structurally wrong:
+[jihad-bs] painted shmid=0x1d67800c bytes=528384 (768x1224 top=-141 band=0 left=0) mZoom=0.7321 contentZoom=0.7321 ms=135 rows new=0 copied=0
+[jihad-gpu] publish: 95 ms from the frame's arrival to the message, msgPainted 0 ms
+[jihad-gpu] tick: loop gap 9 ms before it, pump 10 ms, paint 97 ms
+[jihad-gpu] tick: loop gap 0 ms before it, pump 12 ms, paint 0 ms
+[jihad-gpu] BeginFrame 45: render bounds 0,0 768x512, target 768x512, clip 0,0 768x354, widget 768x512, window fbo 9
+[jihad-gpu] tick: loop gap 8 ms before it, pump 7 ms, paint 0 ms
+[jihad-gpu] column read x 104..560, rows 231..585 (target rows from 0 of 512): glReadPixels 10.4 ms, swizzle+copy 3.1 ms
+[jihad-gpu] compositor thread: band frame 5: rows 231..585 and 0..0, x 104..560, 0 columns in 0 chunks (0 rows), 0 kept, entry 0.3 ms, surface in 9.8 ms, compose 2.2 ms, shift 0.0 ms, read 14.0 ms, surface out 0.0 ms, all 26.6 ms, ok=1
+[jihad-gpu] job done 29 ms after its start, 6 pending polls, read 231..585 and 0..0, changed 231..585, fixed 0..0, nb=528384, 0 still in flight
+[jihad-gpu] BeginFrame 46: render bounds 0,0 768x1224, target 768x1224, clip 0,0 768x1224, widget 768x1224, window fbo 1
+[jihad-gpu] verify slot 2 (y -141, shift 0, bands 231..585 0..0): 0 rows differ in 0 runs:; 0 rows wrong:; 0 rows structurally wrong:
+[jihad-bs] painted shmid=0x1d68000d bytes=528384 (768x1224 top=-141 band=0 left=0) mZoom=0.7321 contentZoom=0.7321 ms=130 rows new=0 copied=0
+[jihad-gpu] publish: 101 ms from the frame's arrival to the message, msgPainted 0 ms
+[jihad-gpu] async scroll: layer 0x33724400 has 1 metadata (first: root content 1, id 3, offset 0.0,0.0), card scroll valid 0 want 0.0,0.0, controller 0
+[jihad-gpu] BeginFrame 47: render bounds 0,0 768x512, target 768x512, clip 0,0 768x354, widget 768x512, window fbo 9
+[jihad-gpu] tick: loop gap 0 ms before it, pump 0 ms, paint 105 ms
+[jihad-gpu] column read x 104..560, rows 231..585 (target rows from 0 of 512): glReadPixels 14.2 ms, swizzle+copy 2.5 ms
+[jihad-gpu] compositor thread: band frame 6: rows 231..585 and 0..0, x 104..560, 0 columns in 0 chunks (0 rows), 0 kept, entry 0.3 ms, surface in 0.4 ms, compose 2.3 ms, shift 0.0 ms, read 17.0 ms, surface out 0.0 ms, all 20.1 ms, ok=1
+[jihad-gpu] job done 33 ms after its start, 1 pending polls, read 231..585 and 0..0, changed 231..585, fixed 0..0, nb=528384, 0 still in flight
+[jihad-gpu] BeginFrame 48: render bounds 0,0 768x1224, target 768x1224, clip 0,0 768x1224, widget 768x1224, window fbo 1
+[jihad-gpu] verify slot 0 (y -141, shift 0, bands 231..585 0..0): 0 rows differ in 0 runs:; 0 rows wrong:; 0 rows structurally wrong:
+[jihad-bs] painted shmid=0x1d67000b bytes=528384 (768x1224 top=-141 band=0 left=0) mZoom=0.7321 contentZoom=0.7321 ms=143 rows new=0 copied=0
+[jihad-gpu] publish: 110 ms from the frame's arrival to the message, msgPainted 1 ms
+[jihad-gpu] tick: loop gap 1 ms before it, pump 31 ms, paint 112 ms
+[jihad-gpu] tick: loop gap 1 ms before it, pump 20 ms, paint 1 ms
+[jihad-gpu] BeginFrame 49: render bounds 0,0 768x512, target 768x512, clip 0,0 768x354, widget 768x512, window fbo 9
+[jihad-gpu] column read x 104..560, rows 231..585 (target rows from 0 of 512): glReadPixels 10.1 ms, swizzle+copy 2.2 ms
+[jihad-gpu] compositor thread: band frame 7: rows 231..585 and 0..0, x 104..560, 0 columns in 0 chunks (0 rows), 0 kept, entry 0.2 ms, surface in 1.4 ms, compose 2.1 ms, shift 0.0 ms, read 12.4 ms, surface out 0.0 ms, all 16.1 ms, ok=1
+[jihad-gpu] BeginFrame 50: render bounds 0,0 768x1224, target 768x1224, clip 0,0 768x1224, widget 768x1224, window fbo 1
+[jihad-gpu] job done 47 ms after its start, 4 pending polls, read 231..585 and 0..0, changed 231..585, fixed 0..0, nb=528384, 0 still in flight
+[jihad-gpu] job 50: queued 16.2 ms on the compositor loop, composed in 44.0 ms
+[jihad-gpu] upload call 256x256 format 0x80e1 type 0x1401 init 0: 0.8 ms
+[jihad-gpu] verify slot 1 (y -141, shift 0, bands 231..585 0..0): 0 rows differ in 0 runs:; 0 rows wrong:; 0 rows structurally wrong:
+[jihad-bs] painted shmid=0x1d67800c bytes=528384 (768x1224 top=-141 band=0 left=0) mZoom=0.7321 contentZoom=0.7321 ms=122 rows new=0 copied=0
+[jihad-gpu] publish: 75 ms from the frame's arrival to the message, msgPainted 0 ms
+[jihad-gpu] tick: loop gap 10 ms before it, pump 27 ms, paint 76 ms
+[jihad-bs] emitGeometry contentSize=768x942 win=768x942 mZoom=0.7321
+[jihad-gpu] tick: loop gap 0 ms before it, pump 13 ms, paint 0 ms
+[jihad-bs] setZoomAndScroll zoom=1.0000 (was 0.7321) scroll=0,0
+[jihad-gpu] upload call 256x256 format 0x80e1 type 0x1401 init 0: 1.7 ms
+[jihad-gpu] upload call 256x256 format 0x80e1 type 0x1401 init 0: 2.0 ms
+[jihad-bs] title changed by the page: [webgl: stopped]
+[jihad-gpu] overscan: 141 card rows each side, the clip widened 142 CSS px each way (code 0)
+[jihad-gpu] tick: loop gap 1 ms before it, pump 9 ms, paint 1 ms
+[jihad-gpu] job done 106 ms after its start, 5 pending polls, read 141..831 and 0..0, changed 141..831, fixed 0..0, nb=390784, 0 still in flight
+[jihad-gpu] verify slot 2 (y -141, shift 0, bands 231..585 0..0): 0 rows differ in 0 runs:; 0 rows wrong:; 0 rows structurally wrong:
+[jihad-bs] painted shmid=0x1d68000d bytes=390784 (768x1224 top=-141 band=0 left=0) mZoom=1.0000 contentZoom=0.7321 ms=174 rows new=0 copied=0
+[jihad-gpu] publish: 68 ms from the frame's arrival to the message, msgPainted 1 ms
+[jihad-gpu] slot 0 read whole: valid=1 x 0/0 y -141/-141 zoom 1.0000/0.7321 w 768/768 h 1224/1224 fixed 0..0
+[jihad-gpu] tick: loop gap 8 ms before it, pump 77 ms, paint 74 ms
+[jihad-bs]   tick period ms min=0 avg=37 max=247 | work avg=33 max=245 (pump avg=11 paint avg=21) | n=59
+[jihad-bs] paint pipeline: wanted=74 deferred=1 done=16 in 2072ms (7.7 fps)
+[jihad-bs]   partial=0 (full: nodmg=79 force=0 slot=2 geom=0 small=0) ticks=74 dirty=2 | frame gap ms min=2 avg=132 max=333
+[jihad-bs]   gap hist ms <16=1 16-23=0 24-31=0 32-39=0 40-55=0 56+=15
+[jihad-gpu] tick: loop gap 19 ms before it, pump 1 ms, paint 2 ms
+[jihad-gpu] job done 49 ms after its start, 6 pending polls, read 0..1224 and 0..0, changed 0..1224, fixed 0..0, nb=724992, 1 still in flight
+[jihad-bs] painted shmid=0x1d67000b bytes=724992 (768x1224 top=-141 band=0 left=0) mZoom=1.0000 contentZoom=1.0000 ms=49 rows new=0 copied=0
+[jihad-gpu] publish: 2 ms from the frame's arrival to the message, msgPainted 0 ms
+[jihad-gpu] zoom 1.0000: the displayport and the anchor follow, 230 ms after the zoom (the first frame at the new zoom is out)
+[jihad-gpu] displayport: scroll port 768x942 CSS px, shown 768x942 at +0,0, resolution 1.0000, margins 942 up and down, 0 sideways (CSS px)
+[jihad-gpu] scroll anchor moved to 0,0 (wanted 0,0)
+[jihad-gpu] displayport: scroll port 768x942 CSS px, shown 768x942 at +0,0, resolution 1.0000, margins 942 up and down, 0 sideways (CSS px)
+[jihad-gpu] displayport shifted to 0,0 from the engine's 0,0
+[jihad-bs] painted shmid=0x1d67800c bytes=724992 (768x1224 top=-141 band=0 left=0) mZoom=1.0000 contentZoom=1.0000 ms=108 rows new=0 copied=0
+[jihad-gpu] publish: 1 ms from the frame's arrival to the message, msgPainted 0 ms
+[jihad-gpu] async scroll: want 0.0,0.0, painted at 0.0,0.0, zoom 1.0000 x 1.0000 -> translation -0.0,-0.0 on layer 0x33726400 (parent 0x33723c00, id 3)
+[jihad-gpu] compositor scroll off (the pan settled, the engine moved there) at 0,0
+[jihad-gpu] read: shift 0 rows 0.0 ms, band 0..1224 39.7 ms, band 0..0 0.0 ms
+[jihad-gpu] verify slot 2 (y -141, shift 0, bands 0..0 0..0): 0 rows differ in 0 runs:; 0 rows wrong:; 0 rows structurally wrong:
+[jihad-bs] painted shmid=0x1d68000d bytes=724992 (768x1224 top=-141 band=0 left=0) mZoom=1.0000 contentZoom=1.0000 ms=215 rows new=0 copied=0
+[jihad-gpu] publish: 142 ms from the frame's arrival to the message, msgPainted 0 ms
+[jihad-gpu] verify slot 0 (y -141, shift 0, bands 0..0 0..0): 0 rows differ in 0 runs:; 0 rows wrong:; 0 rows structurally wrong:
+[jihad-bs] painted shmid=0x1d67000b bytes=724992 (768x1224 top=-141 band=0 left=0) mZoom=1.0000 contentZoom=1.0000 ms=232 rows new=0 copied=0
+[jihad-gpu] publish: 86 ms from the frame's arrival to the message, msgPainted 0 ms
+[jihad-gpu] tick: loop gap 2 ms before it, pump 0 ms, paint 230 ms
+[jihad-gpu] compositor thread: compose 0.3 ms, handoff 0.1 ms (frame 50, rows 0..0 and 0..0 of 1224, x 0..768, 0 columns, 0 kept, changed 0..0 x 0..0, fixed 0..0, tree changed, started=1)
+[jihad-gpu] verify slot 1 (y -141, shift 0, bands 0..0 0..0): 0 rows differ in 0 runs:; 0 rows wrong:; 0 rows structurally wrong:
+[jihad-bs] painted shmid=0x1d67800c bytes=724992 (768x1224 top=-141 band=0 left=0) mZoom=1.0000 contentZoom=1.0000 ms=130 rows new=0 copied=0
+[jihad-gpu] publish: 128 ms from the frame's arrival to the message, msgPainted 1 ms
+[jihad-gpu] tick: loop gap 0 ms before it, pump 1 ms, paint 130 ms
+[jihad-gpu] tick: loop gap 100 ms before it, pump 0 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 101 ms before it, pump 0 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 100 ms before it, pump 0 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 101 ms before it, pump 0 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 100 ms before it, pump 1 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 100 ms before it, pump 0 ms, paint 1 ms
+[jihad-gpu] tick: loop gap 100 ms before it, pump 0 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 100 ms before it, pump 1 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 100 ms before it, pump 0 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 101 ms before it, pump 0 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 100 ms before it, pump 0 ms, paint 1 ms
+[jihad-bs]   tick period ms min=0 avg=26 max=230 | work avg=4 max=230 (pump avg=0 paint avg=4) | n=81
+[jihad-gpu] tick: loop gap 100 ms before it, pump 0 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 102 ms before it, pump 0 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 101 ms before it, pump 28 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 72 ms before it, pump 2 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 99 ms before it, pump 41 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 59 ms before it, pump 1 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 100 ms before it, pump 17 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 83 ms before it, pump 0 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 101 ms before it, pump 52 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 55 ms before it, pump 2 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 98 ms before it, pump 24 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 78 ms before it, pump 0 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 100 ms before it, pump 3 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 98 ms before it, pump 3 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 98 ms before it, pump 0 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 101 ms before it, pump 0 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 100 ms before it, pump 1 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 101 ms before it, pump 0 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 100 ms before it, pump 1 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 100 ms before it, pump 1 ms, paint 0 ms
+[jihad-bs]   tick period ms min=100 avg=101 max=107 | work avg=8 max=52 (pump avg=8 paint avg=0) | n=20
+[jihad-gpu] tick: loop gap 99 ms before it, pump 0 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 101 ms before it, pump 0 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 100 ms before it, pump 64 ms, paint 1 ms
+[jihad-gpu] tick: loop gap 36 ms before it, pump 0 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 100 ms before it, pump 1 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 100 ms before it, pump 0 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 101 ms before it, pump 0 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 101 ms before it, pump 0 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 100 ms before it, pump 1 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 100 ms before it, pump 1 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 101 ms before it, pump 0 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 100 ms before it, pump 0 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 101 ms before it, pump 2 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 99 ms before it, pump 0 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 101 ms before it, pump 0 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 100 ms before it, pump 31 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 70 ms before it, pump 0 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 101 ms before it, pump 0 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 100 ms before it, pump 1 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 100 ms before it, pump 0 ms, paint 0 ms
+[jihad-bs]   tick period ms min=100 avg=100 max=102 | work avg=5 max=70 (pump avg=5 paint avg=0) | n=20
+[jihad-gpu] tick: loop gap 101 ms before it, pump 0 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 100 ms before it, pump 0 ms, paint 0 ms
+[jihad-gpu] tick: loop gap 101 ms before it, pump 0 ms, paint 0 ms
+[jihad-bs] clock hold: released
+[jihad-bs]   tick period ms min=100 avg=101 max=102 | work avg=6 max=59 (pump avg=6 paint avg=0) | n=20
+[jihad-bs]   tick period ms min=100 avg=100 max=101 | work avg=4 max=45 (pump avg=4 paint avg=0) | n=21
+[jihad-bs]   tick period ms min=100 avg=100 max=102 | work avg=3 max=52 (pump avg=3 paint avg=0) | n=20
+=== LOG END
@@ -571,6 +571,9 @@ BrowserAdapter::BrowserAdapter(NPP instance, GMainContext *ctxt, int16_t argc, c
    , m_zoomYInterval(0)
    , m_zoomLevelInterval(0)
    , m_headerHeight(0)
+    , mJihadPaintScrollX(-1)
+    , mJihadPaintScrollY(-1)
+    , mJihadPaintHeader(-1)
    , mScrollbarOpacity(0)
    , mScrollbarFadeSource(0)
    , m_bufferLock(0)
@@ -4214,6 +4217,16 @@ void BrowserAdapter::msgPainted(int32_t sharedBufferKey)
        return;
    }

+    // T-527: the frame shown until now (its number and geometry), for a partial redraw below
+    uint32_t shownSeq = 0;
+    BrowserOffscreenInfo shown;
+    bool haveShown = false;
+    if (mOffscreenCurrent && mOffscreenCurrent->header()) {
+        shownSeq = mOffscreenCurrent->frameSeq();
+        shown = *mOffscreenCurrent->header();
+        haveShown = true;
+    }
+
    if (mOffscreenCurrent) {
        assert(mOffscreenCurrent->ipcBuffer()->key() != sharedBufferKey);
        asyncCmdReturnBuffer(mOffscreenCurrent->key());
@@ -4227,7 +4240,42 @@ void BrowserAdapter::msgPainted(int32_t sharedBufferKey)
      fprintf(lf, "[msgp] key=%d recv=%d frozen=%d rW=%d rH=%d win[%ux%u] -> invalidate\n",
        sharedBufferKey, receivedBuffer, mFrozen?1:0, pi?pi->renderedWidth:-1, pi?pi->renderedHeight:-1,
        mWindow.width, mWindow.height); }
-    invalidate();
+    // T-527: when the daemon says what differs from the frame on screen (JihadFrameWindow.h) and the
+    // frames are of one geometry at the card's own zoom, only that rect is redrawn: the card's blit of
+    // a whole frame for a changed strip (a WebGL canvas, an animation, typing) was a fifth of
+    // LunaSysMgr's time on the 480 px WebGL cube (r304). Anything else redraws the whole.
+    {
+        BrowserOffscreenInfo* ni = mOffscreenCurrent->header();
+        uint32_t base = 0;
+        int dl = 0, dt = 0, dr = 0, db = 0;
+        const bool partial = haveShown && ni && shownSeq != 0 &&
+            mOffscreenCurrent->dirtyRect(&base, &dl, &dt, &dr, &db) && base == shownSeq &&
+            ni->renderedX == shown.renderedX && ni->renderedY == shown.renderedY &&
+            ni->renderedWidth == shown.renderedWidth && ni->renderedHeight == shown.renderedHeight &&
+            ni->contentZoom == shown.contentZoom && fabs(ni->contentZoom - mZoomLevel) < 1e-6 &&
+            mScrollPos.x == mJihadPaintScrollX && mScrollPos.y == mJihadPaintScrollY && m_headerHeight == mJihadPaintHeader;
+        mJihadPaintScrollX = mScrollPos.x; mJihadPaintScrollY = mScrollPos.y; mJihadPaintHeader = m_headerHeight;
+        if (FILE* lf = jihadPaintLog())
+            fprintf(lf, "[msgp-dirty] seq=%u shown=%u base=%u partial=%d rect[%d,%d %d,%d]\n",
+                    mOffscreenCurrent->frameSeq(), shownSeq, base, (int)partial, dl, dt, dr, db);
+        if (partial) {
+            // buffer px to the plugin's (the blit's mapping at a scale of 1)
+            const int pageScrollY = mScrollPos.y - m_headerHeight;
+            int l = dl + ni->renderedX - mScrollPos.x, r = dr + ni->renderedX - mScrollPos.x;
+            int t = dt + ni->renderedY - pageScrollY, b = db + ni->renderedY - pageScrollY;
+            if (l < 0) l = 0;
+            if (t < 0) t = 0;
+            if (r > (int)mWindow.width) r = mWindow.width;
+            if (b > (int)mWindow.height) b = mWindow.height;
+            if (r > l && b > t) {
+                NPRect dirty;
+                dirty.left = l; dirty.top = t; dirty.right = r; dirty.bottom = b;
+                NPN_InvalidateRect(&dirty);
+            }
+        } else {
+            invalidate();
+        }
+    }

    if (m_bufferLock)
        sem_post(m_bufferLock);
@@ -676,6 +676,9 @@ private:
    int m_zoomYInterval;
    double m_zoomLevelInterval;
    int m_headerHeight; ///< Height (in pixels) of the header which is a space above the page we don't draw.
+    // T-527: the card's scroll and header when the shown frame was invalidated (msgPainted): a partial
+    // redraw of the next frame holds only while they are the same
+    int mJihadPaintScrollX, mJihadPaintScrollY, mJihadPaintHeader;

    void showScrollbar();
    void startFadeScrollbar();
@@ -100,6 +100,22 @@ BrowserOffscreen* BrowserOffscreen::create()
    return new BrowserOffscreen(buffer);
 }

+uint32_t BrowserOffscreen::frameSeq() const
+{
+    const JihadFrameTrailer* t = jihadFrameTrailer((unsigned char*)m_ipcBuffer->buffer(), m_ipcBuffer->size());
+    return (t && t->magic == kJihadWindowMagic) ? t->dirtySeq : 0;
+}
+
+bool BrowserOffscreen::dirtyRect(uint32_t* base, int* left, int* top, int* right, int* bottom) const
+{
+    const JihadFrameTrailer* t = jihadFrameTrailer((unsigned char*)m_ipcBuffer->buffer(), m_ipcBuffer->size());
+    if (!t || t->magic != kJihadWindowMagic || t->dirtyMagic != kJihadDirtyMagic)
+        return false;
+    *base = t->dirtyBase;
+    *left = t->dirtyLeft; *top = t->dirtyTop; *right = t->dirtyRight; *bottom = t->dirtyBottom;
+    return true;
+}
+
 BrowserOffscreen* BrowserOffscreen::attach(int key, int size)
 {
    IpcBuffer* buffer = IpcBuffer::attach(key, size);
@@ -65,6 +65,10 @@ public:
        return m_buffer + windowBytes();
    }
    int rasterSize() const;   // the pixels' bytes, without the window trailer
+    // T-527: the frame's number and, when the daemon wrote one, the rect (frame px) that differs from
+    // frame *base (JihadFrameWindow.h); false: no rect, the whole frame is new
+    uint32_t frameSeq() const;
+    bool dirtyRect(uint32_t* base, int* left, int* top, int* right, int* bottom) const;

 private:

@@ -20,16 +20,26 @@
 //   windowRows   the frame starts this many rows (of the header's renderedWidth pixels) in
 //   adapterCaps  kJihadWindowCaps: the adapter that made the segment reads windows; the daemon moves
 //                windows only then (an adapter from before reads every frame from the pixels' start)
+//   dirtySeq     T-527: this frame's number (the daemon counts its publishes)
+//   dirtyMagic   T-527: kJihadDirtyMagic when dirtyLeft..dirtyBottom (frame px, right and bottom
+//                exclusive) hold all that differs from frame dirtyBase, at the same geometry
+//                (renderedX/Y/Width/Height, contentZoom): an adapter showing frame dirtyBase may
+//                invalidate only that rect (an empty one: nothing to redraw). Anything else: the whole
+//                frame. An adapter from before never reads them; a daemon from before leaves them zero.
 struct JihadFrameTrailer {
    uint32_t magic;
    int32_t  windowRows;
    uint32_t adapterCaps;
-    uint32_t reserved[13];
+    uint32_t dirtyMagic;
+    int32_t  dirtyLeft, dirtyTop, dirtyRight, dirtyBottom;
+    uint32_t dirtySeq, dirtyBase;
+    uint32_t reserved[6];
 };

 static const size_t   kJihadTrailerBytes = 64;
 static const uint32_t kJihadWindowMagic  = 0x4e49574aU;   // "JWIN"
 static const uint32_t kJihadWindowCaps   = 0x5041434aU;   // "JCAP"
+static const uint32_t kJihadDirtyMagic   = 0x5452444aU;   // "JDRT"

 // the trailer of a segment of aSegmentBytes bytes mapped at aSegment (0 when it is too small)
 inline JihadFrameTrailer* jihadFrameTrailer(unsigned char* aSegment, size_t aSegmentBytes)
@@ -75,6 +75,7 @@ YapProxy::YapProxy(YapServer* server, int cmdSocketFd, char* msgSocketPath, char
    : m_server(server)
    , m_cmdSocketFd(cmdSocketFd)
    , m_msgSocketFd(-1)
+    , m_sendFailed(false)
    , m_msgSocketPostfix(0)
    , m_privData(0)
    , m_cmdBuffer(0)
@@ -141,7 +141,7 @@ private:
    YapServer*  m_server;
    int         m_cmdSocketFd;
    int         m_msgSocketFd;
-    bool m_sendFailed = false;
+    bool        m_sendFailed;   // T-540; set in the constructor (the PDK's gcc 4.3.3 has no member initializers)
    char*       m_msgSocketPostfix;
    void*       m_privData;
    uint8_t*    m_cmdBuffer;
@@ -377,6 +377,18 @@ bool jihadTimelineOn() {
  static const bool sOn = getenv("JIHAD_GPU_TIMELINE") != nullptr;
  return sOn;
 }
+
+// T-527 device rounds (JIHAD_GPU_TIMELINE=1): why the express lane made no frame, on the timeline when the
+// reason changes or every 25 ms while it stays (the pan's 56 ms+ gaps traced to their source)
+static void jihadXNote(const char* why) {
+  if (!jihadTimelineOn()) return;
+  static const char* sLast = nullptr;
+  static int64_t sLastMs = 0;
+  const int64_t now = jihadNowMs();
+  if (why == sLast && now - sLastMs < 25) return;
+  sLast = why; sLastMs = now;
+  fprintf(stderr, "[jihad-tl] t=%lld express idle: %s\n", (long long)now, why);
+}
 static int64_t gJihadTlLastPub = 0;
 static void jihadTimelinePublish(const char* lane, int64_t start, int y, double zoom) {
  if (!jihadTimelineOn()) return;
@@ -678,13 +690,50 @@ bool BrowserPageGoanna::windowsFor(int key) {
  return t && t->adapterCaps == kJihadWindowCaps;
 }

-void BrowserPageGoanna::publishWindow(int key, int windowRows) {
+void BrowserPageGoanna::publishWindow(int key, int windowRows, const long* dirty) {
+  const uint32_t base = mPubSeq++;   // T-527: every publish is numbered, a trailer or not
  if (JihadFrameTrailer* t = shmTrailer(key)) {
    t->windowRows = windowRows < 0 ? 0 : windowRows;
    t->magic = kJihadWindowMagic;
+    // T-527: the change since the frame before, or the whole
+    static const bool sNoDirty = getenv("JIHAD_GPU_NO_DIRTY") != nullptr;
+    t->dirtySeq = mPubSeq;
+    if (dirty && !sNoDirty) {
+      t->dirtyLeft = (int32_t)dirty[0]; t->dirtyTop = (int32_t)dirty[1];
+      t->dirtyRight = (int32_t)dirty[2]; t->dirtyBottom = (int32_t)dirty[3];
+      t->dirtyBase = base;
+      t->dirtyMagic = kJihadDirtyMagic;
+    } else {
+      t->dirtyMagic = 0;
+    }
+    if (jihadTimelineOn()) {
+      if (t->dirtyMagic) fprintf(stderr, "[jihad-tl] t=%lld trailer: frame %u, changed since %u: x %ld..%ld rows %ld..%ld\n",
+                                 (long long)jihadNowMs(), t->dirtySeq, base, dirty[0], dirty[2], dirty[1], dirty[3]);
+      else fprintf(stderr, "[jihad-tl] t=%lld trailer: frame %u, whole\n", (long long)jihadNowMs(), t->dirtySeq);
+    }
  }
 }

+void BrowserPageGoanna::pubDirtyAdd(long lo, long hi, long x0, long x1, bool xKnown, int x, int y, int w, int h, double zoom) {
+  if (x != mPubX || y != mPubY || w != mPubW || h != mPubH || zoom != mPubZoom) { mPubDirty.all = true; return; }
+  if (hi <= lo) return;   // nothing changed
+  if (!xKnown || x1 <= x0) { x0 = 0; x1 = w; }
+  PubDirty& d = mPubDirty;
+  if (d.hi <= d.lo) { d.lo = lo; d.hi = hi; d.x0 = x0; d.x1 = x1; return; }
+  d.lo = std::min(d.lo, lo); d.hi = std::max(d.hi, hi); d.x0 = std::min(d.x0, x0); d.x1 = std::max(d.x1, x1);
+}
+
+bool BrowserPageGoanna::pubDirtyTake(int x, int y, int w, int h, double zoom, bool popups, bool earlierUnknown, long out[4]) {
+  const bool partial = !mPubDirty.all && !earlierUnknown && !popups && !mPubPopups &&
+                       x == mPubX && y == mPubY && w == mPubW && h == mPubH && zoom == mPubZoom;
+  const PubDirty& d = mPubDirty;
+  out[0] = d.hi > d.lo ? std::max(0L, d.x0) : 0; out[1] = d.hi > d.lo ? std::max(0L, d.lo) : 0;
+  out[2] = d.hi > d.lo ? std::min((long)w, d.x1) : 0; out[3] = d.hi > d.lo ? std::min((long)h, d.hi) : 0;
+  mPubDirty = PubDirty(); mPubDirty.all = false;
+  mPubX = x; mPubY = y; mPubW = w; mPubH = h; mPubZoom = zoom; mPubPopups = popups;
+  return partial;
+}
+
 void BrowserPageGoanna::detachShm() {
  FrameLockGuard frameLock;   // T-515
  gpuJobDrain();   // T-502 (and the express lane's frame, T-515)
@@ -4166,6 +4215,7 @@ void BrowserPageGoanna::noteShown(int key) {

 void BrowserPageGoanna::gpuForget(const GpuJob& j) {
  mPage->ComposeForget(j.token);
+  pubDirtyAll();   // T-527: its change is not known
  if (j.vToken) { mPage->ComposeForget(j.vToken); verifyRefRelease(j.vBuf, true); }
 }

@@ -4298,13 +4348,18 @@ bool BrowserPageGoanna::expressStep(int64_t now) {
      XWant want; int64_t waitSince;
      { std::lock_guard<std::mutex> l(jihadWantLock()); want = mXWant; waitSince = mXWaitSinceMs; }
      const double Z = (want.zoom >= 0.99 && want.zoom <= 1.01) ? 1.0 : want.zoom;
-      if (want.seq && !(mXJob.x == want.x && mXJob.cardY == want.y && mXJob.zoom == Z) && !(Z * 2.0 < mXTreeRes))
-        xStart(now, Z, want, waitSince, &mXJob);
+      if (want.seq && !(mXJob.x == want.x && mXJob.cardY == want.y && mXJob.zoom == Z) && !(Z * 2.0 < mXTreeRes)) {
+        if (!xStart(now, Z, want, waitSince, &mXJob)) jihadXNote("the second frame cannot build on the first");
+      }
+    } else if (mXJob.on && !mXJob.composed && xLeads(now)) {
+      jihadXNote("its frame is being composed");
    }
    return true;
  }
-  if (!mPage || !mPage->GpuPath() || !mPage->ExpressReady() || mFrozen || !mXSnap.ok || mXSnap.popups || mXFailures >= 3)
+  if (!mPage || !mPage->GpuPath() || !mPage->ExpressReady() || mFrozen || !mXSnap.ok || mXSnap.popups || mXFailures >= 3) {
+    jihadXNote("not ready (no snapshot, popups, frozen or failed)");
    return false;
+  }
  XWant want; int64_t waitSince;
  { std::lock_guard<std::mutex> l(jihadWantLock()); want = mXWant; waitSince = mXWaitSinceMs; }
  if (!want.seq) return false;
@@ -4349,26 +4404,28 @@ bool BrowserPageGoanna::expressStep(int64_t now) {
  // second, and a frame composed in a long pump waited that long for the adoption above)
  const bool mainInFlight = sTakeover > 0 && !mGpuJobs.empty();
  if (mXLastXPubMs ? (mXPub.slot >= 0 && mXPub.cardX == want.x && mXPub.cardY == want.y && mXPub.zoom == Z)
-                   : (mXPub.slot >= 0 && mXCmdPub >= want.cmdSeq))
+                   : (mXPub.slot >= 0 && mXCmdPub >= want.cmdSeq)) {
+    jihadXNote("the card is served");
    return mainInFlight;
-  if (!waitSince) return mainInFlight;   // the main lane published since the card's last move
-  if (!mXMainPubMs) return false;      // the main lane's first frame of this geometry and document is not out
+  }
+  if (!waitSince) { jihadXNote("the main lane served the card"); return mainInFlight; }   // the main lane published since the card's last move
+  if (!mXMainPubMs) { jihadXNote("no main-lane frame of this geometry yet"); return false; }   // the main lane's first frame of this geometry and document is not out
  // the main lane's frames in flight: they serve the card while the compositor has them; once
  // composed, the express lane's frame may follow (the main lane drops them as older at its poll:
  // its thread can sit in the page's script a long while before it looks)
-  for (const GpuJob& j : mGpuJobs) if (mPage->ComposePeek(j.token) == 0) return true;
+  for (const GpuJob& j : mGpuJobs) if (mPage->ComposePeek(j.token) == 0) { jihadXNote("a main-lane frame is being composed"); return true; }
  // T-527: no frame that draws the painted tiles at under half their size: the main thread's paint at
  // the new resolution comes first (the card scales its last frame meanwhile)
-  if (Z * 2.0 < mXTreeRes) return true;
+  if (Z * 2.0 < mXTreeRes) { jihadXNote("a zoom out under half the painted resolution"); return true; }
  if (xLeads(now)) return xStart(now, Z, want, waitSince);   // the card is moving: every frame
  static const long sGrace = getenv("JIHAD_GPU_EXPRESS_MS") ? atol(getenv("JIHAD_GPU_EXPRESS_MS")) : 45;
-  if (now - waitSince < sGrace || now - mXMainPubMs < sGrace) return true;
+  if (now - waitSince < sGrace || now - mXMainPubMs < sGrace) { jihadXNote("the grace (the main lane may serve it)"); return true; }
  // only while the main thread is away in the engine (its pump, a layer paint) for a while: back
  // in its tick (or idle between ticks) it makes the frame itself, and the express lane, stepping
  // every 3 ms, would otherwise take every frame from it (its frames do the engine's half: the
  // anchor, the zoom's release)
  const int64_t away = jihadFrameLock().awaySinceMs();
-  if (!away || now - away < sAway) return true;
+  if (!away || now - away < sAway) { jihadXNote("the main thread is in its tick"); return true; }
  return xStart(now, Z, want, waitSince);
 }

@@ -4414,7 +4471,16 @@ bool BrowserPageGoanna::xStart(int64_t now, double Z, const XWant& want, int64_t
      slot = t;
    }
  }
-  if (slot < 0) return true;   // a return frees one (the hook kicks)
+  if (slot < 0) {   // a return frees one (the hook kicks)
+    if (jihadTimelineOn()) {
+      static char sWhy[160];
+      snprintf(sWhy, sizeof sWhy, "no slot: in flight %d%d%d, shown %d, main %d, base %d, active %d, main jobs %zu",
+               (int)mInFlight[0], (int)mInFlight[1], (int)mInFlight[2], slotForKey(mShownKey), mXMainSlot, base ? b : -1,
+               slotForKey(mActiveKey), mGpuJobs.size());
+      jihadXNote(sWhy);
+    }
+    return true;
+  }
  // T-504: a frame at a new zoom goes ahead of the main lane's frames at the old one that have not
  // been composed yet: they would be dropped at their poll once this one is out, and the compositor
  // thread takes jobs in order (on Wikipedia after its load the first double tap's frame waited
@@ -4587,6 +4653,7 @@ bool BrowserPageGoanna::xPoll(int64_t now) {
  }
  if (!genOk || r < 0) {
    // the buffers or the geometry changed under it, or it failed: dropped, and the one built on it
+    pubDirtyAll();   // T-527
    mXJob = XJob(); xForget(mXJob2);
    gpuSlotsLost();   // T-517: its change is in no slot's record
    if (genOk && ++mXFailures >= 3) fprintf(stderr, "[jihad-gpu] express lane off for this page: three frames failed\n");
@@ -4607,7 +4674,16 @@ bool BrowserPageGoanna::xPoll(int64_t now) {
  oi->contentZoom = mXJob.zoom;
  oi->renderedX = mXJob.x; oi->renderedY = frameY;
  oi->renderedWidth = w; oi->renderedHeight = H;
-  publishWindow(mXJob.key, mXJob.win);   // T-517: the frame's window
+  {
+    // T-517: the frame's window; T-527: what changed since the frame before (main-lane jobs posted
+    // before this one and not yet polled: not known)
+    pubDirtyAdd(cr.invLo, cr.invHi, cr.invX0, cr.invX1, cr.invXKnown, mXJob.x, frameY, w, H, mXJob.zoom);
+    bool earlier = false;
+    for (const GpuJob& gj : mGpuJobs) if ((int32_t)(gj.token - mXJob.token) < 0) earlier = true;
+    long dirty[4];
+    const bool partial = pubDirtyTake(mXJob.x, frameY, w, H, mXJob.zoom, false, earlier, dirty);
+    publishWindow(mXJob.key, mXJob.win, partial ? dirty : nullptr);
+  }
  if (mXJob.kind) {
    // T-517: the frame's time, into its kind's running average
    double& avg = mXJob.kind == 1 ? mXOwnMs : mXCopyMs;
@@ -5011,6 +5087,7 @@ void BrowserPageGoanna::paintToSharedBuffer() {
          }
          mLatestSlot = slot;
          publishWindow(mActiveKey, 0);   // T-517: the software path's frames start at the pixels' start
+          pubDirtyAll(); mPubZoom = -1.0;   // T-527: the next GPU frame is drawn whole
          mSink.msgPainted(mActiveKey); noteShown(mActiveKey);
          {
            int ps = slotForKey(mActiveKey);
@@ -5524,6 +5601,10 @@ void BrowserPageGoanna::paintToSharedBuffer() {
        // T-515: the express lane published after this job was posted: its frames are newer and its
        // composite the newest; this one is dropped (its slot's record with it)
        const bool xDropped = r >= 0 && oldest.xFrames != mXFrames;
+        // T-527: its composite's change, into the change since the last published frame
+        if (r >= 0) pubDirtyAdd(cr.invLo, cr.invHi, cr.invX0, cr.invX1, cr.invXKnown, oldest.x,
+                                cr.frameYValid ? (int)cr.frameY : oldest.y, oldest.w, oldest.h, oldest.zoom);
+        else pubDirtyAll();
        if (xDropped) {
          if (gslot >= 0) mGpuSlotValid[gslot] = false;
          // T-517: its composite happened: its change goes into the other slots' records (the
@@ -5603,6 +5684,7 @@ void BrowserPageGoanna::paintToSharedBuffer() {
          gpuT[0] = oldest.t0;
          mGpuJobX = oldest.x; mGpuJobY = frameY; mGpuJobZoom = oldest.zoom;
          mGpuJobViewRow = oldest.viewRow;   // T-507: where the card's view sits in this frame
+          mGpuPubToken = oldest.token;   // T-527: the published job (earlier-posted express jobs not yet polled)
          if (mGpuCriticalPaintMs && oldest.t0 >= mGpuCriticalPaintMs) mGpuCriticalDone = true;   // T-527
          // T-505: the frame's rows outside the page (the overscan above the page's top or below its
          // end) white, as the adapter fills what is past a frame: nothing is drawn there, and a whole
@@ -6106,7 +6188,17 @@ void BrowserPageGoanna::paintToSharedBuffer() {
  {
    // T-502 device rounds: the publish tick's time after the frame came in, around the message
    const int64_t a = jihadNowMs();
-    publishWindow(mActiveKey, pubWin);   // T-517: the frame's window (a GPU frame's; the software path's start at 0)
+    {
+      // T-517: the frame's window (a GPU frame's; the software path's start at 0); T-527: and what
+      // changed since the frame before, when every composite since is known
+      long dirty[4];
+      const bool earlier = (mXJob.on && (int32_t)(mXJob.token - mGpuPubToken) < 0) ||
+                           (mXJob2.on && (int32_t)(mXJob2.token - mGpuPubToken) < 0);
+      const bool partial = gpuFinished &&
+          pubDirtyTake(mGpuJobX, mGpuJobY, paintedW, paintedH, mGpuJobZoom, popupsDrawn > 0, earlier, dirty);
+      if (!gpuFinished) { pubDirtyAll(); mPubZoom = -1.0; }
+      publishWindow(mActiveKey, pubWin, partial ? dirty : nullptr);
+    }
    mSink.msgPainted(mActiveKey); noteShown(mActiveKey);
    const int64_t b = jihadNowMs();
    jihadTimelinePublish("main", gpuFinished ? paintT0 : 0, gpuFinished ? mGpuJobY : paintedTop, oi->contentZoom);
@@ -371,7 +371,19 @@ private:
  // (null when it cannot be had), and the window a frame is published with (written before each
  // msgPainted, 0 = the pixels' start, as every frame was before)
  JihadFrameTrailer* shmTrailer(int key);
-  void               publishWindow(int key, int windowRows);
+  // T-527: what changed on the card since the last published frame, in frame px, for the adapter's
+  // partial invalidation (the trailer's dirty words, JihadFrameWindow.h): the union of every
+  // composite's change since then, at that frame's geometry. Anything not known (a job given up,
+  // another geometry, popups, a software frame, an earlier job not yet polled) makes it the whole.
+  struct PubDirty { bool all = true; long lo = 0, hi = 0, x0 = 0, x1 = 0; };
+  PubDirty mPubDirty;
+  int mPubX = 0, mPubY = 0, mPubW = 0, mPubH = 0; double mPubZoom = -1.0; bool mPubPopups = false;
+  uint32_t mPubSeq = 0;   // the publishes so far (the trailer's dirtySeq)
+  void pubDirtyAll() { mPubDirty.all = true; }
+  void pubDirtyAdd(long lo, long hi, long x0, long x1, bool xKnown, int x, int y, int w, int h, double zoom);
+  // at a publish: the rect for the trailer (false: the whole), and the published frame's geometry kept
+  bool pubDirtyTake(int x, int y, int w, int h, double zoom, bool popups, bool earlierUnknown, long out[4]);
+  void               publishWindow(int key, int windowRows, const long* dirty = nullptr);   // T-527: dirty = l, t, r, b (frame px), else the whole
  void               detachShm();               // shmdt all cached (on thaw/teardown)
  // Double-buffer flow control (F-211): the adapter holds exactly one buffer and returns the
  // previous one (asyncCmdReturnBuffer) each time it receives a new msgPainted. A buffer that has
@@ -461,6 +473,7 @@ private:
  int                mGpuJobPolls = 0;        // ticks that found the oldest pending
  uint32_t           mGpuTrace[8] = {0,0,0,0,0,0,0,0};   // device rounds: where ticks went while a job was pending
  int64_t            mGpuDoneMs = 0;          // when the frame came in (the publish timing)
+  uint32_t           mGpuPubToken = 0;        // T-527: the job of the main lane's frame being published
  bool               mGpuRestarting = false;  // re-entered to start the next frame right after a publish
  bool               mGpuSlotValid[3] = {false, false, false};
  int                mGpuSlotX[3] = {0, 0, 0}, mGpuSlotY[3] = {0, 0, 0};
@@ -563,7 +576,7 @@ private:
  void xInvalidate() { ++mXGeomGen; mXSnap.ok = false; mXPub = XPub(); mXMainPubMs = 0; }
  bool xStart(int64_t now, double zoom, const XWant& want, int64_t waitSince, const XJob* aBase = nullptr);
  // T-517: a forgotten job may have been composed: its change is in no slot's record
-  void xForget(XJob& j) { if (j.on && mPage) { mPage->ComposeForget(j.token); gpuSlotsLost(); } j = XJob(); }
+  void xForget(XJob& j) { if (j.on && mPage) { mPage->ComposeForget(j.token); gpuSlotsLost(); pubDirtyAll(); } j = XJob(); }
  bool xLeads(int64_t now);           // the card is moving: the express lane makes the frames (the frame lock held)
  int64_t mXMainPaintMs = 0;          // the main lane's last layer paint while the express lane leads
  bool xPoll(int64_t now);
@@ -222,6 +222,14 @@ tiles at under half their size (a double tap out from 2.33). `JIHAD_GPU_ZOOM_DUM
 3.7 MB each: delete them at once). `finger-zoom.sh <name> <url> "<env>"` runs the emulated finger's double tap in
 and out and a pinch in and out on the spike daemon (`finger-zoom-device.sh`; `/tmp/finger` on the device) and
 keeps the log in `ROUND_DIR`. Engine 0062: the root's displayport base the daemon sets survives the paint.
+T-527 (R8, R3): the daemon writes the rect that changed since the frame before into the segment's trailer
+(`JihadFrameWindow.h`, the dirty words) and the adapter redraws only that; `JIHAD_GPU_NO_DIRTY=1` writes none (the
+card redraws whole frames). Engine 0063: a change that does not fit the band surface takes a taller one
+(`JIHAD_GPU_BAND_TALL=<rows>`, 512; 0 off). With `JIHAD_GPU_TIMELINE=1` the express lane says why it made no frame
+(`express idle: ...`) and every publish's trailer is logged; `tools/host/gap-trace.py <log> [ms]` lists a pan's gaps
+of 56 ms or more with what happened inside each. `pan-run.sh` leaves the spike daemon running (the upstart job
+stopped): run `gpu-spike-collect-stop.sh` before `default-check.sh`, which now reads across the daemon log's 2 MB
+rotation.

 Older device-round switches still in the code (T-502), for completeness: `JIHAD_GPU_DUMP2=<path>` (the 5th
 frame's buffer as the adapter reads it), `JIHAD_GPU_DUMP_SEQ=<path>` (the first 12 content frames, every
@@ -24,7 +24,15 @@ mark=$(novacom run file:///usr/bin/wc -- -c /var/palm/jihad/$ST/daemon.log 2>/de
 timeout 300 bash build/webos-oe/card-selftest.sh $V run "$STEPS" "$URL" 60 $D/default-$V.jpg 2>&1 | tail -n 2
 build/webos-oe/dev-sh.sh -t 60 $S/default-close.sh 2>&1 | grep 'closed card\|rendering:' | sed "s/^/$V: /"
 rm -f $S/default-close.sh
-novacom get file:///var/palm/jihad/$ST/daemon.log 2>/dev/null | tail -c +$(( ${mark:-0} + 1 )) > $D/default-$V-daemon.log
+# the daemon rotates its log in place at 2 MB (the previous kept as .old): when the log is now shorter than
+# the mark, the run's lines are the old file's from the mark on and the whole new one (T-527)
+novacom get file:///var/palm/jihad/$ST/daemon.log > $D/default-$V-daemon.now 2>/dev/null
+if [ "$(stat -c %s $D/default-$V-daemon.now)" -lt "${mark:-0}" ]; then
+  { novacom get file:///var/palm/jihad/$ST/daemon.log.old 2>/dev/null | tail -c +$(( ${mark:-0} + 1 )); cat $D/default-$V-daemon.now; } > $D/default-$V-daemon.log
+else
+  tail -c +$(( ${mark:-0} + 1 )) $D/default-$V-daemon.now > $D/default-$V-daemon.log
+fi
+rm -f $D/default-$V-daemon.now
 L=$D/default-$V-daemon.log
 echo "$V: painted $(grep -a -c 'painted shmid' $L), express frames $(grep -a 'page closed: ' $L | sed 's/.*page closed: \([0-9]*\) frames.*/\1/' | awk '{n+=$1} END {print n+0}'), zooms $(grep -a -c 'setZoomAndScroll zoom' $L), disconnects $(grep -a -c 'client disconnected' $L), faults $(grep -a -c 'FATAL SIGNAL' $L), GPU off $(grep -a -c 'GPU path is off' $L), express off $(grep -a -c 'express lane off' $L)"
 bash build/webos-oe/card-selftest.sh $V restore 2>&1 | tail -n 1
@@ -1,3 +1,3 @@
 echo "=== LOG BEGIN"; cat /var/palm/jihad/enyo/daemon-gpu.log; echo "=== LOG END"

-rm -f /tmp/frame.raw /tmp/frames.raw
+rm -f /tmp/frame.raw /tmp/frames.raw /tmp/frame.raw-* /tmp/st-pan.png /tmp/st-gpu.png   # T-527: the dumps once fetched (/tmp is 40 MB)
@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+"""gap-trace.py <daemon log> [min gap ms]: T-527 (cavekit-gpu-rendering R3). For every published frame of the pan (the
+first frame that moved to the last) whose gap
+to the previous one is at least MIN (56) ms, the timeline events (JIHAD_GPU_TIMELINE=1) between the two publishes:
+the jobs (queued / composed on the compositor loop), the page's layer transactions on the compositor thread, the
+main thread's long pumps and layer paints, the express lane's waits for the frame lock. Then a count of the gaps
+by the event that took most of them."""
+import re, sys
+from collections import Counter
+
+path = sys.argv[1]
+mingap = int(sys.argv[2]) if len(sys.argv) > 2 else 56
+ev = []   # (t_end, kind, ms, text)
+for line in open(path, encoding='latin1'):
+    m = re.search(r'\[jihad-tl\] t=(\d+) (.*)', line)
+    if not m:
+        continue
+    t, rest = int(m.group(1)), m.group(2).strip()
+    if rest.startswith('publish '):
+        g = re.search(r'publish (\w+) gap=(\d+) made=(\d+)', rest)
+        ev.append((t, 'publish', int(g.group(2)) if g else 0, rest))
+    elif rest.startswith('job '):
+        q = re.search(r'queued ([\d.]+) ms .* composed in ([\d.]+) ms', rest)
+        ev.append((t, 'job', float(q.group(1)) + float(q.group(2)) if q else 0, rest))
+    elif rest.startswith('layer transaction'):
+        q = re.search(r'thread: ([\d.]+) ms', rest)
+        ev.append((t, 'transaction', float(q.group(1)) if q else 0, rest))
+    elif rest.startswith('main '):
+        q = re.search(r'(\d+) ms', rest)
+        ev.append((t, 'main', float(q.group(1)) if q else 0, rest))
+    elif rest.startswith('express idle'):
+        ev.append((t, 'idle', 0.0, rest))
+    elif rest.startswith('express waited'):
+        q = re.search(r'waited (\d+) ms', rest)
+        ev.append((t, 'lockwait', float(q.group(1)) if q else 0, rest))
+ev.sort(key=lambda e: e[0])
+pubs = [e for e in ev if e[1] == 'publish']
+# only the pan: from the first frame at another position than the first one to the last frame that moved
+ys = [int(re.search(r' y=(-?\d+)', p[3]).group(1)) if re.search(r' y=(-?\d+)', p[3]) else 0 for p in pubs]
+moved = [k for k in range(1, len(pubs)) if ys[k] != ys[k - 1]]
+if moved:
+    pubs = pubs[moved[0]:moved[-1] + 1]
+    print('the pan: %d frames over %d ms' % (len(pubs), pubs[-1][0] - pubs[0][0]))
+cause = Counter()
+n = 0
+for p in pubs:
+    t, gap = p[0], p[2]
+    if gap < mingap or gap > 2000:
+        continue
+    n += 1
+    t0 = t - gap
+    inside = [e for e in ev if t0 <= e[0] <= t and e is not p and e[1] != 'publish']
+    # what overlaps the interval most: transactions and main-thread stalls by their duration inside it
+    best = max((e for e in inside if e[1] != 'idle'), key=lambda e: min(e[2], e[0] - t0), default=None)
+    cause[(best[1] + (' ' + best[3].split()[1] if best and best[1] == 'main' else '')) if best else 'none'] += 1
+    print('gap %4d ms ending t=%d (%s)' % (gap, t, p[3][:60]))
+    for e in inside:
+        print('    %+5d %-11s %6.1f  %s' % (e[0] - t, e[1], e[2], e[3][:150]))
+print('\n%d gaps >= %d ms; the longest event in each:' % (n, mingap))
+for k, v in cause.most_common():
+    print('  %3d  %s' % (v, k))