The most powerful and modular diffusion model GUI, api and backend with a graph/nodes interface. The fastest local inference engine in the world.
Revert "execution: fold in dependency aware caching / Fix --cache-none with l…" (#10422)
comfyanonymousb7992f871af3
diff --git a/comfy_execution/caching.py b/comfy_execution/caching.pyindex 566bc3f9c..41224ce3b 100644--- a/comfy_execution/caching.py+++ b/comfy_execution/caching.py@@ -265,26 +265,6 @@ class HierarchicalCache(BasicCache):assert cache is not Nonereturn await cache._ensure_subcache(node_id, children_ids)-class NullCache:-- async def set_prompt(self, dynprompt, node_ids, is_changed_cache):- pass-- def all_node_ids(self):- return []-- def clean_unused(self):- pass-- def get(self, node_id):- return None-- def set(self, node_id, value):- pass-- async def ensure_subcache_for(self, node_id, children_ids):- return self-class LRUCache(BasicCache):def __init__(self, key_class, max_size=100):super().__init__(key_class)@@ -336,3 +316,157 @@ class LRUCache(BasicCache):self._mark_used(child_id)self.children[cache_key].append(self.cache_key_set.get_data_key(child_id))return self+++class DependencyAwareCache(BasicCache):+ """+ A cache implementation that tracks dependencies between nodes and manages+ their execution and caching accordingly. It extends the BasicCache class.+ Nodes are removed from this cache once all of their descendants have been+ executed.+ """++ def __init__(self, key_class):+ """+ Initialize the DependencyAwareCache.++ Args:+ key_class: The class used for generating cache keys.+ """+ super().__init__(key_class)+ self.descendants = {} # Maps node_id -> set of descendant node_ids+ self.ancestors = {} # Maps node_id -> set of ancestor node_ids+ self.executed_nodes = set() # Tracks nodes that have been executed++ async def set_prompt(self, dynprompt, node_ids, is_changed_cache):+ """+ Clear the entire cache and rebuild the dependency graph.++ Args:+ dynprompt: The dynamic prompt object containing node information.+ node_ids: List of node IDs to initialize the cache for.+ is_changed_cache: Flag indicating if the cache has changed.+ """+ # Clear all existing cache data+ self.cache.clear()+ self.subcaches.clear()+ self.descendants.clear()+ self.ancestors.clear()+ self.executed_nodes.clear()++ # Call the parent method to initialize the cache with the new prompt+ await super().set_prompt(dynprompt, node_ids, is_changed_cache)++ # Rebuild the dependency graph+ self._build_dependency_graph(dynprompt, node_ids)++ def _build_dependency_graph(self, dynprompt, node_ids):+ """+ Build the dependency graph for all nodes.++ Args:+ dynprompt: The dynamic prompt object containing node information.+ node_ids: List of node IDs to build the graph for.+ """+ self.descendants.clear()+ self.ancestors.clear()+ for node_id in node_ids:+ self.descendants[node_id] = set()+ self.ancestors[node_id] = set()++ for node_id in node_ids:+ inputs = dynprompt.get_node(node_id)["inputs"]+ for input_data in inputs.values():+ if is_link(input_data): # Check if the input is a link to another node+ ancestor_id = input_data[0]+ self.descendants[ancestor_id].add(node_id)+ self.ancestors[node_id].add(ancestor_id)++ def set(self, node_id, value):+ """+ Mark a node as executed and store its value in the cache.++ Args:+ node_id: The ID of the node to store.+ value: The value to store for the node.+ """+ self._set_immediate(node_id, value)+ self.executed_nodes.add(node_id)+ self._cleanup_ancestors(node_id)++ def get(self, node_id):+ """+ Retrieve the cached value for a node.++ Args:+ node_id: The ID of the node to retrieve.++ Returns:+ The cached value for the node.+ """+ return self._get_immediate(node_id)++ async def ensure_subcache_for(self, node_id, children_ids):+ """+ Ensure a subcache exists for a node and update dependencies.++ Args:+ node_id: The ID of the parent node.+ children_ids: List of child node IDs to associate with the parent node.++ Returns:+ The subcache object for the node.+ """+ subcache = await super()._ensure_subcache(node_id, children_ids)+ for child_id in children_ids:+ self.descendants[node_id].add(child_id)+ self.ancestors[child_id].add(node_id)+ return subcache++ def _cleanup_ancestors(self, node_id):+ """+ Check if ancestors of a node can be removed from the cache.++ Args:+ node_id: The ID of the node whose ancestors are to be checked.+ """+ for ancestor_id in self.ancestors.get(node_id, []):+ if ancestor_id in self.executed_nodes:+ # Remove ancestor if all its descendants have been executed+ if all(descendant in self.executed_nodes for descendant in self.descendants[ancestor_id]):+ self._remove_node(ancestor_id)++ def _remove_node(self, node_id):+ """+ Remove a node from the cache.++ Args:+ node_id: The ID of the node to remove.+ """+ cache_key = self.cache_key_set.get_data_key(node_id)+ if cache_key in self.cache:+ del self.cache[cache_key]+ subcache_key = self.cache_key_set.get_subcache_key(node_id)+ if subcache_key in self.subcaches:+ del self.subcaches[subcache_key]++ def clean_unused(self):+ """+ Clean up unused nodes. This is a no-op for this cache implementation.+ """+ pass++ def recursive_debug_dump(self):+ """+ Dump the cache and dependency graph for debugging.++ Returns:+ A list containing the cache state and dependency graph.+ """+ result = super().recursive_debug_dump()+ result.append({+ "descendants": self.descendants,+ "ancestors": self.ancestors,+ "executed_nodes": list(self.executed_nodes),+ })+ return resultdiff --git a/comfy_execution/graph.py b/comfy_execution/graph.pyindex d5bbacde3..f4b427265 100644--- a/comfy_execution/graph.py+++ b/comfy_execution/graph.py@@ -153,9 +153,8 @@ class TopologicalSort:continue_, _, input_info = self.get_input_info(unique_id, input_name)is_lazy = input_info is not None and "lazy" in input_info and input_info["lazy"]- if (include_lazy or not is_lazy):- if not self.is_cached(from_node_id):- node_ids.append(from_node_id)+ if (include_lazy or not is_lazy) and not self.is_cached(from_node_id):+ node_ids.append(from_node_id)links.append((from_node_id, from_socket, unique_id))for link in links:@@ -195,34 +194,10 @@ class ExecutionList(TopologicalSort):super().__init__(dynprompt)self.output_cache = output_cacheself.staged_node_id = None- self.execution_cache = {}- self.execution_cache_listeners = {}def is_cached(self, node_id):return self.output_cache.get(node_id) is not None- def cache_link(self, from_node_id, to_node_id):- if not to_node_id in self.execution_cache:- self.execution_cache[to_node_id] = {}- self.execution_cache[to_node_id][from_node_id] = self.output_cache.get(from_node_id)- if not from_node_id in self.execution_cache_listeners:- self.execution_cache_listeners[from_node_id] = set()- self.execution_cache_listeners[from_node_id].add(to_node_id)-- def get_output_cache(self, from_node_id, to_node_id):- if not to_node_id in self.execution_cache:- return None- return self.execution_cache[to_node_id].get(from_node_id)-- def cache_update(self, node_id, value):- if node_id in self.execution_cache_listeners:- for to_node_id in self.execution_cache_listeners[node_id]:- self.execution_cache[to_node_id][node_id] = value-- def add_strong_link(self, from_node_id, from_socket, to_node_id):- super().add_strong_link(from_node_id, from_socket, to_node_id)- self.cache_link(from_node_id, to_node_id)-async def stage_node_execution(self):assert self.staged_node_id is Noneif self.is_empty():@@ -302,8 +277,6 @@ class ExecutionList(TopologicalSort):def complete_node_execution(self):node_id = self.staged_node_idself.pop_node(node_id)- self.execution_cache.pop(node_id, None)- self.execution_cache_listeners.pop(node_id, None)self.staged_node_id = Nonedef get_nodes_in_cycle(self):diff --git a/execution.py b/execution.pyindex 78c36a4b0..1dc35738b 100644--- a/execution.py+++ b/execution.py@@ -18,7 +18,7 @@ from comfy_execution.caching import (BasicCache,CacheKeySetID,CacheKeySetInputSignature,- NullCache,+ DependencyAwareCache,HierarchicalCache,LRUCache,)@@ -91,13 +91,13 @@ class IsChangedCache:class CacheType(Enum):CLASSIC = 0LRU = 1- NONE = 2+ DEPENDENCY_AWARE = 2class CacheSet:def __init__(self, cache_type=None, cache_size=None):- if cache_type == CacheType.NONE:- self.init_null_cache()+ if cache_type == CacheType.DEPENDENCY_AWARE:+ self.init_dependency_aware_cache()logging.info("Disabling intermediate node cache.")elif cache_type == CacheType.LRU:if cache_size is None:@@ -120,12 +120,11 @@ class CacheSet:self.ui = LRUCache(CacheKeySetInputSignature, max_size=cache_size)self.objects = HierarchicalCache(CacheKeySetID)- def init_null_cache(self):- self.outputs = NullCache()- #The UI cache is expected to be iterable at the end of each workflow- #so it must cache at least a full workflow. Use Heirachical- self.ui = HierarchicalCache(CacheKeySetInputSignature)- self.objects = NullCache()+ # only hold cached items while the decendents have not executed+ def init_dependency_aware_cache(self):+ self.outputs = DependencyAwareCache(CacheKeySetInputSignature)+ self.ui = DependencyAwareCache(CacheKeySetInputSignature)+ self.objects = DependencyAwareCache(CacheKeySetID)def recursive_debug_dump(self):result = {@@ -136,7 +135,7 @@ class CacheSet:SENSITIVE_EXTRA_DATA_KEYS = ("auth_token_comfy_org", "api_key_comfy_org")-def get_input_data(inputs, class_def, unique_id, execution_list=None, dynprompt=None, extra_data={}):+def get_input_data(inputs, class_def, unique_id, outputs=None, dynprompt=None, extra_data={}):is_v3 = issubclass(class_def, _ComfyNodeInternal)if is_v3:valid_inputs, schema = class_def.INPUT_TYPES(include_hidden=False, return_schema=True)@@ -154,10 +153,10 @@ def get_input_data(inputs, class_def, unique_id, execution_list=None, dynprompt=if is_link(input_data) and (not input_info or not input_info.get("rawLink", False)):input_unique_id = input_data[0]output_index = input_data[1]- if execution_list is None:+ if outputs is None:mark_missing()continue # This might be a lazily-evaluated input- cached_output = execution_list.get_output_cache(input_unique_id, unique_id)+ cached_output = outputs.get(input_unique_id)if cached_output is None:mark_missing()continue@@ -406,7 +405,6 @@ async def execute(server, dynprompt, caches, current_item, extra_data, executed,cached_output = caches.ui.get(unique_id) or {}server.send_sync("executed", { "node": unique_id, "display_node": display_node_id, "output": cached_output.get("output",None), "prompt_id": prompt_id }, server.client_id)get_progress_state().finish_progress(unique_id)- execution_list.cache_update(unique_id, caches.outputs.get(unique_id))return (ExecutionResult.SUCCESS, None, None)input_data_all = None@@ -436,7 +434,7 @@ async def execute(server, dynprompt, caches, current_item, extra_data, executed,for r in result:if is_link(r):source_node, source_output = r[0], r[1]- node_output = execution_list.get_output_cache(source_node, unique_id)[source_output]+ node_output = caches.outputs.get(source_node)[source_output]for o in node_output:resolved_output.append(o)@@ -448,7 +446,7 @@ async def execute(server, dynprompt, caches, current_item, extra_data, executed,has_subgraph = Falseelse:get_progress_state().start_progress(unique_id)- input_data_all, missing_keys, hidden_inputs = get_input_data(inputs, class_def, unique_id, execution_list, dynprompt, extra_data)+ input_data_all, missing_keys, hidden_inputs = get_input_data(inputs, class_def, unique_id, caches.outputs, dynprompt, extra_data)if server.client_id is not None:server.last_node_id = display_node_idserver.send_sync("executing", { "node": unique_id, "display_node": display_node_id, "prompt_id": prompt_id }, server.client_id)@@ -551,15 +549,11 @@ async def execute(server, dynprompt, caches, current_item, extra_data, executed,subcache.clean_unused()for node_id in new_output_ids:execution_list.add_node(node_id)- execution_list.cache_link(node_id, unique_id)for link in new_output_links:execution_list.add_strong_link(link[0], link[1], unique_id)pending_subgraph_results[unique_id] = cached_outputsreturn (ExecutionResult.PENDING, None, None)-caches.outputs.set(unique_id, output_data)- execution_list.cache_update(unique_id, output_data)-except comfy.model_management.InterruptProcessingException as iex:logging.info("Processing interrupted")diff --git a/main.py b/main.pyindex 4b4c5dcc4..35857dba8 100644--- a/main.py+++ b/main.py@@ -173,7 +173,7 @@ def prompt_worker(q, server_instance):if args.cache_lru > 0:cache_type = execution.CacheType.LRUelif args.cache_none:- cache_type = execution.CacheType.NONE+ cache_type = execution.CacheType.DEPENDENCY_AWAREe = execution.PromptExecutor(server_instance, cache_type=cache_type, cache_size=args.cache_lru)last_gc_collect = 0diff --git a/tests/execution/test_execution.py b/tests/execution/test_execution.pyindex ace0d2279..ef73ad9fd 100644--- a/tests/execution/test_execution.py+++ b/tests/execution/test_execution.py@@ -152,12 +152,12 @@ class TestExecution:# Initialize server and client#@fixture(scope="class", autouse=True, params=[- { "extra_args" : [], "should_cache_results" : True },- { "extra_args" : ["--cache-lru", 0], "should_cache_results" : True },- { "extra_args" : ["--cache-lru", 100], "should_cache_results" : True },- { "extra_args" : ["--cache-none"], "should_cache_results" : False },+ # (use_lru, lru_size)+ (False, 0),+ (True, 0),+ (True, 100),])- def server(self, args_pytest, request):+ def _server(self, args_pytest, request):# Start serverpargs = ['python','main.py',@@ -167,10 +167,12 @@ class TestExecution:'--extra-model-paths-config', 'tests/execution/extra_model_paths.yaml','--cpu',]- pargs += [ str(param) for param in request.param["extra_args"] ]+ use_lru, lru_size = request.param+ if use_lru:+ pargs += ['--cache-lru', str(lru_size)]print("Running server with args:", pargs) # noqa: T201p = subprocess.Popen(pargs)- yield request.param+ yieldp.kill()torch.cuda.empty_cache()@@ -191,7 +193,7 @@ class TestExecution:return comfy_client@fixture(scope="class", autouse=True)- def shared_client(self, args_pytest, server):+ def shared_client(self, args_pytest, _server):client = self.start_client(args_pytest["listen"], args_pytest["port"])yield clientdel client@@ -223,7 +225,7 @@ class TestExecution:assert result.did_run(mask)assert result.did_run(lazy_mix)- def test_full_cache(self, client: ComfyClient, builder: GraphBuilder, server):+ def test_full_cache(self, client: ComfyClient, builder: GraphBuilder):g = builderinput1 = g.node("StubImage", content="BLACK", height=512, width=512, batch_size=1)input2 = g.node("StubImage", content="NOISE", height=512, width=512, batch_size=1)@@ -235,12 +237,9 @@ class TestExecution:client.run(g)result2 = client.run(g)for node_id, node in g.nodes.items():- if server["should_cache_results"]:- assert not result2.did_run(node), f"Node {node_id} ran, but should have been cached"- else:- assert result2.did_run(node), f"Node {node_id} was cached, but should have been run"+ assert not result2.did_run(node), f"Node {node_id} ran, but should have been cached"- def test_partial_cache(self, client: ComfyClient, builder: GraphBuilder, server):+ def test_partial_cache(self, client: ComfyClient, builder: GraphBuilder):g = builderinput1 = g.node("StubImage", content="BLACK", height=512, width=512, batch_size=1)input2 = g.node("StubImage", content="NOISE", height=512, width=512, batch_size=1)@@ -252,12 +251,8 @@ class TestExecution:client.run(g)mask.inputs['value'] = 0.4result2 = client.run(g)- if server["should_cache_results"]:- assert not result2.did_run(input1), "Input1 should have been cached"- assert not result2.did_run(input2), "Input2 should have been cached"- else:- assert result2.did_run(input1), "Input1 should have been rerun"- assert result2.did_run(input2), "Input2 should have been rerun"+ assert not result2.did_run(input1), "Input1 should have been cached"+ assert not result2.did_run(input2), "Input2 should have been cached"def test_error(self, client: ComfyClient, builder: GraphBuilder):g = builder@@ -416,7 +411,7 @@ class TestExecution:input2 = g.node("StubImage", id="removeme", content="WHITE", height=512, width=512, batch_size=1)client.run(g)- def test_custom_is_changed(self, client: ComfyClient, builder: GraphBuilder, server):+ def test_custom_is_changed(self, client: ComfyClient, builder: GraphBuilder):g = builder# Creating the nodes in this specific order previously caused a bugsave = g.node("SaveImage")@@ -432,10 +427,7 @@ class TestExecution:result3 = client.run(g)result4 = client.run(g)assert result1.did_run(is_changed), "is_changed should have been run"- if server["should_cache_results"]:- assert not result2.did_run(is_changed), "is_changed should have been cached"- else:- assert result2.did_run(is_changed), "is_changed should have been re-run"+ assert not result2.did_run(is_changed), "is_changed should have been cached"assert result3.did_run(is_changed), "is_changed should have been re-run"assert result4.did_run(is_changed), "is_changed should not have been cached"@@ -522,7 +514,7 @@ class TestExecution:assert len(images2) == 1, "Should have 1 image"# This tests that only constant outputs are used in the call to `IS_CHANGED`- def test_is_changed_with_outputs(self, client: ComfyClient, builder: GraphBuilder, server):+ def test_is_changed_with_outputs(self, client: ComfyClient, builder: GraphBuilder):g = builderinput1 = g.node("StubConstantImage", value=0.5, height=512, width=512, batch_size=1)test_node = g.node("TestIsChangedWithConstants", image=input1.out(0), value=0.5)@@ -538,11 +530,7 @@ class TestExecution:images = result.get_images(output)assert len(images) == 1, "Should have 1 image"assert numpy.array(images[0]).min() == 63 and numpy.array(images[0]).max() == 63, "Image should have value 0.25"- if server["should_cache_results"]:- assert not result.did_run(test_node), "The execution should have been cached"- else:- assert result.did_run(test_node), "The execution should have been re-run"-+ assert not result.did_run(test_node), "The execution should have been cached"def test_parallel_sleep_nodes(self, client: ComfyClient, builder: GraphBuilder, skip_timing_checks):# Warmup execution to ensure server is fully initialized