optimize sync hot path and add dedicated perf benchmark

注意不要破坏公开api和现有测试

建议先生成专门的性能测试以对比效果

Author: codehz

src/__tests__/sync-hotpath.perf.test.ts

@@ -0,0 +1,79 @@
+import { describe, expect, it } from "bun:test";
+import { component, relation, type EntityId } from "../core/entity";
+import { World } from "../core/world";
+
+function benchmark(label: string, warmupRounds: number, measuredRounds: number, fn: (round: number) => void): number {
+  const durations: number[] = [];
+
+  const totalRounds = warmupRounds + measuredRounds;
+  for (let round = 0; round < totalRounds; round++) {
+    const start = performance.now();
+    fn(round);
+    const duration = performance.now() - start;
+    if (round >= warmupRounds) {
+      durations.push(duration);
+    }
+  }
+
+  const average = durations.reduce((sum, duration) => sum + duration, 0) / durations.length;
+  console.log(
+    `${label}: avg ${average.toFixed(2)}ms after ${warmupRounds} warmup rounds (${durations
+      .map((d) => d.toFixed(2))
+      .join("ms, ")}ms per measured round)`,
+  );
+  return average;
+}
+
+describe("World sync hot-path performance", () => {
+  it("should keep stable sync throughput for frequent set/remove patterns", () => {
+    const world = new World();
+    const Position = component<{ x: number; y: number }>();
+    const ChildOf = component({ dontFragment: true, exclusive: true });
+
+    const parentA = world.new();
+    const parentB = world.new();
+
+    const entityCount = 4000;
+    const entities: EntityId[] = [];
+
+    for (let i = 0; i < entityCount; i++) {
+      const entity = world.new();
+      entities.push(entity);
+      world.set(entity, Position, { x: i, y: i });
+      world.set(entity, relation(ChildOf, parentA));
+    }
+    world.sync();
+
+    const warmupRounds = 2;
+    const measuredRounds = 8;
+
+    const positionAverage = benchmark("position update + sync", warmupRounds, measuredRounds, (round) => {
+      for (let i = 0; i < entities.length; i++) {
+        const entity = entities[i]!;
+        world.set(entity, Position, { x: round, y: i });
+      }
+      world.sync();
+    });
+
+    const relationAverage = benchmark(
+      "exclusive dontFragment relation flip + sync",
+      warmupRounds,
+      measuredRounds,
+      (round) => {
+        const target = round % 2 === 0 ? parentB : parentA;
+        for (let i = 0; i < entities.length; i++) {
+          const entity = entities[i]!;
+          world.set(entity, relation(ChildOf, target));
+        }
+        world.sync();
+      },
+    );
+
+    expect(world.query([Position]).length).toBe(entityCount);
+    expect(world.query([relation(ChildOf, "*")]).length).toBe(entityCount);
+
+    // Guard against pathological regressions while keeping CI variance tolerance.
+    expect(positionAverage).toBeLessThan(250);
+    expect(relationAverage).toBeLessThan(350);
+  });
+});

src/core/archetype.ts

@@ -6,8 +6,8 @@ import {
   getWildcardRelationDataSource,
   isRelationType,
 } from "./archetype-helpers";
-import type { EntityId, WildcardRelationId } from "./entity";
 import { normalizeComponentTypes } from "./component-type-utils";
+import type { EntityId, WildcardRelationId } from "./entity";
 import {
   getComponentIdFromRelationId,
   getDetailedIdType,
@@ -156,6 +156,10 @@ export class Archetype {
     return entityData;
   }
 
+  getEntityDontFragmentRelations(entityId: EntityId): Map<EntityId<any>, any> | undefined {
+    return this.dontFragmentRelations.get(entityId);
+  }
+
   dump(): Array<{ entity: EntityId; components: Map<EntityId<any>, any> }> {
     return this.entities.map((entity, i) => {
       const components = new Map<EntityId<any>, any>();

src/core/world-commands.ts

@@ -103,10 +103,9 @@ export function removeMatchingRelations(
   }
 
   // Check dontFragment relations stored on entity
-  const entityData = archetype.getEntity(entityId);
-  if (entityData) {
-    for (const [componentType] of entityData) {
-      if (archetype.componentTypeSet.has(componentType)) continue;
+  const dontFragmentData = archetype.getEntityDontFragmentRelations(entityId);
+  if (dontFragmentData) {
+    for (const componentType of dontFragmentData.keys()) {
       if (getComponentIdFromRelationId(componentType) === baseComponentId) {
         changeset.delete(componentType);
       }
@@ -140,14 +139,9 @@ export function maybeRemoveWildcardMarker(
   }
 
   const wildcardMarker = relation(componentId, "*");
-  const entityData = archetype.getEntity(entityId);
-  if (!entityData) {
-    changeset.delete(wildcardMarker);
-    return;
-  }
 
   // Check if there are any other relations with the same component ID
-  for (const [otherComponentType] of entityData) {
+  for (const otherComponentType of archetype.componentTypes) {
     if (otherComponentType === removedComponentType) continue;
     if (otherComponentType === wildcardMarker) continue;
     if (changeset.removes.has(otherComponentType)) continue;
@@ -157,52 +151,99 @@ export function maybeRemoveWildcardMarker(
     }
   }
 
+  const dontFragmentData = archetype.getEntityDontFragmentRelations(entityId);
+  if (dontFragmentData) {
+    for (const otherComponentType of dontFragmentData.keys()) {
+      if (otherComponentType === removedComponentType) continue;
+      if (changeset.removes.has(otherComponentType)) continue;
+
+      if (getComponentIdFromRelationId(otherComponentType) === componentId) {
+        return; // Found another relation, keep the marker
+      }
+    }
+  }
+
   changeset.delete(wildcardMarker);
 }
 
+function hasEntityComponent(archetype: Archetype, entityId: EntityId, componentType: EntityId<any>): boolean {
+  if (archetype.componentTypeSet.has(componentType)) {
+    return true;
+  }
+
+  return archetype.getEntityDontFragmentRelations(entityId)?.has(componentType) ?? false;
+}
+
+function pruneMissingRemovals(changeset: ComponentChangeset, archetype: Archetype, entityId: EntityId): void {
+  for (const componentType of Array.from(changeset.removes)) {
+    if (!hasEntityComponent(archetype, entityId, componentType)) {
+      changeset.removes.delete(componentType);
+    }
+  }
+}
+
+function hasArchetypeStructuralChange(changeset: ComponentChangeset, currentArchetype: Archetype): boolean {
+  for (const componentType of changeset.removes) {
+    if (!isDontFragmentRelation(componentType) && currentArchetype.componentTypeSet.has(componentType)) {
+      return true;
+    }
+  }
+
+  for (const componentType of changeset.adds.keys()) {
+    if (!isDontFragmentRelation(componentType) && !currentArchetype.componentTypeSet.has(componentType)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function buildFinalRegularComponentTypes(currentArchetype: Archetype, changeset: ComponentChangeset): EntityId<any>[] {
+  const finalRegularTypes = new Set(currentArchetype.componentTypes);
+
+  for (const componentType of changeset.removes) {
+    if (!isDontFragmentRelation(componentType)) {
+      finalRegularTypes.delete(componentType);
+    }
+  }
+
+  for (const componentType of changeset.adds.keys()) {
+    if (!isDontFragmentRelation(componentType)) {
+      finalRegularTypes.add(componentType);
+    }
+  }
+
+  return Array.from(finalRegularTypes);
+}
+
 export function applyChangeset(
   ctx: CommandProcessorContext,
   entityId: EntityId,
   currentArchetype: Archetype,
   changeset: ComponentChangeset,
   entityToArchetype: Map<EntityId, Archetype>,
 ): { removedComponents: Map<EntityId<any>, any>; newArchetype: Archetype } {
-  const currentEntityData = currentArchetype.getEntity(entityId);
-  const allCurrentComponentTypes = currentEntityData
-    ? Array.from(currentEntityData.keys())
-    : currentArchetype.componentTypes;
-
-  const finalComponentTypes = changeset.getFinalComponentTypes(allCurrentComponentTypes);
   const removedComponents = new Map<EntityId<any>, any>();
-
-  if (finalComponentTypes) {
-    // Check if archetype-affecting components actually changed
-    // (dontFragment components don't affect archetype signature)
-    const currentRegularTypes = filterRegularComponentTypes(allCurrentComponentTypes);
-    const finalRegularTypes = filterRegularComponentTypes(finalComponentTypes);
-    const archetypeChanged = !areComponentTypesEqual(currentRegularTypes, finalRegularTypes);
-
-    if (archetypeChanged) {
-      // Move to new archetype (regular components changed)
-      const newArchetype = moveEntityToNewArchetype(
-        ctx,
-        entityId,
-        currentArchetype,
-        finalComponentTypes,
-        changeset,
-        removedComponents,
-        entityToArchetype,
-      );
-      return { removedComponents, newArchetype };
-    } else {
-      // Only dontFragment components changed, stay in same archetype
-      updateEntityInSameArchetype(ctx, entityId, currentArchetype, changeset, removedComponents);
-    }
-  } else {
-    // Update in same archetype
-    updateEntityInSameArchetype(ctx, entityId, currentArchetype, changeset, removedComponents);
+  pruneMissingRemovals(changeset, currentArchetype, entityId);
+  const archetypeChanged = hasArchetypeStructuralChange(changeset, currentArchetype);
+
+  if (archetypeChanged) {
+    const finalRegularTypes = buildFinalRegularComponentTypes(currentArchetype, changeset);
+    const newArchetype = moveEntityToNewArchetype(
+      ctx,
+      entityId,
+      currentArchetype,
+      finalRegularTypes,
+      changeset,
+      removedComponents,
+      entityToArchetype,
+    );
+    return { removedComponents, newArchetype };
   }
 
+  // No archetype move needed: only component payload updates and/or dontFragment relation updates.
+  updateEntityInSameArchetype(ctx, entityId, currentArchetype, changeset, removedComponents);
+
   return { removedComponents, newArchetype: currentArchetype };
 }