Tests: benchmark of linear allocator now compares to various allocation strategies.
diff --git a/src/Tests.cpp b/src/Tests.cpp
index a508fb0..c5cf05b 100644
--- a/src/Tests.cpp
+++ b/src/Tests.cpp
@@ -130,6 +130,33 @@
VmaAllocation Allocation = VK_NULL_HANDLE;
};
+static uint32_t GetAllocationStrategyCount()
+{
+ uint32_t strategyCount = 0;
+ switch(ConfigType)
+ {
+ case CONFIG_TYPE_MINIMUM: strategyCount = 1; break;
+ case CONFIG_TYPE_SMALL: strategyCount = 1; break;
+ case CONFIG_TYPE_AVERAGE: strategyCount = 2; break;
+ case CONFIG_TYPE_LARGE: strategyCount = 2; break;
+ case CONFIG_TYPE_MAXIMUM: strategyCount = 3; break;
+ default: assert(0);
+ }
+ return strategyCount;
+}
+
+static const char* GetAllocationStrategyName(VmaAllocationCreateFlags allocStrategy)
+{
+ switch(allocStrategy)
+ {
+ case VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT: return "BEST_FIT"; break;
+ case VMA_ALLOCATION_CREATE_STRATEGY_WORST_FIT_BIT: return "WORST_FIT"; break;
+ case VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT: return "FIRST_FIT"; break;
+ case 0: return "Default"; break;
+ default: assert(0); return "";
+ }
+}
+
static void InitResult(Result& outResult)
{
outResult.TotalTime = duration::zero();
@@ -2104,7 +2131,11 @@
vmaDestroyPool(g_hAllocator, pool);
}
-static void BenchmarkLinearAllocatorCase(FILE* file, bool linear, bool empty, FREE_ORDER freeOrder)
+static void BenchmarkLinearAllocatorCase(FILE* file,
+ bool linear,
+ bool empty,
+ VmaAllocationCreateFlags allocStrategy,
+ FREE_ORDER freeOrder)
{
RandomNumberGenerator rand{16223};
@@ -2145,6 +2176,7 @@
VmaAllocationCreateInfo allocCreateInfo = {};
allocCreateInfo.pool = pool;
+ allocCreateInfo.flags = allocStrategy;
VmaAllocation alloc;
std::vector<VmaAllocation> baseAllocations;
@@ -2226,9 +2258,10 @@
const float allocTotalSeconds = ToFloatSeconds(allocTotalDuration);
const float freeTotalSeconds = ToFloatSeconds(freeTotalDuration);
- printf(" LinearAlgorithm=%u %s FreeOrder=%s: allocations %g s, free %g s\n",
+ printf(" LinearAlgorithm=%u %s Allocation=%s FreeOrder=%s: allocations %g s, free %g s\n",
linear ? 1 : 0,
empty ? "Empty" : "Not empty",
+ GetAllocationStrategyName(allocStrategy),
FREE_ORDER_NAMES[(size_t)freeOrder],
allocTotalSeconds,
freeTotalSeconds);
@@ -2238,10 +2271,11 @@
std::string currTime;
CurrentTimeToStr(currTime);
- fprintf(file, "%s,%s,%u,%u,%s,%g,%g\n",
+ fprintf(file, "%s,%s,%u,%u,%s,%s,%g,%g\n",
CODE_DESCRIPTION, currTime.c_str(),
linear ? 1 : 0,
empty ? 1 : 0,
+ GetAllocationStrategyName(allocStrategy),
FREE_ORDER_NAMES[(uint32_t)freeOrder],
allocTotalSeconds,
freeTotalSeconds);
@@ -2256,7 +2290,7 @@
{
fprintf(file,
"Code,Time,"
- "Linear,Empty,Free order,"
+ "Linear,Empty,Allocation strategy,Free order,"
"Allocation time (s),Deallocation time (s)\n");
}
@@ -2267,6 +2301,7 @@
freeOrderCount = 2;
const uint32_t emptyCount = ConfigType >= CONFIG_TYPE::CONFIG_TYPE_SMALL ? 2 : 1;
+ const uint32_t allocStrategyCount = GetAllocationStrategyCount();
for(uint32_t freeOrderIndex = 0; freeOrderIndex < freeOrderCount; ++freeOrderIndex)
{
@@ -2283,11 +2318,30 @@
{
for(uint32_t linearIndex = 0; linearIndex < 2; ++linearIndex)
{
- BenchmarkLinearAllocatorCase(
- file,
- linearIndex ? 1 : 0, // linear
- emptyIndex ? 0 : 1, // empty
- freeOrder); // freeOrder
+ const bool linear = linearIndex ? 1 : 0;
+
+ uint32_t currAllocStrategyCount = linear ? 1 : allocStrategyCount;
+ for(uint32_t allocStrategyIndex = 0; allocStrategyIndex < currAllocStrategyCount; ++allocStrategyIndex)
+ {
+ VmaAllocatorCreateFlags strategy = 0;
+ if(!linear)
+ {
+ switch(allocStrategyIndex)
+ {
+ case 0: strategy = VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT; break;
+ case 1: strategy = VMA_ALLOCATION_CREATE_STRATEGY_WORST_FIT_BIT; break;
+ case 2: strategy = VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT; break;
+ default: assert(0);
+ }
+ }
+
+ BenchmarkLinearAllocatorCase(
+ file,
+ linear, // linear
+ emptyIndex ? 0 : 1, // empty
+ strategy,
+ freeOrder); // freeOrder
+ }
}
}
}
@@ -3555,16 +3609,7 @@
default: assert(0);
}
- size_t strategyCount = 0;
- switch(ConfigType)
- {
- case CONFIG_TYPE_MINIMUM: strategyCount = 1; break;
- case CONFIG_TYPE_SMALL: strategyCount = 1; break;
- case CONFIG_TYPE_AVERAGE: strategyCount = 2; break;
- case CONFIG_TYPE_LARGE: strategyCount = 2; break;
- case CONFIG_TYPE_MAXIMUM: strategyCount = 3; break;
- default: assert(0);
- }
+ const size_t strategyCount = GetAllocationStrategyCount();
for(size_t threadCountIndex = 0; threadCountIndex < threadCountCount; ++threadCountIndex)
{
@@ -4041,6 +4086,8 @@
if(false)
{
// # Temporarily insert custom tests here
+ // ########################################
+ // ########################################
return;
}
