Enable multiple tile painting threads

Use one thread by default. Further experiments should be done with determining
the correct number of threads, and better scheduling.

Change-Id: I2a87dac7d0b652b5ab627744650d12b0b8842003

6 files changed, 85 insertions, 44 deletions

diff --git a/Source/WebCore/platform/graphics/android/rendering/RasterRenderer.cpp b/Source/WebCore/platform/graphics/android/rendering/RasterRenderer.cpp
index 8fb4d12..8ad1fc8 100644
--- a/Source/WebCore/platform/graphics/android/rendering/RasterRenderer.cpp
+++ b/Source/WebCore/platform/graphics/android/rendering/RasterRenderer.cpp
@@ -42,20 +42,11 @@
 
 namespace WebCore {
 
-SkBitmap* RasterRenderer::g_bitmap = 0;
-
 RasterRenderer::RasterRenderer() : BaseRenderer(BaseRenderer::Raster)
 {
 #ifdef DEBUG_COUNT
     ClassTracker::instance()->increment("RasterRenderer");
 #endif
-    if (!g_bitmap) {
-        g_bitmap = new SkBitmap();
-        g_bitmap->setConfig(SkBitmap::kARGB_8888_Config,
-                           TilesManager::instance()->tileWidth(),
-                           TilesManager::instance()->tileHeight());
-        g_bitmap->allocPixels();
-    }
 }
 
 RasterRenderer::~RasterRenderer()
@@ -68,9 +59,11 @@ RasterRenderer::~RasterRenderer()
 void RasterRenderer::setupCanvas(const TileRenderInfo& renderInfo, SkCanvas* canvas)
 {
     TRACE_METHOD();
+
+    SkBitmap* bitmap = TilesManager::instance()->threadLocalBitmap();
     if (renderInfo.baseTile->isLayerTile()) {
-        g_bitmap->setIsOpaque(false);
-        g_bitmap->eraseARGB(0, 0, 0, 0);
+        bitmap->setIsOpaque(false);
+        bitmap->eraseARGB(0, 0, 0, 0);
     } else {
         Color defaultBackground = Color::white;
         Color* background = renderInfo.tilePainter->background();
@@ -79,12 +72,12 @@ void RasterRenderer::setupCanvas(const TileRenderInfo& renderInfo, SkCanvas* can
             background = &defaultBackground;
         }
         ALOGV("setupCanvas use background on Base Layer %x", background->rgb());
-        g_bitmap->setIsOpaque(!background->hasAlpha());
-        g_bitmap->eraseARGB(background->alpha(), background->red(),
+        bitmap->setIsOpaque(!background->hasAlpha());
+        bitmap->eraseARGB(background->alpha(), background->red(),
                           background->green(), background->blue());
     }
 
-    SkDevice* device = new SkDevice(*g_bitmap);
+    SkDevice* device = new SkDevice(*bitmap);
 
     canvas->setDevice(device);
 
diff --git a/Source/WebCore/platform/graphics/android/rendering/RasterRenderer.h b/Source/WebCore/platform/graphics/android/rendering/RasterRenderer.h
index 39e00f2..55759e4 100644
--- a/Source/WebCore/platform/graphics/android/rendering/RasterRenderer.h
+++ b/Source/WebCore/platform/graphics/android/rendering/RasterRenderer.h
@@ -29,7 +29,6 @@
 #if USE(ACCELERATED_COMPOSITING)
 
 #include "BaseRenderer.h"
-#include "SkBitmap.h"
 #include "SkRect.h"
 
 class SkCanvas;
@@ -50,10 +49,6 @@ protected:
     virtual void setupCanvas(const TileRenderInfo& renderInfo, SkCanvas* canvas);
     virtual void renderingComplete(const TileRenderInfo& renderInfo, SkCanvas* canvas);
     virtual void checkForPureColor(TileRenderInfo& renderInfo, SkCanvas* canvas);
-
-private:
-    static SkBitmap* g_bitmap;
-
 };
 
 } // namespace WebCore
diff --git a/Source/WebCore/platform/graphics/android/rendering/TexturesGenerator.cpp b/Source/WebCore/platform/graphics/android/rendering/TexturesGenerator.cpp
index cc94c9c..1ee3b67 100644
--- a/Source/WebCore/platform/graphics/android/rendering/TexturesGenerator.cpp
+++ b/Source/WebCore/platform/graphics/android/rendering/TexturesGenerator.cpp
@@ -39,6 +39,13 @@
 
 namespace WebCore {
 
+TexturesGenerator::TexturesGenerator(TilesManager* instance)
+  : Thread(false)
+  , m_tilesManager(instance)
+  , m_deferredMode(false)
+{
+}
+
 bool TexturesGenerator::tryUpdateOperationWithPainter(Tile* tile, TilePainter* painter)
 {
     android::Mutex::Autolock lock(mRequestedOperationsLock);
@@ -83,12 +90,14 @@ void TexturesGenerator::removeOperationsForFilter(OperationFilter* filter)
             i++;
         }
     }
-    delete filter;
 }
 
 status_t TexturesGenerator::readyToRun()
 {
-    ALOGV("Thread ready to run");
+    m_bitmap.setConfig(SkBitmap::kARGB_8888_Config,
+                       TilesManager::instance()->tileWidth(),
+                       TilesManager::instance()->tileHeight());
+    m_bitmap.allocPixels();
     return NO_ERROR;
 }
 
diff --git a/Source/WebCore/platform/graphics/android/rendering/TexturesGenerator.h b/Source/WebCore/platform/graphics/android/rendering/TexturesGenerator.h
index 290ad08..22ecf69 100644
--- a/Source/WebCore/platform/graphics/android/rendering/TexturesGenerator.h
+++ b/Source/WebCore/platform/graphics/android/rendering/TexturesGenerator.h
@@ -29,7 +29,7 @@
 #if USE(ACCELERATED_COMPOSITING)
 
 #include "QueuedOperation.h"
-#include "TilePainter.h"
+#include "TransferQueue.h"
 #include <wtf/HashMap.h>
 #include <wtf/Vector.h>
 
@@ -43,10 +43,9 @@ class TilesManager;
 
 class TexturesGenerator : public Thread {
 public:
-    TexturesGenerator(TilesManager* instance) : Thread(false)
-        , m_tilesManager(instance)
-        , m_deferredMode(false) { }
-    virtual ~TexturesGenerator() { }
+    TexturesGenerator(TilesManager* instance);
+    virtual ~TexturesGenerator() {}
+
     virtual status_t readyToRun();
 
     bool tryUpdateOperationWithPainter(Tile* tile, TilePainter* painter);
@@ -59,6 +58,7 @@ public:
     // signifying that they should be deferred
     static const int gDeferPriorityCutoff = 500000000;
 
+    SkBitmap* bitmap() { return &m_bitmap; }
 private:
     QueuedOperation* popNext();
     virtual bool threadLoop();
@@ -68,6 +68,7 @@ private:
     android::Condition mRequestedOperationsCond;
     TilesManager* m_tilesManager;
 
+    SkBitmap m_bitmap;
     bool m_deferredMode;
 
     // defer painting for one second if best in queue has priority
diff --git a/Source/WebCore/platform/graphics/android/rendering/TilesManager.cpp b/Source/WebCore/platform/graphics/android/rendering/TilesManager.cpp
index 0b4ba7b..8a8a43b 100644
--- a/Source/WebCore/platform/graphics/android/rendering/TilesManager.cpp
+++ b/Source/WebCore/platform/graphics/android/rendering/TilesManager.cpp
@@ -65,6 +65,10 @@
 
 #define LAYER_TEXTURES_DESTROY_TIMEOUT 60 // If we do not need layers for 60 seconds, free the textures
 
+// Eventually this should be dynamically be determined, and smart scheduling
+// between the generators should be implemented
+#define NUM_TEXTURES_GENERATORS 1
+
 namespace WebCore {
 
 int TilesManager::getMaxTextureAllocation()
@@ -105,10 +109,21 @@ TilesManager::TilesManager()
     m_availableTextures.reserveCapacity(MAX_TEXTURE_ALLOCATION);
     m_tilesTextures.reserveCapacity(MAX_TEXTURE_ALLOCATION);
     m_availableTilesTextures.reserveCapacity(MAX_TEXTURE_ALLOCATION);
-    m_pixmapsGenerationThread = new TexturesGenerator(this);
-    m_pixmapsGenerationThread->run("TexturesGenerator");
+
+    m_textureGenerators = new sp<TexturesGenerator>[NUM_TEXTURES_GENERATORS];
+    for (int i = 0; i < NUM_TEXTURES_GENERATORS; i++) {
+        m_textureGenerators[i] = new TexturesGenerator(this);
+        ALOGD("Starting TG #%d, %p", i, m_textureGenerators[i].get());
+        m_textureGenerators[i]->run("TexturesGenerator");
+    }
+}
+
+TilesManager::~TilesManager()
+{
+    delete[] m_textureGenerators;
 }
 
+
 void TilesManager::allocateTextures()
 {
     int nbTexturesToAllocate = m_currentTextureCount - m_textures.size();
@@ -488,6 +503,40 @@ void TilesManager::updateTilesIfContextVerified()
     return;
 }
 
+void TilesManager::removeOperationsForFilter(OperationFilter* filter)
+{
+    for (int i = 0; i < NUM_TEXTURES_GENERATORS; i++)
+        m_textureGenerators[i]->removeOperationsForFilter(filter);
+    delete filter;
+}
+
+bool TilesManager::tryUpdateOperationWithPainter(Tile* tile, TilePainter* painter)
+{
+    for (int i = 0; i < NUM_TEXTURES_GENERATORS; i++) {
+        if (m_textureGenerators[i]->tryUpdateOperationWithPainter(tile, painter))
+            return true;
+    }
+    return false;
+}
+
+void TilesManager::scheduleOperation(QueuedOperation* operation)
+{
+    // TODO: painter awareness, store prefer awareness, store preferred thread into painter
+    m_scheduleThread = (m_scheduleThread + 1) % NUM_TEXTURES_GENERATORS;
+    m_textureGenerators[m_scheduleThread]->scheduleOperation(operation);
+}
+
+SkBitmap* TilesManager::threadLocalBitmap()
+{
+    pid_t localTid = androidGetTid();
+    for (int i = 0; i < NUM_TEXTURES_GENERATORS; i++) {
+        if (localTid == m_textureGenerators[i]->getTid())
+            return m_textureGenerators[i]->bitmap();
+    }
+    return 0;
+}
+
+
 int TilesManager::tileWidth()
 {
     return TILE_WIDTH;
diff --git a/Source/WebCore/platform/graphics/android/rendering/TilesManager.h b/Source/WebCore/platform/graphics/android/rendering/TilesManager.h
index f0d2eac..f022ebf 100644
--- a/Source/WebCore/platform/graphics/android/rendering/TilesManager.h
+++ b/Source/WebCore/platform/graphics/android/rendering/TilesManager.h
@@ -53,23 +53,9 @@ public:
         return gInstance != 0;
     }
 
-    void removeOperationsForFilter(OperationFilter* filter)
-    {
-        m_pixmapsGenerationThread->removeOperationsForFilter(filter);
-    }
-
-    bool tryUpdateOperationWithPainter(Tile* tile, TilePainter* painter)
-    {
-        return m_pixmapsGenerationThread->tryUpdateOperationWithPainter(tile, painter);
-    }
-
-    void scheduleOperation(QueuedOperation* operation)
-    {
-        m_pixmapsGenerationThread->scheduleOperation(operation);
-    }
-
     ShaderProgram* shader() { return &m_shader; }
     TransferQueue* transferQueue();
+
     VideoLayerManager* videoLayerManager() { return &m_videoLayerManager; }
 
     void updateTilesIfContextVerified();
@@ -165,8 +151,16 @@ public:
         return m_drawGLCount;
     }
 
+    // operations on/for texture generator threads
+    void removeOperationsForFilter(OperationFilter* filter);
+    bool tryUpdateOperationWithPainter(Tile* tile, TilePainter* painter);
+    void scheduleOperation(QueuedOperation* operation);
+    SkBitmap* threadLocalBitmap();
+
 private:
     TilesManager();
+    ~TilesManager();
+    int m_scheduleThread;
 
     void discardTexturesVector(unsigned long long sparedDrawCount,
                                WTF::Vector<TileTexture*>& textures,
@@ -198,7 +192,7 @@ private:
     unsigned int m_contentUpdates; // nr of successful tiled paints
     unsigned int m_webkitContentUpdates; // nr of paints from webkit
 
-    sp<TexturesGenerator> m_pixmapsGenerationThread;
+    sp<TexturesGenerator>* m_textureGenerators;
 
     android::Mutex m_texturesLock;