Refactor bucketing code a little to use a record type enum

renderdoc/api/replay/data_types.h

@@ -142,21 +142,17 @@ struct DebugMessage
 
 DECLARE_REFLECTION_STRUCT(DebugMessage);
 
-enum BucketRecordType
+enum class BucketRecordType : int
 {
-  BUCKET_RECORD_TYPE_LINEAR,
-  BUCKET_RECORD_TYPE_POW2,
-
-  BUCKET_RECORD_TYPE_COUNT,
+  Linear,
+  Pow2,
 };
 
 struct ConstantBindStats
 {
-  enum Constants
-  {
-    BUCKET_TYPE = BUCKET_RECORD_TYPE_POW2,
-    BUCKET_COUNT = 31,
-  };
+  static const BucketRecordType BucketType = BucketRecordType::Pow2;
+  static const size_t BucketCount = 31;
+
   uint32_t calls;
   uint32_t sets;
   uint32_t nulls;
@@ -189,11 +185,9 @@ DECLARE_REFLECTION_STRUCT(ResourceBindStats);
 
 struct ResourceUpdateStats
 {
-  enum Constants
-  {
-    BUCKET_TYPE = BUCKET_RECORD_TYPE_POW2,
-    BUCKET_COUNT = 31,
-  };
+  static const BucketRecordType BucketType = BucketRecordType::Pow2;
+  static const size_t BucketCount = 31;
+
   uint32_t calls;
   uint32_t clients;
   uint32_t servers;
@@ -205,12 +199,10 @@ DECLARE_REFLECTION_STRUCT(ResourceUpdateStats);
 
 struct DrawcallStats
 {
-  enum Constants
-  {
-    BUCKET_TYPE = BUCKET_RECORD_TYPE_LINEAR,
-    BUCKET_SIZE = 1,
-    BUCKET_COUNT = 16,
-  };
+  static const BucketRecordType BucketType = BucketRecordType::Linear;
+  static const size_t BucketSize = 1;
+  static const size_t BucketCount = 16;
+
   uint32_t calls;
   uint32_t instanced;
   uint32_t indirect;

renderdoc/common/common.h

@@ -163,6 +163,39 @@ uint32_t Log2Floor(uint32_t value);
 uint64_t Log2Floor(uint64_t value);
 #endif
 
+template <typename T, BucketRecordType bucketType = T::BucketType>
+struct BucketForRecord
+{
+  static size_t Get(size_t value);
+};
+
+template <typename T>
+struct BucketForRecord<T, BucketRecordType::Linear>
+{
+  static size_t Get(size_t value)
+  {
+    const size_t size = T::BucketSize;
+    const size_t count = T::BucketCount;
+    const size_t maximum = size * count;
+    const size_t index = (value < maximum) ? (value / size) : (count - 1);
+    return index;
+  }
+};
+
+template <typename T>
+struct BucketForRecord<T, BucketRecordType::Pow2>
+{
+  static size_t Get(size_t value)
+  {
+    const size_t count = T::BucketCount;
+    static_assert(count <= (sizeof(size_t) * 8),
+                  "Unexpected correspondence between bucket size and sizeof(size_t)");
+    const size_t maximum = (size_t)1 << count;
+    const size_t index = (value < maximum) ? (size_t)(Log2Floor(value)) : (count - 1);
+    return index;
+  }
+};
+
 /////////////////////////////////////////////////
 // Debugging features
 

renderdoc/driver/d3d11/d3d11_context.cpp

@@ -1729,7 +1729,7 @@ void WrappedID3D11DeviceContext::RecordConstantStats(ShaderStage stage, UINT Num
       D3D11_BUFFER_DESC desc;
       Buffers[i]->GetDesc(&desc);
       uint32_t bufferSize = desc.ByteWidth;
-      size_t bucket = BucketForRecordPow2<ConstantBindStats>(bufferSize);
+      size_t bucket = BucketForRecord<ConstantBindStats>::Get(bufferSize);
       RDCASSERT(bucket < constants.sizes.size());
       constants.sizes[bucket] += 1;
     }
@@ -1830,7 +1830,7 @@ void WrappedID3D11DeviceContext::RecordUpdateStats(ID3D11Resource *res, uint32_t
   // #mivance it might be nice to query the buffer to differentiate
   // between bindings for constant buffers
 
-  size_t bucket = BucketForRecordPow2<ResourceUpdateStats>(Size);
+  size_t bucket = BucketForRecord<ResourceUpdateStats>::Get(Size);
   updates.sizes[bucket] += 1;
 }
 
@@ -1845,7 +1845,7 @@ void WrappedID3D11DeviceContext::RecordDrawStats(bool instanced, bool indirect,
 
   if(instanced)
   {
-    size_t bucket = BucketForRecordLinear<DrawcallStats>(InstanceCount);
+    size_t bucket = BucketForRecord<DrawcallStats>::Get(InstanceCount);
     RDCASSERT(bucket < draws.counts.size());
     draws.counts[bucket] += 1;
   }

renderdoc/driver/d3d11/d3d11_context.h

@@ -122,31 +122,6 @@ struct DrawcallTreeNode
   }
 };
 
-template <typename T>
-size_t BucketForRecordLinear(size_t value)
-{
-  RDCCOMPILE_ASSERT(T::BUCKET_TYPE == BUCKET_RECORD_TYPE_LINEAR,
-                    "Incorrect bucket type for record query.");
-  const size_t size = T::BUCKET_SIZE;
-  const size_t count = T::BUCKET_COUNT;
-  const size_t maximum = size * count;
-  const size_t index = (value < maximum) ? (value / size) : (count - 1);
-  return index;
-}
-
-template <typename T>
-size_t BucketForRecordPow2(size_t value)
-{
-  RDCCOMPILE_ASSERT(T::BUCKET_TYPE == BUCKET_RECORD_TYPE_POW2,
-                    "Incorrect bucket type for record query.");
-  const size_t count = T::BUCKET_COUNT;
-  RDCCOMPILE_ASSERT(count <= (sizeof(size_t) * 8),
-                    "Unexpected correspondence between bucket size and sizeof(size_t)");
-  const size_t maximum = (size_t)1 << count;
-  const size_t index = (value < maximum) ? (size_t)(Log2Floor(value)) : (count - 1);
-  return index;
-}
-
 class WrappedID3D11DeviceContext : public RefCounter, public ID3D11DeviceContext3
 {
 private:

renderdoc/driver/d3d11/d3d11_device.cpp

@@ -1112,7 +1112,7 @@ void WrappedID3D11Device::Serialise_CaptureScope(uint64_t offset)
     {
       create_array(stats.constants[stage].bindslots,
                    D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT + 1);
-      create_array(stats.constants[stage].sizes, ConstantBindStats::BUCKET_COUNT);
+      create_array(stats.constants[stage].sizes, ConstantBindStats::BucketCount);
 
       create_array(stats.samplers[stage].bindslots, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT + 1);
 
@@ -1122,9 +1122,9 @@ void WrappedID3D11Device::Serialise_CaptureScope(uint64_t offset)
     }
 
     create_array(stats.updates.types, uint32_t(TextureDim::Count));
-    create_array(stats.updates.sizes, ResourceUpdateStats::BUCKET_COUNT);
+    create_array(stats.updates.sizes, ResourceUpdateStats::BucketCount);
 
-    create_array(stats.draws.counts, DrawcallStats::BUCKET_COUNT);
+    create_array(stats.draws.counts, DrawcallStats::BucketCount);
 
     create_array(stats.vertices.bindslots, D3D11_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT + 1);