swr: [rasterizer core] buckets fixes

1. Don't clear bucket descriptions to fix issues with sim level
   buckets getting out of sync.

2. Close out threadviz file descriptors in ClearThreads().

3. Skip buckets for jitter based buckets when multithreaded. We need
   thread local storage through llvm jit functions to be fixed before
   we can enable this.

4. Fix buckets StopCapture to correctly detect capture complete.

Reviewed-by: Bruce Cherniak <bruce.cherniak@intel.com>

diff --git a/src/gallium/drivers/swr/rasterizer/common/rdtsc_buckets.cpp b/src/gallium/drivers/swr/rasterizer/common/rdtsc_buckets.cpp
index 8df5deb3416a2d2cabceccf7437aa28c3bfceb6b..412182f22aa8dc6c03db0150b47ba998486b589a 100644 (file)
--- a/src/gallium/drivers/swr/rasterizer/common/rdtsc_buckets.cpp
+++ b/src/gallium/drivers/swr/rasterizer/common/rdtsc_buckets.cpp
@@ -175,6 +175,7 @@ void BucketManager::DumpThreadViz()
     {
         fflush(thread.vizFile);
         fclose(thread.vizFile);
+        thread.vizFile = nullptr;
     }
     mThreadMutex.unlock();
 

diff --git a/src/gallium/drivers/swr/rasterizer/common/rdtsc_buckets.h b/src/gallium/drivers/swr/rasterizer/common/rdtsc_buckets.h
index 95841163155785ee6f3101a14d706ce30f896261..fe25e77832e0bc5dbf04cc7330b9d16abc7e4e8c 100644 (file)
--- a/src/gallium/drivers/swr/rasterizer/common/rdtsc_buckets.h
+++ b/src/gallium/drivers/swr/rasterizer/common/rdtsc_buckets.h
@@ -53,6 +53,17 @@ public:
     void ClearThreads()
     {
         mThreadMutex.lock();
+        // close out the threadviz files if threadviz is enabled
+        if (KNOB_BUCKETS_ENABLE_THREADVIZ)
+        {
+            for (auto& thread : mThreads)
+            {
+                if (thread.vizFile != nullptr)
+                {
+                    fclose(thread.vizFile);
+                }
+            }
+        }
         mThreads.clear();
         mThreadMutex.unlock();
     }
@@ -99,7 +110,7 @@ public:
             stillCapturing = false;
             for (const BUCKET_THREAD& t : mThreads)
             {
-                if (t.pCurrent != &t.root)
+                if (t.level > 0)
                 {
                     stillCapturing = true;
                     continue;

diff --git a/src/gallium/drivers/swr/rasterizer/core/rdtsc_core.cpp b/src/gallium/drivers/swr/rasterizer/core/rdtsc_core.cpp
index 52c84ee2465615e1cd96bf14e8de9d11208e03f8..56eed25f959c0f11f84ee22ff687b5b351c7ea05 100644 (file)
--- a/src/gallium/drivers/swr/rasterizer/core/rdtsc_core.cpp
+++ b/src/gallium/drivers/swr/rasterizer/core/rdtsc_core.cpp
@@ -93,3 +93,4 @@ std::vector<uint32_t> gBucketMap;
 BucketManager gBucketMgr;
 
 uint32_t gCurrentFrame = 0;
+bool gBucketsInitialized = false;

diff --git a/src/gallium/drivers/swr/rasterizer/core/rdtsc_core.h b/src/gallium/drivers/swr/rasterizer/core/rdtsc_core.h
index e1dde61b38621ace5307dd55c172b6b6fb0c5c56..36f36ab1fc19a2525aa1eec97ca74bc0ea5de5f6 100644 (file)
--- a/src/gallium/drivers/swr/rasterizer/core/rdtsc_core.h
+++ b/src/gallium/drivers/swr/rasterizer/core/rdtsc_core.h
@@ -122,24 +122,25 @@ extern std::vector<uint32_t> gBucketMap;
 extern BucketManager gBucketMgr;
 extern BUCKET_DESC gCoreBuckets[];
 extern uint32_t gCurrentFrame;
+extern bool gBucketsInitialized;
 
 INLINE void rdtscReset()
 {
     gCurrentFrame = 0;
     gBucketMgr.ClearThreads();
-    gBucketMgr.ClearBuckets();
 }
 
 INLINE void rdtscInit(int threadId)
 {
     // register all the buckets once
-    if (threadId == 0)
+    if (!gBucketsInitialized && (threadId == 0))
     {
         gBucketMap.resize(NumBuckets);
         for (uint32_t i = 0; i < NumBuckets; ++i)
         {
             gBucketMap[i] = gBucketMgr.RegisterBucket(gCoreBuckets[i]);
         }
+        gBucketsInitialized = true;
     }
 
     std::string name = threadId == 0 ? "API" : "WORKER";

diff --git a/src/gallium/drivers/swr/rasterizer/jitter/builder_misc.cpp b/src/gallium/drivers/swr/rasterizer/jitter/builder_misc.cpp
index 7da4c025a7ad5b9400492ab1b5d95dc1d7dd9d22..2f4fa382ebf152cd40d322b9b4b8613f68e404f7 100644 (file)
--- a/src/gallium/drivers/swr/rasterizer/jitter/builder_misc.cpp
+++ b/src/gallium/drivers/swr/rasterizer/jitter/builder_misc.cpp
@@ -1459,35 +1459,45 @@ Value *Builder::VINSERTI128(Value* a, Value* b, Constant* imm8)
 // rdtsc buckets macros
 void Builder::RDTSC_START(Value* pBucketMgr, Value* pId)
 {
-    std::vector<Type*> args{
-        PointerType::get(mInt32Ty, 0),   // pBucketMgr
-        mInt32Ty                        // id
-    };
-
-    FunctionType* pFuncTy = FunctionType::get(Type::getVoidTy(JM()->mContext), args, false);
-    Function* pFunc = cast<Function>(JM()->mpCurrentModule->getOrInsertFunction("BucketManager_StartBucket", pFuncTy));
-    if (sys::DynamicLibrary::SearchForAddressOfSymbol("BucketManager_StartBucket") == nullptr)
+    // @todo due to an issue with thread local storage propagation in llvm, we can only safely call into
+    // buckets framework when single threaded
+    if (KNOB_SINGLE_THREADED)
     {
-        sys::DynamicLibrary::AddSymbol("BucketManager_StartBucket", (void*)&BucketManager_StartBucket);
-    }
+        std::vector<Type*> args{
+            PointerType::get(mInt32Ty, 0),   // pBucketMgr
+            mInt32Ty                        // id
+        };
+
+        FunctionType* pFuncTy = FunctionType::get(Type::getVoidTy(JM()->mContext), args, false);
+        Function* pFunc = cast<Function>(JM()->mpCurrentModule->getOrInsertFunction("BucketManager_StartBucket", pFuncTy));
+        if (sys::DynamicLibrary::SearchForAddressOfSymbol("BucketManager_StartBucket") == nullptr)
+        {
+            sys::DynamicLibrary::AddSymbol("BucketManager_StartBucket", (void*)&BucketManager_StartBucket);
+        }
 
-    CALL(pFunc, { pBucketMgr, pId });
+        CALL(pFunc, { pBucketMgr, pId });
+    }
 }
 
 void Builder::RDTSC_STOP(Value* pBucketMgr, Value* pId)
 {
-    std::vector<Type*> args{
-        PointerType::get(mInt32Ty, 0),   // pBucketMgr
-        mInt32Ty                        // id
-    };
-
-    FunctionType* pFuncTy = FunctionType::get(Type::getVoidTy(JM()->mContext), args, false);
-    Function* pFunc = cast<Function>(JM()->mpCurrentModule->getOrInsertFunction("BucketManager_StopBucket", pFuncTy));
-    if (sys::DynamicLibrary::SearchForAddressOfSymbol("BucketManager_StopBucket") == nullptr)
+    // @todo due to an issue with thread local storage propagation in llvm, we can only safely call into
+    // buckets framework when single threaded
+    if (KNOB_SINGLE_THREADED)
     {
-        sys::DynamicLibrary::AddSymbol("BucketManager_StopBucket", (void*)&BucketManager_StopBucket);
-    }
+        std::vector<Type*> args{
+            PointerType::get(mInt32Ty, 0),   // pBucketMgr
+            mInt32Ty                        // id
+        };
+
+        FunctionType* pFuncTy = FunctionType::get(Type::getVoidTy(JM()->mContext), args, false);
+        Function* pFunc = cast<Function>(JM()->mpCurrentModule->getOrInsertFunction("BucketManager_StopBucket", pFuncTy));
+        if (sys::DynamicLibrary::SearchForAddressOfSymbol("BucketManager_StopBucket") == nullptr)
+        {
+            sys::DynamicLibrary::AddSymbol("BucketManager_StopBucket", (void*)&BucketManager_StopBucket);
+        }
 
-    CALL(pFunc, { pBucketMgr, pId });
+        CALL(pFunc, { pBucketMgr, pId });
+    }
 }