Cap table array size growth to 256 item increments

This limits "wasteful" pre-allocation in user-created tables to
a reasonable minimum while still allowing reasonable performance
when quickly creating a lot of lists.

Author: HaroldCindy

VM/src/ltable.cpp

@@ -38,6 +38,9 @@
 #define MAXBITS 26
 #define MAXSIZE (1 << MAXBITS)
 
+// ServerLua: alignment for large array sizes (caps wasted slots at this value - 1)
+constexpr int kLargeArrayAlign = 256;
+
 static_assert(offsetof(LuaNode, val) == 0, "Unexpected Node memory layout, pointer cast in gval2slot is incorrect");
 
 // TKey is bitpacked for memory efficiency so we need to validate bit counts for worst case
@@ -284,7 +287,7 @@ int luaH_next(lua_State* L, LuaTable* t, StkId key)
 
 #define getaboundary(t) (t->aboundary < 0 ? -t->aboundary : t->sizearray)
 
-static int computesizes(int nums[], int* narray)
+static int computesizes(int nums[], int* narray, int max_idx)
 {
     int i;
     int twotoi; // 2^i
@@ -305,6 +308,18 @@ static int computesizes(int nums[], int* narray)
         if (a == *narray)
             break; // all elements already counted
     }
+
+    // ServerLua: For large arrays, cap to 256-aligned size if all elements fit.
+    //  This is necessary because otherwise we'll use use the next power of 2
+    //  that fits 50%. For large array-like tables, that's not necessarily what
+    //  you want in a memory-constrained environment.
+    if (max_idx > 0 && n > kLargeArrayAlign && na > kLargeArrayAlign)
+    {
+        int capped = ((na + kLargeArrayAlign - 1) / kLargeArrayAlign) * kLargeArrayAlign;
+        if (capped < n && max_idx <= capped)
+            n = capped;
+    }
+
     *narray = n;
     LUAU_ASSERT(*narray / 2 <= na && na <= *narray);
     return na;
@@ -322,7 +337,7 @@ static int countint(double key, int* nums)
         return 0;
 }
 
-static int numusearray(const LuaTable* t, int* nums)
+static int numusearray(const LuaTable* t, int* nums, int* max_idx)
 {
     int lg;
     int ttlg;     // 2^lg
@@ -342,15 +357,19 @@ static int numusearray(const LuaTable* t, int* nums)
         for (; i <= lim; i++)
         {
             if (!ttisnil(&t->array[i - 1]))
+            {
                 lc++;
+                // ServerLua: track max_idx for size capping
+                *max_idx = i;
+            }
         }
         nums[lg] += lc;
         ause += lc;
     }
     return ause;
 }
 
-static int numusehash(const LuaTable* t, int* nums, int* pnasize)
+static int numusehash(const LuaTable* t, int* nums, int* pnasize, int* max_idx)
 {
     int totaluse = 0; // total number of elements
     int ause = 0;     // summation of `nums'
@@ -361,7 +380,14 @@ static int numusehash(const LuaTable* t, int* nums, int* pnasize)
         if (!ttisnil(gval(n)))
         {
             if (ttisnumber(gkey(n)))
-                ause += countint(nvalue(gkey(n)), nums);
+            {
+                // ServerLua: support non-pow2 sizes for array in rehash()
+                double key = nvalue(gkey(n));
+                ause += countint(key, nums);
+                int k = arrayindex(key);
+                if (k > *max_idx)
+                    *max_idx = k;
+            }
             totaluse++;
         }
     }
@@ -511,18 +537,32 @@ static void rehash(lua_State* L, LuaTable* t, const TValue* ek)
 {
     int nums[MAXBITS + 1]; // nums[i] = number of keys between 2^(i-1) and 2^i
     for (int i = 0; i <= MAXBITS; i++)
-        nums[i] = 0;                          // reset counts
-    int nasize = numusearray(t, nums);        // count keys in array part
-    int totaluse = nasize;                    // all those keys are integer keys
-    totaluse += numusehash(t, nums, &nasize); // count keys in hash part
+        nums[i] = 0;                                    // reset counts
+    int max_idx = -1;                                   // ServerLua: track max array-eligible index
+    int nasize = numusearray(t, nums, &max_idx);        // count keys in array part
+    int totaluse = nasize;                              // all those keys are integer keys
+    totaluse += numusehash(t, nums, &nasize, &max_idx); // count keys in hash part
 
     // count extra key
     if (ttisnumber(ek))
+    {
+        // ServerLua: we need to keep track of the _max_.
+        int k = arrayindex(nvalue(ek));
+        if (k > 0 && k > max_idx)
+            max_idx = k;
         nasize += countint(nvalue(ek), nums);
+    }
     totaluse++;
 
+    // ServerLua: Don't try to be conservative about array allocation size,
+    //  this is a system table.
+    if (t->memcat < 2)
+    {
+        max_idx = -1;
+    }
+
     // compute new size for array part
-    int na = computesizes(nums, &nasize);
+    int na = computesizes(nums, &nasize, max_idx);
     int nh = totaluse - na;
 
     // enforce the boundary invariant; for performance, only do hash lookups if we must

tests/SLConformance.test.cpp

@@ -21,6 +21,7 @@
 #include "../VM/src/mono_strings.h"
 #include "../VM/src/lapi.h"
 #include "../VM/src/lgc.h"
+#include "../VM/src/ltable.h"
 
 #include <fstream>
 #include <string>
@@ -158,6 +159,16 @@ static int test_integer_call(lua_State *L)
     return lsl_cast(L);
 }
 
+// Returns (array_size, hash_size) for a table - for testing table sizing behavior
+static int lua_table_sizes(lua_State* L)
+{
+    luaL_checktype(L, 1, LUA_TTABLE);
+    LuaTable* t = hvalue(luaA_toobject(L, 1));
+    lua_pushinteger(L, t->sizearray);
+    lua_pushinteger(L, t->node == &luaH_dummynode ? 0 : sizenode(t));
+    return 2;
+}
+
 // Helper callback that enforces reachability-based memory limits
 // Reads max_mem and free_objects from the RuntimeState
 static int memoryLimitCallback(lua_State *L, size_t osize, size_t nsize)
@@ -976,4 +987,14 @@ TEST_CASE("Metamethods and library callbacks receive interrupt checks")
     });
 }
 
+TEST_CASE("Table Sizing")
+{
+    runConformance("table_sizing.lua", nullptr, [](lua_State *L) {
+        lua_pushcfunction(L, lua_table_sizes, "table_sizes");
+        lua_setglobal(L, "table_sizes");
+        lua_pushcfunction(L, [](lua_State *L) {lua_setmemcat(L, luaL_checkinteger(L, 1)); return 0;}, "change_memcat");
+        lua_setglobal(L, "change_memcat");
+    });
+}
+
 TEST_SUITE_END();

tests/conformance/table_sizing.lua

@@ -0,0 +1,153 @@
+-- Tests for array sizing cap behavior
+-- The cap limits "wasted" array slots to at most 255 for large arrays
+
+-- Build array by insertion to trigger rehash (table.create() pre-allocates, skipping resize)
+local function make_array(n)
+    local t = {}
+    for i = 1, n do
+        t[i] = true
+    end
+    return t
+end
+
+local function check_sizes(t, expected_arr, expected_hash, desc)
+    local arr_size, hash_size = table_sizes(t)
+    assert(arr_size == expected_arr, `{desc}: expected {expected_arr} array slots, got {arr_size}`)
+    assert(hash_size == expected_hash, `{desc}: expected {expected_hash} hash slots, got {hash_size}`)
+end
+
+-- Basic cap behavior - 600 elements should get 768, not 1024
+local t = make_array(600)
+check_sizes(t, 768, 0, "600 elements")
+
+t = make_array(512)
+check_sizes(t, 512, 0, "512 threshold")
+
+t = make_array(513)
+check_sizes(t, 768, 0, "513 threshold")
+
+t = make_array(1500)
+check_sizes(t, 1536, 0, "1500 elements")
+
+t = make_array(2000)
+check_sizes(t, 2048, 0, "2000 elements")
+
+-- Boundary invariant - sparse table with boundary at high index
+-- Element at 1000 doesn't meet 50% threshold, goes to hash
+t = {}
+t[1] = true
+t[1000] = true
+check_sizes(t, 1, 1, "boundary invariant")
+
+-- Mixed array/hash - string keys don't affect array sizing
+t = make_array(600)
+t["foo"] = "bar"
+t["baz"] = "qux"
+check_sizes(t, 768, 2, "mixed keys")
+
+-- Small arrays (below threshold) - normal power-of-2 sizing
+t = make_array(100)
+check_sizes(t, 128, 0, "100 elements")
+
+-- Incremental growth
+t = make_array(520)
+check_sizes(t, 768, 0, "520 elements")
+
+-- Offset array - elements not starting from 1
+-- 600 elements at indices 401-1000, meets 50% threshold for 1024
+t = {}
+for i = 401, 1000 do
+    t[i] = true
+end
+check_sizes(t, 1024, 0, "offset array 401-1000")
+
+-- Sparse with gap - should not cap due to high max_idx
+t = make_array(1100)
+for i = 1500, 1549 do
+    t[i] = true
+end
+check_sizes(t, 2048, 0, "sparse with gap")
+
+-- Sequential growth across cap threshold
+t = make_array(400)
+check_sizes(t, 512, 0, "pre-growth 400 elements")
+for i = 401, 600 do
+    t[i] = true
+end
+check_sizes(t, 768, 0, "post-growth 600 elements")
+
+-- Index 0 goes to hash, not array
+t = make_array(600)
+t[0] = true
+check_sizes(t, 768, 1, "with index 0")
+
+-- Negative indices go to hash
+t = make_array(600)
+t[-1] = true
+t[-100] = true
+check_sizes(t, 768, 2, "with negative indices")
+
+-- Non-integer keys go to hash
+t = make_array(600)
+t[1.5] = true
+t[2.7] = true
+check_sizes(t, 768, 2, "with float indices")
+
+-- Exactly at power-of-2 boundaries
+t = make_array(1024)
+check_sizes(t, 1024, 0, "exactly 1024 elements")
+
+t = make_array(2048)
+check_sizes(t, 2048, 0, "exactly 2048 elements")
+
+-- table.create pre-allocates without rehash(), allows creating tables with
+--  sizes that rehash() would not normally create.
+t = table.create(1535, true)
+check_sizes(t, 1535, 0, "exactly 1535 elements")
+-- But it'll go to a "normal" size if we overfill it.
+t[1536] = 1
+check_sizes(t, 1536, 0, "resized to next increment after insert")
+t[1537] = 2
+check_sizes(t, 1792, 0, "second bigger resize")
+-- Double check we didn't muck up the data with either of those resizes
+assert(t[1536] == 1)
+assert(t[1537] == 2)
+
+-- Exact cap boundary - 1536 elements should get exactly 1536 slots
+t = make_array(1536)
+check_sizes(t, 1536, 0, "exactly 1536 elements")
+
+-- Just over cap boundary - 1537 elements should grow to 1792
+t = make_array(1537)
+check_sizes(t, 1792, 0, "1537 elements")
+
+-- Very large array - 10000 elements should get 10240, not 16384
+t = make_array(10000)
+check_sizes(t, 10240, 0, "10000 elements")
+
+-- Hash spillover triggers rehash and array growth
+-- Inserting beyond array size into dummynode triggers rehash
+t = make_array(1536)
+check_sizes(t, 1536, 0, "before spillover")
+-- These will go into hash because they're not sequential with array
+t.foo = true
+t.bar = true
+t.baz = true
+-- Should be one space free in `node`
+check_sizes(t, 1536, 4, "node insert - node grew")
+t[1538] = true
+check_sizes(t, 1536, 4, "after num insert - placed in node")
+
+-- This will overflow `t->node`, so it should try to resize array now
+t[1537] = true
+-- Note that node will NOT shrink, but the values will be moved!
+check_sizes(t, 1792, 4, "after spillover - array grew")
+assert(t[1538] == true, "1538 still present")
+
+-- System tables (memcat < 2) use power-of-2 sizing, no cap
+change_memcat(0)
+t = make_array(600)
+check_sizes(t, 1024, 0, "system table memcat 0")
+change_memcat(2)
+
+return "OK"