/** * Returns all paths in the return stack. * Paths which have been processed are put in the return stack. * This function will pop all items from the stack and return them to e.g the Seeker requesting them. * * \param timeSlice Do not return all paths at once if it takes a long time, instead return some and wait until the next call. */ public void ReturnPaths(bool timeSlice) { // Pop all items from the stack Path p = pathReturnStack.PopAll(); if (pathReturnPop == null) { pathReturnPop = p; } else { Path tail = pathReturnPop; while (tail.next != null) { tail = tail.next; } tail.next = p; } // Hard coded limit on 1.0 ms long targetTick = timeSlice ? System.DateTime.UtcNow.Ticks + 1 * 10000 : 0; int counter = 0; // Loop through the linked list and return all paths while (pathReturnPop != null) { //Move to the next path Path prev = pathReturnPop; pathReturnPop = pathReturnPop.next; // Remove the reference to prevent possible memory leaks // If for example the first path computed was stored somewhere, // it would through the linked list contain references to all comming paths to be computed, // and thus the nodes those paths searched. // That adds up to a lot of memory not being released prev.next = null; //Return the path prev.ReturnPath(); // Will increment to Returned // However since multithreading is annoying, it might be set to ReturnQueue for a small time until the pathfinding calculation // thread advanced the state as well prev.AdvanceState(PathState.Returned); prev.ReleaseSilent(pathsClaimedSilentlyBy); counter++; // At least 5 paths will be returned, even if timeSlice is enabled if (counter > 5 && timeSlice) { counter = 0; if (System.DateTime.UtcNow.Ticks >= targetTick) { return; } } } }
static int ReleaseSilent(IntPtr L) { try { ToLua.CheckArgsCount(L, 2); Pathfinding.Path obj = (Pathfinding.Path)ToLua.CheckObject <Pathfinding.Path>(L, 1); object arg0 = ToLua.ToVarObject(L, 2); obj.ReleaseSilent(arg0); return(0); } catch (Exception e) { return(LuaDLL.toluaL_exception(L, e)); } }