cache query major chunks: first impl

develop/all.lua

@@ -21,6 +21,8 @@ local basics = require 'develop.basics'
 print '----------------------------------------'
 basics.describe_fuzz 'develop.fuzzing.destroy_fuzz'
 print '----------------------------------------'
+basics.describe_fuzz 'develop.fuzzing.execute_fuzz'
+print '----------------------------------------'
 basics.describe_fuzz 'develop.fuzzing.batch_destroy_fuzz'
 print '----------------------------------------'
 basics.describe_fuzz 'develop.fuzzing.explicit_fuzz'

develop/fuzzing/execute_fuzz.lua

@@ -0,0 +1,237 @@
+local evo = require 'evolved'
+
+evo.debug_mode(true)
+
+---
+---
+---
+---
+---
+
+local __table_unpack = (function()
+    ---@diagnostic disable-next-line: deprecated
+    return table.unpack or unpack
+end)()
+
+---
+---
+---
+---
+---
+
+local all_fragment_list = {} ---@type evolved.fragment[]
+
+for i = 1, math.random(1, 10) do
+    local fragment = evo.id()
+    all_fragment_list[i] = fragment
+end
+
+---@param query evolved.query
+local function generate_query(query)
+    local include_set = {}
+    local include_list = {}
+    local include_count = 0
+
+    for _ = 1, math.random(0, #all_fragment_list) do
+        local include = all_fragment_list[math.random(1, #all_fragment_list)]
+
+        if not include_set[include] then
+            include_count = include_count + 1
+            include_set[include] = include_count
+            include_list[include_count] = include
+        end
+    end
+
+    local exclude_set = {}
+    local exclude_list = {}
+    local exclude_count = 0
+
+    for _ = 1, math.random(0, #all_fragment_list) do
+        local exclude = all_fragment_list[math.random(1, #all_fragment_list)]
+
+        if not exclude_set[exclude] then
+            exclude_count = exclude_count + 1
+            exclude_set[exclude] = exclude_count
+            exclude_list[exclude_count] = exclude
+        end
+    end
+
+    if include_count > 0 then
+        evo.set(query, evo.INCLUDES, include_list)
+    end
+
+    if exclude_count > 0 then
+        evo.set(query, evo.EXCLUDES, exclude_list)
+    end
+end
+
+---@param query_count integer
+---@return evolved.query[] query_list
+---@return integer query_count
+---@nodiscard
+local function generate_queries(query_count)
+    local query_list = {} ---@type evolved.query[]
+
+    for i = 1, query_count do
+        local query = evo.id()
+        query_list[i] = query
+        generate_query(query)
+    end
+
+    return query_list, query_count
+end
+
+---@param entity evolved.entity
+local function generate_entity(entity)
+    for _ = 0, math.random(0, #all_fragment_list) do
+        local fragment = all_fragment_list[math.random(1, #all_fragment_list)]
+        evo.set(entity, fragment)
+    end
+end
+
+---@param entity_count integer
+---@return evolved.entity[] entity_list
+---@return integer entity_count
+local function generate_entities(entity_count)
+    local entity_list = {} ---@type evolved.entity[]
+
+    for i = 1, entity_count do
+        local entity = evo.id()
+        entity_list[i] = entity
+        generate_entity(entity)
+    end
+
+    return entity_list, entity_count
+end
+
+local pre_query_list, pre_query_count = generate_queries(math.random(1, 10))
+local pre_entity_list, pre_entity_count = generate_entities(math.random(1, 10))
+
+for _ = 1, math.random(1, 5) do
+    local fragment = all_fragment_list[math.random(1, #all_fragment_list)]
+
+    evo.set(fragment, evo.EXPLICIT)
+end
+
+for _ = 1, math.random(1, 5) do
+    local query = pre_query_list[math.random(1, pre_query_count)]
+
+    if math.random(1, 2) == 1 then
+        generate_query(query)
+    else
+        if math.random(1, 2) == 1 then
+            evo.remove(query, evo.INCLUDES)
+        else
+            evo.remove(query, evo.EXCLUDES)
+        end
+    end
+end
+
+local post_query_list, post_query_count = generate_queries(math.random(1, 10))
+local post_entity_list, post_entity_count = generate_entities(math.random(1, 10))
+
+---
+---
+---
+---
+---
+
+local all_query_list = {}
+local all_query_count = 0
+local all_entity_list = {}
+local all_entity_count = 0
+
+for i = 1, pre_query_count do
+    all_query_count = all_query_count + 1
+    all_query_list[all_query_count] = pre_query_list[i]
+end
+
+for i = 1, post_query_count do
+    all_query_count = all_query_count + 1
+    all_query_list[all_query_count] = post_query_list[i]
+end
+
+for i = 1, pre_entity_count do
+    all_entity_count = all_entity_count + 1
+    all_entity_list[all_entity_count] = pre_entity_list[i]
+end
+
+for i = 1, post_entity_count do
+    all_entity_count = all_entity_count + 1
+    all_entity_list[all_entity_count] = post_entity_list[i]
+end
+
+---
+---
+---
+---
+---
+
+local function execute_query(query)
+    local query_chunk_set = {}
+    local query_entity_set = {}
+
+    local query_include_list = evo.get(query, evo.INCLUDES) or {}
+    local query_exclude_list = evo.get(query, evo.EXCLUDES) or {}
+
+    local query_include_set = {}
+    for _, include in ipairs(query_include_list) do
+        query_include_set[include] = true
+    end
+
+    for chunk, entity_list, entity_count in evo.execute(query) do
+        assert(not query_chunk_set[chunk])
+        query_chunk_set[chunk] = true
+
+        for i = 1, entity_count do
+            local entity = entity_list[i]
+            assert(not query_entity_set[entity])
+            query_entity_set[entity] = true
+        end
+
+        assert(chunk:has_all(__table_unpack(query_include_list)))
+        assert(not chunk:has_any(__table_unpack(query_exclude_list)))
+    end
+
+    for i = 1, all_entity_count do
+        local entity = all_entity_list[i]
+
+        local is_entity_matched =
+            evo.has_all(entity, __table_unpack(query_include_list))
+            and not evo.has_any(entity, __table_unpack(query_exclude_list))
+
+        for fragment in evo.each(entity) do
+            if evo.has(fragment, evo.EXPLICIT) and not query_include_set[fragment] then
+                is_entity_matched = false
+            end
+        end
+
+        if is_entity_matched then
+            assert(query_entity_set[entity])
+        else
+            assert(not query_entity_set[entity])
+        end
+    end
+end
+
+for i = 1, all_query_count do
+    execute_query(all_query_list[i])
+end
+
+---
+---
+---
+---
+---
+
+if math.random(1, 2) == 1 then
+    evo.collect_garbage()
+end
+
+evo.destroy(__table_unpack(all_query_list))
+evo.destroy(__table_unpack(all_entity_list))
+evo.destroy(__table_unpack(all_fragment_list))
+
+if math.random(1, 2) == 1 then
+    evo.collect_garbage()
+end

develop/untests.lua

@@ -6449,3 +6449,161 @@ do
     assert(b:has_all() and not b:has_any())
     assert(b:has(ff) and b:has(ft) and b:has_all(ff, ft) and b:has_any(ff, ft))
 end
+
+do
+    do
+        local f = evo.id()
+        local q = evo.builder():include(f):spawn()
+        local e = evo.builder():set(f, 42):spawn()
+
+        local iter, state = evo.execute(q)
+        local chunk, entity_list, entity_count = iter(state)
+        assert(chunk and entity_list and entity_count)
+        assert(chunk == evo.chunk(f) and entity_count == 1 and entity_list[1] == e)
+    end
+
+    do
+        local f = evo.id()
+        local e = evo.builder():set(f, 42):spawn()
+        local q = evo.builder():include(f):spawn()
+
+        local iter, state = evo.execute(q)
+        local chunk, entity_list, entity_count = iter(state)
+        assert(chunk and entity_list and entity_count)
+        assert(chunk == evo.chunk(f) and entity_count == 1 and entity_list[1] == e)
+    end
+
+    do
+        local f1, f2 = evo.id(2)
+        local q = evo.builder():exclude(f2):spawn()
+        local e = evo.builder():set(f1, 42):spawn()
+
+        local e_count = 0
+
+        for chunk, entity_list, entity_count in evo.execute(q) do
+            for i = 1, entity_count do
+                if entity_list[i] == e then
+                    e_count = e_count + 1
+                    assert(chunk == evo.chunk(f1))
+                    assert(chunk:components(f1)[1] == 42)
+                end
+            end
+        end
+
+        assert(e_count == 1)
+    end
+
+    do
+        local f1, f2, f3 = evo.id(3)
+        local q = evo.builder():exclude(f2):spawn()
+        local e1 = evo.builder():set(f1, 42):spawn()
+        local e2 = evo.builder():set(f1, 42):set(f3, 21):spawn()
+
+        local e1_count, e2_count = 0, 0
+
+        for chunk, entity_list, entity_count in evo.execute(q) do
+            for i = 1, entity_count do
+                if entity_list[i] == e1 then
+                    e1_count = e1_count + 1
+                    assert(chunk == evo.chunk(f1))
+                    assert(chunk:components(f1)[1] == 42)
+                end
+
+                if entity_list[i] == e2 then
+                    e2_count = e2_count + 1
+                    assert(chunk == evo.chunk(f1, f3))
+                    assert(chunk:components(f1)[1] == 42)
+                    assert(chunk:components(f3)[1] == 21)
+                end
+            end
+        end
+
+        assert(e1_count == 1)
+        assert(e2_count == 1)
+    end
+
+    do
+        local f1, f2 = evo.id(2)
+        local e = evo.builder():set(f1, 42):spawn()
+        local q = evo.builder():exclude(f2):spawn()
+
+        local e_count = 0
+
+        for chunk, entity_list, entity_count in evo.execute(q) do
+            for i = 1, entity_count do
+                if entity_list[i] == e then
+                    e_count = e_count + 1
+                    assert(chunk == evo.chunk(f1))
+                    assert(chunk:components(f1)[1] == 42)
+                end
+            end
+        end
+
+        assert(e_count == 1)
+    end
+
+    do
+        local f1, f2, f3 = evo.id(3)
+        local e1 = evo.builder():set(f1, 42):spawn()
+        local e2 = evo.builder():set(f1, 42):set(f3, 21):spawn()
+        local q = evo.builder():exclude(f2):spawn()
+
+        local e1_count, e2_count = 0, 0
+
+        for chunk, entity_list, entity_count in evo.execute(q) do
+            for i = 1, entity_count do
+                if entity_list[i] == e1 then
+                    e1_count = e1_count + 1
+                    assert(chunk == evo.chunk(f1))
+                    assert(chunk:components(f1)[1] == 42)
+                end
+
+                if entity_list[i] == e2 then
+                    e2_count = e2_count + 1
+                    assert(chunk == evo.chunk(f1, f3))
+                    assert(chunk:components(f1)[1] == 42)
+                    assert(chunk:components(f3)[1] == 21)
+                end
+            end
+        end
+
+        assert(e1_count == 1)
+        assert(e2_count == 1)
+    end
+end
+
+do
+    local f1, f2 = evo.id(2)
+    local q1 = evo.builder():include(f1):spawn()
+    local q2 = evo.builder():include(f2):spawn()
+    local e12 = evo.builder():set(f1, 42):set(f2, 21):spawn()
+
+    do
+        local iter, state = evo.execute(q1)
+        local chunk, entity_list, entity_count = iter(state)
+        assert(chunk and entity_list and entity_count)
+        assert(chunk == evo.chunk(f1, f2) and entity_count == 1 and entity_list[1] == e12)
+    end
+
+    do
+        local iter, state = evo.execute(q2)
+        local chunk, entity_list, entity_count = iter(state)
+        assert(chunk and entity_list and entity_count)
+        assert(chunk == evo.chunk(f1, f2) and entity_count == 1 and entity_list[1] == e12)
+    end
+
+    evo.set(f1, evo.EXPLICIT)
+
+    do
+        local iter, state = evo.execute(q1)
+        local chunk, entity_list, entity_count = iter(state)
+        assert(chunk and entity_list and entity_count)
+        assert(chunk == evo.chunk(f1, f2) and entity_count == 1 and entity_list[1] == e12)
+    end
+
+    do
+        local iter, state = evo.execute(q2)
+        local chunk, entity_list, entity_count = iter(state)
+        assert(not chunk and not entity_list and not entity_count)
+    end
+end