/// <include file='../../_Doc/mscorlib.xml' path='doc/members/member[@name="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Concurrent.Partitioner{``0},System.Threading.Tasks.ParallelOptions,System.Action{``0,System.Threading.Tasks.ParallelLoopState})"]/*' />
public static ParallelLoopResult ForEach <TSource>(
Partitioner <TSource> source,
ParallelOptions parallelOptions,
Action <TSource, ParallelLoopState> body)
{
var loopState = new ParallelLoopState();
foreach (var partition in source.GetPartitions(1))
{
while (partition.MoveNext())
{
if (loopState.ShouldExitCurrentIteration)
{
return new ParallelLoopResult {
IsCompleted = false, LowestBreakIteration = null
}
}
;
body(partition.Current, loopState);
}
}
return(new ParallelLoopResult {
IsCompleted = true
});
}
#endregion
}
private static void ShrinkFile(string filename, ParallelLoopState arg2, long arg3)
{
FileStream fs = new FileStream(filename, FileMode.Open, FileAccess.Read);
Image img = new Image(fs);
var wpercent = (300 / img.Width);
var hsize = img.Height * wpercent;
}
int DoExecute(IGrouping <string, ITaskItem> imageGroup, ThreadingTasks.ParallelLoopState state, int loop)
{
var tempDirectory = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
Directory.CreateDirectory(tempDirectory);
var tempOutputDirectory = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
Directory.CreateDirectory(tempOutputDirectory);
try {
LogDebugMessage("Crunch Processing : {0}", imageGroup.Key);
LogDebugTaskItems(" Items :", imageGroup.ToArray());
foreach (var item in imageGroup)
{
var dest = Path.GetFullPath(item.ItemSpec).Replace(imageGroup.Key, tempDirectory);
Directory.CreateDirectory(Path.GetDirectoryName(dest));
MonoAndroidHelper.CopyIfChanged(item.ItemSpec, dest);
MonoAndroidHelper.SetWriteable(dest);
}
// crunch them
if (!RunAapt(GenerateCommandLineCommands(tempDirectory, tempOutputDirectory)))
{
return(0);
}
// copy them back
foreach (var item in imageGroup)
{
var dest = Path.GetFullPath(item.ItemSpec).Replace(imageGroup.Key, tempOutputDirectory);
var srcmodifiedDate = File.GetLastWriteTimeUtc(item.ItemSpec);
if (!File.Exists(dest))
{
continue;
}
MonoAndroidHelper.CopyIfChanged(dest, item.ItemSpec);
MonoAndroidHelper.SetWriteable(dest);
// reset the Dates so MSBuild/xbuild doesn't think they changed.
MonoAndroidHelper.SetLastAccessAndWriteTimeUtc(item.ItemSpec, srcmodifiedDate, Log);
}
}
finally {
Directory.Delete(tempDirectory, recursive: true);
Directory.Delete(tempOutputDirectory, recursive: true);
}
return(0);
}
/// <include file='../../_Doc/mscorlib.xml' path='doc/members/member[@name="M:System.Threading.Tasks.Parallel.For(System.Int32,System.Int32,System.Action{System.Int32,System.Threading.Tasks.ParallelLoopState})"]/*' />
public static ParallelLoopResult For(int fromInclusive, int toExclusive, Action <int, ParallelLoopState> body)
{
var loopState = new ParallelLoopState();
for (var i = fromInclusive; i < toExclusive; ++i)
{
if (loopState.ShouldExitCurrentIteration)
{
return new ParallelLoopResult {
IsCompleted = false, LowestBreakIteration = null
}
}
;
body(i, loopState);
}
return(new ParallelLoopResult {
IsCompleted = true
});
}
int DoExecute(ITaskItem manifestFile, ThreadingTasks.ParallelLoopState state, int loop)
{
if (!File.Exists(manifestFile.ItemSpec))
{
LogDebugMessage("{0} does not exists. Skipping", manifestFile.ItemSpec);
return(0);
}
bool upToDate = ManifestIsUpToDate(manifestFile.ItemSpec);
if (AdditionalAndroidResourcePaths != null)
{
foreach (var dir in AdditionalAndroidResourcePaths)
{
if (!string.IsNullOrEmpty(dir.ItemSpec))
{
upToDate = upToDate && ManifestIsUpToDate(string.Format("{0}{1}{2}{3}{4}", dir, Path.DirectorySeparatorChar, "manifest", Path.DirectorySeparatorChar, "AndroidManifest.xml"));
}
}
}
if (upToDate)
{
LogMessage(" Additional Android Resources manifsets files are unchanged. Skipping.");
return(0);
}
var defaultAbi = new string [] { null };
var abis = SupportedAbis?.Split(new char [] { ',', ';' }, StringSplitOptions.RemoveEmptyEntries);
foreach (var abi in (CreatePackagePerAbi && abis?.Length > 1) ? defaultAbi.Concat(abis) : defaultAbi)
{
var currentResourceOutputFile = abi != null?string.Format("{0}-{1}", ResourceOutputFile, abi) : ResourceOutputFile;
if (!ExecuteForAbi(GenerateCommandLineCommands(manifestFile.ItemSpec, abi, currentResourceOutputFile), currentResourceOutputFile))
{
Cancel();
}
}
return(0);
}
/// <include file='../../_Doc/mscorlib.xml' path='doc/members/member[@name="M:System.Threading.Tasks.Parallel.For``1(System.Int32,System.Int32,System.Threading.Tasks.ParallelOptions,System.Func{``0},System.Func{System.Int32,System.Threading.Tasks.ParallelLoopState,``0,``0},System.Action{``0})"]/*' />
public static ParallelLoopResult For <TLocal>(int fromInclusive, int toExclusive, ParallelOptions parallelOptions,
Func <TLocal> localInit, Func <int, ParallelLoopState, TLocal, TLocal> body, Action <TLocal> localFinally)
{
var loopState = new ParallelLoopState();
for (var i = fromInclusive; i < toExclusive; ++i)
{
if (loopState.ShouldExitCurrentIteration)
{
return new ParallelLoopResult {
IsCompleted = false, LowestBreakIteration = null
}
}
;
localFinally(body(i, loopState, localInit()));
}
return(new ParallelLoopResult {
IsCompleted = true
});
}
private void ProcessXPSFile(FileInfo xpsF, ParallelLoopState pls, long l)
{
Log("Processing: " + xpsF.Name);
string xpsFileName = xpsF.FullName;
try
{
XpsDocument xpsDoc = new XpsDocument(xpsFileName, System.IO.FileAccess.Read);
System.Threading.ParameterizedThreadStart ts = new System.Threading.ParameterizedThreadStart(ProcessXPSonSTA);
System.Threading.Thread tProcess = new System.Threading.Thread(ts);
tProcess.SetApartmentState(System.Threading.ApartmentState.STA);
tProcess.Start(new XPSParams() { xpsFileName = xpsFileName, xpsDoc = xpsDoc });
}
catch (Exception e)
{
Log(e.ToString());
}
}
private void CalculateImage(ImageViewModel imageViewModel, ParallelLoopState state, Int64 counter)
{
if (DoRestart) state.Stop();
var messageText = "Calculating Compressed Size" +
new string('.', (int)(counter % 4));
if (Application.Current == null) return;
Application.Current.Dispatcher.Invoke(
DispatcherPriority.Normal,
(Action)(() =>
{
Ui.ProgressValue += 1;
Ui.MessageText = messageText;
}));
lock (_lockObject)
{
_sizeSum += ImageModel.GetFileSizeScaledInMegaByte(imageViewModel);
}
}
private void RenderTile(Tuple<int, int> range, ParallelLoopState state)
{
_loger.Log(Level.Verbose, string.Format("Started tile {0} {1}", range.Item1, range.Item2));
int height = _scene.Camera.Height;
Bitmap buffer = new Bitmap(range.Item2 - range.Item1, height);
for (int x = range.Item1; x < range.Item2; x++)
{
for (int y = 0; y < height; y++)
{
var finalColor = _rayTracer.CalculatePixelColor(x, y);
SetPixelColor(x - range.Item1, y, finalColor, buffer);
}
}
CopyBitmap(buffer, _bitmap, range.Item1);
_pictureBox.Manipulate(p => p.Refresh());
_loger.Log(Level.Verbose, string.Format("Finished {0} {1}", range.Item1, range.Item2));
}
static ParallelLoopResult ForEach <TSource, TLocal> (Func <int, IList <IEnumerator <TSource> > > enumerable, ParallelOptions options,
Func <TLocal> init, Func <TSource, ParallelLoopState, TLocal, TLocal> action,
Action <TLocal> destruct)
{
if (enumerable == null)
{
throw new ArgumentNullException("source");
}
if (options == null)
{
throw new ArgumentNullException("options");
}
if (action == null)
{
throw new ArgumentNullException("action");
}
if (init == null)
{
throw new ArgumentNullException("init");
}
if (destruct == null)
{
throw new ArgumentNullException("destruct");
}
int num = Math.Min(GetBestWorkerNumber(options.TaskScheduler),
options != null && options.MaxDegreeOfParallelism != -1 ? options.MaxDegreeOfParallelism : int.MaxValue);
Task[] tasks = new Task[num];
ParallelLoopState.ExternalInfos infos = new ParallelLoopState.ExternalInfos();
SimpleConcurrentBag <TSource> bag = new SimpleConcurrentBag <TSource> (num);
const int bagCount = 5;
IList <IEnumerator <TSource> > slices = enumerable(num);
int sliceIndex = -1;
Action workerMethod = delegate {
IEnumerator <TSource> slice = slices[Interlocked.Increment(ref sliceIndex)];
TLocal local = init();
ParallelLoopState state = new ParallelLoopState(infos);
int workIndex = bag.GetNextIndex();
CancellationToken token = options.CancellationToken;
try {
bool cont = true;
TSource element;
while (cont)
{
if (infos.IsStopped || infos.IsBroken.Value)
{
return;
}
token.ThrowIfCancellationRequested();
for (int i = 0; i < bagCount && (cont = slice.MoveNext()); i++)
{
bag.Add(workIndex, slice.Current);
}
for (int i = 0; i < bagCount && bag.TryTake(workIndex, out element); i++)
{
if (infos.IsStopped)
{
return;
}
token.ThrowIfCancellationRequested();
local = action(element, state, local);
}
}
while (bag.TrySteal(workIndex, out element))
{
token.ThrowIfCancellationRequested();
local = action(element, state, local);
if (infos.IsStopped || infos.IsBroken.Value)
{
return;
}
}
} finally {
destruct(local);
}
};
InitTasks(tasks, num, workerMethod, options);
try {
Task.WaitAll(tasks);
} catch {
HandleExceptions(tasks, infos);
}
return(new ParallelLoopResult(infos.LowestBreakIteration, !(infos.IsStopped || infos.IsExceptional)));
}
public abstract void ParallelLoopBody(string str, ParallelLoopState state, long i);
private void RenderToImage(int layerIndex, ParallelLoopState pls)
{
if (pls.ShouldExitCurrentIteration)
return;
var layer = _layers[layerIndex];
if (layer.Enabled)
{
if (layer.MaxVisible >= _map.Zoom && layer.MinVisible < _map.Zoom)
{
var image = _images[layerIndex] = new Bitmap(_map.Size.Width, _map.Size.Height, PixelFormat.Format32bppArgb);
using (IGraphics g = Graphics.FromImage(image).G())
{
g.PageUnit = GraphicsUnitType.Pixel;
ApplyTransform(_transform, g);
g.Clear(Color.Transparent);
layer.Render(g, _map);
}
}
}
}
public static ParallelLoopResult For <TLocal> (int from,
int to,
ParallelOptions options,
Func <TLocal> init,
Func <int, ParallelLoopState, TLocal, TLocal> action,
Action <TLocal> destruct)
{
if (action == null)
{
throw new ArgumentNullException("action");
}
if (init == null)
{
throw new ArgumentNullException("localInit");
}
if (destruct == null)
{
throw new ArgumentNullException("localFinally");
}
if (options == null)
{
throw new ArgumentNullException("options");
}
if (from >= to)
{
return(new ParallelLoopResult(null, true));
}
// Number of task to be launched (normally == Env.ProcessorCount)
int step;
int num = GetBestWorkerNumber(from, to, options, out step);
Task[] tasks = new Task [num];
StealRange[] ranges = new StealRange[num];
for (int i = 0; i < num; i++)
{
ranges[i] = new StealRange(from, i, step);
}
ParallelLoopState.ExternalInfos infos = new ParallelLoopState.ExternalInfos();
int currentIndex = -1;
Action workerMethod = delegate {
int localWorker = Interlocked.Increment(ref currentIndex);
StealRange range = ranges[localWorker];
int index = range.Actual;
int stopIndex = localWorker + 1 == num ? to : Math.Min(to, index + step);
TLocal local = init();
ParallelLoopState state = new ParallelLoopState(infos);
CancellationToken token = options.CancellationToken;
try {
for (int i = index; i < stopIndex; range.Actual = ++i)
{
if (infos.IsStopped)
{
return;
}
token.ThrowIfCancellationRequested();
if (infos.LowestBreakIteration != null && infos.LowestBreakIteration > i)
{
return;
}
state.CurrentIteration = i;
local = action(i, state, local);
if (i >= stopIndex - range.Stolen)
{
break;
}
}
// Try to steal from our right neighbor (cyclic)
int len = num + localWorker;
for (int sIndex = localWorker + 1; sIndex < len; ++sIndex)
{
int extWorker = sIndex % num;
range = ranges[extWorker];
stopIndex = extWorker + 1 == num ? to : Math.Min(to, from + (extWorker + 1) * step);
int stolen;
do
{
stolen = range.Stolen;
if (stopIndex - stolen > range.Actual)
{
goto next;
}
} while (Interlocked.CompareExchange(ref range.Stolen, stolen + 1, stolen) != stolen);
stolen = stopIndex - stolen - 1;
if (stolen > range.Actual)
{
local = action(stolen, state, local);
}
next:
continue;
}
} finally {
destruct(local);
}
};
InitTasks(tasks, num, workerMethod, options);
try {
Task.WaitAll(tasks);
} catch {
HandleExceptions(tasks, infos);
}
return(new ParallelLoopResult(infos.LowestBreakIteration, !(infos.IsStopped || infos.IsExceptional)));
}
private void RenderToImage(int layerIndex, ParallelLoopState pls)
{
if (pls.ShouldExitCurrentIteration)
return;
var layer = _layers[layerIndex];
if (layer.Enabled)
{
double compare = layer.VisibilityUnits == VisibilityUnits.ZoomLevel ? _map.Zoom : _map.MapScale;
if (layer.MaxVisible >= compare && layer.MinVisible < compare)
{
var image = _images[layerIndex] = new Bitmap(_map.Size.Width, _map.Size.Height, PixelFormat.Format32bppArgb);
using (var g = Graphics.FromImage(image))
{
g.PageUnit = GraphicsUnit.Pixel;
ApplyTransform(_transform, g);
g.Clear(Color.Transparent);
RenderLayer(layer, g, _map);
}
}
}
}
void CheckAndAddAssambly(string filename, ParallelLoopState state)
{
AssemblyName assemblyName = null;
try
{
assemblyName = AssemblyName.GetAssemblyName(filename);
}
catch (ArgumentException e)
{
IsHandeld(e, filename);
return;
}
catch (BadImageFormatException e)
{
IsHandeld(e, filename);
return;
}
catch (FileLoadException e)
{
IsHandeld(e, filename);
return;
}
catch (FileNotFoundException e)
{
IsHandeld(e, filename);
return;
}
catch (PlatformNotSupportedException e)
{
IsHandeld(e, filename);
return;
}
catch (SecurityException e)
{
IsHandeld(e, filename);
return;
}
catch (Exception e)
{
Console.WriteLine("first chance exception of type '" + e.GetType().ToString() + "' in assambly '" + filename + "' was NOT Handeled by StrongNameCatalog ...");
state.Stop();
}
if (assemblyName == null)
return;
#if (SECLOADING)
var publicKey = assemblyName.GetPublicKey();
if (publicKey == null)
continue;
var trusted = _trustedKeys.Any(trustedKey => assemblyName.GetPublicKey().SequenceEqual(trustedKey));
if (!trusted)
continue;
#endif
try
{
var assam = new AssemblyCatalog(filename);
if (!assam.Parts.Any())
return;
if (Changing != null)
Changing.Invoke(this, new ComposablePartCatalogChangeEventArgs(assam.Parts, new List<ComposablePartDefinition>(), null));
_aggregateCatalog.Catalogs.Add(assam);
ImportPool.AddSuccessIncludedMessage(filename);
if (Changed != null)
Changed.Invoke(this, new ComposablePartCatalogChangeEventArgs(assam.Parts, new List<ComposablePartDefinition>(), null));
}
catch (Exception e)
{
IsHandeld(e, filename);
return;
}
}
/// <summary>
/// Communicates that parallel tasks should stop when they reach a specified iteration element.
/// (which is CurrentIteration of the caller).
/// </summary>
/// <exception cref="T:System.InvalidOperationException">Break() called after Stop().</exception>
/// <remarks>
/// Atomically sets shared StoppedBroken flag to BROKEN, then atomically sets shared
/// LowestBreakIteration to CurrentIteration, but only if CurrentIteration is less than
/// LowestBreakIteration.
/// </remarks>
internal override void InternalBreak()
{
ParallelLoopState.Break(CurrentIteration, m_sharedParallelStateFlags);
}
public static ParallelLoopResult For <TLocal> (int fromInclusive,
int toExclusive,
ParallelOptions parallelOptions,
Func <TLocal> localInit,
Func <int, ParallelLoopState, TLocal, TLocal> body,
Action <TLocal> localFinally)
{
if (body == null)
{
throw new ArgumentNullException("body");
}
if (localInit == null)
{
throw new ArgumentNullException("localInit");
}
if (localFinally == null)
{
throw new ArgumentNullException("localFinally");
}
if (parallelOptions == null)
{
throw new ArgumentNullException("options");
}
if (fromInclusive >= toExclusive)
{
return(new ParallelLoopResult(null, true));
}
// Number of task toExclusive be launched (normally == Env.ProcessorCount)
int step;
int num = GetBestWorkerNumber(fromInclusive, toExclusive, parallelOptions, out step);
Task[] tasks = new Task [num];
StealRange[] ranges = new StealRange[num];
for (int i = 0; i < num; i++)
{
ranges[i] = new StealRange(fromInclusive, i, step);
}
ParallelLoopState.ExternalInfos infos = new ParallelLoopState.ExternalInfos();
int currentIndex = -1;
Action workerMethod = delegate {
int localWorker = Interlocked.Increment(ref currentIndex);
StealRange range = ranges[localWorker];
int index = range.V64.Actual;
int stopIndex = localWorker + 1 == num ? toExclusive : Math.Min(toExclusive, index + step);
TLocal local = localInit();
ParallelLoopState state = new ParallelLoopState(infos);
CancellationToken token = parallelOptions.CancellationToken;
try {
for (int i = index; i < stopIndex;)
{
if (infos.IsStopped)
{
return;
}
token.ThrowIfCancellationRequested();
if (i >= stopIndex - range.V64.Stolen)
{
break;
}
if (infos.LowestBreakIteration != null && infos.LowestBreakIteration > i)
{
return;
}
state.CurrentIteration = i;
local = body(i, state, local);
if (i + 1 >= stopIndex - range.V64.Stolen)
{
break;
}
range.V64.Actual = ++i;
}
bool sixtyfour = IntPtr.Size == 8; // Environment.Is64BitProcess;
// Try toExclusive steal fromInclusive our right neighbor (cyclic)
int len = num + localWorker;
for (int sIndex = localWorker + 1; sIndex < len; ++sIndex)
{
int extWorker = sIndex % num;
range = ranges[extWorker];
stopIndex = extWorker + 1 == num ? toExclusive : Math.Min(toExclusive, fromInclusive + (extWorker + 1) * step);
int stolen = -1;
do
{
do
{
long old;
StealValue64 val = new StealValue64();
old = sixtyfour ? range.V64.Value : Interlocked.CompareExchange(ref range.V64.Value, 0, 0);
val.Value = old;
if (val.Actual >= stopIndex - val.Stolen - 2)
{
goto next;
}
stolen = (val.Stolen += 1);
if (Interlocked.CompareExchange(ref range.V64.Value, val.Value, old) == old)
{
break;
}
} while (true);
stolen = stopIndex - stolen;
if (stolen > range.V64.Actual)
{
local = body(stolen, state, local);
}
else
{
break;
}
} while (true);
next:
continue;
}
} finally {
localFinally(local);
}
};
InitTasks(tasks, num, workerMethod, parallelOptions);
try {
Task.WaitAll(tasks);
} catch {
HandleExceptions(tasks, infos);
}
return(new ParallelLoopResult(infos.LowestBreakIteration, !(infos.IsStopped || infos.IsExceptional)));
}
public override void ParallelLoopBody(string str, ParallelLoopState state, long i)
{
this.buffer[i] = base.Replacer.Replace(str);
}