public static void CancelBeforeWait()
{
CountdownEvent countdownEvent = new CountdownEvent(2);
CancellationTokenSource cs = new CancellationTokenSource();
cs.Cancel();
CancellationToken ct = cs.Token;
const int millisec = 100;
TimeSpan timeSpan = new TimeSpan(100);
string message = "CancelBeforeWait: > Cancellation token does not match.";
EnsureOperationCanceledExceptionThrown(() => countdownEvent.Wait(ct), ct, message);
EnsureOperationCanceledExceptionThrown(() => countdownEvent.Wait(millisec, ct), ct, message);
EnsureOperationCanceledExceptionThrown(() => countdownEvent.Wait(timeSpan, ct), ct, message);
countdownEvent.Dispose();
}
// Tries some simple timeout cases.
private static void RunCountdownEventTest1_SimpleTimeout(int ms)
{
// Wait on the event.
CountdownEvent ev = new CountdownEvent(999);
Assert.False(ev.Wait(ms));
Assert.False(ev.IsSet);
Assert.False(ev.WaitHandle.WaitOne(ms));
}
public static void RunPartitionerStaticTest_SingleChunking()
{
CountdownEvent cde = new CountdownEvent(2);
Action[] actions = new Action[256];
// The thinking here is that we'll put enough "filler" into this array to
// insure that "natural" chunk size is greater than 2. Without the
// NoBuffering option, the Parallel.ForEach below is certain to deadlock.
// Somewhere a Signal() is going to be after a Wait() in the same chunk, and
// the loop will deadlock.
for (int i = 0; i < 252; i++) actions[i] = () => { };
actions[252] = () => { cde.Wait(); };
actions[253] = () => { cde.Signal(); };
actions[254] = () => { cde.Wait(); };
actions[255] = () => { cde.Signal(); };
Debug.WriteLine(" * We'll hang here if EnumerablePartitionerOptions.NoBuffering is not working properly");
Parallel.ForEach(Partitioner.Create(actions, EnumerablePartitionerOptions.NoBuffering), item =>
{
item();
});
}
public static void For(int minInclusive, int maxExlusive, Action<int> action)
{
var countdownEvent = new CountdownEvent(maxExlusive - minInclusive);
WaitCallback worker = delegate(object o)
{
action((int)o);
countdownEvent.ReleaseOne();
};
for (var i = minInclusive; i < maxExlusive; i++)
{
ThreadPool.QueueUserWorkItem(worker, i);
}
countdownEvent.Wait();
}
public static void CancelAfterWait()
{
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
CancellationToken cancellationToken = cancellationTokenSource.Token;
CountdownEvent countdownEvent = new CountdownEvent(2); ; // countdownEvent that will block all waiters
Task.Run(() =>
{
cancellationTokenSource.Cancel();
});
//Now wait.. the wait should abort and an exception should be thrown
EnsureOperationCanceledExceptionThrown(() => countdownEvent.Wait(cancellationToken), cancellationToken,
"CancelAfterWait: An OCE(null) should have been thrown that references the cancellationToken.");
// the token should not have any listeners.
// currently we don't expose this.. but it was verified manually
}
/// <summary>
/// Creates the reader and processor threads, waits for them to finish
/// the work and then prints the sum of the results from the result queue.
/// </summary>
static void Main()
{
_allThreadsDone = new CountdownEvent(DegreeOfParallelism);
new Thread(Reader).Start();
for (int i = 0; i < DegreeOfParallelism; ++i)
{
new Thread(Processor).Start();
}
_allThreadsDone.Wait();
int sum = 0;
//Here we can use UnsafeItems to access the queue because we know
//for sure that all concurrent work on it has finished.
foreach (int wc in _wordCounts.UnsafeItems)
{
sum += wc;
}
Console.WriteLine("Total words: " + sum);
}
public async Task DisposeWatch()
{
var connectionClosed = new AsyncManualResetEvent();
var eventsReceived = new CountdownEvent(1);
bool serverRunning = true;
using (var server = new MockKubeApiServer(testOutput, async httpContext =>
{
await WriteStreamLine(httpContext, MockKubeApiServer.MockPodResponse);
while (serverRunning)
{
await WriteStreamLine(httpContext, MockAddedEventStreamLine);
}
return(true);
}))
{
var client = new Kubernetes(new KubernetesClientConfiguration
{
Host = server.Uri.ToString()
});
var listTask = await client.ListNamespacedPodWithHttpMessagesAsync("default", watch : true);
var events = new HashSet <WatchEventType>();
var watcher = listTask.Watch <V1Pod, V1PodList>(
(type, item) =>
{
events.Add(type);
eventsReceived.Signal();
},
onClosed: connectionClosed.Set
);
// wait at least an event
await Task.WhenAny(Task.Run(() => eventsReceived.Wait()), Task.Delay(TestTimeout));
Assert.True(
eventsReceived.CurrentCount == 0,
"Timed out waiting for events."
);
Assert.NotEmpty(events);
Assert.True(watcher.Watching);
watcher.Dispose();
events.Clear();
// Let the server disconnect
serverRunning = false;
var timeout = Task.Delay(TestTimeout);
while (!timeout.IsCompleted && watcher.Watching)
{
await Task.Yield();
}
Assert.Empty(events);
Assert.False(watcher.Watching);
Assert.True(connectionClosed.IsSet);
}
}
public void SudokuTest()
{
try
{
Handler handler = new DesktopHandler(new ClingoDesktopService(GetPath()));
InputProgram inputProgram = new ASPInputProgram();
for (int i = 0; i < N; i++)
{
for (int j = 0; j < N; j++)
{
if (sudokuMatrix[i, j] != 0)
{
inputProgram.AddObjectInput(new Cell(i, j, sudokuMatrix[i, j]));
}
}
}
inputProgram.AddFilesPath(".." + Path.DirectorySeparatorChar + ".." + Path.DirectorySeparatorChar + "test-resources" + Path.DirectorySeparatorChar + "asp" + Path.DirectorySeparatorChar + "sudoku");
handler.AddProgram(inputProgram);
handler.StartAsync(new CallbackAction(o =>
{
if (!(o is AnswerSets))
{
return;
}
answerSets = (AnswerSets)o;
@lock.Signal();
}));
@lock.Wait(new TimeSpan(0, 0, 0, 0, 5000));
Assert.IsNotNull(answerSets);
Assert.IsTrue(String.IsNullOrEmpty(answerSets.ErrorsString), "Found error in the Plan\n" + answerSets.ErrorsString);
if (answerSets.Answersets.Count == 0)
{
return;
}
AnswerSet @as = answerSets.Answersets[0];
foreach (object obj in @as.Atoms)
{
Cell cell = (Cell)obj;
sudokuMatrix[cell.getRow(), cell.getColumn()] = cell.getValue();
}
for (int i = 0; i < N; i++)
{
for (int j = 0; j < N; j++)
{
Console.Write(sudokuMatrix[i, j] + " ");
if (sudokuMatrix[i, j] == 0)
{
Assert.Fail("NumberNotValid");
}
}
Console.WriteLine();
}
}
catch (Exception e)
{
Assert.Fail("Exception " + e.Message);
}
}
public void RazerChromaApiGetsCalledOnGameEvents()
{
const string statusFile = "Status.json";
const string journalFile = "Journal.190101020000.01.log";
using var cpl = ColoreProviderLock.GetLock();
var chromaApi = new Mock <IChromaApi> {
DefaultValue = DefaultValue.Mock
};
var mockIA = chromaApi.Setup(x => x.InitializeAsync(It.IsAny <AppInfo>()));
var mockCKEA = chromaApi.Setup(x => x.CreateKeyboardEffectAsync(It.IsAny <KeyboardEffect>(), It.IsAny <It.IsValueType>()));
var mockUA = chromaApi.Setup(x => x.UninitializeAsync());
using TestFolder
dirRoot = new TestFolder(_gameRootFolder),
dirOpts = new TestFolder(_gameOptionsFolder),
dirJournal = new TestFolder();
dirJournal.WriteText(statusFile, EventSequence.BuildEvent("Status", new { Flags = 0 }));
dirJournal.WriteText(journalFile, EventSequence.BuildEvent("Fileheader", new { part = 1, language = @"English\UK", gameversion = "3.5.0.200 EDH", build = "r210198/r0 " }));
using var cc = new ChromaController(dirRoot.Name, dirOpts.Name, dirJournal.Name)
{
ChromaFactory = new ChromaFactory
{
ChromaApi = chromaApi.Object,
ChromaAppInfo = null,
},
AnimationFrameRate = 0,
DetectGameInForeground = false,
};
Assert.False(cc.DetectGameInForeground);
using var ceIA = new CountdownEvent(1);
mockIA.Callback(() => ceIA.Signal());
using var ceCKEA = new CountdownEvent(1);
mockCKEA.Callback(() => ceCKEA.Signal());
cc.Start();
Assert.True(ceIA.Wait(1000));
Assert.True(ceCKEA.Wait(1000));
var seq = BuildEventSequence();
ceCKEA.Reset(seq.Count(x => x.ChangesGameState));
seq.Play(dirJournal, journalFile, statusFile);
Assert.True(ceCKEA.Wait(200 * seq.Count));
using var ceUA = new CountdownEvent(1);
mockUA.Callback(() => ceUA.Signal());
cc.Stop();
Assert.True(ceUA.Wait(1000));
}
private static double RunInParallel <TData, TResult>(
ThreadLocal <BatchPredictionEngine <TData, TResult> > engine,
List <TData[]> batches,
IExecutor[] executors,
int numThreadsPerExecutor,
int numRequestors,
int numRepeat)
where TData : class, new()
where TResult : class, new()
{
CountdownEvent warmupCde = new CountdownEvent(executors.Length * numThreadsPerExecutor);
foreach (var executor in executors)
{
for (int i = 0; i < numThreadsPerExecutor; i++)
{
// Does it make sure we cache?
executor.Submit(() =>
{
var result = engine.Value.Predict(batches[0], false);
var resultStr = string.Join(',', result.Select(x =>
{
if (x is AttendeeResult)
{
return((x as AttendeeResult).Score);
}
else if (x is AmazonResult)
{
return((x as AmazonResult).Score);
}
else
{
throw new Exception("Unsupported result type");
}
}));
warmupCde.Signal();
});
}
}
warmupCde.Wait();
CountdownEvent outerCde = new CountdownEvent(numRepeat * batches.Count);
CountdownEvent cde = new CountdownEvent(1);
Action compute = () =>
{
cde.Wait();
for (int bIdx = 0; bIdx < numRepeat * batches.Count / numRequestors; bIdx++)
{
// Internally an executor is chosen in round-robin.
executors[bIdx % executors.Length].Submit(() =>
{
//results.Enqueue(engine.Predict(batches[bIdx % batches.Count]));
var result = engine.Value.Predict(batches[bIdx % batches.Count], true);
var resultStr = string.Join(',', result.Select(x =>
{
if (x is AttendeeResult)
{
return((x as AttendeeResult).Score);
}
else if (x is AmazonResult)
{
return((x as AmazonResult).Score);
}
else
{
throw new Exception("Unsupported result type");
}
}));
outerCde.Signal();
});
}
};
int cores = RegisterRequestorThreads(compute, numRequestors);
var startTime = Stopwatch.GetTimestamp();
cde.Signal();
outerCde.Wait();
var elapsedTime = (Stopwatch.GetTimestamp() - startTime) * 1000.0 / Stopwatch.Frequency;
System.Console.WriteLine("Prediction took {0} ms", elapsedTime);
return(elapsedTime);
}
public async Task RunsTasksConcurrently(int concurrentTasks)
{
// Control + 3 experiments
var totalTasks = 1 + 3;
// Expected number of batches
var expectedBatches = Math.Ceiling(1D * totalTasks / concurrentTasks);
// Use CountdownEvents to ensure tasks don't finish before all tasks in that batch have started
var startedSignal = new CountdownEvent(concurrentTasks);
var finishedSignal = new CountdownEvent(concurrentTasks);
// Batch counter
int batch = 1;
// Our test task
var task = new Func <Task <KeyValuePair <int, int> > >(() =>
{
return(Task.Run(() =>
{
// Signal that we have started
var last = startedSignal.Signal();
var myBatch = batch;
// Wait till all tasks for this batch have started
startedSignal.Wait();
// Signal we have finished
finishedSignal.Signal();
// Last task to start needs to reset the events
if (last)
{
// Wait for all tasks in the batch to have finished
finishedSignal.Wait();
// Reset the countdown events
startedSignal.Reset();
finishedSignal.Reset();
batch++;
}
// Return threadId
return new KeyValuePair <int, int>(myBatch, Thread.CurrentThread.ManagedThreadId);
}));
});
// Run the experiment
string experimentName = nameof(RunsTasksConcurrently) + concurrentTasks;
await Scientist.ScienceAsync <KeyValuePair <int, int> >(experimentName, concurrentTasks, experiment =>
{
// Add our control and experiments
experiment.Use(task);
for (int idx = 2; idx <= totalTasks; idx++)
{
experiment.Try($"experiment{idx}", task);
}
});
// Get the test result
var result = TestHelper.Results <KeyValuePair <int, int> >(experimentName).First();
// Consolidate the returned values from the tasks
var results = result.Observations.Select(x => x.Value);
// Assert correct number of batches
Assert.Equal(expectedBatches, results.Select(x => x.Key).Distinct().Count());
// Now check each batch
for (int batchNo = 1; batchNo <= expectedBatches; batchNo++)
{
// Get the threadIds used by each task in the batch
var batchThreadIds = results.Where(x => x.Key == batchNo).Select(x => x.Value);
// Assert expected number of concurrent tasks in batch
Assert.Equal(concurrentTasks, batchThreadIds.Count());
// Assert unique threadIds in batch
Assert.Equal(batchThreadIds.Count(), batchThreadIds.Distinct().Count());
}
}
public bool CheckLatch(CountdownEvent latch)
{
return(latch.Wait(AwaitTimeout));
}
public object Clone()
{
var filePaths = new List<string>();
var fileRelativePaths = new List<string>();
AppDomain.CurrentDomain.UnhandledException += OnUnhandledException;
try
{
var cssSpriteOutput = string.Empty;
var jsOutput = string.Empty;
var cssOutput = string.Empty;
var countdownEvents = new CountdownEvent(3);
ThreadPool.QueueUserWorkItem(data =>
{
var countdownEvent = (CountdownEvent) data;
try
{
if (_crusherConfiguration != null)
{
var cssSpriteGroups = _crusherConfiguration.CssSpriteGroups;
var cssSpriteCreator = new CssSpriteCreator(_cacheManager, _retryableFileOpener, _pathProvider, _retryableFileWriter, _fileMetaData);
var cssSpriteGroupsProcessor = new CssSpriteGroupsProcessor();
cssSpriteOutput = cssSpriteGroupsProcessor.ProcessGroups(_pathProvider, cssSpriteCreator, cssSpriteGroups).ToString();
var cssFilePaths = new List<string>();
var cssFileRelativePaths = new List<string>();
foreach (CssSpriteGroupElement cssSpriteGroup in cssSpriteGroups)
{
cssFilePaths.Add(new Uri(_pathProvider.MapPath(cssSpriteGroup.CssOutputFilePath)).LocalPath);
cssFilePaths.Add(new Uri(_pathProvider.MapPath(cssSpriteGroup.ImageOutputFilePath)).LocalPath);
cssFileRelativePaths.Add(MakeRelative(cssSpriteGroup.CssOutputFilePath));
cssFileRelativePaths.Add(MakeRelative(cssSpriteGroup.ImageOutputFilePath));
}
filePaths.AddRange(cssFilePaths);
fileRelativePaths.AddRange(cssFileRelativePaths);
_logMessage(cssSpriteOutput);
}
}
catch (Exception exception)
{
_logError(exception.ToString());
}
countdownEvent.Signal();
}, countdownEvents);
ThreadPool.QueueUserWorkItem(data =>
{
var countdownEvent = (CountdownEvent) data;
try
{
if (_crusherConfiguration != null)
{
var jsCrusher = new JsCrusher(_cacheManager, _pathProvider, _retryableFileOpener, _retryableFileWriter, _fileMetaData);
var jsGroups = _crusherConfiguration.JsGroups;
var jsGroupsProcessor = new JsGroupsProcessor();
jsOutput = jsGroupsProcessor.ProcessGroups(_pathProvider, jsCrusher, jsGroups).ToString();
var jsFilePaths = new List<string>();
var jsFileRelativePaths = new List<string>();
foreach (JsGroupElement jsGroup in jsGroups)
{
jsFilePaths.Add(new Uri(_pathProvider.MapPath(jsGroup.OutputFilePath)).LocalPath);
jsFileRelativePaths.Add(MakeRelative(jsGroup.OutputFilePath));
}
filePaths.AddRange(jsFilePaths);
fileRelativePaths.AddRange(jsFileRelativePaths);
_logMessage(jsOutput);
}
}
catch (Exception exception)
{
_logError(exception.ToString());
}
countdownEvent.Signal();
}, countdownEvents);
ThreadPool.QueueUserWorkItem(data =>
{
var countdownEvent = (CountdownEvent) data;
try
{
if (_crusherConfiguration != null)
{
var hashQueryStringKeyName = _crusherConfiguration.QuerystringKeyName;
var cssAssetsFileHasher = new CssAssetsFileHasher(hashQueryStringKeyName, _hasher, _pathProvider);
var cssPathRewriter = new CssPathRewriter(cssAssetsFileHasher, _pathProvider);
var cssCrusher = new CssCrusher(_cacheManager, _pathProvider, _retryableFileOpener, _retryableFileWriter, cssPathRewriter, _fileMetaData, _crusherConfiguration.WatchAssets);
var cssGroups = _crusherConfiguration.CssGroups;
var cssGroupsCrusher = new CssGroupsProcessor();
cssOutput = cssGroupsCrusher.ProcessGroups(_pathProvider, cssCrusher, cssGroups).ToString();
var cssFilePaths = new List<string>();
var cssFileRelativePaths = new List<string>();
foreach (CssGroupElement cssGroup in cssGroups)
{
cssFilePaths.Add(new Uri(_pathProvider.MapPath(cssGroup.OutputFilePath)).LocalPath);
cssFileRelativePaths.Add(MakeRelative(cssGroup.OutputFilePath));
}
filePaths.AddRange(cssFilePaths);
fileRelativePaths.AddRange(cssFileRelativePaths);
_logMessage(cssOutput);
}
}
catch (Exception exception)
{
_logError(exception.ToString());
}
countdownEvent.Signal();
}, countdownEvents);
countdownEvents.Wait();
}
catch (Exception exception)
{
_logError(exception.ToString());
}
finally
{
AppDomain.CurrentDomain.UnhandledException -= OnUnhandledException;
}
_setOutputFilePaths(filePaths.ToArray());
_setOutputFileRelativePaths(fileRelativePaths.ToArray());
return null;
}
public async Task Concurrent_callers_to_Next_only_result_in_one_non_cancelled_token_being_issued()
{
const int loopCount = 10000;
var logicalProcessorCount = Environment.ProcessorCount;
var threadCount = Math.Max(2, logicalProcessorCount);
using (var sequence = new CancellationTokenSequence())
using (var barrier = new Barrier(threadCount))
using (var countdown = new CountdownEvent(loopCount * threadCount))
{
var completedCount = 0;
var completionTokenSource = new CancellationTokenSource();
var completionToken = completionTokenSource.Token;
var winnerByIndex = new int[threadCount];
var tasks = Enumerable
.Range(0, threadCount)
.Select(i => Task.Run(() => ThreadMethod(i)))
.ToList();
Assert.True(
countdown.Wait(TimeSpan.FromSeconds(10)),
"Test should have completed within a reasonable amount of time");
await Task.WhenAll(tasks);
Assert.AreEqual(loopCount, completedCount);
await Console.Out.WriteLineAsync("Winner by index: " + string.Join(",", winnerByIndex));
// Assume hyper threading, so halve logical processors (could use WMI or P/Invoke for more robust answer)
if (logicalProcessorCount <= 2)
{
Assert.Inconclusive("This test requires more than one physical processor to run.");
}
return;
void ThreadMethod(int i)
{
while (true)
{
barrier.SignalAndWait();
if (completionToken.IsCancellationRequested)
{
return;
}
var token = sequence.Next();
barrier.SignalAndWait();
if (!token.IsCancellationRequested)
{
Interlocked.Increment(ref completedCount);
Interlocked.Increment(ref winnerByIndex[i]);
}
if (countdown.Signal())
{
completionTokenSource.Cancel();
}
}
}
}
}
public static ParallelTaskResult StaticFor(int low, int high,
Action<ParallelTaskOptions, int, int> work, int workerCount, int chunk)
{
if (low < 0 || high < low) return new ParallelTaskResult();
ModuleProc PROC = new ModuleProc("ParallelTasks", "StaticFor");
ParallelTaskResult result = new ParallelTaskResult(ParallelTaskResultStatus.Created);
if (workerCount <= 0) workerCount = 1;
if (chunk <= 0) chunk = 1;
if (high < chunk) chunk = ((high - low) / workerCount);
CountdownEvent cde = new CountdownEvent(workerCount);
Thread[] threads = new Thread[workerCount];
int currentCount = 0;
ParallelTaskOptions options = new ParallelTaskOptions();
try
{
for (int i = 0; i < workerCount; i++)
{
threads[i] = Extensions.CreateThreadAndStart((o) =>
{
int k = (int)o;
int start = low + (k * chunk);
int end = ((k == (workerCount - 1)) ? high : (start + chunk));
for (int j = start; j < end; j++)
{
if (options.IsCancelled) break;
try
{
work(options, j, currentCount);
}
catch (Exception ex)
{
Log.Exception(PROC, ex);
result.Exceptions.Add(ex);
}
finally
{
Interlocked.Increment(ref currentCount);
}
}
cde.Signal();
}, i, "StaticFor_" + i.ToString());
}
}
catch (Exception ex)
{
Log.Exception(PROC, ex);
}
finally
{
cde.Wait();
result.Status = (options.IsCancelled ? ParallelTaskResultStatus.Canceled : ParallelTaskResultStatus.Completed);
}
return result;
}
public static ParallelTaskResult DynamicFor(int low, int high,
Action<ParallelTaskOptions, int, int> work, int workerCount)
{
if (low < 0 || high < low) return new ParallelTaskResult();
ModuleProc PROC = new ModuleProc("ParallelTasks", "For");
ParallelTaskResult result = new ParallelTaskResult(ParallelTaskResultStatus.Created);
if (workerCount <= 0) workerCount = 1;
const int chunk = 16;
CountdownEvent cde = new CountdownEvent(workerCount);
Thread[] threads = new Thread[workerCount];
int currentCount = 0;
int currentValue = low;
ParallelTaskOptions options = new ParallelTaskOptions();
try
{
for (int i = 0; i < workerCount; i++)
{
threads[i] = Extensions.CreateThreadAndStart((o) =>
{
int j = 0;
int currentChunk = 1;
while (true)
{
if (options.IsCancelled) break;
if ((currentValue + currentChunk) > Int32.MaxValue) break;
j = Interlocked.Add(ref currentValue, currentChunk) - currentChunk;
if (j >= high) break;
for (int k = 0; (k < currentChunk) && ((j + k) < high); k++)
{
if (options.IsCancelled) break;
try
{
work(options, j, currentCount);
}
catch (Exception ex)
{
Log.Exception(PROC, ex);
}
finally
{
Interlocked.Increment(ref currentCount);
}
}
if (currentChunk < chunk) currentChunk *= 2;
}
cde.Signal();
}, i);
}
}
catch (Exception ex)
{
Log.Exception(PROC, ex);
}
finally
{
cde.Wait();
result.Status = (options.IsCancelled ? ParallelTaskResultStatus.Canceled : ParallelTaskResultStatus.Completed);
}
return result;
}
public static void RunCountdownEventTest2_Exceptions()
{
CountdownEvent cde = null;
Assert.Throws<ArgumentOutOfRangeException>(() => cde = new CountdownEvent(-1));
// Failure Case: Constructor didn't throw AORE when -1 passed
cde = new CountdownEvent(1);
Assert.Throws<ArgumentOutOfRangeException>(() => cde.Signal(0));
// Failure Case: Signal didn't throw AORE when 0 passed
cde = new CountdownEvent(0);
Assert.Throws<InvalidOperationException>(() => cde.Signal());
// Failure Case: Signal didn't throw IOE when the count is zero
cde = new CountdownEvent(1);
Assert.Throws<InvalidOperationException>(() => cde.Signal(2));
// Failure Case: Signal didn't throw IOE when the signal count > current count
Assert.Throws<ArgumentOutOfRangeException>(() => cde.AddCount(0));
// Failure Case: AddCount didn't throw AORE when 0 passed
cde = new CountdownEvent(0);
Assert.Throws<InvalidOperationException>(() => cde.AddCount(1));
// Failure Case: AddCount didn't throw IOE when the count is zero
cde = new CountdownEvent(int.MaxValue - 10);
Assert.Throws<InvalidOperationException>(() => cde.AddCount(20));
// Failure Case: AddCount didn't throw IOE when the count > int.Max
cde = new CountdownEvent(2);
Assert.Throws<ArgumentOutOfRangeException>(() => cde.Reset(-1));
// Failure Case: Reset didn't throw AORE when the count is zero
Assert.Throws<ArgumentOutOfRangeException>(() => cde.Wait(-2));
// Failure Case: Wait(int) didn't throw AORE when the totalmilliseconds < -1
Assert.Throws<ArgumentOutOfRangeException>(() => cde.Wait(TimeSpan.FromDays(-1)));
// Failure Case: FAILED. Wait(TimeSpan) didn't throw AORE when the totalmilliseconds < -1
Assert.Throws<ArgumentOutOfRangeException>(() => cde.Wait(TimeSpan.MaxValue));
// Failure Case: Wait(TimeSpan, CancellationToken) didn't throw AORE when the totalmilliseconds > int.max
Assert.Throws<ArgumentOutOfRangeException>(() => cde.Wait(TimeSpan.FromDays(-1), new CancellationToken()));
// Failure Case: Wait(TimeSpan) didn't throw AORE when the totalmilliseconds < -1
Assert.Throws<ArgumentOutOfRangeException>(() => cde.Wait(TimeSpan.MaxValue, new CancellationToken()));
// Failure Case: Wait(TimeSpan, CancellationToken) didn't throw AORE when the totalmilliseconds > int.max
cde.Dispose();
Assert.Throws<ObjectDisposedException>(() => cde.Wait());
// Failure Case: Wait() didn't throw ODE after Dispose
}
private void InitManager()
{
AppDomain.CurrentDomain.DomainUnload += OnDomainUnload;
var jsExceptions = new List<JsException>();
var cssExceptions = new List<CssException>();
var countdownEvents = new CountdownEvent(2);
ThreadPool.QueueUserWorkItem(data =>
{
var manualResetEvent = (CountdownEvent)data;
try
{
var groupsProcessor = new JsGroupsProcessor();
groupsProcessor.ProcessGroups(_pathProvider, _jsCrusher, _jsGroups);
}
catch (Exception exception)
{
jsExceptions.Add(new JsException(exception));
}
manualResetEvent.Signal();
}, countdownEvents);
ThreadPool.QueueUserWorkItem(data =>
{
var manualResetEvent = (CountdownEvent)data;
try
{
var groupsProcessor = new CssGroupsProcessor();
groupsProcessor.ProcessGroups(_pathProvider, _cssCrusher, _cssGroups);
}
catch (Exception exception)
{
cssExceptions.Add(new CssException(exception));
}
manualResetEvent.Signal();
}, countdownEvents);
countdownEvents.Wait();
var exceptions = cssExceptions.Cast<Exception>().Concat(jsExceptions.Cast<Exception>()).ToList();
if (exceptions.Any())
{
throw new AggregateException(exceptions);
}
}
//---------------------------------------------------------------------------------------
// Straightforward IEnumerator<T> methods.
//
internal override bool MoveNext([MaybeNullWhen(false), AllowNull] ref TSource currentElement, ref int currentKey)
{
Debug.Assert(_source != null);
if (_alreadySearched)
{
return(false);
}
// Look for the greatest element.
TSource candidate = default(TSource) !;
TKey candidateKey = default(TKey) !;
bool candidateFound = false;
try
{
int loopCount = 0; //counter to help with cancellation
TSource value = default(TSource) !;
TKey key = default(TKey) !;
while (_source.MoveNext(ref value !, ref key))
{
if ((loopCount & CancellationState.POLL_INTERVAL) == 0)
{
_cancellationToken.ThrowIfCancellationRequested();
}
;
// If the predicate is null or the current element satisfies it, we will remember
// it as the current partition's candidate for the last element, and move on.
if (_predicate == null || _predicate(value))
{
candidate = value;
candidateKey = key;
candidateFound = true;
}
loopCount++;
}
// If we found a candidate element, try to publish it, so long as it's greater.
if (candidateFound)
{
lock (_operatorState)
{
if (_operatorState._partitionId == -1 || _keyComparer.Compare(candidateKey, _operatorState._key) > 0)
{
_operatorState._partitionId = _partitionId;
_operatorState._key = candidateKey;
}
}
}
}
finally
{
// No matter whether we exit due to an exception or normal completion, we must ensure
// that we signal other partitions that we have completed. Otherwise, we can cause deadlocks.
_sharedBarrier.Signal();
}
_alreadySearched = true;
// Only if we have a candidate do we wait.
if (_partitionId == _operatorState._partitionId)
{
_sharedBarrier.Wait(_cancellationToken);
// Now re-read the shared index. If it's the same as ours, we won and return true.
if (_operatorState._partitionId == _partitionId)
{
currentElement = candidate;
currentKey = 0; // 1st (and only) element, so we hardcode the output index to 0.
return(true);
}
}
// If we got here, we didn't win. Return false.
return(false);
}
private void Test(int[] results_sizes, string instance_name)
{
string instance_path = base_path + instance_name + Path.DirectorySeparatorChar;
Console.WriteLine("Testing " + results_sizes.Length + " files for " + instance_path);
for (int i = 1; i <= results_sizes.Length; i++)
{
try
{
plan = null;
@lock = new CountdownEvent(1);
Handler handler = new DesktopHandler(new SPDDesktopService());
Console.WriteLine();
InputProgram inputProgramDomain = new PDDLInputProgram(PDDLProgramType.DOMAIN);
inputProgramDomain.AddFilesPath(instance_path + "domain.pddl");
InputProgram inputProgramProblem = new PDDLInputProgram(PDDLProgramType.PROBLEM);
string problem = instance_path + "p" + (i < 10 ? "0" : "") + i + ".pddl";
Console.WriteLine(problem);
Assert.IsTrue(File.Exists(problem), "File not found: " + problem);
inputProgramProblem.AddFilesPath(problem);
handler.AddProgram(inputProgramDomain);
handler.AddProgram(inputProgramProblem);
PDDLMapper.Instance.RegisterClass(typeof(PickUp));
Assert.IsNull(plan);
handler.StartAsync(new CallbackAction(o =>
{
if (!(o is Plan))
{
return;
}
plan = (Plan)o;
foreach (embasp.languages.pddl.Action action in plan.Actions)
{
Console.Write(action.Name + ",");
}
@lock.Signal();
}));
@lock.Wait(new TimeSpan(0, 0, 0, 0, 15000));
Assert.IsNotNull(plan);
if (results_sizes[i - 1] != 0)
{
Assert.IsTrue(String.IsNullOrEmpty(plan.ErrorsString) || plan.ErrorsString.ToLower().Contains("server busy"), "Found error in the Plan " + problem + "\n" + plan.ErrorsString);
}
if (plan.ErrorsString.ToLower().Contains("server busy."))
{
Console.WriteLine("[WARNING] Server busy occurred!");
}
Assert.AreEqual(results_sizes[i - 1], plan.Actions.Count);
foreach (object obj in plan.ActionsObjects)
{
if (obj is PickUp)
{
PickUp pickUp = (PickUp)obj;
Console.WriteLine(pickUp.getBlock());
}
}
Thread.Sleep(500);
}
catch (Exception e)
{
Assert.Fail(e.Message);
}
}
Console.WriteLine();
}
/// <summary>
/// The method that performs the tests
/// Depending on the inputs different test code paths will be exercised
/// </summary>
internal void RealRun()
{
TaskScheduler tm = TaskScheduler.Default;
CreateTask(tm, _taskTree);
// wait the whole task tree to be created
_countdownEvent.Wait();
Stopwatch sw = Stopwatch.StartNew();
try
{
switch (_api)
{
case API.Cancel:
_taskTree.CancellationTokenSource.Cancel();
break;
case API.Wait:
switch (_waitBy)
{
case WaitBy.None:
_taskTree.Task.Wait();
_taskCompleted = true;
break;
case WaitBy.Millisecond:
_taskCompleted = _taskTree.Task.Wait(_waitTimeout);
break;
case WaitBy.TimeSpan:
_taskCompleted = _taskTree.Task.Wait(new TimeSpan(0, 0, 0, 0, _waitTimeout));
break;
}
break;
}
}
catch (AggregateException exp)
{
_caughtException = exp.Flatten();
}
finally
{
sw.Stop();
}
if (_waitTimeout != -1)
{
long delta = sw.ElapsedMilliseconds - ((long)_waitTimeout + s_deltaTimeOut);
if (delta > 0)
{
Debug.WriteLine("ElapsedMilliseconds way more than requested Timeout.");
Debug.WriteLine("WaitTime= {0} ms, ElapsedTime= {1} ms, Allowed Descrepancy = {2} ms", _waitTimeout, sw.ElapsedMilliseconds, s_deltaTimeOut);
Debug.WriteLine("Delta= {0} ms", delta);
}
else
{
var delaytask = Task.Delay((int)Math.Abs(delta)); // give delay to allow Context being collected before verification
delaytask.Wait();
}
}
Verify();
_countdownEvent.Dispose();
}
private void InitManager()
{
AppDomain.CurrentDomain.DomainUnload += OnDomainUnload;
var jsExceptions = new List<JsException>();
var cssExceptions = new List<CssException>();
var countdownEvents = new CountdownEvent(2);
ThreadPool.QueueUserWorkItem(data =>
{
var manualResetEvent = (CountdownEvent)data;
try
{
var jsGroups = _crusherConfiguration.JsGroups;
var jsCrusher = new JsCrusher(_cacheManager, _pathProvider, _retryableFileOpener, _retryableFileWriter, _fileMetaData);
var groupsProcessor = new JsGroupsProcessor();
groupsProcessor.ProcessGroups(_pathProvider, jsCrusher, jsGroups);
}
catch (Exception exception)
{
jsExceptions.Add(new JsException(exception));
}
manualResetEvent.Signal();
}, countdownEvents);
ThreadPool.QueueUserWorkItem(data =>
{
var manualResetEvent = (CountdownEvent)data;
try
{
var hashQueryStringKeyName = _crusherConfiguration.QuerystringKeyName;
var cssGroups = _crusherConfiguration.CssGroups;
var cssAssetsFileHasher = new CssAssetsFileHasher(hashQueryStringKeyName, _hasher, _pathProvider);
var cssPathRewriter = new CssPathRewriter(cssAssetsFileHasher, _pathProvider);
var cssCrusher = new CssCrusher(_cacheManager, _pathProvider, _retryableFileOpener, _retryableFileWriter, cssPathRewriter, _fileMetaData, _crusherConfiguration.WatchAssets);
var groupsProcessor = new CssGroupsProcessor();
groupsProcessor.ProcessGroups(_pathProvider, cssCrusher, cssGroups);
}
catch (Exception exception)
{
cssExceptions.Add(new CssException(exception));
}
manualResetEvent.Signal();
}, countdownEvents);
countdownEvents.Wait();
var exceptions = cssExceptions.Cast<Exception>().Concat(jsExceptions.Cast<Exception>()).ToList();
if (exceptions.Any())
{
throw new AggregateException(exceptions);
}
}
public void StopTest_MultiplyWaiters()
{
var target = CreateFixedThreadPool(2, false);
var heavyTask = new TaskMock(Wait);
Assert.AreEqual(true, target.Execute(heavyTask, Priority.High));
Assert.AreEqual(true, target.Execute(heavyTask, Priority.Medium));
Assert.AreEqual(true, target.Execute(heavyTask, Priority.Low));
Assert.AreEqual(true, target.Execute(heavyTask, Priority.Low));
Exception deferedException = null;
var waitersCounter = new CountdownEvent(4);
for (var i = 0; i < 4; i++)
{
new Thread(() =>
{
target.Stop();
try
{ // each thread should see properly stopped pool.
AssertIsProperlyStopped(target);
}
catch (Exception e)
{
deferedException = e;
}
waitersCounter.Signal();
}).Start();
}
target.Stop();
AssertIsProperlyStopped(target);
waitersCounter.Wait(); // if thread pool works properly, will never blocked here
if (deferedException != null)
{
throw deferedException;
}
}
public virtual void TestStressMultiThreading()
{
Directory dir = NewDirectory();
IndexWriterConfig conf = NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random()));
IndexWriter writer = new IndexWriter(dir, conf);
// create index
int numThreads = TestUtil.NextInt(Random(), 3, 6);
int numDocs = AtLeast(2000);
for (int i = 0; i < numDocs; i++)
{
Document doc = new Document();
doc.Add(new StringField("id", "doc" + i, Store.NO));
double group = Random().NextDouble();
string g;
if (group < 0.1)
{
g = "g0";
}
else if (group < 0.5)
{
g = "g1";
}
else if (group < 0.8)
{
g = "g2";
}
else
{
g = "g3";
}
doc.Add(new StringField("updKey", g, Store.NO));
for (int j = 0; j < numThreads; j++)
{
long value = Random().Next();
doc.Add(new BinaryDocValuesField("f" + j, TestBinaryDocValuesUpdates.ToBytes(value)));
doc.Add(new NumericDocValuesField("cf" + j, value * 2)); // control, always updated to f * 2
}
writer.AddDocument(doc);
}
CountdownEvent done = new CountdownEvent(numThreads);
AtomicInt32 numUpdates = new AtomicInt32(AtLeast(100));
// same thread updates a field as well as reopens
ThreadClass[] threads = new ThreadClass[numThreads];
for (int i = 0; i < threads.Length; i++)
{
string f = "f" + i;
string cf = "cf" + i;
threads[i] = new ThreadAnonymousInnerClassHelper(this, "UpdateThread-" + i, writer, numDocs, done, numUpdates, f, cf);
}
foreach (ThreadClass t in threads)
{
t.Start();
}
done.Wait();
writer.Dispose();
DirectoryReader reader = DirectoryReader.Open(dir);
BytesRef scratch = new BytesRef();
foreach (AtomicReaderContext context in reader.Leaves)
{
AtomicReader r = context.AtomicReader;
for (int i = 0; i < numThreads; i++)
{
BinaryDocValues bdv = r.GetBinaryDocValues("f" + i);
NumericDocValues control = r.GetNumericDocValues("cf" + i);
IBits docsWithBdv = r.GetDocsWithField("f" + i);
IBits docsWithControl = r.GetDocsWithField("cf" + i);
IBits liveDocs = r.LiveDocs;
for (int j = 0; j < r.MaxDoc; j++)
{
if (liveDocs == null || liveDocs.Get(j))
{
Assert.AreEqual(docsWithBdv.Get(j), docsWithControl.Get(j));
if (docsWithBdv.Get(j))
{
long ctrlValue = control.Get(j);
long bdvValue = TestBinaryDocValuesUpdates.GetValue(bdv, j, scratch) * 2;
// if (ctrlValue != bdvValue) {
// System.out.println("seg=" + r + ", f=f" + i + ", doc=" + j + ", group=" + r.Document(j).Get("updKey") + ", ctrlValue=" + ctrlValue + ", bdvBytes=" + scratch);
// }
Assert.AreEqual(ctrlValue, bdvValue);
}
}
}
}
}
reader.Dispose();
dir.Dispose();
}
//---------------------------------------------------------------------------------------
// Straightforward IEnumerator<T> methods.
//
internal override bool MoveNext([MaybeNullWhen(false), AllowNull] ref TResult currentElement, ref TKey currentKey)
{
// If the buffer has not been created, we will generate it lazily on demand.
if (_buffer == null)
{
// Create a buffer, but don't publish it yet (in case of exception).
List <Pair <TResult, TKey> > buffer = new List <Pair <TResult, TKey> >();
// Enter the search phase. In this phase, we scan the input until one of three
// things happens: (1) all input has been exhausted, (2) the predicate yields
// false for one of our elements, or (3) we move past the current lowest index
// found by other partitions for a false element. As we go, we have to remember
// the elements by placing them into the buffer.
try
{
TResult current = default(TResult) !;
TKey key = default(TKey) !;
int i = 0; //counter to help with cancellation
while (_source.MoveNext(ref current !, ref key))
{
if ((i++ & CancellationState.POLL_INTERVAL) == 0)
{
_cancellationToken.ThrowIfCancellationRequested();
}
;
// Add the current element to our buffer.
buffer.Add(new Pair <TResult, TKey>(current, key));
// See if another partition has found a false value before this element. If so,
// we should stop scanning the input now and reach the barrier ASAP.
if (_updatesSeen != _operatorState._updatesDone)
{
lock (_operatorState)
{
_currentLowKey = _operatorState._currentLowKey;
_updatesSeen = _operatorState._updatesDone;
}
}
if (_updatesSeen > 0 && _keyComparer.Compare(key, _currentLowKey) > 0)
{
break;
}
// Evaluate the predicate, either indexed or not based on info passed to the ctor.
bool predicateResult;
if (_predicate != null)
{
predicateResult = _predicate(current);
}
else
{
Debug.Assert(_indexedPredicate != null);
predicateResult = _indexedPredicate(current, key);
}
if (!predicateResult)
{
// Signal that we've found a false element, racing with other partitions to
// set the shared index value.
lock (_operatorState)
{
if (_operatorState._updatesDone == 0 || _keyComparer.Compare(_operatorState._currentLowKey, key) > 0)
{
_currentLowKey = _operatorState._currentLowKey = key;
_updatesSeen = ++_operatorState._updatesDone;
}
}
break;
}
}
}
finally
{
// No matter whether we exit due to an exception or normal completion, we must ensure
// that we signal other partitions that we have completed. Otherwise, we can cause deadlocks.
_sharedBarrier.Signal();
}
// Before exiting the search phase, we will synchronize with others. This is a barrier.
_sharedBarrier.Wait(_cancellationToken);
// Publish the buffer and set the index to just before the 1st element.
_buffer = buffer;
_bufferIndex = new Shared <int>(-1);
}
Debug.Assert(_bufferIndex != null);
// Now either enter (or continue) the yielding phase. As soon as we reach this, we know the
// current shared "low false" value is the absolute lowest with a false.
if (_take)
{
// In the case of a take-while, we will yield each element from our buffer for which
// the element is lesser than the lowest false index found.
if (_bufferIndex.Value >= _buffer.Count - 1)
{
return(false);
}
// Increment the index, and remember the values.
++_bufferIndex.Value;
currentElement = _buffer[_bufferIndex.Value].First;
currentKey = _buffer[_bufferIndex.Value].Second;
return(_operatorState._updatesDone == 0 || _keyComparer.Compare(_operatorState._currentLowKey, currentKey) > 0);
}
else
{
// If no false was found, the output is empty.
if (_operatorState._updatesDone == 0)
{
return(false);
}
// In the case of a skip-while, we must skip over elements whose index is lesser than the
// lowest index found. Once we've exhausted the buffer, we must go back and continue
// enumerating the data source until it is empty.
if (_bufferIndex.Value < _buffer.Count - 1)
{
for (_bufferIndex.Value++; _bufferIndex.Value < _buffer.Count; _bufferIndex.Value++)
{
// If the current buffered element's index is greater than or equal to the smallest
// false index found, we will yield it as a result.
if (_keyComparer.Compare(_buffer[_bufferIndex.Value].Second, _operatorState._currentLowKey) >= 0)
{
currentElement = _buffer[_bufferIndex.Value].First;
currentKey = _buffer[_bufferIndex.Value].Second;
return(true);
}
}
}
// Lastly, so long as our input still has elements, they will be yieldable.
if (_source.MoveNext(ref currentElement !, ref currentKey))
{
Debug.Assert(_keyComparer.Compare(currentKey, _operatorState._currentLowKey) > 0,
"expected remaining element indices to be greater than smallest");
return(true);
}
}
return(false);
}
public unsafe static bool SaveImageBytes(byte[][,] rgb, string fileName, string format, int threadsToRun = 0)
{
if (3 != rgb.GetLength(0))
{
throw new ArrayTypeMismatchException("Size of first dimension for passed array must be 3 (RGB components).");
}
if (2 != rgb[0].Rank)
{
throw new ArrayTypeMismatchException("Every passed component array should have 2 dimensions.");
}
int height = rgb[0].GetLength(0), width = rgb[0].GetLength(1);
Bitmap res = new Bitmap(width, height, PixelFormat.Format24bppRgb);
BitmapData bd = res.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.WriteOnly, PixelFormat.Format24bppRgb);
try {
if (2 > threadsToRun)
{
int h, w;
byte *curpos;
Console.WriteLine("Using 1 thread to save image");
for (h = 0; h < height; h++)
{
curpos = (( byte * )bd.Scan0) + h * bd.Stride;
for (w = 0; w < width; w++)
{
*(curpos++) = rgb[2][h, w];
*(curpos++) = rgb[1][h, w];
*(curpos++) = rgb[0][h, w];
}
}
}
else
{
int step = height / threadsToRun, rest = height % threadsToRun;
Console.WriteLine("Using " + threadsToRun + " threads to save image");
using (CountdownEvent completed = new CountdownEvent(threadsToRun)) {
for (int num = 0; num < threadsToRun; num++)
{
ThreadPool.QueueUserWorkItem(new WaitCallback(idx => {
int i = ( int )idx;
int start = i * step, finish = start + step, h, w;
byte *curpos;
if (i < rest)
{
start += i;
finish += i + 1;
}
else
{
start += rest;
finish += rest;
}
Console.WriteLine("Thread " + i + " saving lines from " + start + " till " + finish);
for (h = start; h < finish; h++)
{
curpos = (( byte * )bd.Scan0) + h * bd.Stride;
for (w = 0; w < width; w++)
{
*(curpos++) = rgb[2][h, w];
*(curpos++) = rgb[1][h, w];
*(curpos++) = rgb[0][h, w];
}
}
completed.Signal();
}), num);
}
completed.Wait();
}
}
} finally {
res.UnlockBits(bd);
}
return(SaveBitmap(ref res, fileName, Ext2Fmt(format)));
}
public static void Main()
{
using (var ignite = Ignition.StartFromApplicationConfiguration())
{
var remotes = ignite.GetCluster().ForRemotes();
if (remotes.GetNodes().Count == 0)
{
Console.WriteLine(">>> This example requires remote nodes to be started.");
Console.WriteLine(">>> Please start at least 1 remote node.");
Console.WriteLine(">>> Refer to example's documentation for details on configuration.");
}
else
{
Console.WriteLine(">>> Messaging example started.");
Console.WriteLine();
// Set up local listeners
var localMessaging = ignite.GetCluster().ForLocal().GetMessaging();
var msgCount = remotes.GetNodes().Count * 10;
var orderedCounter = new CountdownEvent(msgCount);
var unorderedCounter = new CountdownEvent(msgCount);
localMessaging.LocalListen(new LocalListener(unorderedCounter), Topic.Unordered);
localMessaging.LocalListen(new LocalListener(orderedCounter), Topic.Ordered);
// Set up remote listeners
var remoteMessaging = remotes.GetMessaging();
var idUnordered = remoteMessaging.RemoteListen(new RemoteUnorderedListener(), Topic.Unordered);
var idOrdered = remoteMessaging.RemoteListen(new RemoteOrderedListener(), Topic.Ordered);
// Send unordered
Console.WriteLine(">>> Sending unordered messages...");
for (var i = 0; i < 10; i++)
{
remoteMessaging.Send(i, Topic.Unordered);
}
Console.WriteLine(">>> Finished sending unordered messages.");
// Send ordered
Console.WriteLine(">>> Sending ordered messages...");
for (var i = 0; i < 10; i++)
{
remoteMessaging.SendOrdered(i, Topic.Ordered);
}
Console.WriteLine(">>> Finished sending ordered messages.");
Console.WriteLine(">>> Check output on all nodes for message printouts.");
Console.WriteLine(">>> Waiting for messages acknowledgements from all remote nodes...");
unorderedCounter.Wait();
orderedCounter.Wait();
// Unsubscribe
remoteMessaging.StopRemoteListen(idUnordered);
remoteMessaging.StopRemoteListen(idOrdered);
}
}
Console.WriteLine();
Console.WriteLine(">>> Example finished, press any key to exit ...");
Console.ReadKey();
}
public unsafe static byte[][,] LoadImageBytes(string fileName, int threadsToRun = 0)
{
Bitmap bmp = LoadBitmap(fileName);
if (null == bmp)
{
return(null);
}
int width = bmp.Width, height = bmp.Height;
byte[][,] res = CreateImageBytes(height, width);
BitmapData bd = bmp.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
try {
if (2 > threadsToRun)
{
int h, w;
byte *curpos;
Console.WriteLine("Using 1 thread to load image");
for (h = 0; h < height; h++)
{
curpos = (( byte * )bd.Scan0) + h * bd.Stride;
for (w = 0; w < width; w++)
{
res[2][h, w] = *(curpos++);
res[1][h, w] = *(curpos++);
res[0][h, w] = *(curpos++);
}
}
}
else
{
int step = height / threadsToRun, rest = height % threadsToRun;
Console.WriteLine("Using " + threadsToRun + " threads to load image");
using (CountdownEvent completed = new CountdownEvent(threadsToRun)) {
for (int num = 0; num < threadsToRun; num++)
{
ThreadPool.QueueUserWorkItem(new WaitCallback(idx => {
int i = ( int )idx;
int start = i * step, finish = start + step, h, w;
byte *curpos;
if (i < rest)
{
start += i;
finish += i + 1;
}
else
{
start += rest;
finish += rest;
}
Console.WriteLine("Thread " + i + " loading lines from " + start + " till " + finish);
for (h = start; h < finish; h++)
{
curpos = (( byte * )bd.Scan0) + h * bd.Stride;
for (w = 0; w < width; w++)
{
res[2][h, w] = *(curpos++);
res[1][h, w] = *(curpos++);
res[0][h, w] = *(curpos++);
}
}
completed.Signal();
}), num);
}
completed.Wait();
}
}
} finally {
bmp.UnlockBits(bd);
}
return(res);
}
public void MultiOffer2()
{
var q = new MpscLinkedArrayQueue <int>(4);
int[] sync = { 2 };
CountdownEvent latch = new CountdownEvent(2);
Task.Factory.StartNew(() =>
{
Interlocked.Decrement(ref sync[0]);
while (Volatile.Read(ref sync[0]) != 0)
{
;
}
for (int i = 0; i < 500000; i++)
{
if (i % 50000 == 0)
{
Console.WriteLine("Written " + i);
}
q.Offer(i);
}
Console.WriteLine("Written " + 500000);
latch.Signal();
}, TaskCreationOptions.LongRunning);
Task.Factory.StartNew(() =>
{
Interlocked.Decrement(ref sync[0]);
while (Volatile.Read(ref sync[0]) != 0)
{
;
}
for (int i = 500000; i < 1000000; i++)
{
if (i % 50000 == 0)
{
Console.WriteLine("Written " + i);
}
q.Offer(i);
}
Console.WriteLine("Written " + 1000000);
latch.Signal();
}, TaskCreationOptions.LongRunning);
latch.Wait(5000);
for (int i = 0; i < 1000000; i++)
{
if (i % 10000 == 0)
{
Console.WriteLine("Read " + i);
}
if (!q.Poll(out int item))
{
Assert.Fail("Queue appears to be empty?!");
}
}
Assert.IsTrue(q.IsEmpty());
}
public static void RunWithProcessorPressure(int threadCount, int lockCount, double activePercent, double lockChancePercent, Action a)
{
var stopped = 0;
var started = new CountdownEvent(threadCount);
var ts = new Thread[threadCount];
var locks = Enumerable.Range(0, lockCount).Select(_ => new object()).ToArray();
for (int i = 0; i < threadCount; i++)
{
var id = i;
var t = ts[i] = new Thread(() =>
{
var rand = new Random();
started.Signal();
var sw = Stopwatch.StartNew();
var run = TimeSpan.Zero;
while (Thread.VolatileRead(ref stopped) == 0)
{
var busy = new Stopwatch();
while (Thread.VolatileRead(ref stopped) == 0 && (double)run.Ticks / (double)sw.ElapsedTicks < activePercent)
{
busy.Restart();
const int RUN = 0;
const int BLOCK = 1;
var action = lockCount > 0 && rand.Next() % 100 <= lockChancePercent * 100 ? BLOCK : RUN;
switch (action)
{
case RUN:
//Console.WriteLine("~" + id);
while (busy.ElapsedMilliseconds < 10)
{
;
}
break;
case BLOCK:
//Console.WriteLine("!" + id);
lock (locks[rand.Next(0, lockCount)])
Thread.Sleep(rand.Next(100, 1000));
break;
}
run += busy.Elapsed;
}
Thread.Sleep(rand.Next(100, 1000));
}
});
t.Start();
}
started.Wait();
try
{
a();
}
finally
{
Interlocked.Exchange(ref stopped, 1);
foreach (var t in ts)
{
t.Join();
}
}
}
public void TestSemaphoreRejected()
{
IHystrixCommandGroupKey groupKey = HystrixCommandGroupKeyDefault.AsKey("ThreadPool-H");
IHystrixThreadPoolKey threadPoolKey = HystrixThreadPoolKeyDefault.AsKey("ThreadPool-H");
IHystrixCommandKey key = HystrixCommandKeyDefault.AsKey("RollingCounter-H");
stream = RollingThreadPoolEventCounterStream.GetInstance(threadPoolKey, 10, 500);
stream.StartCachingStreamValuesIfUnstarted();
CountdownEvent latch = new CountdownEvent(1);
stream.Observe().Take(5).Subscribe(GetSubscriber(output, latch));
// 10 commands will saturate semaphore when called from different threads.
// submit 2 more requests and they should be SEMAPHORE_REJECTED
// should see 10 SUCCESSes, 2 SEMAPHORE_REJECTED and 2 FALLBACK_SUCCESSes
List <Command> saturators = new List <Command>();
for (int i = 0; i < 10; i++)
{
saturators.Add(CommandStreamTest.Command.From(groupKey, key, HystrixEventType.SUCCESS, 500, ExecutionIsolationStrategy.SEMAPHORE));
}
CommandStreamTest.Command rejected1 = CommandStreamTest.Command.From(groupKey, key, HystrixEventType.SUCCESS, 0, ExecutionIsolationStrategy.SEMAPHORE);
CommandStreamTest.Command rejected2 = CommandStreamTest.Command.From(groupKey, key, HystrixEventType.SUCCESS, 0, ExecutionIsolationStrategy.SEMAPHORE);
foreach (CommandStreamTest.Command saturator in saturators)
{
Task t = new Task(
() =>
{
saturator.Observe();
}, CancellationToken.None,
TaskCreationOptions.LongRunning);
t.Start();
}
try
{
Time.Wait(100);
}
catch (Exception ie)
{
Assert.False(true, ie.Message);
}
rejected1.Observe();
rejected2.Observe();
try
{
Assert.True(latch.Wait(10000));
}
catch (Exception)
{
Assert.False(true, "Interrupted ex");
}
output.WriteLine("ReqLog : " + HystrixRequestLog.CurrentRequestLog.GetExecutedCommandsAsString());
Assert.True(rejected1.IsResponseSemaphoreRejected);
Assert.True(rejected2.IsResponseSemaphoreRejected);
// none of these got executed on a thread-pool, so thread pool metrics should be 0
Assert.Equal(2, stream.Latest.Length);
Assert.Equal(0, stream.GetLatestCount(ThreadPoolEventType.EXECUTED));
Assert.Equal(0, stream.GetLatestCount(ThreadPoolEventType.REJECTED));
}
private bool WaitForBatchAllowingPartialBatchResumption(CountdownEvent completionEvent, BatchStatistics batch, List <ThreadTask> childTasks, DocumentDatabase database = null)
{
Interlocked.Increment(ref _hasPartialBatchResumption);
var cancellationToken = database?.WorkContext.CancellationToken ?? _ct;
try
{
var waitHandles = new[] { completionEvent.WaitHandle, _threadHasNoWorkToDo };
var sp = Stopwatch.StartNew();
var batchRanToCompletion = false;
var lastThreadIndexChecked = 0;
while (cancellationToken.IsCancellationRequested == false)
{
// First, try to find work to do among child tasks, instead of just waiting
ThreadTask busyWaitWorkToDo = null;
for (; lastThreadIndexChecked < childTasks.Count && completionEvent.IsSet == false && _ct.IsCancellationRequested == false; lastThreadIndexChecked++)
{
var task = childTasks[lastThreadIndexChecked];
if (Interlocked.CompareExchange(ref task.Proccessing, 1, 0) == 1)
{
continue;
}
busyWaitWorkToDo = task;
break;
}
int returnedWaitHandleIndex;
// Run found work or just wait for all work to finish (returnedWaitHandleIndex=0) or to be notified about free threads in the system (returnedWaitHandleIndex=1)
// After which we'll decide whether we should early exit, or to wait some more
if (busyWaitWorkToDo != null)
{
RunThreadTask(busyWaitWorkToDo);
returnedWaitHandleIndex = WaitHandle.WaitAny(waitHandles, 0);
}
else
{
returnedWaitHandleIndex = WaitHandle.WaitAny(waitHandles);
}
if (returnedWaitHandleIndex == 0)
{
break;
}
// we won't consider breaking early if we haven't completed at least half the work
if (Thread.VolatileRead(ref batch.Completed) < batch.Total / 2)
{
continue;
}
var currentFreeThreads = _freedThreadsValue.Values.Count(isFree => isFree);
// we will break early only if there are more then half free threads
if (currentFreeThreads > _currentWorkingThreadsAmount / 2)
{
break;
}
}
// after we've decided to quit early, we will wait some more time, allowing a normal wait.
// we decide how much we will wait by choosing the biggest among the next:
// 1) half the time we've waited on the current batch
// 2) a waiting time factor that increase for every second left early batch and decreases for every leave early batch that completed before leaving early
var elapsedMilliseconds = (int)sp.ElapsedMilliseconds;
if (completionEvent.Wait(Math.Max(elapsedMilliseconds / 2, Thread.VolatileRead(ref _partialMaxWait)), cancellationToken))
{
_concurrentEvents.Enqueue(completionEvent);
}
// updating the waiting time factor
if (batch.Completed != batch.Total)
{
if (_partialMaxWaitChangeFlag > 0)
{
Interlocked.Exchange(ref _partialMaxWait, Math.Min(2500, (int)(Thread.VolatileRead(ref _partialMaxWait) * 1.25)));
}
}
else if (_partialMaxWaitChangeFlag < 0)
{
batchRanToCompletion = true;
Interlocked.Exchange(ref _partialMaxWait, Math.Max(Thread.VolatileRead(ref _partialMaxWait) / 2, 10));
}
Interlocked.Exchange(ref _partialMaxWaitChangeFlag, Thread.VolatileRead(ref _partialMaxWaitChangeFlag) * -1);
// completionEvent is explicitly left to the finalizer
// we expect this to be rare, and it isn't worth the trouble of trying
// to manage this
if (logger.IsDebugEnabled)
{
logger.Debug($"Raven Thread Pool ended batch for database {database?.Name}. Done {batch.Completed} items out of {batch.Total}. Batch {(batchRanToCompletion ? "was not" : "was")} left early");
}
return(batchRanToCompletion);
}
finally
{
Interlocked.Decrement(ref _hasPartialBatchResumption);
}
}
public void OnStart()
{
_globalSignal.Signal();
_globalSignal.Wait();
}
public bool @await()
{
return(waiter.Wait(new TimeSpan(0, 0, 0, 10)));
}
public void Third(Action printThird)
{
second.Wait();
// printThird() outputs "third". Do not change or remove this line.
printThird();
}
public void TestTwoSubscribersBothUnsubscribe()
{
CountdownEvent latch1 = new CountdownEvent(1);
CountdownEvent latch2 = new CountdownEvent(1);
AtomicInteger payloads1 = new AtomicInteger(0);
AtomicInteger payloads2 = new AtomicInteger(0);
IDisposable s1 = stream
.Observe()
.Take(100)
.OnDispose(() =>
{
latch1.SignalEx();
})
.Subscribe(
(utilization) =>
{
output.WriteLine((DateTime.Now.Ticks / 10000) + " : " + Thread.CurrentThread.ManagedThreadId + " : Dashboard 1 OnNext : " + utilization);
payloads1.IncrementAndGet();
},
(e) =>
{
output.WriteLine((DateTime.Now.Ticks / 10000) + " : " + Thread.CurrentThread.ManagedThreadId + " Dashboard 1 OnError : " + e);
latch1.SignalEx();
},
() =>
{
output.WriteLine((DateTime.Now.Ticks / 10000) + " : " + Thread.CurrentThread.ManagedThreadId + " Dashboard 1 OnCompleted");
latch1.SignalEx();
});
IDisposable s2 = stream
.Observe()
.Take(100)
.OnDispose(() =>
{
latch2.SignalEx();
})
.Subscribe(
(utilization) =>
{
output.WriteLine((DateTime.Now.Ticks / 10000) + " : " + Thread.CurrentThread.ManagedThreadId + " : Dashboard 2 OnNext : " + utilization);
payloads2.IncrementAndGet();
},
(e) =>
{
output.WriteLine((DateTime.Now.Ticks / 10000) + " : " + Thread.CurrentThread.ManagedThreadId + " Dashboard 2 OnError : " + e);
latch2.SignalEx();
},
() =>
{
output.WriteLine((DateTime.Now.Ticks / 10000) + " : " + Thread.CurrentThread.ManagedThreadId + " Dashboard 2 OnCompleted");
latch2.SignalEx();
});
// execute 2 commands, then unsubscribe from both streams, then execute the rest
for (int i = 0; i < 10; i++)
{
HystrixCommand <int> cmd = Command.From(GroupKey, CommandKey, HystrixEventType.SUCCESS, 50);
cmd.Execute();
if (i == 2)
{
s1.Dispose();
s2.Dispose();
}
}
Assert.False(stream.IsSourceCurrentlySubscribed); // both subscriptions have been cancelled - source should be too
Assert.True(latch1.Wait(10000));
Assert.True(latch2.Wait(10000));
output.WriteLine("s1 got : " + payloads1.Value + ", s2 got : " + payloads2.Value);
Assert.True(payloads1.Value > 0); // "s1 got data",
Assert.True(payloads2.Value > 0); // "s2 got data",
}
/// <summary>
/// 百度矢量要素下载(数据下载写入shp文件的时候可能出现问题，比如下载网络波动中断到时系统无法识别（解决办法先吧数据下载到数据在写入shp文件）)
/// </summary>
/// <param name="Result"></param>
/// <returns></returns>
public WebApiResult <string> BaiduDownload(BaiduMapFeatureDownloadResult Result)
{
this.countdown = new CountdownEvent(Result.TaskCount);
this.Result_BFeature = Result;
this.N = Result.TaskCount;
UpdateLastLoc <BaiduMapFeatureDownloadResult>(Result.GUID);
log = new TaskLogEntity()
{
GUID = Result.GUID, Name = Result.TName, Type = "矢量要素", Description = "BaiduDownload", Status = "进行中", Parameter = JsonHelper.ToJson(Result), SavePath = Result.SavePathText
};
//操作日志
new Log <BaiduMapFeatureDownloadResult>(log);
if (Result.LayerName == "道路")
{
xmlDoc.Load(MapFeatureConfig);
///////////////////////////////////////////////////////////////////////////////
// GDAL创建shp文件
// 注册所有的驱动
Ogr.RegisterAll();
// GDAL中文路径支持
OSGeo.GDAL.Gdal.SetConfigOption("GDAL_FILENAME_IS_UTF8", "YES");
// 属性表字段中文支持
OSGeo.GDAL.Gdal.SetConfigOption("SHAPE_ENCODING", "CP936");
// 设置坐标系存储文件夹gdal-data路径
OSGeo.GDAL.Gdal.SetConfigOption("GDAL_DATA", System.Windows.Forms.Application.StartupPath + "\\gdal-data");
Driver oDriver = Ogr.GetDriverByName("ESRI Shapefile");
if (oDriver == null)
{
return(new WebApiResult <string>()
{
success = 0, msg = "GDAL驱动不可用，请检查！"
});
}
// 创建数据源
DataSource oDS = oDriver.CreateDataSource(Result.SavePathText, null);
if (oDS == null)
{
return(new WebApiResult <string>()
{
success = 0, msg = "创建数据源失败，请检查！"
});
}
oLayer = oDS.GetLayerByName(Result.TName);
if (oLayer == null)
{
// 创建图层，创建一个多线图层，并指定空间参考
OSGeo.OSR.SpatialReference oSRS = new OSGeo.OSR.SpatialReference("PROJCS[\"WGS_1984_Pseudo_Mercator\",GEOGCS[\"GCS_WGS_1984\",DATUM[\"D_WGS_1984\",SPHEROID[\"WGS_1984\",6378137.0,298.257223563]],PRIMEM[\"Greenwich\",0.0],UNIT[\"Degree\",0.0174532925199433]],PROJECTION[\"Mercator\"],PARAMETER[\"false_easting\",0.0],PARAMETER[\"false_northing\",0.0],PARAMETER[\"central_meridian\",0.0],PARAMETER[\"standard_parallel_1\",0.0],UNIT[\"Meter\",1.0]]");
//OSGeo.OSR.SpatialReference oSRS = new OSGeo.OSR.SpatialReference("");
//oSRS.SetWellKnownGeogCS("EPSG:4326");
oLayer = oDS.CreateLayer(Result.TName, oSRS, wkbGeometryType.wkbMultiLineString, null);
if (oLayer == null)
{
return(new WebApiResult <string>()
{
success = 0, msg = "创建图层失败，请检查！"
});
}
// 创建属性表
// 先创建一个叫Name的字符型属性，字符长度为100
FieldDefn oFieldName = new FieldDefn("Name", FieldType.OFTString);
oFieldName.SetWidth(100);
oLayer.CreateField(oFieldName, 1);
// 再创建一个叫Type的字符型属性，字符长度为50
FieldDefn oFieldType = new FieldDefn("Type", FieldType.OFTString);
oFieldType.SetWidth(50);
oLayer.CreateField(oFieldType, 1);
// 再创建一个叫UID的字符型属性，字符长度为50
FieldDefn oFieldUID = new FieldDefn("UID", FieldType.OFTString);
oFieldUID.SetWidth(50);
oLayer.CreateField(oFieldUID, 1);
}
/////////////////////////////////////////////////////////////////////////////////
threadlog = new ThreadTaskLogEntity()
{
GUID = Result.GUID, TaskLog_GUID = Result.GUID, Status = "进行中", TStatus = 1, TName = Result.TName, IsPaused = false, URL = Result.URL, Parameter = JsonHelper.ToJson(Result)
};
//计算Total并更新
threadlog.Total = GetList("SELECT KWName FROM mapbar_poi WHERE KWType = '道路'", "KWName").Count;
new Log <BaiduMapFeatureDownloadResult>(threadlog);
log.Count = threadlog.Total;
new Log <BaiduMapFeatureDownloadResult>(log);
Thread[] t = new Thread[Result.TaskCount];
for (int num = 0; num < Result.TaskCount; num++)
{
try
{
t[num] = new Thread(new ParameterizedThreadStart(run_BFeature))
{
Name = "Thread " + num.ToString()
};
t[num].Start(num);
}
catch (Exception ex)
{
threadlog.Status = "错误";
threadlog.ErrorMsg = ex.ToString();
threadlog.TStatus = 3;
new Log <BaiduMapFeatureDownloadResult>(threadlog);
log.Status = "错误";
log.ErrorMsg = ex.ToString();
log.ErrorDate = DateTime.Now.ToString();
//操作日志
new Log <BaiduMapFeatureDownloadResult>(log);
return(new WebApiResult <string>()
{
success = 0, msg = ex.ToString()
});
}
}
countdown.Wait();
oLayer.Dispose();
oDS.Dispose();
for (int num = 0; num < Result.TaskCount; num++)
{
t[num].Abort();
}
lock (obj)
{
if (!Log <BaiduMapFeatureDownloadResult> .GetThreadLogEntity(this.Result_BFeature.GUID).IsPaused)
{
//配置文件参数信息更新
xmlDoc["MapFeature"]["bmap"]["dict_index"].InnerText = "0";
xmlDoc.Save(MapFeatureConfig);
log.Status = "已完成";
log.CompleteTime = DateTime.Now.ToString();
log.Current = log.Count;
threadlog.Status = "已完成";
threadlog.TStatus = 2;
threadlog.Current = threadlog.Total;
threadlog.Current_loc = List2Str(current_loc);
//操作日志
new Log <BaiduMapFeatureDownloadResult>(threadlog);
new Log <BaiduMapFeatureDownloadResult>(log);
return(new WebApiResult <string>()
{
success = 1, msg = "百度地图要素下载完成！"
});
}
}
}
else
{
return(new WebApiResult <string>()
{
success = 2, msg = "图层类型不符合"
});
}
return(null);
}
public void TestTwoSubscribersOneUnsubscribes()
{
CountdownEvent latch1 = new CountdownEvent(1);
CountdownEvent latch2 = new CountdownEvent(1);
AtomicInteger payloads1 = new AtomicInteger(0);
AtomicInteger payloads2 = new AtomicInteger(0);
IDisposable s1 = stream
.Observe()
.Take(100)
.OnDispose(() =>
{
latch1.SignalEx();
})
.Subscribe(
(utilization) =>
{
output.WriteLine((DateTime.Now.Ticks / 10000) + " : " + Thread.CurrentThread.ManagedThreadId + " : Dashboard 1 OnNext : " + utilization);
payloads1.IncrementAndGet();
},
(e) =>
{
output.WriteLine((DateTime.Now.Ticks / 10000) + " : " + Thread.CurrentThread.ManagedThreadId + " Dashboard 1 OnError : " + e);
latch1.SignalEx();
},
() =>
{
output.WriteLine((DateTime.Now.Ticks / 10000) + " : " + Thread.CurrentThread.ManagedThreadId + " Dashboard 1 OnCompleted");
latch1.SignalEx();
});
IDisposable s2 = stream
.Observe()
.Take(100)
.OnDispose(() =>
{
latch2.SignalEx();
})
.Subscribe(
(utilization) =>
{
output.WriteLine((DateTime.Now.Ticks / 10000) + " : " + Thread.CurrentThread.ManagedThreadId + " : Dashboard 2 OnNext : " + utilization);
payloads2.IncrementAndGet();
},
(e) =>
{
output.WriteLine((DateTime.Now.Ticks / 10000) + " : " + Thread.CurrentThread.ManagedThreadId + " Dashboard 2 OnError : " + e);
latch2.SignalEx();
},
() =>
{
output.WriteLine((DateTime.Now.Ticks / 10000) + " : " + Thread.CurrentThread.ManagedThreadId + " Dashboard 2 OnCompleted");
latch2.SignalEx();
});
// execute 1 command, then unsubscribe from first stream. then execute the rest
for (int i = 0; i < 50; i++)
{
HystrixCommand <int> cmd = Command.From(GroupKey, CommandKey, HystrixEventType.SUCCESS, 50);
cmd.Execute();
if (i == 1)
{
s1.Dispose();
}
}
Assert.True(latch1.Wait(10000));
Assert.True(latch2.Wait(10000));
output.WriteLine("s1 got : " + payloads1.Value + ", s2 got : " + payloads2.Value);
Assert.True(payloads1.Value > 0); // "s1 got data",
Assert.True(payloads2.Value > 0); // "s2 got data",
Assert.True(payloads2.Value > payloads1.Value); // "s1 got less data than s2",
}
/// <summary>
/// Calculates Node based Betweeness Centrality using multiple threads
/// </summary>
/// <param name="g"></param>
/// <returns></returns>
public static double[] ParallelBrandesBcNodes(LightWeightGraph g)
{
int numNodes = g.NumNodes;
int numThreads = Settings.Threading.NumThreadsBc;
int workSize = numNodes / numThreads;
int workSizeExtra = numNodes % numThreads;
//Start getting a randomized work load
List <int> nodes = new List <int>(numNodes);
for (int i = 0; i < numNodes; i++)
{
nodes.Add(i);
}
nodes.Shuffle();
//Create an array of work items for each thread and assign the nodes in a randomized order
int[][] workItems = new int[numThreads][];
for (int t = 0; t < numThreads; t++)
{
int size = workSize + (t == (numThreads - 1) ? workSizeExtra : 0);
workItems[t] = new int[size];
for (int i = 0; i < size; i++)
{
workItems[t][i] = nodes[t * workSize + i];
}
}
//Create our threads use a closure to get our return arrays
BetweenessCalc[] threadResults = new BetweenessCalc[numThreads];
//ManualResetEvent[] waitHandles = new ManualResetEvent[numThreads];
CountdownEvent cde = new CountdownEvent(numThreads);
for (int t = 0; t < numThreads; t++)
{
int tIndex = t;
//waitHandles[tIndex] = new ManualResetEvent(false);
BetweenessCalc tResult = new BetweenessCalc(g, workItems[tIndex]);
threadResults[tIndex] = tResult;
ThreadPool.QueueUserWorkItem(tResult.ThreadPoolCallback, cde);
}
cde.Wait();
//WaitHandle.WaitAll(waitHandles);
//Create our betweeness map and sum all of the thread results
double[] bcMap = new double[numNodes];
for (int t = 0; t < numThreads; t++)
{
var threadR = threadResults[t].BcMap;
for (int n = 0; n < numNodes; n++)
{
bcMap[n] += threadR[n];
}
}
//divide all by 2 (undirected)
for (int v = 0; v < numNodes; v++)
{
bcMap[v] /= 2f;
}
return(bcMap);
}
public void ClosedSocketFromServer()
{
int port = 15001;
string data = "testData";
bool closed = false;
EasyServer server = new EasyServer();
Task.Run(() =>
{
server.ConnectHandler(socket =>
{
string socketId = socket.SocketId;
socket.CloseHandler(() =>
{
_output.WriteLine($"[{socketId}] server socket close handler");
});
socket.ExceptionHandler(exception =>
{
_output.WriteLine($"[{socketId}] server socket exception handler - {exception}");
});
socket.Receive(receivedData =>
{
string stringData = Encoding.UTF8.GetString(receivedData);
_output.WriteLine($"[{socketId}] server socket receive - {stringData}:{stringData.Length}");
socket.Close();
});
});
server.ExceptionHandler(exception =>
{
_output.WriteLine($"server start exception handler - {exception}");
});
server.Start("127.0.0.1", port);
}).Wait(1500);
EasyClient client = new EasyClient();
CountdownEvent countdownEvent = new CountdownEvent(1);
client.ConnectHandler(socket =>
{
string socketId = socket.SocketId;
socket.CloseHandler(() =>
{
_output.WriteLine($"[{socketId}] client socket close handler");
closed = true;
countdownEvent.Signal();
});
socket.ExceptionHandler(exception =>
{
_output.WriteLine($"[{socketId}] client socket close handler");
});
byte[] sendData = Encoding.UTF8.GetBytes(data);
socket.Send(sendData, sendSize =>
{
_output.WriteLine($"[{socketId}] client socket send - {data}:{data.Length}");
});
socket.Receive(receivedData =>
{
string stringData = Encoding.UTF8.GetString(receivedData);
_output.WriteLine($"[{socketId}] client socket receive - {stringData}:{stringData.Length}");
});
});
client.ExceptionHandler(exception =>
{
_output.WriteLine($"client connect exception handler - {exception}");
});
client.Connect("127.0.0.1", port);
countdownEvent.Wait();
server.Stop();
Assert.True(closed);
}
static int Main(string[] args)
{
var showHelp = false;
var configPath = string.Empty;
var crusherSectionName = "Crusher";
var cssSpriteSectionName = "CssSprite";
var applicationPath = "/";
var options = new OptionSet()
{
{
"c=|configPath=",
"the configuration path to the web.config or app.config file. E.g. ../../../Talifun.Web.Examples/Crusher.Demo/web.config",
c => configPath = c
},
{
"cs=|crusherSectionName=",
"the section name of the configuration element for the Talifun.Crusher configuration. Defaults to 'Crusher' if not specified.",
cs => crusherSectionName = cs
},
{
"css=|cssSpriteSectionName=",
"the section name of the configuration element for the Talifun.CssSprite configuration. Defaults to 'CssSprite' if not specified.",
css => cssSpriteSectionName = css
},
{
"a=|applicationPath=",
"the application path to be relative from. Defaults to '/' if not specified.",
a => applicationPath = a
},
{
"?|h|help",
"display help screen",
h => showHelp = h != null
}
};
try
{
options.Parse(args);
}
catch(OptionException e)
{
Console.WriteLine(HeaderMessage);
Console.WriteLine(e.Message);
Console.WriteLine(UsageMessage);
Console.WriteLine(HelpMessage);
return DisplayHelpScreenExitCode;
}
if (showHelp)
{
DisplayHelp(options);
return DisplayHelpScreenExitCode;
}
if (string.IsNullOrEmpty(configPath))
{
Console.WriteLine(HeaderMessage);
Console.WriteLine(UsageMessage);
Console.WriteLine(HelpMessage);
return DisplayHelpScreenExitCode;
}
var crusherConfiguration = GetCrusherSection(configPath, crusherSectionName);
if (crusherConfiguration == null)
{
Console.WriteLine(HeaderMessage);
Console.WriteLine("\"{0}\" section name not found in {1} ", crusherSectionName, configPath);
Console.WriteLine(HelpMessage);
return DisplayHelpScreenExitCode;
}
try
{
Console.WriteLine();
Console.WriteLine("Settings used:");
Console.WriteLine("configPath = " + configPath);
Console.WriteLine("crusherSectionName = " + crusherSectionName);
Console.WriteLine("applicationPath = " + applicationPath);
var configUri = new Uri(configPath, UriKind.RelativeOrAbsolute);
if (!configUri.IsAbsoluteUri)
{
configUri = new Uri(Path.Combine(Environment.CurrentDirectory, configUri.ToString()));
}
var physicalApplicationPath = new FileInfo(configUri.LocalPath).DirectoryName;
var retryableFileOpener = new RetryableFileOpener();
var hasher = new Md5Hasher(retryableFileOpener);
var retryableFileWriter = new RetryableFileWriter(BufferSize, Encoding, retryableFileOpener, hasher);
var pathProvider = new PathProvider(applicationPath, physicalApplicationPath);
var cacheManager = new HttpCacheManager();
var fileMetaData = new MultiFileMetaData(retryableFileOpener, retryableFileWriter);
var jsOutput = string.Empty;
var cssOutput = string.Empty;
var cssSpriteOutput = string.Empty;
//We want to be able to use output from css sprites in crushed content
var countdownEvents = new CountdownEvent(3);
var cssSpriteExceptions = new List<CssSpriteException>();
ThreadPool.QueueUserWorkItem(data =>
{
var manualResetEvent = (CountdownEvent)data;
try
{
if (crusherConfiguration != null)
{
var cssSpriteGroups = crusherConfiguration.CssSpriteGroups;
var cssSpriteCreator = new CssSpriteCreator(cacheManager, retryableFileOpener, pathProvider, retryableFileWriter, fileMetaData);
var cssSpriteGroupsProcessor = new CssSpriteGroupsProcessor();
cssSpriteOutput = cssSpriteGroupsProcessor.ProcessGroups(pathProvider, cssSpriteCreator, cssSpriteGroups).ToString();
}
}
catch (Exception exception)
{
cssSpriteExceptions.Add(new CssSpriteException(exception));
}
manualResetEvent.Signal();
}, countdownEvents);
var jsExceptions = new List<JsException>();
ThreadPool.QueueUserWorkItem(data =>
{
var manualResetEvent = (CountdownEvent)data;
try
{
if (crusherConfiguration != null)
{
var jsCrusher = new JsCrusher(cacheManager, pathProvider, retryableFileOpener, retryableFileWriter, fileMetaData);
var jsGroups = crusherConfiguration.JsGroups;
var jsGroupsProcessor = new JsGroupsProcessor();
jsOutput = jsGroupsProcessor.ProcessGroups(pathProvider, jsCrusher, jsGroups).ToString();
}
}
catch (Exception exception)
{
jsExceptions.Add(new JsException(exception));
}
manualResetEvent.Signal();
}, countdownEvents);
var cssExceptions = new List<CssException>();
ThreadPool.QueueUserWorkItem(data =>
{
var manualResetEvent = (CountdownEvent)data;
try
{
if (crusherConfiguration != null)
{
var hashQueryStringKeyName = crusherConfiguration.QuerystringKeyName;
var cssAssetsFileHasher = new CssAssetsFileHasher(hashQueryStringKeyName, hasher, pathProvider);
var cssPathRewriter = new CssPathRewriter(cssAssetsFileHasher, pathProvider);
var cssCrusher = new CssCrusher(cacheManager, pathProvider, retryableFileOpener, retryableFileWriter, cssPathRewriter, fileMetaData, crusherConfiguration.WatchAssets);
var cssGroups = crusherConfiguration.CssGroups;
var cssGroupsCrusher = new CssGroupsProcessor();
cssOutput = cssGroupsCrusher.ProcessGroups(pathProvider, cssCrusher, cssGroups).ToString();
}
}
catch (Exception exception)
{
cssExceptions.Add(new CssException(exception));
}
manualResetEvent.Signal();
}, countdownEvents);
countdownEvents.Wait();
if (string.IsNullOrEmpty(cssSpriteOutput) && !cssSpriteExceptions.Any())
{
Console.WriteLine();
Console.WriteLine("Skipping css sprite creation. \"{0}\" section name not found in \"{1}\"", cssSpriteSectionName, configPath);
}
else
{
Console.WriteLine();
Console.WriteLine(cssSpriteOutput);
if (cssSpriteExceptions.Any())
{
Console.WriteLine("Css sprite errors:");
Console.WriteLine(new AggregateException(cssSpriteExceptions.Cast<Exception>()));
}
}
if (string.IsNullOrEmpty(jsOutput) && string.IsNullOrEmpty(cssOutput) && !jsExceptions.Any() && !cssExceptions.Any())
{
Console.WriteLine();
Console.WriteLine("Skipping css/js crushed content creation. \"{0}\" section name not found in \"{1}\"", crusherSectionName, configPath);
}
else
{
Console.WriteLine();
Console.WriteLine(cssOutput);
if (cssExceptions.Any())
{
Console.WriteLine("Css errors:");
Console.WriteLine(new AggregateException(cssExceptions.Cast<Exception>()));
}
Console.WriteLine();
Console.WriteLine(jsOutput);
if (jsExceptions.Any())
{
Console.WriteLine("Js errors:");
Console.WriteLine(new AggregateException(jsExceptions.Cast<Exception>()));
}
}
}
catch (Exception exception)
{
Console.Write(exception);
return ErrorExitCode;
}
return SuccessExitCode;
}
protected override void Execute(CodeActivityContext context)
{
string attribute_str = Attribute.Get(context);
string attribute_value = Value.Get(context);
try
{
Int32 _timeout = TimeoutMS.Get(context);
Thread.Sleep(_timeout);
latch = new CountdownEvent(1);
Thread td = new Thread(() =>
{
if (Selector.Expression == null)
{
//ActiveElement处理
}
else
{
var selStr = Selector.Get(context);
UiElement element = GetValueOrDefault(context, this.Element, null);
if (element == null && selStr != null)
{
element = UiElement.FromSelector(selStr);
}
if (element != null)
{
element.SetForeground();
mshtml.IHTMLDocument2 currDoc = null;
SHDocVw.InternetExplorer ieBrowser = GetIEFromHWndClass.GetIEFromHWnd((int)element.WindowHandle, out currDoc);
mshtml.IHTMLElement currEle = GetIEFromHWndClass.GetEleFromDoc(
element.GetClickablePoint(), (int)element.WindowHandle, currDoc);
currEle.setAttribute(attribute_str, attribute_value);
}
else
{
SharedObject.Instance.Output(SharedObject.enOutputType.Error, "有一个错误产生", "查找不到元素");
if (ContinueOnError.Get(context))
{
return;
}
else
{
throw new NotImplementedException("查找不到元素");
}
}
}
refreshData(latch);
});
td.TrySetApartmentState(ApartmentState.STA);
td.IsBackground = true;
td.Start();
latch.Wait();
}
catch (Exception e)
{
SharedObject.Instance.Output(SharedObject.enOutputType.Error, "出现异常", e.Message);
if (ContinueOnError.Get(context))
{
}
}
}
public override void Run()
{
using (Stream stream = new NetworkStream(cs))
{
BinaryReader intReader = new BinaryReader(stream);
BinaryWriter intWriter = new BinaryWriter(stream);
try
{
int id = intReader.ReadInt32();
if (id < 0)
{
throw new IOException("Client closed connection before communication started.");
}
startingGun.Wait();
intWriter.Write(43);
stream.Flush();
while (true)
{
int command = stream.ReadByte();
if (command < 0)
{
return; // closed
}
lock (localLock)
{
int currentLock = lockedID[0];
if (currentLock == -2)
{
return; // another thread got error, so we exit, too!
}
switch (command)
{
case 1:
// Locked
if (currentLock != -1)
{
lockedID[0] = -2;
throw new InvalidOperationException("id " + id + " got lock, but " + currentLock + " already holds the lock");
}
lockedID[0] = id;
break;
case 0:
// Unlocked
if (currentLock != id)
{
lockedID[0] = -2;
throw new InvalidOperationException("id " + id + " released the lock, but " + currentLock + " is the one holding the lock");
}
lockedID[0] = -1;
break;
default:
throw new Exception("Unrecognized command: " + command);
}
intWriter.Write((byte)command);
stream.Flush();
}
}
}
catch (IOException ioe)
{
throw new Exception(ioe.ToString(), ioe);
}
catch (Exception e)
{
// LUCENENET NOTE: We need to throw a new exception
// to ensure this is Exception and not some other type.
throw new Exception(e.ToString(), e);
}
finally
{
IOUtils.DisposeWhileHandlingException(cs);
}
}
}
static void Impl(int disposeAt)
{
var rand = new Random();
var g = new CompositeDisposable();
Console.Write("Dispose @ = {0} - ", disposeAt);
if (disposeAt == 0)
{
g.Dispose();
Console.Write("{GD} ");
}
if (disposeAt == 1)
{
var sleep = rand.Next(0, 5) > 1 /* 60% chance */ ? rand.Next(2, 1000) : 0;
ThreadPool.QueueUserWorkItem(_ =>
{
Helpers.SleepOrSpin(sleep);
g.Dispose();
Console.Write("{GD} ");
});
}
var n = rand.Next(0, 1000);
var cd = new CountdownEvent(n);
var ds = Enumerable.Range(0, n).Select(_ => Disposable.Create(() => cd.Signal())).ToArray();
var m = rand.Next(1, 100);
var jobs = ds.GroupBy(_ => rand.Next() % m).Select(Enumerable.ToList).ToList();
Console.Write("N = {0}, M = {1} - ", n, m);
var done = new CountdownEvent(jobs.Count);
foreach (var job in jobs)
{
var sleep = rand.Next(0, 10) == 0 /* 10% chance */ ? rand.Next(2, 100) : 0;
var sleepAt = Enumerable.Range(0, rand.Next(0, job.Count) / rand.Next(1, 100)).ToArray();
var sleeps = sleepAt.Select(_ => rand.Next(0, 50)).ToArray();
var rem = rand.Next(0, 3) == 0; /* 33% chance */
var remAt = rand.Next(0, 10) == 0 /* 10% chance */ ? rand.Next(2, 100) : 0;
var mine = job;
ThreadPool.QueueUserWorkItem(_ =>
{
Helpers.SleepOrSpin(sleep);
var j = 0;
foreach (var d in mine)
{
var dd = d;
if (sleepAt.Contains(j))
{
Helpers.SleepOrSpin(sleeps[j]);
}
g.Add(dd);
Console.Write("+");
if (rem)
{
ThreadPool.QueueUserWorkItem(__ =>
{
Helpers.SleepOrSpin(remAt);
g.Remove(dd);
Console.Write("-");
});
}
j++;
}
done.Signal();
});
}
done.Wait();
if (disposeAt == 2)
{
g.Dispose();
Console.Write("{GD} ");
}
cd.Wait();
Console.WriteLine(".");
}
public void TestEtw()
{
using (var listener = new TestEventListener(new Guid("16F53577-E41D-43D4-B47E-C17025BF4025"), EventLevel.Verbose))
{
ActionBlock<int> ab = null;
BufferBlock<int> bb = null;
int remaining = 0;
CountdownEvent ce = new CountdownEvent(0);
// Check that block creation events fire
const int DataflowBlockCreatedId = 1;
remaining = 2;
listener.RunWithCallback(ev => {
Assert.Equal(expected: DataflowBlockCreatedId, actual: ev.EventId);
remaining--;
},
() => {
ab = new ActionBlock<int>(i => { });
bb = new BufferBlock<int>(); // trigger block creation event
Assert.Equal(expected: 0, actual: remaining);
});
// Check that linking events fire
const int BlockLinkedId = 4;
remaining = 1;
IDisposable link = null;
listener.RunWithCallback(ev => {
Assert.Equal(expected: BlockLinkedId, actual: ev.EventId);
remaining--;
},
() => {
link = bb.LinkTo(ab);
Assert.Equal(expected: 0, actual: remaining);
});
// Check that unlinking events fire
const int BlockUnlinkedId = 5;
remaining = 1;
listener.RunWithCallback(ev => {
Assert.Equal(expected: BlockUnlinkedId, actual: ev.EventId);
remaining--;
},
() => {
link.Dispose();
Assert.Equal(expected: 0, actual: remaining);
});
// Check that task launched events fire
const int TaskLaunchedId = 2;
ce.Reset(1);
listener.RunWithCallback(ev => {
Assert.Equal(expected: TaskLaunchedId, actual: ev.EventId);
ce.Signal();
},
() => {
ab.Post(42);
ce.Wait();
Assert.Equal(expected: 0, actual: ce.CurrentCount);
});
// Check that completion events fire
const int BlockCompletedId = 3;
ce.Reset(2);
listener.RunWithCallback(ev => {
Assert.Equal(expected: BlockCompletedId, actual: ev.EventId);
ce.Signal();
},
() => {
ab.Complete();
bb.Complete();
ce.Wait();
Assert.Equal(expected: 0, actual: ce.CurrentCount);
});
}
}
public object Clone()
{
AppDomain.CurrentDomain.UnhandledException += OnUnhandledException;
try
{
var cssSpriteOutput = string.Empty;
var jsOutput = string.Empty;
var cssOutput = string.Empty;
var countdownEvents = new CountdownEvent(1);
ThreadPool.QueueUserWorkItem(data =>
{
var countdownEvent = (CountdownEvent) data;
try
{
if (_cssSpriteConfiguration != null)
{
var cssSpriteGroups = _cssSpriteConfiguration.CssSpriteGroups;
var cssSpriteCreator = new CssSpriteCreator(_cacheManager, _retryableFileOpener, _pathProvider, _retryableFileWriter, _fileMetaData);
var cssSpriteGroupsProcessor = new CssSpriteGroupsProcessor();
cssSpriteOutput = cssSpriteGroupsProcessor.ProcessGroups(_pathProvider, cssSpriteCreator, cssSpriteGroups).ToString();
_logMessage(cssSpriteOutput);
}
}
catch (Exception exception)
{
_logError(exception.ToString());
}
countdownEvent.Signal();
}, countdownEvents);
countdownEvents.Wait();
countdownEvents = new CountdownEvent(2);
ThreadPool.QueueUserWorkItem(data =>
{
var countdownEvent = (CountdownEvent) data;
try
{
if (_crusherConfiguration != null)
{
var jsCrusher = new JsCrusher(_cacheManager, _pathProvider, _retryableFileOpener, _retryableFileWriter, _fileMetaData);
var jsGroups = _crusherConfiguration.JsGroups;
var jsGroupsProcessor = new JsGroupsProcessor();
jsOutput = jsGroupsProcessor.ProcessGroups(_pathProvider, jsCrusher, jsGroups).ToString();
_logMessage(jsOutput);
}
}
catch (Exception exception)
{
_logError(exception.ToString());
}
countdownEvent.Signal();
}, countdownEvents);
ThreadPool.QueueUserWorkItem(data =>
{
var countdownEvent = (CountdownEvent) data;
try
{
if (_crusherConfiguration != null)
{
var hashQueryStringKeyName = _crusherConfiguration.QuerystringKeyName;
var cssAssetsFileHasher = new CssAssetsFileHasher(hashQueryStringKeyName, _hasher, _pathProvider);
var cssPathRewriter = new CssPathRewriter(cssAssetsFileHasher, _pathProvider);
var cssCrusher = new CssCrusher(_cacheManager, _pathProvider, _retryableFileOpener, _retryableFileWriter, cssPathRewriter, _fileMetaData, _crusherConfiguration.WatchAssets);
var cssGroups = _crusherConfiguration.CssGroups;
var cssGroupsCrusher = new CssGroupsProcessor();
cssOutput = cssGroupsCrusher.ProcessGroups(_pathProvider, cssCrusher, cssGroups).ToString();
_logMessage(cssOutput);
}
}
catch (Exception exception)
{
_logError(exception.ToString());
}
countdownEvent.Signal();
}, countdownEvents);
countdownEvents.Wait();
}
catch (Exception exception)
{
_logError(exception.ToString());
}
finally
{
AppDomain.CurrentDomain.UnhandledException -= OnUnhandledException;
}
return null;
}
