src/gallium/drivers/swr/rasterizer/core/tilemgr.h

   1 /****************************************************************************
   2 * Copyright (C) 2014-2015 Intel Corporation.   All Rights Reserved.
   3 *
   4 * Permission is hereby granted, free of charge, to any person obtaining a
   5 * copy of this software and associated documentation files (the "Software"),
   6 * to deal in the Software without restriction, including without limitation
   7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8 * and/or sell copies of the Software, and to permit persons to whom the
   9 * Software is furnished to do so, subject to the following conditions:
  10 *
  11 * The above copyright notice and this permission notice (including the next
  12 * paragraph) shall be included in all copies or substantial portions of the
  13 * Software.
  14 *
  15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21 * IN THE SOFTWARE.
  22 *
  23 * @file tilemgr.h
  24 *
  25 * @brief Definitions for Macro Tile Manager which provides the facilities
  26 *        for threads to work on an macro tile.
  27 *
  28 ******************************************************************************/
  29 #pragma once
  30
  31 #include <set>
  32 #include <unordered_map>
  33 #include "common/formats.h"
  34 #include "fifo.hpp"
  35 #include "context.h"
  36 #include "format_traits.h"
  37
  38 //////////////////////////////////////////////////////////////////////////
  39 /// MacroTile - work queue for a tile.
  40 //////////////////////////////////////////////////////////////////////////
  41 struct MacroTileQueue
  42 {
  43     MacroTileQueue() { }
  44     ~MacroTileQueue() { }
  45
  46     //////////////////////////////////////////////////////////////////////////
  47     /// @brief Returns number of work items queued for this tile.
  48     uint32_t getNumQueued()
  49     {
  50         return mFifo.getNumQueued();
  51     }
  52
  53     //////////////////////////////////////////////////////////////////////////
  54     /// @brief Attempt to lock the work fifo. If already locked then return false.
  55     bool tryLock()
  56     {
  57         return mFifo.tryLock();
  58     }
  59
  60     //////////////////////////////////////////////////////////////////////////
  61     /// @brief Clear fifo and unlock it.
  62     template <typename ArenaT>
  63     void clear(ArenaT& arena)
  64     {
  65         mFifo.clear(arena);
  66     }
  67
  68     //////////////////////////////////////////////////////////////////////////
  69     /// @brief Peek at work sitting at the front of the fifo.
  70     BE_WORK* peek()
  71     {
  72         return mFifo.peek();
  73     }
  74
  75     template <typename ArenaT>
  76     bool enqueue_try_nosync(ArenaT& arena, const BE_WORK* entry)
  77     {
  78         return mFifo.enqueue_try_nosync(arena, entry);
  79     }
  80
  81     //////////////////////////////////////////////////////////////////////////
  82     /// @brief Move to next work item
  83     void dequeue()
  84     {
  85         mFifo.dequeue_noinc();
  86     }
  87
  88     //////////////////////////////////////////////////////////////////////////
  89     /// @brief Destroy fifo
  90     void destroy()
  91     {
  92         mFifo.destroy();
  93     }
  94
  95     ///@todo This will all be private.
  96     uint32_t mWorkItemsFE = 0;
  97     uint32_t mWorkItemsBE = 0;
  98
  99 private:
 100     QUEUE<BE_WORK> mFifo;
 101 };
 102
 103 //////////////////////////////////////////////////////////////////////////
 104 /// MacroTileMgr - Manages macrotiles for a draw.
 105 //////////////////////////////////////////////////////////////////////////
 106 class MacroTileMgr
 107 {
 108 public:
 109     MacroTileMgr(CachingArena& arena);
 110     ~MacroTileMgr()
 111     {
 112         for (auto &tile : mTiles)
 113         {
 114             tile.second.destroy();
 115         }
 116     }
 117
 118     INLINE void initialize()
 119     {
 120         mWorkItemsProduced = 0;
 121         mWorkItemsConsumed = 0;
 122
 123         mDirtyTiles.clear();
 124     }
 125
 126     INLINE std::vector<uint32_t>& getDirtyTiles() { return mDirtyTiles; }
 127     INLINE MacroTileQueue& getMacroTileQueue(uint32_t id) { return mTiles[id]; }
 128     void markTileComplete(uint32_t id);
 129
 130     INLINE bool isWorkComplete()
 131     {
 132         return mWorkItemsProduced == mWorkItemsConsumed;
 133     }
 134
 135     void enqueue(uint32_t x, uint32_t y, BE_WORK *pWork);
 136
 137     static INLINE void getTileIndices(uint32_t tileID, uint32_t &x, uint32_t &y)
 138     {
 139         y = tileID & 0xffff;
 140         x = (tileID >> 16) & 0xffff;
 141     }
 142
 143 private:
 144     CachingArena& mArena;
 145     std::unordered_map<uint32_t, MacroTileQueue> mTiles;
 146
 147     // Any tile that has work queued to it is a dirty tile.
 148     std::vector<uint32_t> mDirtyTiles;
 149
 150     OSALIGNLINE(LONG) mWorkItemsProduced { 0 };
 151     OSALIGNLINE(volatile LONG) mWorkItemsConsumed { 0 };
 152 };
 153
 154 //////////////////////////////////////////////////////////////////////////
 155 /// DispatchQueue - work queue for dispatch
 156 //////////////////////////////////////////////////////////////////////////
 157 class DispatchQueue
 158 {
 159 public:
 160     DispatchQueue() {}
 161
 162     //////////////////////////////////////////////////////////////////////////
 163     /// @brief Setup the producer consumer counts.
 164     void initialize(uint32_t totalTasks, void* pTaskData)
 165     {
 166         // The available and outstanding counts start with total tasks.
 167         // At the start there are N tasks available and outstanding.
 168         // When both the available and outstanding counts have reached 0 then all work has completed.
 169         // When a worker starts on a threadgroup then it decrements the available count.
 170         // When a worker completes a threadgroup then it decrements the outstanding count.
 171
 172         mTasksAvailable = totalTasks;
 173         mTasksOutstanding = totalTasks;
 174
 175         mpTaskData = pTaskData;
 176     }
 177
 178     //////////////////////////////////////////////////////////////////////////
 179     /// @brief Returns number of tasks available for this dispatch.
 180     uint32_t getNumQueued()
 181     {
 182         return (mTasksAvailable > 0) ? mTasksAvailable : 0;
 183     }
 184
 185     //////////////////////////////////////////////////////////////////////////
 186     /// @brief Atomically decrement the work available count. If the result
 187     //         is greater than 0 then we can on the associated thread group.
 188     //         Otherwise, there is no more work to do.
 189     bool getWork(uint32_t& groupId)
 190     {
 191         LONG result = InterlockedDecrement(&mTasksAvailable);
 192
 193         if (result >= 0)
 194         {
 195             groupId = result;
 196             return true;
 197         }
 198
 199         return false;
 200     }
 201
 202     //////////////////////////////////////////////////////////////////////////
 203     /// @brief Atomically decrement the outstanding count. A worker is notifying
 204     ///        us that he just finished some work. Also, return true if we're
 205     ///        the last worker to complete this dispatch.
 206     bool finishedWork()
 207     {
 208         LONG result = InterlockedDecrement(&mTasksOutstanding);
 209         SWR_ASSERT(result >= 0, "Should never oversubscribe work");
 210
 211         return (result == 0) ? true : false;
 212     }
 213
 214     //////////////////////////////////////////////////////////////////////////
 215     /// @brief Work is complete once both the available/outstanding counts have reached 0.
 216     bool isWorkComplete()
 217     {
 218         return ((mTasksAvailable <= 0) &&
 219                 (mTasksOutstanding <= 0));
 220     }
 221
 222     //////////////////////////////////////////////////////////////////////////
 223     /// @brief Return pointer to task data.
 224     const void* GetTasksData()
 225     {
 226         return mpTaskData;
 227     }
 228
 229     void* mpTaskData{ nullptr };        // The API thread will set this up and the callback task function will interpet this.
 230
 231     OSALIGNLINE(volatile LONG) mTasksAvailable{ 0 };
 232     OSALIGNLINE(volatile LONG) mTasksOutstanding{ 0 };
 233 };
 234
 235
 236 enum HOTTILE_STATE
 237 {
 238     HOTTILE_INVALID,        // tile is in unitialized state and should be loaded with surface contents before rendering
 239     HOTTILE_CLEAR,          // tile should be cleared
 240     HOTTILE_DIRTY,          // tile has been rendered to
 241     HOTTILE_RESOLVED,       // tile has been stored to memory
 242 };
 243
 244 struct HOTTILE
 245 {
 246     uint8_t *pBuffer;
 247     HOTTILE_STATE state;
 248     DWORD clearData[4];                 // May need to change based on pfnClearTile implementation.  Reorder for alignment?
 249     uint32_t numSamples;
 250     uint32_t renderTargetArrayIndex;    // current render target array index loaded
 251 };
 252
 253 union HotTileSet
 254 {
 255     struct
 256     {
 257         HOTTILE Color[SWR_NUM_RENDERTARGETS];
 258         HOTTILE Depth;
 259         HOTTILE Stencil;
 260     };
 261     HOTTILE Attachment[SWR_NUM_ATTACHMENTS];
 262 };
 263
 264 class HotTileMgr
 265 {
 266 public:
 267     HotTileMgr()
 268     {
 269         memset(mHotTiles, 0, sizeof(mHotTiles));
 270
 271         // cache hottile size
 272         for (uint32_t i = SWR_ATTACHMENT_COLOR0; i <= SWR_ATTACHMENT_COLOR7; ++i)
 273         {
 274             mHotTileSize[i] = KNOB_MACROTILE_X_DIM * KNOB_MACROTILE_Y_DIM * FormatTraits<KNOB_COLOR_HOT_TILE_FORMAT>::bpp / 8;
 275         }
 276         mHotTileSize[SWR_ATTACHMENT_DEPTH] = KNOB_MACROTILE_X_DIM * KNOB_MACROTILE_Y_DIM * FormatTraits<KNOB_DEPTH_HOT_TILE_FORMAT>::bpp / 8;
 277         mHotTileSize[SWR_ATTACHMENT_STENCIL] = KNOB_MACROTILE_X_DIM * KNOB_MACROTILE_Y_DIM * FormatTraits<KNOB_STENCIL_HOT_TILE_FORMAT>::bpp / 8;
 278     }
 279
 280     ~HotTileMgr()
 281     {
 282         for (int x = 0; x < KNOB_NUM_HOT_TILES_X; ++x)
 283         {
 284             for (int y = 0; y < KNOB_NUM_HOT_TILES_Y; ++y)
 285             {
 286                 for (int a = 0; a < SWR_NUM_ATTACHMENTS; ++a)
 287                 {
 288                     FreeHotTileMem(mHotTiles[x][y].Attachment[a].pBuffer);
 289                 }
 290             }
 291         }
 292     }
 293
 294     void InitializeHotTiles(SWR_CONTEXT* pContext, DRAW_CONTEXT* pDC, uint32_t macroID);
 295
 296     HOTTILE *GetHotTile(SWR_CONTEXT* pContext, DRAW_CONTEXT* pDC, uint32_t macroID, SWR_RENDERTARGET_ATTACHMENT attachment, bool create, uint32_t numSamples = 1,
 297         uint32_t renderTargetArrayIndex = 0);
 298
 299     HOTTILE *GetHotTileNoLoad(SWR_CONTEXT* pContext, DRAW_CONTEXT* pDC, uint32_t macroID, SWR_RENDERTARGET_ATTACHMENT attachment, bool create, uint32_t numSamples = 1);
 300
 301     static void ClearColorHotTile(const HOTTILE* pHotTile);
 302     static void ClearDepthHotTile(const HOTTILE* pHotTile);
 303     static void ClearStencilHotTile(const HOTTILE* pHotTile);
 304
 305 private:
 306     HotTileSet mHotTiles[KNOB_NUM_HOT_TILES_X][KNOB_NUM_HOT_TILES_Y];
 307     uint32_t mHotTileSize[SWR_NUM_ATTACHMENTS];
 308
 309     void* AllocHotTileMem(size_t size, uint32_t align, uint32_t numaNode)
 310     {
 311         void* p = nullptr;
 312 #if defined(_WIN32)
 313         HANDLE hProcess = GetCurrentProcess();
 314         p = VirtualAllocExNuma(hProcess, nullptr, size, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE, numaNode);
 315 #else
 316         p = AlignedMalloc(size, align);
 317 #endif
 318
 319         return p;
 320     }
 321
 322     void FreeHotTileMem(void* pBuffer)
 323     {
 324         if (pBuffer)
 325         {
 326 #if defined(_WIN32)
 327             VirtualFree(pBuffer, 0, MEM_RELEASE);
 328 #else
 329             AlignedFree(pBuffer);
 330 #endif
 331         }
 332     }
 333 };
 334