public static void For(int from, int to, DelegateFor delFor) { DelegateProcess process = delegate(int chunkStart, int chunkEnd) { for (int i = chunkStart; i < chunkEnd; ++i) { delFor(i); } }; int cores = Environment.ProcessorCount; int chunks = (to - from) / cores; IAsyncResult[] asyncResults = new IAsyncResult[cores]; int end = 0; for (int i = 0; i < cores; ++i) { int start = i * chunks; end = Math.Min(start + chunks, to); asyncResults [i] = process.BeginInvoke(start, end, null, null); } for (int i = end; i < to; ++i) { delFor(i); } for (int i = 0; i < cores; ++i) { process.EndInvoke(asyncResults [i]); } }
internal void ProcessWithAllId(DelegateProcess delegateProcess) { var rowsSet = _session.Execute("select id, url from price_crl.html", 100); foreach (var VARIABLE in rowsSet) { long id = Convert.ToInt64(VARIABLE.GetValue(typeof(long), "id")); string url = Convert.ToString(VARIABLE.GetValue(typeof(string), "url")); delegateProcess(new Tuple <long, string>(id, url)); } }
/// <summary> /// Parallel for loop. Invokes given action, passing arguments /// fromInclusive - toExclusive on multiple threads. /// Returns when loop finished. /// </summary> public static void For(int fromInclusive, int toExclusive, ForDelegate forDelegate) { // chunkSize = 1 makes items to be processed in order. // Bigger chunk size should reduce lock waiting time and thus // increase paralelism. int chunkSize = 4; // number of process() threads int threadCount = Environment.ProcessorCount; int index = fromInclusive - chunkSize; // locker object shared by all the process() delegates object locker = new object(); // processing function // takes next chunk and processes it using action DelegateProcess process = delegate() { while (true) { int chunkStart = 0; lock (locker) { // take next chunk index += chunkSize; chunkStart = index; } // process the chunk // (another thread is processing another chunk // so the real order of items will be out-of-order) for (int i = chunkStart; i < chunkStart + chunkSize; i++) { if (i >= toExclusive) { return; } forDelegate(i); } } }; // launch process() threads IAsyncResult[] asyncResults = new IAsyncResult[threadCount]; for (int i = 0; i < threadCount; ++i) { asyncResults[i] = process.BeginInvoke(null, null); } // wait for all threads to complete for (int i = 0; i < threadCount; ++i) { process.EndInvoke(asyncResults[i]); } }
/// <summary> /// Parallel for loop. Invokes given action, passing arguments /// fromInclusive - toExclusive on multiple threads. /// Returns when loop finished. /// </summary> /// <param name="chunkSize"> /// chunkSize = 1 makes items to be processed in order. /// Bigger chunk size should reduce lock waiting time and thus /// increase paralelism. /// </param> /// <param name="threadCount">number of process() threads</param> public static void For(int fromInclusive, int toExclusive, int chunkSize, int threadCount, ForDelegate forDelegate) { int index = fromInclusive - chunkSize; // locker object shared by all the process() delegates object locker = new object(); // processing function // takes next chunk and processes it using action DelegateProcess process = delegate() { while (true) { int chunkStart = 0; lock (locker) { // take next chunk index += chunkSize; chunkStart = index; } // process the chunk // (another thread is processing another chunk // so the real order of items will be out-of-order) for (int i = chunkStart; i < chunkStart + chunkSize; i++) { if (i >= toExclusive) { return; } forDelegate(i); } } }; // launch process() threads IAsyncResult[] asyncResults = new IAsyncResult[threadCount]; for (int i = 0; i < threadCount; ++i) { asyncResults[i] = process.BeginInvoke(null, null); } // wait for all threads to complete for (int i = 0; i < threadCount; ++i) { process.EndInvoke(asyncResults[i]); } }
public static Process CreateLaserEnemyProcessChain(ProcessManager processManager, Engine engine, Entity entity, float waitTime, bool loop) { Process chain = new WaitProcess(waitTime); Process loopProcess = null; if (loop) { loopProcess = new DelegateProcess(() => { processManager.Attach(CreateLaserEnemyProcessChain(processManager, engine, entity, CVars.Get <float>("laser_enemy_successive_wait_period"), true)); }); } chain.SetNext(new LaserEnemyFreezeRotation(engine, entity)) .SetNext(new LaserWarmUpProcess(engine, entity)) .SetNext(new WaitProcess(CVars.Get <float>("laser_enemy_warm_up_duration"))) .SetNext(new LaserShootProcess(engine, entity)) .SetNext(new LaserEnemyUnfreezeRotation(engine, entity)) .SetNext(loopProcess); return(chain); }