GraphCommitChanges

Documentation

API Reference

GraphCommitChanges

Description

Apply all pending edge removals and node deletion marks.

Deleted slots remain reusable and future nodes may reuse their slot indices with fresh generations. Any deleted node id or GraphNode handle becomes invalid immediately after commit returns.

This deferred mutation model is meant for passes that need stable traversal first and destructive graph rewrites second.

Parameters

Name	Direction	Description
`g`	in,out	Graph to commit.

Success

Returns the count of pending removals applied (explicit edge removals plus node deletion marks; cascading edge cleanup from node deletion is not counted separately). live_count shrinks by the number of deleted nodes; edge_count shrinks accordingly; pending-delete count drops to 0. Freed slot indices are pushed onto the reuse list with incremented generations; previously-stored payloads have been torn down via copy_deinit (if configured). All previously-issued node ids and GraphNode handles for the deleted nodes are now stale.

Failure

Does not return - aborts via LOG_FATAL for an invalid graph (caller bug).

Usage example (Cross-references)

Usage examples (Cross-references)

In Ops.c:34:

    
    static bool test_graph_mark_delete_commit_and_reuse(void) {
        WriteFmt("Testing GraphMarkNodeForDeletion and GraphCommitChanges\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Ops.c:56:

    
        bool result  = GraphContainsNode(&graph, b) && (graph.pending_delete_count == 1);
        u64  removed = GraphCommitChanges(&graph);
    
        result = result && (removed == 1);

In Ops.c:98:

        result      = result && !GraphNodeMarkedForDeletion(node);
        result      = result && !GraphUnmarkNodeForDeletion(node);
        result      = result && (GraphCommitChanges(&graph) == 0);
        result      = result && GraphContainsNode(&graph, a);
        result      = result && (GraphNodeCount(&graph) == 1);

In Ops.c:138:

        result      = result && !GraphMarkEdgeForRemoval(&graph, c, b);
    
        u64 committed = GraphCommitChanges(&graph);
    
        result = result && (committed == 2);

In Ops.c:176:

        result      = result && !GraphEdgeMarkedForRemoval(&graph, a, b);
        result      = result && !GraphUnmarkEdgeForRemoval(&graph, a, b);
        result      = result && (GraphCommitChanges(&graph) == 0);
        result      = result && GraphHasEdge(&graph, a, b);
        result      = result && (GraphEdgeCount(&graph) == 1);

In Ops.c:207:

        result      = result && !GraphEdgeMarkedForRemoval(&graph, a, b);
        result      = result && GraphEdgeMarkedForRemoval(&graph, a, c);
        result      = result && (GraphCommitChanges(&graph) == 1);
        result      = result && GraphHasEdge(&graph, a, b);
        result      = result && !GraphHasEdge(&graph, a, c);

In Ops.c:235:

        result      = result && (GraphPredecessorAt(&graph, a, 0) == a);
        result      = result && GraphMarkEdgeForRemoval(&graph, a, a);
        result      = result && (GraphCommitChanges(&graph) == 1);
        result      = result && (GraphEdgeCount(&graph) == 0);
        result      = result && (GraphOutDegree(&graph, a) == 0);

In Ops.c:266:

        result      = result && GraphEdgeMarkedForRemoval(&graph, a, b);
        result      = result && GraphNodeMarkedForDeletion(GraphGetNode(&graph, b));
        result      = result && (GraphCommitChanges(&graph) == 2);
        result      = result && !GraphContainsNode(&graph, b);
        result      = result && (GraphNodeCount(&graph) == 3);

In Ops.c:297:

    
        bool result = GraphMarkNodeForDeletion(GraphGetNode(&graph, b));
        result      = result && (GraphCommitChanges(&graph) == 1);
        result      = result && !GraphContainsNode(&graph, b);

In Ops.c:328:

    
        (void)GraphMarkNodeForDeletion(node);
        (void)GraphCommitChanges(&graph);
        (void)GraphNodeVisit(node);

In Ops.c:364:

        GraphMarkNodeForDeletion(GraphGetNode(&graph, b));
    
        u64 committed = GraphCommitChanges(&graph);
    
        bool result = (committed == 1);

In Ops.c:399:

        // Delete b so its slot is free at the time GraphClear walks it.
        bool result = GraphMarkNodeForDeletion(GraphGetNode(&graph, b));
        result      = result && (GraphCommitChanges(&graph) == 1);
        result      = result && !GraphContainsNode(&graph, b);
        (void)a;

In Ops.c:435:

        // One deletion leaves a single entry in free_indices going into clear.
        bool result = GraphMarkNodeForDeletion(GraphGetNode(&graph, b));
        result      = result && (GraphCommitChanges(&graph) == 1);
    
        GraphClear(&graph);

In Ops.c:471:

        // First commit frees b's slot (free-list entry, generation bumped).
        bool result  = GraphMarkNodeForDeletion(GraphGetNode(&graph, b));
        u64  removed = GraphCommitChanges(&graph);
        result       = result && (removed == 1);
        result       = result && !GraphContainsNode(&graph, b);

In Ops.c:478:

        // iterate every slot; the free slot must be skipped, not validated.
        result  = result && GraphMarkNodeForDeletion(GraphGetNode(&graph, a));
        removed = GraphCommitChanges(&graph);
    
        result = result && (removed == 1);

In Ops.c:507:

    
        (void)GraphMarkNodeForDeletion(GraphGetNode(&graph, a));
        (void)GraphCommitChanges(&graph);
        (void)GraphAddNodeR(&graph, 99); // reuse a's slot, a is now stale

In Ops.c:531:

    
        (void)GraphMarkNodeForDeletion(GraphGetNode(&graph, b));
        (void)GraphCommitChanges(&graph);
        (void)GraphAddNodeR(&graph, 99); // reuse b's slot, b is now stale

In Ops.c:557:

    
        (void)GraphMarkNodeForDeletion(GraphGetNode(&graph, a));
        (void)GraphCommitChanges(&graph);
        (void)GraphAddNodeR(&graph, 99); // reuse a's slot, a is now stale

In Ops.c:581:

    
        (void)GraphMarkNodeForDeletion(GraphGetNode(&graph, b));
        (void)GraphCommitChanges(&graph);
        (void)GraphAddNodeR(&graph, 99); // reuse b's slot, b is now stale

In Ops.c:645:

        // returns the explicit-removal count (1). Mutant: over-scan finds stale b,
        // in-side find fails -> abort.
        u64 committed = GraphCommitChanges(&graph);
        result        = result && (committed == 1);

In Ops.c:695:

        GENERIC_GRAPH(&graph)->__magic &= ~MAGIC_VALIDATED_BIT;
    
        u64 removed = GraphCommitChanges(&graph);
    
        // Restore the hidden slot (real code never touched it).

In Ops.c:749:

        GENERIC_GRAPH(&graph)->__magic &= ~MAGIC_VALIDATED_BIT;
    
        u64 removed = GraphCommitChanges(&graph);
    
        // Restore the hidden slot (real code never reached it; c is still marked).

In Insert.c:157:

    
        (void)GraphMarkNodeForDeletion(GraphGetNode(&graph, b));
        (void)GraphCommitChanges(&graph);
    
        u64         old_epoch = GraphMutationEpoch(&graph);

In Insert.c:188:

    
        (void)GraphMarkNodeForDeletion(GraphGetNode(&graph, b));
        (void)GraphCommitChanges(&graph);
    
        g_fail_copy           = true;

In Insert.c:224:

    
        (void)GraphMarkNodeForDeletion(GraphGetNode(&graph, b));
        (void)GraphCommitChanges(&graph);
    
        g_fail_copy = true;

In Insert.c:305:

        // Delete + commit b so its slot lands on the free list (reuse target).
        bool result = GraphMarkNodeForDeletion(GraphGetNode(&graph, b));
        result      = result && (GraphCommitChanges(&graph) == 1);
    
        size before = DebugAllocatorLiveCount(&dbg);

In Type.c:377:

    
        (void)GraphMarkNodeForDeletion(GraphGetNode(&graph, b));
        (void)GraphCommitChanges(&graph);
    
        GenericGraph *g = GENERIC_GRAPH(&graph);

In Type.c:407:

    
        (void)GraphMarkNodeForDeletion(GraphGetNode(&graph, b));
        (void)GraphCommitChanges(&graph);
    
        GenericGraph *g = GENERIC_GRAPH(&graph);

In Type.c:438:

        (void)GraphMarkNodeForDeletion(GraphGetNode(&graph, b));
        (void)GraphMarkNodeForDeletion(GraphGetNode(&graph, c));
        (void)GraphCommitChanges(&graph);
    
        GenericGraph *g = GENERIC_GRAPH(&graph);

In Foreach.c:338:

        // live slots, then commit so the deletion materializes.
        (void)GraphMarkNodeForDeletion(GraphGetNode(&graph, b));
        (void)GraphCommitChanges(&graph);
    
        u64 visited = 0;

In Foreach.c:450:

        GraphNode stale = GraphGetNode(&graph, a);
        (void)GraphMarkNodeForDeletion(GraphGetNode(&graph, a));
        (void)GraphCommitChanges(&graph);
        (void)GraphAddNodeR(&graph, 99); // reuse a's slot at a higher generation

In Foreach.c:540:

    // aborts on the next iteration step -> DEADEND.
    static bool test_graph_commit_invalidates_live_iterator_deadend(void) {
        WriteFmt("Testing GraphCommitChanges invalidates a live node iterator (should abort)\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Foreach.c:556:

            // mutation epoch, so the iterator's next step must abort.
            (void)GraphMarkNodeForDeletion(GraphGetNode(&graph, b));
            (void)GraphCommitChanges(&graph);
        }

In Access.c:205:

        // GraphNodeIdGeneration(a) + 1.
        result = result && GraphMarkNodeForDeletion(GraphGetNode(&graph, a));
        result = result && (GraphCommitChanges(&graph) == 1);
        result = result && !GraphContainsNode(&graph, a);

In Access.c:269:

    
        (void)GraphMarkNodeForDeletion(GraphGetNode(&graph, a));
        (void)GraphCommitChanges(&graph);
    
        // a now refers to a freed slot with a stale generation.

In Access.c:318:

    
        (void)GraphMarkNodeForDeletion(GraphGetNode(&graph, a));
        (void)GraphCommitChanges(&graph);
        // Reuse a's slot at a higher generation; `a` is now stale.
        (void)GraphAddNodeR(&graph, 99);

In Access.c:350:

    
        (void)GraphMarkNodeForDeletion(GraphGetNode(&graph, a));
        (void)GraphCommitChanges(&graph);
    
        // Slot a's index is now free with generation bumped to gen(a)+1. Build an

Last updated on July 1, 2026

GraphClear GraphContainsNode