some progress bah

Author: emwang-jump

src/discof/forest/fd_forest.c

@@ -1086,17 +1086,29 @@ fd_forest_evict( fd_forest_t * forest, ulong new_slot, ulong parent_slot ) {
   ulong                  null     = fd_forest_pool_idx_null( pool );
 
 
-  int has_orphans = !fd_forest_subtlist_is_empty( subtlist, pool );
+  int has_orphans   = !fd_forest_subtlist_is_empty( subtlist, pool );
   int parent_exists = fd_forest_query( forest, parent_slot )!=NULL;
 
   /* During regular operation there's usually no orphans, but if eviction
      is called then it's likely we have orphans. */
   if( FD_LIKELY( has_orphans ) ) {
     /* We'll keep it if it's older than all of our orphans, or if it's
        parent is part of the main tree. */
+
+    ulong evict_orphan_slot = ULONG_MAX; /* best orphan candidate for eviction is the newest one. */
+    for( fd_forest_subtlist_iter_t iter = fd_forest_subtlist_iter_fwd_init( subtlist, pool );
+                                         !fd_forest_subtlist_iter_done( iter, subtlist, pool );
+                                   iter = fd_forest_subtlist_iter_fwd_next( iter, subtlist, pool ) ) {
+      fd_forest_blk_t * ele = fd_forest_subtlist_iter_ele( iter, subtlist, pool );
+      if( FD_LIKELY( evict_orphan_slot == ULONG_MAX ) ) evict_orphan_slot = ele->slot;
+      else                                              evict_orphan_slot = fd_ulong_max( evict_orphan_slot, ele->slot );
+
+    }
+    /// TODO: idk should we evict the whole subtree??? or just like the leafy
     if( fd_forest_ancestry_ele_query( ancestry, &parent_slot, NULL, pool ) ||
         fd_forest_frontier_ele_query( frontier, &parent_slot, NULL, pool ) ) {
       // choose something to evict from orphans
+
       return SLOT_INSERT;
     }
 
@@ -1117,22 +1129,38 @@ fd_forest_evict( fd_forest_t * forest, ulong new_slot, ulong parent_slot ) {
     if( FD_LIKELY( parent_exists ) ) {
       /* Parent exists. This slot chains to the main tree.  From oldest to newest,
          choose an unconfirmed leaf to evict. */
-      ulong unconfirmed_leaves[128];
-      uint  cnt = 0;
+      ulong evict_slot = ULONG_MAX;
+      uint  fork_cnt   = 0;
       for( fd_forest_frontier_iter_t iter = fd_forest_frontier_iter_init( frontier, pool );
                                            !fd_forest_frontier_iter_done( iter, frontier, pool );
                                      iter = fd_forest_frontier_iter_next( iter, frontier, pool ) ) {
         fd_forest_blk_t * ele = fd_forest_frontier_iter_ele( iter, frontier, pool );
         if( !ele->confirmed ) {
-          unconfirmed_leaves[cnt++] = ele->slot;
-          if( FD_UNLIKELY( cnt == 128 ) ) break; // It doesn't matter if we don't get all the unconfirmed leaves, we'll just evict the oldest from what we've seen.
+          if( FD_UNLIKELY( evict_slot == ULONG_MAX ) ) evict_slot = ele->slot;
+          else                                         evict_slot = fd_ulong_min( evict_slot, ele->slot );
         }
+        fork_cnt++;
       }
 
-      /* Take the oldest unconfirmed leaf */
-       
-
+      if( FD_UNLIKELY( evict_slot == ULONG_MAX ) ) {
+        /* It should be impossible to confirm more than
+           one fork (one leaf) at a time. If there is NO leaf that is
+           unconfirmed, then that means there's either multiple forks
+           that have been confirmed ( in this case its JOVER. For
+           EVERYONE!), or that we have only one fork, that has been
+           confirmed, but it hasn't been rooted in SLOT_MAX.  Now it's
+           possible that the leaf of our one fork has been confirmed,
+           but we're still in the process of confirming all of it's
+           ancestors.  In that case... we can't evict anything, but our
+           state is POTENTIALLY valid (but unlikely) */
+        FD_TEST( fork_cnt >= 1 );
+        if( FD_UNLIKELY( fork_cnt > 1 )) FD_LOG_CRIT(( "Multiple forks confirmed. Ignore? Crit? Pick..." ));
+        else                             return SLOT_IGNORE;
+      } else {
+        /* evict slot found. EVICT IT. */
 
+        return SLOT_INSERT;
+      }
     } else {
       /* Parent does not exist.  This new slot would've been added as an orphan. */
       return SLOT_IGNORE;