TaskManager optimization

src/neo/Ledger/Blockchain.cs

@@ -310,10 +310,15 @@ private void OnNewHeaders(Header[] headers)
             {
                 if (header.Index > headerHeight + 1) break;
                 if (header.Index < headerHeight + 1) continue;
-                if (!header.Verify(system.Settings, snapshot, system.HeaderCache)) break;
+                if (!header.Verify(system.Settings, snapshot, system.HeaderCache))
+                {
+                    Sender.Tell(VerifyResult.Invalid);
+                    break;
+                }
                 system.HeaderCache.Add(header);
                 ++headerHeight;
             }
+            system.TaskManager.Tell(headers, Sender);
         }
 
         private VerifyResult OnNewExtensiblePayload(ExtensiblePayload payload)

src/neo/Network/P2P/RemoteNode.ProtocolHandler.cs

@@ -299,14 +299,14 @@ private void OnGetHeadersMessageReceived(GetBlockByIndexPayload payload)
         private void OnHeadersMessageReceived(HeadersPayload payload)
         {
             UpdateLastBlockIndex(payload.Headers[^1].Index);
-            system.TaskManager.Tell(payload.Headers);
             system.Blockchain.Tell(payload.Headers);
         }
 
         private void OnInventoryReceived(IInventory inventory)
         {
             knownHashes.Add(inventory.Hash);
             pendingKnownHashes.Remove(inventory.Hash);
+            system.TaskManager.Tell(inventory);
             switch (inventory)
             {
                 case Transaction transaction:
@@ -322,7 +322,6 @@ private void OnInventoryReceived(IInventory inventory)
                     system.Blockchain.Tell(inventory);
                     break;
             }
-            system.TaskManager.Tell(inventory);
         }
 
         private void OnInvMessageReceived(InvPayload payload)

src/neo/Network/P2P/TaskManager.cs

@@ -62,6 +62,7 @@ private class Timer { }
         private readonly Dictionary<uint, int> globalIndexTasks = new();
         private readonly Dictionary<IActorRef, TaskSession> sessions = new();
         private readonly ICancelable timer = Context.System.Scheduler.ScheduleTellRepeatedlyCancelable(TimerInterval, TimerInterval, Context.Self, new Timer(), ActorRefs.NoSender);
+        private uint lastSeenPersistedIndex = 0;
 
         private bool HasHeaderTask => globalInvTasks.ContainsKey(HeaderTaskHash);
 
@@ -136,6 +137,8 @@ private void OnNewTasks(InvPayload payload)
 
         private void OnPersistCompleted(Block block)
         {
+            lastSeenPersistedIndex = block.Index;
+
             foreach (var (actor, session) in sessions)
                 if (session.ReceivedBlock.Remove(block.Index, out Block receivedBlock))
                 {
@@ -236,7 +239,10 @@ private void OnTaskCompleted(IInventory inventory)
                         session.ReceivedBlock.Add(block.Index, block);
                     }
                 }
-                RequestTasks(Sender, session);
+                if (inventory is not Block)
+                {
+                    RequestTasks(Sender, session);
+                }
             }
         }
 
@@ -372,7 +378,7 @@ private void RequestTasks(IActorRef remoteNode, TaskSession session)
             }
 
             uint currentHeight = NativeContract.Ledger.CurrentIndex(snapshot);
-            uint headerHeight = system.HeaderCache.Last?.Index ?? currentHeight;
+            uint headerHeight = (system.HeaderCache.Last?.Index ?? currentHeight) + 1;
             // When the number of AvailableTasks is no more than 0, no pending tasks of InventoryType.Block, it should process pending the tasks of headers
             // If not HeaderTask pending to be processed it should ask for more Blocks
             if ((!HasHeaderTask || globalInvTasks[HeaderTaskHash] < MaxConncurrentTasks) && headerHeight < session.LastBlockIndex && !system.HeaderCache.Full)
@@ -383,8 +389,8 @@ private void RequestTasks(IActorRef remoteNode, TaskSession session)
             }
             else if (currentHeight < session.LastBlockIndex)
             {
-                uint startHeight = currentHeight;
-                while (globalIndexTasks.ContainsKey(++startHeight)) { }
+                uint startHeight = Math.Max(currentHeight, lastSeenPersistedIndex + 1);
+                while (globalIndexTasks.ContainsKey(startHeight) || session.ReceivedBlock.ContainsKey(startHeight)) { startHeight++; }
                 if (startHeight > session.LastBlockIndex || startHeight >= currentHeight + InvPayload.MaxHashesCount) return;
                 uint endHeight = startHeight;
                 while (!globalIndexTasks.ContainsKey(++endHeight) && endHeight <= session.LastBlockIndex && endHeight <= currentHeight + InvPayload.MaxHashesCount) { }