Add per-node origin cap (nOriginsMax) to bound accumulation

Shared fanin cones can accumulate origins from all CO drivers,
causing O(n²) dedup cost in Gia_ObjAddOrigin. Add nOriginsMax
field to Gia_Man_t that short-circuits overflow-mode AddOrigin
when the node has reached the limit. Cap is set via &origins_id -M.

Pathological case (10K outputs, shared 50-deep cone):
  No cap:   5.70s, 1.01M total origins, max 10000/node
  -M 256:   0.79s, 45K total origins, max 256/node (7.2x faster)
Normal designs (i10.aig, max 165/node): identical results.

Co-developed-by: Claude Code v2.1.89 (claude-opus-4-6)

Author: robtaylor

src/aig/gia/gia.h

@@ -220,6 +220,7 @@ struct Gia_Man_t_
     Vec_Int_t *    vIdsEquiv;     // original object IDs proved equivalent
     Vec_Int_t *    vEquLitIds;    // original object IDs proved equivalent
     Vec_Int_t *    vOrigins;      // per-object origin mapping (from "y" extension)
+    int            nOriginsMax;   // max origins per object (0 = unlimited)
     Vec_Int_t *    vCofVars;      // cofactoring variables
     Vec_Vec_t *    vClockDoms;    // clock domains
     Vec_Flt_t *    vTiming;       // arrival/required/slack

src/aig/gia/giaDup.c

@@ -213,6 +213,9 @@ void Gia_ObjAddOrigin( Gia_Man_t * p, int iObj, int iOrig )
     e = Gia_ObjOriginsEntry( p, iObj );
     if ( Gia_ObjOriginsIsOverflow(e) )
     {
+        // cap check: skip if at user-specified limit
+        if ( p->nOriginsMax > 0 && e->large.count >= p->nOriginsMax )
+            return;
         // overflow mode: check for duplicate
         for ( k = 0; k < e->large.count; k++ )
             if ( e->large.overflow[k] == iOrig ) return;
@@ -331,6 +334,7 @@ void Gia_ManOriginsDup( Gia_Man_t * pNew, Gia_Man_t * pOld )
     if ( !pOld->vOrigins )
         return;
     Gia_ManOriginsReset( pNew );
+    pNew->nOriginsMax = pOld->nOriginsMax;
     pNew->vOrigins = Gia_ManOriginsAlloc( Gia_ManObjNum(pNew) );
     Gia_ManForEachObj( pOld, pObj, i )
     {
@@ -364,6 +368,7 @@ void Gia_ManOriginsDupVec( Gia_Man_t * pNew, Gia_Man_t * pOld, Vec_Int_t * vCopi
     if ( !pOld->vOrigins )
         return;
     Gia_ManOriginsReset( pNew );
+    pNew->nOriginsMax = pOld->nOriginsMax;
     pNew->vOrigins = Gia_ManOriginsAlloc( Gia_ManObjNum(pNew) );
     Vec_IntForEachEntry( vCopies, iLit, i )
     {
@@ -399,6 +404,7 @@ void Gia_ManOriginsAfterRoundTrip( Gia_Man_t * pNew, Gia_Man_t * pOld )
     assert( Gia_ManCiNum(pNew) == Gia_ManCiNum(pOld) );
     assert( Gia_ManCoNum(pNew) == Gia_ManCoNum(pOld) );
     Gia_ManOriginsReset( pNew );
+    pNew->nOriginsMax = pOld->nOriginsMax;
     pNew->vOrigins = Gia_ManOriginsAlloc( Gia_ManObjNum(pNew) );
     // const0
     Gia_ObjUnionOrigins( pNew, 0, pOld, 0 );
@@ -456,6 +462,7 @@ void Gia_ManOriginsDupIf( Gia_Man_t * pNew, Gia_Man_t * p, void * pIfManVoid )
     if ( !p->vOrigins )
         return;
     Gia_ManOriginsReset( pNew );
+    pNew->nOriginsMax = p->nOriginsMax;
     pNew->vOrigins = Gia_ManOriginsAlloc( Gia_ManObjNum(pNew) );
     If_ManForEachObj( pIfMan, pIfObj, i )
     {
@@ -1108,6 +1115,7 @@ Gia_Man_t * Gia_ManDupWithAttributes( Gia_Man_t * p )
     if ( p->pCellStr )
         pNew->pCellStr = Abc_UtilStrsav( p->pCellStr );
     // copy origins if present (deep-copy overflow arrays)
+    pNew->nOriginsMax = p->nOriginsMax;
     if ( p->vOrigins )
     {
         int iObj, nObjs;

src/base/abci/abc.c

@@ -35617,12 +35617,26 @@ int Abc_CommandAbc9Origins( Abc_Frame_t * pAbc, int argc, char ** argv )
 int Abc_CommandAbc9OriginsId( Abc_Frame_t * pAbc, int argc, char ** argv )
 {
     Gia_Man_t * pGia = pAbc->pGia;
-    int c;
+    int c, nOriginsMax = 0;
     Extra_UtilGetoptReset();
-    while ( ( c = Extra_UtilGetopt( argc, argv, "h" ) ) != EOF )
+    while ( ( c = Extra_UtilGetopt( argc, argv, "Mh" ) ) != EOF )
     {
         switch ( c )
         {
+        case 'M':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-M\" should be followed by an integer.\n" );
+                goto usage;
+            }
+            nOriginsMax = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            if ( nOriginsMax < 0 )
+            {
+                Abc_Print( -1, "The max origins value should be non-negative.\n" );
+                goto usage;
+            }
+            break;
         case 'h':
             goto usage;
         default:
@@ -35643,17 +35657,22 @@ int Abc_CommandAbc9OriginsId( Abc_Frame_t * pAbc, int argc, char ** argv )
     {
         int i, nObjs = Gia_ManObjNum(pGia);
         Gia_Obj_t * pObj;
+        pGia->nOriginsMax = nOriginsMax;
         pGia->vOrigins = Gia_ManOriginsAlloc( nObjs );
         Gia_ManForEachAnd( pGia, pObj, i )
             Gia_ObjSetOrigin( pGia, i, i );
-        Abc_Print( 1, "Initialized identity origins for %d AND nodes.\n", Gia_ManAndNum(pGia) );
+        Abc_Print( 1, "Initialized identity origins for %d AND nodes", Gia_ManAndNum(pGia) );
+        if ( nOriginsMax > 0 )
+            Abc_Print( 1, " (max %d per node)", nOriginsMax );
+        Abc_Print( 1, ".\n" );
     }
     return 0;
 
 usage:
-    Abc_Print( -2, "usage: &origins_id [-h]\n" );
+    Abc_Print( -2, "usage: &origins_id [-M num] [-h]\n" );
     Abc_Print( -2, "\t          sets identity origins for testing (each AND node -> itself)\n" );
     Abc_Print( -2, "\t          in normal abc9 flow, origins come from XAIGER \"y\" extension\n" );
+    Abc_Print( -2, "\t-M num  : max origins per object, 0 = unlimited [default = %d]\n", nOriginsMax );
     Abc_Print( -2, "\t-h      : print the command usage\n");
     return 1;
 }