protected override void SetupActivities()
{
var partitioner = new Partitioner(8, new Murmur3UnsafeHashGenerator());
AddActivityContext<TestActivity, TestArguments, TestLog>(() => new TestActivity(), h => h.UsePartitioner(partitioner, args => args.Arguments.Value),
h => h.UsePartitioner(partitioner, args => args.Log.OriginalValue));
}
public float doallmoves(Playfield playf)
{
print = playf.print;
this.isLethalCheck = playf.isLethalCheck;
enoughCalculations = false;
botBase = Ai.Instance.botBase;
this.posmoves.Clear();
this.twoturnfields.Clear();
this.addToPosmoves(playf);
bool havedonesomething = true;
List <Playfield> temp = new List <Playfield>();
int deep = 0;
this.calculated = 0;
Playfield bestold = null;
bestoldval = -20000000;
while (havedonesomething)
{
if (this.printNormalstuff)
{
Helpfunctions.Instance.logg("ailoop");
}
GC.Collect();
temp.Clear();
temp.AddRange(this.posmoves);
this.posmoves.Clear();
havedonesomething = false;
threadnumberGlobal = 0;
if (print)
{
startEnemyTurnSimThread(temp, 0, temp.Count);
}
else
{
Parallel.ForEach(Partitioner.Create(0, temp.Count),
range =>
{
startEnemyTurnSimThread(temp, range.Item1, range.Item2);
});
}
foreach (Playfield p in temp)
{
if (this.totalboards > 0)
{
this.calculated += p.nextPlayfields.Count;
}
if (this.calculated <= this.totalboards)
{
this.posmoves.AddRange(p.nextPlayfields);
p.nextPlayfields.Clear();
}
//get the best Playfield
float pVal = botBase.getPlayfieldValue(p);
if (pVal > bestoldval)
{
bestoldval = pVal;
bestold = p;
bestoldDuplicates.Clear();
}
else if (pVal == bestoldval)
{
bestoldDuplicates.Add(p);
}
}
if (isLethalCheck && bestoldval >= 10000)
{
this.posmoves.Clear();
}
if (this.posmoves.Count > 0)
{
havedonesomething = true;
}
if (this.printNormalstuff)
{
int donec = 0;
foreach (Playfield p in posmoves)
{
if (p.complete)
{
donec++;
}
}
Helpfunctions.Instance.logg("deep " + deep + " len " + this.posmoves.Count + " dones " + donec);
}
cuttingposibilities(isLethalCheck);
if (this.printNormalstuff)
{
Helpfunctions.Instance.logg("cut to len " + this.posmoves.Count);
}
deep++;
temp.Clear();
if (this.calculated > this.totalboards)
{
enoughCalculations = true;
}
if (deep >= this.maxdeep)
{
enoughCalculations = true;
}
}
if (this.dirtyTwoTurnSim > 0 && !twoturnfields.Contains(bestold))
{
twoturnfields.Add(bestold);
}
this.posmoves.Clear();
this.posmoves.Add(bestold);
this.posmoves.AddRange(bestoldDuplicates);
// search the best play...........................................................
//do dirtytwoturnsim first :D
if (!isLethalCheck && bestoldval < 10000)
{
doDirtyTwoTurnsim();
}
if (posmoves.Count >= 1)
{
posmoves.Sort((a, b) => botBase.getPlayfieldValue(b).CompareTo(botBase.getPlayfieldValue(a)));
Playfield bestplay = posmoves[0];
float bestval = botBase.getPlayfieldValue(bestplay);
int pcount = posmoves.Count;
for (int i = 1; i < pcount; i++)
{
float val = botBase.getPlayfieldValue(posmoves[i]);
if (bestval > val)
{
break;
}
if (posmoves[i].cardsPlayedThisTurn > bestplay.cardsPlayedThisTurn)
{
continue;
}
else if (posmoves[i].cardsPlayedThisTurn == bestplay.cardsPlayedThisTurn)
{
if (bestplay.optionsPlayedThisTurn > posmoves[i].optionsPlayedThisTurn)
{
continue;
}
else if (bestplay.optionsPlayedThisTurn == posmoves[i].optionsPlayedThisTurn && bestplay.enemyHero.Hp <= posmoves[i].enemyHero.Hp)
{
continue;
}
}
bestplay = posmoves[i];
bestval = val;
}
this.bestmove = bestplay.getNextAction();
this.bestmoveValue = bestval;
this.bestboard = new Playfield(bestplay);
this.bestboard.guessingHeroHP = bestplay.guessingHeroHP;
this.bestboard.value = bestplay.value;
this.bestboard.hashcode = bestplay.hashcode;
bestoldDuplicates.Clear();
return(bestval);
}
this.bestmove = null;
this.bestmoveValue = -100000;
this.bestboard = playf;
return(-10000);
}
private cImage _RunLoop(Rectangle?filterRegion, byte scaleX, byte scaleY, Action <PixelWorker <sPixel> > scaler)
{
var startX = filterRegion == null ? 0 : Math.Max(0, filterRegion.Value.Left);
var startY = filterRegion == null ? 0 : Math.Max(0, filterRegion.Value.Top);
var endX = filterRegion == null ? this.Width : Math.Min(this.Width, filterRegion.Value.Right);
var endY = filterRegion == null ? this.Height : Math.Min(this.Height, filterRegion.Value.Bottom);
var width = endX - startX;
var result = new cImage(width * scaleX, (endY - startY) * scaleY);
Parallel.ForEach(
Partitioner.Create(startY, endY),
() => 0,
(range, _, threadStorage) => {
var threadSrcMinY = range.Item1;
var threadSrcMaxY = range.Item2;
var targetY = (threadSrcMinY - startY) * scaleY;
for (var sourceY = threadSrcMinY; sourceY < threadSrcMaxY; ++sourceY)
{
var worker = new PixelWorker <sPixel>(
this.GetImageData(),
startX,
sourceY,
this._width,
this._height,
this._horizontalOutOfBoundsHandler,
this._verticalOutOfBoundsHandler,
result.GetImageData(),
0,
targetY,
result._width
);
var xRange = width;
while (xRange >= 64)
{
xRange -= 64;
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
scaler(worker);
worker.IncrementX(scaleX);
}
for (; xRange > 0; --xRange)
{
scaler(worker);
worker.IncrementX(scaleX);
}
targetY += scaleY;
}
return(threadStorage);
},
_ => { }
);
return(result);
}
public static ParallelLoopResult ForEach <TSource, TLocal> (Partitioner <TSource> source, Func <TLocal> localInit,
Func <TSource, ParallelLoopState, TLocal, TLocal> body,
Action <TLocal> localFinally)
{
return(ForEach <TSource, TLocal> (source, ParallelOptions.Default, localInit, body, localFinally));
}
/// <summary>
/// Ensure that the range partitioner doesn't chunk up elements i.e. uses chunk size = 1
/// </summary>
/// <param name="from"></param>
/// <param name="count"></param>
/// <param name="rangeSize"></param>
public static void RangePartitionerDynamicChunking(int from, int count, int rangeSize)
{
int to = from + count;
var partitioner = (rangeSize == -1) ? Partitioner.Create(from, to) : Partitioner.Create(from, to, rangeSize);
// Check static partitions
var partitions = partitioner.GetDynamicPartitions();
var partition1 = partitions.GetEnumerator();
var partition2 = partitions.GetEnumerator();
// Initialize the from / to values from the first element
if (!partition1.MoveNext())
{
return;
}
Assert.True(from == partition1.Current.Item1);
if (rangeSize == -1)
{
rangeSize = partition1.Current.Item2 - partition1.Current.Item1;
}
int nextExpectedFrom = partition1.Current.Item2;
int nextExpectedTo = (nextExpectedFrom + rangeSize) > to ? to : (nextExpectedFrom + rangeSize);
// Ensure that each partition gets one range only
// we check this by alternating partitions asking for elements and make sure
// that we get ranges in a sequence. If chunking were to happen then we wouldn't see a sequence
int actualCount = partition1.Current.Item2 - partition1.Current.Item1;
while (true)
{
if (!partition1.MoveNext())
{
break;
}
Assert.Equal(nextExpectedFrom, partition1.Current.Item1);
Assert.Equal(nextExpectedTo, partition1.Current.Item2);
nextExpectedFrom = (nextExpectedFrom + rangeSize) > to ? to : (nextExpectedFrom + rangeSize);
nextExpectedTo = (nextExpectedTo + rangeSize) > to ? to : (nextExpectedTo + rangeSize);
actualCount += partition1.Current.Item2 - partition1.Current.Item1;
if (!partition2.MoveNext())
{
break;
}
Assert.Equal(nextExpectedFrom, partition2.Current.Item1);
Assert.Equal(nextExpectedTo, partition2.Current.Item2);
nextExpectedFrom = (nextExpectedFrom + rangeSize) > to ? to : (nextExpectedFrom + rangeSize);
nextExpectedTo = (nextExpectedTo + rangeSize) > to ? to : (nextExpectedTo + rangeSize);
actualCount += partition2.Current.Item2 - partition2.Current.Item1;
if (!partition2.MoveNext())
{
break;
}
Assert.Equal(nextExpectedFrom, partition2.Current.Item1);
Assert.Equal(nextExpectedTo, partition2.Current.Item2);
nextExpectedFrom = (nextExpectedFrom + rangeSize) > to ? to : (nextExpectedFrom + rangeSize);
nextExpectedTo = (nextExpectedTo + rangeSize) > to ? to : (nextExpectedTo + rangeSize);
actualCount += partition2.Current.Item2 - partition2.Current.Item1;
if (!partition1.MoveNext())
{
break;
}
Assert.Equal(nextExpectedFrom, partition1.Current.Item1);
Assert.Equal(nextExpectedTo, partition1.Current.Item2);
nextExpectedFrom = (nextExpectedFrom + rangeSize) > to ? to : (nextExpectedFrom + rangeSize);
nextExpectedTo = (nextExpectedTo + rangeSize) > to ? to : (nextExpectedTo + rangeSize);
actualCount += partition1.Current.Item2 - partition1.Current.Item1;
}
// Verifying that all items are there
Assert.Equal(count, actualCount);
}
/// <summary>
/// Selects an item (such as Max or Min).
/// </summary>
/// <param name="array">The array to iterate over.</param>
/// <param name="select">The function to select items over a subset.</param>
/// <param name="reduce">The function to select the item of selection from the subsets.</param>
/// <returns>The selected value.</returns>
public static TOut Aggregate <T, TOut>(T[] array, Func <int, T, TOut> select, Func <TOut[], TOut> reduce)
{
if (select == null)
{
throw new ArgumentNullException(nameof(select));
}
if (reduce == null)
{
throw new ArgumentNullException(nameof(reduce));
}
// Special case: no action
if (array == null || array.Length == 0)
{
return(reduce(new TOut[0]));
}
// Special case: single action, inline
if (array.Length == 1)
{
return(reduce(new[] { select(0, array[0]) }));
}
// Special case: straight execution without parallelism
if (Control.MaxDegreeOfParallelism < 2)
{
var mapped = new TOut[array.Length];
for (var k = 0; k < mapped.Length; k++)
{
mapped[k] = select(k, array[k]);
}
return(reduce(mapped));
}
// Common case
var intermediateResults = new List <TOut>();
var syncLock = new object();
Parallel.ForEach(
Partitioner.Create(0, array.Length),
CreateParallelOptions(),
() => new List <TOut>(),
(range, loop, localData) =>
{
var mapped = new TOut[range.Item2 - range.Item1];
for (var k = 0; k < mapped.Length; k++)
{
mapped[k] = select(k + range.Item1, array[k + range.Item1]);
}
localData.Add(reduce(mapped));
return(localData);
},
localResult =>
{
lock (syncLock)
{
intermediateResults.Add(reduce(localResult.ToArray()));
}
});
return(reduce(intermediateResults.ToArray()));
}
private Partitioner <TElement> _partitioner; // The partitioner to use as data source.
internal PartitionerQueryOperator(Partitioner <TElement> partitioner)
: base(false, QuerySettings.Empty)
{
_partitioner = partitioner;
}
/// <summary>
/// Validate After and Before fill the quantities for Stock Exit in Livestock Matrix
/// </summary>
/// <param name="beforeQuantities"></param>
/// <returns></returns>
public bool ValidateLivestockExit(bool beforeQuantities)
{
if (beforeQuantities)
{
if (selectedRow.Equals(0))
{
UIApplication.ShowMessageBox("Selecionar Cliente");
return(false);
}
if (String.IsNullOrEmpty(cbxType.Value))
{
return(false);
}
if (cbxType.Value.Equals("Facturación Subasta"))
{
return(false);
}
if (cbOutAll.Checked)
{
if (UIApplication.ShowOptionBox("Estas seguro se sar salida a todo el ganado") == 2)
{
return(false);
}
}
if (!pendingInvoices[selectedRow - 1].Debt.Equals(0))
{
UIApplication.ShowMessageBox("No se puede dar salida al ganado sin haber facturado la deuda");
return(false);
}
}
else //Validate the Quantities
{
var appraisalImport = 0.0;
var debtImport = 0.0;
if (livestock.Where(l => l.Quantity == 0).AsParallel().Count() == livestock.Count)
{
UIApplication.ShowMessageBox("No se ha ingresado cantidad para dar salida al ganado");
return(false);
}
//This task validate that the Quantity have to be less or equal than Existence
var task = Task.Factory.StartNew(() => {
var cts = new CancellationTokenSource();
var po = new ParallelOptions();
po.CancellationToken = cts.Token;
ParallelLoopResult result = Parallel.ForEach(Partitioner.Create(0, livestock.Count), (range, state) => {
for (int i = range.Item1; i < range.Item2; i++)
{
if (livestock[i].Quantity > livestock[i].Exist)
{
cts.Cancel(); //cancel the loop
}
}
});
if (cts.IsCancellationRequested)
{
return(false);
}
return(true);
});
task.Wait();
if (!task.Result)
{
UIApplication.ShowMessageBox("La cantidad no debe ser mayor que la existencia");
return(false);
}
//Validate Appraisal Import and Debt Import
var task2 = Task.Factory.StartNew(() => { appraisalImport = CalculateAppraisalImport(livestock); });
var task3 = Task.Factory.StartNew(() => { debtImport = massInvoicingDAO.GetDebtImport(pendingInvoices[selectedRow - 1].Code, user.WhsCode); });
Task.WaitAll(task2, task3);
if (appraisalImport < debtImport)
{
if (UIApplication.ShowOptionBox("El importe avaluo es menor que el importe deuda, estas seguro de dar salida al ganado") == 2)
{
mBoolAuthP = false;
return(false);
}
else
{
mBoolAuthP = true;
user.AppraisalValidation = true;
}
}
}
return(true);
}
// This is the entry point after the root node has been pushed into the queue
// and the first change to the game has occurred
public override async Task PostProcess(GameTree <GameNode> t)
{
// Breadth-first processing loop
do
{
// Merge the TLS lists into the main lists
foreach (var sq in tlsSearchQueue.Values)
{
foreach (var qi in sq)
{
if (!searchQueue.ContainsKey(qi.Key))
{
searchQueue.Add(qi.Key, qi.Value);
}
else
{
searchQueue[qi.Key].Probability += qi.Value.Probability;
}
}
}
foreach (var ug in tlsUniqueGames.Values)
{
foreach (var qi in ug)
{
if (!uniqueGames.ContainsKey(qi.Key))
{
uniqueGames.Add(qi.Key, qi.Value);
}
else
{
uniqueGames[qi.Key].Probability += qi.Value.Probability;
}
}
}
#if _TREE_DEBUG
DebugLog.WriteLine("QUEUE SIZE: " + searchQueue.Count);
#endif
// Wipe the TLS lists
tlsSearchQueue = new ThreadLocal <Dictionary <Game, ProbabilisticGameNode> >(() => new Dictionary <Game, ProbabilisticGameNode>(new FuzzyGameComparer()), trackAllValues: true);
tlsUniqueGames = new ThreadLocal <Dictionary <Game, ProbabilisticGameNode> >(() => new Dictionary <Game, ProbabilisticGameNode>(new FuzzyGameComparer()), trackAllValues: true);
// Quit if we have processed all nodes and none of them have children (all leaf nodes)
if (searchQueue.Count == 0)
{
break;
}
// Copy the search queue and clear the current one; it will be refilled
var nextQueue = new Dictionary <Game, ProbabilisticGameNode>(searchQueue);
searchQueue.Clear();
// Only parallelize if there are sufficient nodes to do so
if (nextQueue.Count >= MinNodesToParallelize && ((RandomOutcomeSearch)t).Parallel && MaxDegreesOfParallelism > 1)
{
// Process each game's action queue until it is interrupted by OnAction above
await Task.WhenAll(
// Split search queue into MaxDegreesOfParallelism partitions
from partition in Partitioner.Create(nextQueue).GetPartitions(MaxDegreesOfParallelism)
// Run each partition in its own task
select Task.Run(async delegate {
#if _TREE_DEBUG
var count = 0;
DebugLog.WriteLine("Start partition run with " + MaxDegreesOfParallelism + " degrees of parallelism");
#endif
using (partition)
while (partition.MoveNext())
{
// Process each node
var kv = partition.Current;
await kv.Key.ActionQueue.ProcessAllAsync(kv.Value);
#if _TREE_DEBUG
count++;
#endif
}
#if _TREE_DEBUG
DebugLog.WriteLine("End run with partition size {0}", count);
#endif
}));
#if _TREE_DEBUG
DebugLog.WriteLine("=======================");
DebugLog.WriteLine("CLONES SO FAR: " + t.NodeCount + " / " + t.LeafNodeCount);
DebugLog.WriteLine("UNIQUE GAMES SO FAR: " + uniqueGames.Count);
DebugLog.WriteLine("NEW QUEUE SIZE: " + searchQueue.Count + "\r\n");
#endif
}
else
{
#if _TREE_DEBUG
DebugLog.WriteLine("Start single-threaded run");
#endif
// Process each node in the search queue sequentially
foreach (var kv in nextQueue)
{
await kv.Key.ActionQueue.ProcessAllAsync(kv.Value);
}
#if _TREE_DEBUG
DebugLog.WriteLine("End single-threaded run");
#endif
}
} while (true);
}
static int Main(string[] args)
{
var softwareUnderTest = args[0];
_logFile = args[1];
_logFile = _logFile.Replace("%TIMESTAMP%", DateTime.Now.ToString("yyyy-MM-dd HHmmss"));
if (!File.Exists(softwareUnderTest))
{
LogText(string.Format("The file {0} does not exist.", softwareUnderTest));
return(-1);
}
LogText("Loading test suite...");
// Load static container of all tests.
List <TestEnvironment> listEnvironments = new List <TestEnvironment>();
TestEnvironments.AddAll(listEnvironments);
int testIndex = 0;
var f = TaskScheduler.Default;
var options = new ParallelOptions()
{
MaxDegreeOfParallelism = 4,
};
// We can run tests on XP and Vista/2003/2008 at the same time since it's separate VMware images.
var environmentsGroupedByVmwareImage = listEnvironments.GroupBy(item => item.VMwarePath).ToList();
var partitioner = Partitioner.Create(environmentsGroupedByVmwareImage, EnumerablePartitionerOptions.NoBuffering);
Parallel.ForEach(partitioner, options, environmentGroup =>
{
foreach (var environment in environmentGroup)
{
int localIndex;
lock (_lockCounterTest)
{
localIndex = ++testIndex;
string message =
string.Format("{0}: {1}/{2} - Test: {3} on {4} with db {5}. Image: {6} (Snapshot: {7})",
DateTime.Now,
localIndex,
listEnvironments.Count,
environment.Description,
environment.OperatingSystem,
environment.DatabaseType,
Path.GetFileName(environment.VMwarePath),
environment.SnapshotName);
LogText(message);
}
var runner = new TestRunner(true, environment, false, softwareUnderTest);
try
{
runner.Run();
LogText(string.Format("{0}: Test {1} completed successfully.", DateTime.Now, localIndex));
}
catch (Exception ex)
{
LogText(string.Format("{0}: Test {1} failed.", DateTime.Now, localIndex));
LogText(ex.ToString());
throw;
}
}
});
System.Console.WriteLine("All tests completed succesfully.");
if (System.Diagnostics.Debugger.IsAttached)
{
System.Console.WriteLine("Press Enter to exit.");
System.Console.ReadLine();
}
return(0);
}
public void TestJsonDictThreading()
{
var jsonResolver = new RefResolve();
var settings = new JsonSerializerSettings {
ReferenceResolverProvider = () => jsonResolver
};
var rnd = new Random(123);
var examples = new List <Context>();
var id = 0;
// different reference objects
for (int i = 0; i < 10; i++)
{
var data = Enumerable.Range(1, 5).Select(_ => (float)rnd.Next(10)).ToArray();
// referencing the same data
for (int j = 0; j < 5; j++)
{
examples.Add(new Context(data, id++, settings));
}
}
for (int i = 0; i < 4; i++)
{
Permute(examples, rnd);
for (int maxDegreeOfParallelism = 1; maxDegreeOfParallelism < 4; maxDegreeOfParallelism++)
{
var examplesFound = 0;
using (var vw = new VowpalWabbit(new VowpalWabbitSettings {
EnableStringExampleGeneration = true, EnableThreadSafeExamplePooling = true
}))
using (var resolver = new VowpalWabbitJsonReferenceResolver(serializer =>
{
using (var example = serializer.CreateExamples())
{
ValidateExample(example, (Context)serializer.UserContext);
}
serializer.Dispose();
Interlocked.Increment(ref examplesFound);
}))
{
Parallel.ForEach(
Partitioner.Create(0, examples.Count),
new ParallelOptions {
MaxDegreeOfParallelism = maxDegreeOfParallelism
},
range =>
{
for (int j = range.Item1; j < range.Item2; j++)
{
var ctx = examples[j];
var serializer = new VowpalWabbitJsonSerializer(vw, resolver)
{
UserContext = ctx
};
var example = serializer.ParseAndCreate(ctx.JSON);
// example not ready yet
if (example == null)
{
continue;
}
ValidateExample(example, ctx);
example.Dispose();
serializer.Dispose();
Interlocked.Increment(ref examplesFound);
}
});
}
Assert.AreEqual(examples.Count, examplesFound);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ClusterState"/> class.
/// </summary>
public ClusterState(IClusterOptions options, string clusterName, string clientName, Partitioner partitioner, ILoggerFactory loggerFactory)
{
Options = options;
ClusterName = clusterName;
ClientName = clientName;
Partitioner = partitioner;
LoggerFactory = loggerFactory;
_stateChangeQueue = new StateChangeQueue(loggerFactory);
}
public BitmapFont(Canvas canvas, string path)
{
this.canvas = canvas;
#if UNCOMPRESSED_CONTENT
string png = PathOp.Combine(DualityApp.DataDirectory, "Animations", path + ".png");
#else
string png = PathOp.Combine(DualityApp.DataDirectory, "Main.dz", "Animations", path + ".png");
#endif
string pathFont = png + ".font";
int textureHeight;
using (Stream s = FileOp.Open(png, FileAccessMode.Read)) {
PixelData pixelData = new Png(s).GetPixelData();
textureHeight = pixelData.Height;
ColorRgba[] palette = ContentResolver.Current.Palette.Res.BasePixmap.Res.MainLayer.Data;
ColorRgba[] data = pixelData.Data;
#if !DISABLE_ASYNC
Parallel.ForEach(Partitioner.Create(0, data.Length), range => {
for (int i = range.Item1; i < range.Item2; i++) {
#else
for (int i = 0; i < data.Length; i++) {
#endif
int colorIdx = data[i].R;
data[i] = palette[colorIdx].WithAlpha(palette[colorIdx].A * data[i].A / (255f * 255f));
}
#if !DISABLE_ASYNC
});
#endif
Texture texture = new Texture(new Pixmap(pixelData), TextureSizeMode.NonPowerOfTwo, TextureMagFilter.Linear, TextureMinFilter.Linear);
materialPlain = new Material(DrawTechnique.Alpha, texture);
materialColor = new Material(ContentResolver.Current.RequestShader("Colorize"), texture);
}
using (Stream s = FileOp.Open(pathFont, FileAccessMode.Read)) {
byte[] internalBuffer = new byte[128];
byte flags = s.ReadUInt8(ref internalBuffer);
ushort width = s.ReadUInt16(ref internalBuffer);
ushort height = s.ReadUInt16(ref internalBuffer);
byte cols = s.ReadUInt8(ref internalBuffer);
int rows = textureHeight / height;
short spacing = s.ReadInt16(ref internalBuffer);
int asciiFirst = s.ReadUInt8(ref internalBuffer);
int asciiCount = s.ReadUInt8(ref internalBuffer);
s.Read(internalBuffer, 0, asciiCount);
int i = 0;
for (; i < asciiCount; i++) {
asciiChars[i + asciiFirst] = new Rect(
(float)(i % cols) / cols,
(float)(i / cols) / rows,
internalBuffer[i],
height);
}
UTF8Encoding enc = new UTF8Encoding(false, true);
int unicodeCharCount = asciiCount + s.ReadInt32(ref internalBuffer);
for (; i < unicodeCharCount; i++) {
s.Read(internalBuffer, 0, 1);
int remainingBytes =
((internalBuffer[0] & 240) == 240) ? 3 : (
((internalBuffer[0] & 224) == 224) ? 2 : (
((internalBuffer[0] & 192) == 192) ? 1 : -1
));
if (remainingBytes == -1) {
throw new InvalidDataException("Char \"" + (char)internalBuffer[0] + "\" is not UTF-8");
}
s.Read(internalBuffer, 1, remainingBytes);
char c = enc.GetChars(internalBuffer, 0, remainingBytes + 1)[0];
byte charWidth = s.ReadUInt8(ref internalBuffer);
unicodeChars[c] = new Rect(
(float)(i % cols) / cols,
(float)(i / cols) / rows,
charWidth,
height);
}
this.charHeight = height;
this.baseSpacing = spacing;
}
}
protected override MetaMorpheusEngineResults RunSpecific()
{
double progress = 0;
int oldPercentProgress = 0;
TerminusType terminusType = ProductTypeMethod.IdentifyTerminusType(lp);
// digest database
HashSet <CompactPeptide> peptideToId = new HashSet <CompactPeptide>();
Parallel.ForEach(Partitioner.Create(0, proteinList.Count), new ParallelOptions {
MaxDegreeOfParallelism = commonParams.MaxThreadsToUsePerFile
}, range =>
{
for (int i = range.Item1; i < range.Item2; i++)
{
foreach (var digestionParams in CollectionOfDigestionParams)
{
foreach (var pepWithSetMods in proteinList[i].Digest(digestionParams, fixedModifications, variableModifications))
{
CompactPeptide compactPeptide = pepWithSetMods.CompactPeptide(terminusType);
var observed = peptideToId.Contains(compactPeptide);
if (observed)
{
continue;
}
lock (peptideToId)
{
observed = peptideToId.Contains(compactPeptide);
if (observed)
{
continue;
}
peptideToId.Add(compactPeptide);
}
}
}
progress++;
var percentProgress = (int)((progress / proteinList.Count) * 100);
if (percentProgress > oldPercentProgress)
{
oldPercentProgress = percentProgress;
ReportProgress(new ProgressEventArgs(percentProgress, "Digesting proteins...", nestedIds));
}
}
});
// sort peptides by mass
var peptidesSortedByMass = peptideToId.AsParallel().WithDegreeOfParallelism(commonParams.MaxThreadsToUsePerFile).OrderBy(p => p.MonoisotopicMassIncludingFixedMods).ToList();
peptideToId = null;
// create fragment index
List <int>[] fragmentIndex;
try
{
fragmentIndex = new List <int> [(int)Math.Ceiling(maxFragmentSize) * fragmentBinsPerDalton + 1];
}
catch (OutOfMemoryException)
{
throw new MetaMorpheusException("Max fragment mass too large for indexing engine; try \"Classic Search\" mode, or make the maximum fragment mass smaller");
}
// populate fragment index
progress = 0;
oldPercentProgress = 0;
for (int peptideId = 0; peptideId < peptidesSortedByMass.Count; peptideId++)
{
var validFragments = peptidesSortedByMass[peptideId].ProductMassesMightHaveDuplicatesAndNaNs(lp).Distinct().Where(p => !Double.IsNaN(p));
foreach (var theoreticalFragmentMass in validFragments)
{
if (theoreticalFragmentMass < maxFragmentSize)
{
int fragmentBin = (int)Math.Round(theoreticalFragmentMass * fragmentBinsPerDalton);
if (fragmentIndex[fragmentBin] == null)
{
fragmentIndex[fragmentBin] = new List <int> {
peptideId
}
}
;
else
{
fragmentIndex[fragmentBin].Add(peptideId);
}
}
}
progress++;
var percentProgress = (int)((progress / peptidesSortedByMass.Count) * 100);
if (percentProgress > oldPercentProgress)
{
oldPercentProgress = percentProgress;
ReportProgress(new ProgressEventArgs(percentProgress, "Creating fragment index...", nestedIds));
}
}
return(new IndexingResults(peptidesSortedByMass, fragmentIndex, this));
}
private async Task <IList <ArmorSetSearchResult> > SearchArmorSetsInternal(
ISolverData data,
CancellationToken cancellationToken
)
{
if (cancellationToken.IsCancellationRequested)
{
return(null);
}
var heads = new List <IArmorPiece>();
var chests = new List <IArmorPiece>();
var gloves = new List <IArmorPiece>();
var waists = new List <IArmorPiece>();
var legs = new List <IArmorPiece>();
var allCharms = new List <ICharmLevel>();
var results = new List <ArmorSetSearchResult>();
var generator = new EquipmentCombinationGenerator(
searchEquipmentsObjectPool,
data.AllHeads.Where(x => x.IsSelected).Select(x => x.Equipment),
data.AllChests.Where(x => x.IsSelected).Select(x => x.Equipment),
data.AllGloves.Where(x => x.IsSelected).Select(x => x.Equipment),
data.AllWaists.Where(x => x.IsSelected).Select(x => x.Equipment),
data.AllLegs.Where(x => x.IsSelected).Select(x => x.Equipment),
data.AllCharms.Where(x => x.IsSelected).Select(x => x.Equipment)
);
long hh = data.AllHeads.Count(x => x.IsSelected);
long cc = data.AllChests.Count(x => x.IsSelected);
long gg = data.AllGloves.Count(x => x.IsSelected);
long ww = data.AllWaists.Count(x => x.IsSelected);
long ll = data.AllLegs.Count(x => x.IsSelected);
long ch = data.AllCharms.Count(x => x.IsSelected);
long combinationCount =
Math.Max(hh, 1) *
Math.Max(cc, 1) *
Math.Max(gg, 1) *
Math.Max(ww, 1) *
Math.Max(ll, 1) *
Math.Max(ch, 1);
await Task.Yield();
var parallelOptions = new ParallelOptions
{
//MaxDegreeOfParallelism = 1, // to ease debugging
MaxDegreeOfParallelism = Environment.ProcessorCount
};
currentCombinations = 0;
totalCombinations = combinationCount;
ParallelLoopResult parallelResult;
try
{
const int batchSize = 4096;
using (var equipmentBatchObjectPool = new ObjectPool <EquipmentBatch>(() => EquipmentBatch.Create(batchSize)))
{
OrderablePartitioner <EquipmentBatch> partitioner = Partitioner.Create(generator.AllBatch(equipmentBatchObjectPool, cancellationToken), EnumerablePartitionerOptions.NoBuffering);
parallelResult = Parallel.ForEach(partitioner, parallelOptions, equipmentBatch =>
{
if (cancellationToken.IsCancellationRequested)
{
equipmentBatchObjectPool.PutObject(equipmentBatch);
return;
}
for (int i = 0; i < equipmentBatch.Size; i++)
{
EvaluateArmorSet(equipmentBatch.Equipment[i], data, results);
}
equipmentBatchObjectPool.PutObject(equipmentBatch);
});
}
}
finally
{
generator.Reset();
}
return(results);
}
public void RunMap(string inputSplit, int numReducers, bool pipedInputs)
{
this.inputSplit = inputSplit;
reader = factory.CreateRecordReader(this);
if (reader != null)
{
valuee = new byte[0];
}
mapper = factory.CreateMapper(this);
this.numReducers = numReducers;
if (numReducers != 0)
{
reducer = factory.CreateCombiner(this);
partitioner = factory.CreatePartitioner(this);
}
if (reducer != null)
{
long spillSize = 100;
if (jobConf.ContainsKey("io.sort.mb"))
{
spillSize = Convert.ToInt64(jobConf["io.sort.mb"]);
}
// TODO writer = new CombineRunner (
}
hasTask = true;
}
public static void WVELcalculate(int NI, int NJ, int NK)
{
if (Program.ICW)
{
//computation of Coriolis-term
Parallel.For(2, NI, Program.pOptions, i =>
{
int NK_P = NK; int NJ_P = NJ;
for (int j = 2; j <= NJ_P - 1; j++)
{
float[] AP0_L = Program.AP0[i][j];
double[] W2_L = Program.W2[i][j];
double[] DIMW_L = Program.DIMW[i][j];
double[] W1_L = Program.W1[i][j];
float[] F1W_L = Program.F1W[i][j];
float[] F2W_L = Program.F2W[i][j];
double[] QBZ_L = Program.QBZ[i][j];
double[] QUN_L = Program.QUN[i][j];
float[] RHO_L = Program.RHO[i][j];
float[] RHOBZ_L = Program.RHOBZ[i][j];
double[] TBZ_L = Program.TBZ[i][j];
double[] TN_L = Program.TN[i][j];
double[] U1N_L = Program.U1N[i][j];
float[] VOL_L = Program.VOL[i][j];
double f1, f2;
for (int kn = 1; kn <= 2 * (NK_P - 1); kn++)
{
int k = 1 + kn >> 1; // (int) (kn * 0.5F + 0.5F)
f1 = RHO_L[k] * Program.FH * U1N_L[k] * 0.5F * VOL_L[k];
f2 = 0;
if (Program.ICPSI == false)
{
f2 = 0.5F * VOL_L[k] * ((TN_L[k] + Program.TBZ1) * (1 + 0.00061 * QUN_L[k]) - (TBZ_L[k] * (1 + 0.00061 * QBZ_L[k]))) /
(TBZ_L[k] * (1 + 0.00061 * QBZ_L[k])) * RHOBZ_L[k] * Program.GERD;
}
//no bouyancy, where terrain is smoothed at the border
/*
* if ((i < nr_cell_smooth) || (i > NI - nr_cell_smooth)||(j < nr_cell_smooth) || (j > NJ - nr_cell_smooth))
* {
* f2 = 0;
* }
*/
f1 += f2;
f1 += DIMW_L[kn];
F1W_L[kn] = (float)(AP0_L[k] * W1_L[k] + f1);
F2W_L[kn] = (float)(AP0_L[k] * W2_L[k] + f1);
}
}
});
int range_parallel = (int)(NI / Program.pOptions.MaxDegreeOfParallelism - (ITIME % 3) * 2);
range_parallel = Math.Max(30 - (ITIME % 3) * 2, range_parallel); // min. 30 steps per processor
range_parallel = Math.Min(NI, range_parallel); // if NI < range_parallel
//Iterative solution using an implicit scheme and the TDMA or Thomas-Algorithm
//Parallel.For(2, NI, Program.pOptions, i =>
Parallel.ForEach(Partitioner.Create(2, NI, range_parallel), range =>
{
int NK_P = NK; int NJ_P = NJ;
double DIM;
double[] PIM = new double[2 * NK];
double[] QIM = new double[2 * NK];
double help;
for (int i = range.Item1; i < range.Item2; i++)
{
for (int j = 2; j <= NJ_P - 1; j++)
{
float relaxv = (float)(Program.RELAXV * Program.Relax_Border_factor[i][j]);
float[] AE2_L = Program.AE2[i][j];
float[] AN2_L = Program.AN2[i][j];
float[] AIM_L = Program.AIM[i][j];
float[] AREAZX_L = Program.AREAZX[i][j];
float[] AREAZY_L = Program.AREAZY[i][j];
float[] AS1_L = Program.AS1[i][j];
float[] AW1_L = Program.AW1[i][j];
float[] BIM_L = Program.BIM[i][j];
float[] CIM_L = Program.CIM[i][j];
float[] F1W_L = Program.F1W[i][j];
float[] F2W_L = Program.F2W[i][j];
float[] RHO_L = Program.RHO[i][j];
double[] W1N_L = Program.W1N[i][j]; double[] W1Ni_L = Program.W1N[i + 1][j]; double[] W1NJ_P_L = Program.W1N[i][j + 1];
double[] W2N_L = Program.W2N[i][j]; double[] W2Ni_L = Program.W2N[i - 1][j]; double[] W2NJ_P_L = Program.W2N[i][j - 1];
float USTxUSTV = (float)(Program.UST[i][j] * Program.USTV[i][j]);
int m = 2;
for (int kn = 1; kn <= 2 * (NK_P - 1); kn++)
{
int k = 1 + kn >> 1; // (int) (kn * 0.5F + 0.5F)
//Coefficients for the lower half-cell
if (m == 2)
{
DIM = AW1_L[k] * W2Ni_L[k] + AS1_L[k] * W2NJ_P_L[k] + F1W_L[kn];
if (k == 1)
{
DIM -= RHO_L[k] * W1N_L[k] * USTxUSTV * MathF.Sqrt(Pow2(AREAZX_L[k]) + Pow2(AREAZY_L[k]));
}
//Recurrence formula
if (k > 1)
{
help = 1 / (AIM_L[kn] - CIM_L[kn] * PIM[kn - 1]);
PIM[kn] = BIM_L[kn] * help;
QIM[kn] = (DIM + CIM_L[kn] * QIM[kn - 1]) * help;
}
else
{
help = 1 / AIM_L[kn];
PIM[kn] = BIM_L[kn] * help;
QIM[kn] = DIM * help;
}
m--;
}
//Coefficients for the upper half-cell
else
{
DIM = AE2_L[k] * W1Ni_L[k] + AN2_L[k] * W1NJ_P_L[k] + F2W_L[kn];
if (k == 1)
{
DIM -= RHO_L[k] * W2N_L[k] * USTxUSTV * MathF.Sqrt(Pow2(AREAZX_L[k]) + Pow2(AREAZY_L[k]));
}
//Recurrence formula
help = 1 / (AIM_L[kn] - CIM_L[kn] * PIM[kn - 1]);
PIM[kn] = BIM_L[kn] * help;
QIM[kn] = (DIM + CIM_L[kn] * QIM[kn - 1]) * help;
m = 2;
}
}
//Obtain new W-components
m = 1;
for (int kn = 2 * (NK_P - 1); kn >= 1; kn--)
{
int k = 1 + kn >> 1; // (int) (kn * 0.5F + 0.5F)
if (m == 2)
{
W1N_L[k] += (relaxv * (PIM[kn] * W2N_L[k] + QIM[kn] - W1N_L[k]));
m--;
}
else
{
W2N_L[k] += (relaxv * (PIM[kn] * W1N_L[k + 1] + QIM[kn] - W2N_L[k]));
m = 2;
}
}
}
}
});
range_parallel = (int)(NI / Program.pOptions.MaxDegreeOfParallelism - (ITIME % 3) * 2);
range_parallel = Math.Max(30 - (ITIME % 3) * 2, range_parallel); // min. 30 steps per processor
range_parallel = Math.Min(NI, range_parallel); // if NI < range_parallel
//Iterative solution using an implicit scheme and the TDMA or Thomas-Algorithm
// Parallel.For(2, NI, Program.pOptions, ih =>
Parallel.ForEach(Partitioner.Create(2, NI, range_parallel), range =>
{
int NK_P = NK; int NJ_P = NJ;
double DIM;
double[] PIM = new double[2 * NK_P];
double[] QIM = new double[2 * NK_P];
double help;
for (int ih = range.Item1; ih < range.Item2; ih++)
{
int i = NI + 1 - ih;
for (int j = NJ_P - 1; j >= 2; j--)
{
float relaxv = (float)(Program.RELAXV * Program.Relax_Border_factor[i][j]);
float[] AE2_L = Program.AE2[i][j];
float[] AN2_L = Program.AN2[i][j];
float[] AIM_L = Program.AIM[i][j];
float[] AREAZX_L = Program.AREAZX[i][j];
float[] AREAZY_L = Program.AREAZY[i][j];
float[] AS1_L = Program.AS1[i][j];
float[] AW1_L = Program.AW1[i][j];
float[] BIM_L = Program.BIM[i][j];
float[] CIM_L = Program.CIM[i][j];
float[] F1W_L = Program.F1W[i][j];
float[] F2W_L = Program.F2W[i][j];
float[] RHO_L = Program.RHO[i][j];
double[] W1N_L = Program.W1N[i][j]; double[] W1Ni_L = Program.W1N[i + 1][j]; double[] W1NJ_P_L = Program.W1N[i][j + 1];
double[] W2N_L = Program.W2N[i][j]; double[] W2Ni_L = Program.W2N[i - 1][j]; double[] W2NJ_P_L = Program.W2N[i][j - 1];
float USTxUSTV = (float)(Program.UST[i][j] * Program.USTV[i][j]);
int m = 2;
for (int kn = 1; kn <= 2 * (NK_P - 1); kn++)
{
int k = 1 + kn >> 1; // (int) (kn * 0.5F + 0.5F)
//Coefficients for the lower half-cell
if (m == 2)
{
DIM = AW1_L[k] * W2Ni_L[k] + AS1_L[k] * W2NJ_P_L[k] + F1W_L[kn];
if (k == 1)
{
DIM -= RHO_L[k] * W1N_L[k] * USTxUSTV * MathF.Sqrt(Pow2(AREAZX_L[k]) + Pow2(AREAZY_L[k]));
}
//Recurrence formula
if (k > 1)
{
help = 1 / (AIM_L[kn] - CIM_L[kn] * PIM[kn - 1]);
PIM[kn] = BIM_L[kn] * help;
QIM[kn] = (DIM + CIM_L[kn] * QIM[kn - 1]) * help;
}
else
{
help = 1 / AIM_L[kn];
PIM[kn] = BIM_L[kn] * help;
QIM[kn] = DIM * help;
}
m--;
}
//Coefficients for the upper half-cell
else
{
DIM = AE2_L[k] * W1Ni_L[k] + AN2_L[k] * W1NJ_P_L[k] + F2W_L[kn];
if (k == 1)
{
DIM -= RHO_L[k] * W2N_L[k] * USTxUSTV * MathF.Sqrt(Pow2(AREAZX_L[k]) + Pow2(AREAZY_L[k]));
}
//Recurrence formula
help = 1 / (AIM_L[kn] - CIM_L[kn] * PIM[kn - 1]);
PIM[kn] = BIM_L[kn] * help;
QIM[kn] = (DIM + CIM_L[kn] * QIM[kn - 1]) * help;
m = 2;
}
}
//Obtain new W-components
m = 1;
for (int kn = 2 * (NK_P - 1); kn >= 1; kn--)
{
int k = 1 + kn >> 1; // (int) (kn * 0.5F + 0.5F)
if (m == 2)
{
W1N_L[k] += (relaxv * (PIM[kn] * W2N_L[k] + QIM[kn] - W1N_L[k]));
m--;
}
else
{
W2N_L[k] += (relaxv * (PIM[kn] * W1N_L[k + 1] + QIM[kn] - W2N_L[k]));
m = 2;
}
}
}
}
});
range_parallel = (int)(NJ / Program.pOptions.MaxDegreeOfParallelism - (ITIME % 3) * 2);
range_parallel = Math.Max(30 - (ITIME % 3) * 2, range_parallel); // min. 30 steps per processor
range_parallel = Math.Min(NJ, range_parallel); // if NI < range_parallel
//Iterative solution using an implicit scheme and the TDMA or Thomas-Algorithm
//Parallel.For(2, NJ, Program.pOptions, jh =>
Parallel.ForEach(Partitioner.Create(2, NJ, range_parallel), range =>
{
int NK_P = NK; int NI_P = NI;
double DIM;
double[] PIM = new double[2 * NK_P];
double[] QIM = new double[2 * NK_P];
double help;
for (int jh = range.Item1; jh < range.Item2; jh++)
{
int j = NJ + 1 - jh;
for (int i = NI_P - 1; i >= 2; i--)
{
float relaxv = (float)(Program.RELAXV * Program.Relax_Border_factor[i][j]);
float[] AE2_L = Program.AE2[i][j];
float[] AN2_L = Program.AN2[i][j];
float[] AIM_L = Program.AIM[i][j];
float[] AREAZX_L = Program.AREAZX[i][j];
float[] AREAZY_L = Program.AREAZY[i][j];
float[] AS1_L = Program.AS1[i][j];
float[] AW1_L = Program.AW1[i][j];
float[] BIM_L = Program.BIM[i][j];
float[] CIM_L = Program.CIM[i][j];
float[] F1W_L = Program.F1W[i][j];
float[] F2W_L = Program.F2W[i][j];
float[] RHO_L = Program.RHO[i][j];
double[] W1N_L = Program.W1N[i][j]; double[] W1Ni_L = Program.W1N[i + 1][j]; double[] W1NJ_P_L = Program.W1N[i][j + 1];
double[] W2N_L = Program.W2N[i][j]; double[] W2Ni_L = Program.W2N[i - 1][j]; double[] W2NJ_P_L = Program.W2N[i][j - 1];
float USTxUSTV = (float)(Program.UST[i][j] * Program.USTV[i][j]);
int m = 2;
for (int kn = 1; kn <= 2 * (NK_P - 1); kn++)
{
int k = 1 + kn >> 1; // (int) (kn * 0.5F + 0.5F)
//Coefficients for the lower half-cell
if (m == 2)
{
DIM = AW1_L[k] * W2Ni_L[k] + AS1_L[k] * W2NJ_P_L[k] + F1W_L[kn];
if (k == 1)
{
DIM -= RHO_L[k] * W1N_L[k] * USTxUSTV * MathF.Sqrt(Pow2(AREAZX_L[k]) + Pow2(AREAZY_L[k]));
}
//Recurrence formula
if (k > 1)
{
help = 1 / (AIM_L[kn] - CIM_L[kn] * PIM[kn - 1]);
PIM[kn] = BIM_L[kn] * help;
QIM[kn] = (DIM + CIM_L[kn] * QIM[kn - 1]) * help;
}
else
{
help = 1 / AIM_L[kn];
PIM[kn] = BIM_L[kn] * help;
QIM[kn] = DIM * help;
}
m--;
}
//Coefficients for the upper half-cell
else
{
DIM = AE2_L[k] * W1Ni_L[k] + AN2_L[k] * W1NJ_P_L[k] + F2W_L[kn];
if (k == 1)
{
DIM -= RHO_L[k] * W2N_L[k] * USTxUSTV * MathF.Sqrt(Pow2(AREAZX_L[k]) + Pow2(AREAZY_L[k]));
}
//Recurrence formula
help = 1 / (AIM_L[kn] - CIM_L[kn] * PIM[kn - 1]);
PIM[kn] = BIM_L[kn] * help;
QIM[kn] = (DIM + CIM_L[kn] * QIM[kn - 1]) * help;
m = 2;
}
}
//Obtain new W-components
m = 1;
for (int kn = 2 * (NK_P - 1); kn >= 1; kn--)
{
int k = 1 + kn >> 1; // (int) (kn * 0.5F + 0.5F)
if (m == 2)
{
W1N_L[k] += (relaxv * (PIM[kn] * W2N_L[k] + QIM[kn] - W1N_L[k]));
m--;
}
else
{
W2N_L[k] += (relaxv * (PIM[kn] * W1N_L[k + 1] + QIM[kn] - W2N_L[k]));
m = 2;
}
}
}
}
});
range_parallel = (int)(NJ / Program.pOptions.MaxDegreeOfParallelism - (ITIME % 3) * 2);
range_parallel = Math.Max(30 - (ITIME % 3) * 2, range_parallel); // min. 30 steps per processor
range_parallel = Math.Min(NJ, range_parallel); // if NI < range_parallel
//Iterative solution using an implicit scheme and the TDMA or Thomas-Algorithm
// Parallel.For(2, NJ, Program.pOptions, j =>
Parallel.ForEach(Partitioner.Create(2, NJ, range_parallel), range =>
{
int NK_P = NK; int NI_P = NI;
double DIM;
double[] PIM = new double[2 * NK_P];
double[] QIM = new double[2 * NK_P];
double help;
for (int j = range.Item1; j < range.Item2; j++)
{
for (int i = 2; i <= NI_P - 1; i++)
{
float relaxv = (float)(Program.RELAXV * Program.Relax_Border_factor[i][j]);
float[] AE2_L = Program.AE2[i][j];
float[] AN2_L = Program.AN2[i][j];
float[] AIM_L = Program.AIM[i][j];
float[] AREAZX_L = Program.AREAZX[i][j];
float[] AREAZY_L = Program.AREAZY[i][j];
float[] AS1_L = Program.AS1[i][j];
float[] AW1_L = Program.AW1[i][j];
float[] BIM_L = Program.BIM[i][j];
float[] CIM_L = Program.CIM[i][j];
float[] F1W_L = Program.F1W[i][j];
float[] F2W_L = Program.F2W[i][j];
float[] RHO_L = Program.RHO[i][j];
double[] W1N_L = Program.W1N[i][j]; double[] W1Ni_L = Program.W1N[i + 1][j]; double[] W1NJ_P_L = Program.W1N[i][j + 1];
double[] W2N_L = Program.W2N[i][j]; double[] W2Ni_L = Program.W2N[i - 1][j]; double[] W2NJ_P_L = Program.W2N[i][j - 1];
float USTxUSTV = (float)(Program.UST[i][j] * Program.USTV[i][j]);
int m = 2;
for (int kn = 1; kn <= 2 * (NK_P - 1); kn++)
{
int k = 1 + kn >> 1; // (int) (kn * 0.5F + 0.5F)
//Coefficients for the lower half-cell
if (m == 2)
{
DIM = AW1_L[k] * W2Ni_L[k] + AS1_L[k] * W2NJ_P_L[k] + F1W_L[kn];
if (k == 1)
{
DIM -= RHO_L[k] * W1N_L[k] * USTxUSTV * MathF.Sqrt(Pow2(AREAZX_L[k]) + Pow2(AREAZY_L[k]));
}
//Recurrence formula
if (k > 1)
{
help = 1 / (AIM_L[kn] - CIM_L[kn] * PIM[kn - 1]);
PIM[kn] = BIM_L[kn] * help;
QIM[kn] = (DIM + CIM_L[kn] * QIM[kn - 1]) * help;
}
else
{
help = 1 / AIM_L[kn];
PIM[kn] = BIM_L[kn] * help;
QIM[kn] = DIM * help;
}
m--;
}
//Coefficients for the upper half-cell
else
{
DIM = AE2_L[k] * W1Ni_L[k] + AN2_L[k] * W1NJ_P_L[k] + F2W_L[kn];
if (k == 1)
{
DIM -= RHO_L[k] * W2N_L[k] * USTxUSTV * MathF.Sqrt(Pow2(AREAZX_L[k]) + Pow2(AREAZY_L[k]));
}
//Recurrence formula
help = 1 / (AIM_L[kn] - CIM_L[kn] * PIM[kn - 1]);
PIM[kn] = BIM_L[kn] * help;
QIM[kn] = (DIM + CIM_L[kn] * QIM[kn - 1]) * help;
m = 2;
}
}
//Obtain new W-components
m = 1;
for (int kn = 2 * (NK_P - 1); kn >= 1; kn--)
{
int k = 1 + kn >> 1; // (int) (kn * 0.5F + 0.5F)
if (m == 2)
{
W1N_L[k] += (relaxv * (PIM[kn] * W2N_L[k] + QIM[kn] - W1N_L[k]));
m--;
}
else
{
W2N_L[k] += (relaxv * (PIM[kn] * W1N_L[k + 1] + QIM[kn] - W2N_L[k]));
m = 2;
}
}
}
}
});
range_parallel = (int)(NI / Program.pOptions.MaxDegreeOfParallelism - (ITIME % 3) * 2);
range_parallel = Math.Max(30 - (ITIME % 3) * 2, range_parallel); // min. 30 steps per processor
range_parallel = Math.Min(NI, range_parallel); // if NI < range_parallel
//Iterative solution using an implicit scheme and the TDMA or Thomas-Algorithm
//Parallel.For(2, NI, Program.pOptions, ih =>
Parallel.ForEach(Partitioner.Create(2, NI, range_parallel), range =>
{
int NK_P = NK; int NJ_P = NJ;
double DIM;
double[] PIM = new double[2 * NK_P];
double[] QIM = new double[2 * NK_P];
double help;
for (int ih = range.Item1; ih < range.Item2; ih++)
{
int i = NI + 1 - ih;
for (int j = 2; j <= NJ_P - 1; j++)
{
float relaxv = (float)(Program.RELAXV * Program.Relax_Border_factor[i][j]);
float[] AE2_L = Program.AE2[i][j];
float[] AN2_L = Program.AN2[i][j];
float[] AIM_L = Program.AIM[i][j];
float[] AREAZX_L = Program.AREAZX[i][j];
float[] AREAZY_L = Program.AREAZY[i][j];
float[] AS1_L = Program.AS1[i][j];
float[] AW1_L = Program.AW1[i][j];
float[] BIM_L = Program.BIM[i][j];
float[] CIM_L = Program.CIM[i][j];
float[] F1W_L = Program.F1W[i][j];
float[] F2W_L = Program.F2W[i][j];
float[] RHO_L = Program.RHO[i][j];
double[] W1N_L = Program.W1N[i][j]; double[] W1Ni_L = Program.W1N[i + 1][j]; double[] W1NJ_P_L = Program.W1N[i][j + 1];
double[] W2N_L = Program.W2N[i][j]; double[] W2Ni_L = Program.W2N[i - 1][j]; double[] W2NJ_P_L = Program.W2N[i][j - 1];
float USTxUSTV = (float)(Program.UST[i][j] * Program.USTV[i][j]);
int m = 2;
for (int kn = 1; kn <= 2 * (NK_P - 1); kn++)
{
int k = 1 + kn >> 1; // (int) (kn * 0.5F + 0.5F)
//Coefficients for the lower half-cell
if (m == 2)
{
DIM = AW1_L[k] * W2Ni_L[k] + AS1_L[k] * W2NJ_P_L[k] + F1W_L[kn];
if (k == 1)
{
DIM -= RHO_L[k] * W1N_L[k] * USTxUSTV * MathF.Sqrt(Pow2(AREAZX_L[k]) + Pow2(AREAZY_L[k]));
}
//Recurrence formula
if (k > 1)
{
help = 1 / (AIM_L[kn] - CIM_L[kn] * PIM[kn - 1]);
PIM[kn] = BIM_L[kn] * help;
QIM[kn] = (DIM + CIM_L[kn] * QIM[kn - 1]) * help;
}
else
{
help = 1 / AIM_L[kn];
PIM[kn] = BIM_L[kn] * help;
QIM[kn] = DIM * help;
}
m--;
}
//Coefficients for the upper half-cell
else
{
DIM = AE2_L[k] * W1Ni_L[k] + AN2_L[k] * W1NJ_P_L[k] + F2W_L[kn];
if (k == 1)
{
DIM -= RHO_L[k] * W2N_L[k] * USTxUSTV * MathF.Sqrt(Pow2(AREAZX_L[k]) + Pow2(AREAZY_L[k]));
}
//Recurrence formula
help = 1 / (AIM_L[kn] - CIM_L[kn] * PIM[kn - 1]);
PIM[kn] = BIM_L[kn] * help;
QIM[kn] = (DIM + CIM_L[kn] * QIM[kn - 1]) * help;
m = 2;
}
}
//Obtain new W-components
m = 1;
for (int kn = 2 * (NK_P - 1); kn >= 1; kn--)
{
int k = 1 + kn >> 1; // (int) (kn * 0.5F + 0.5F)
if (m == 2)
{
W1N_L[k] += (relaxv * (PIM[kn] * W2N_L[k] + QIM[kn] - W1N_L[k]));
m--;
}
else
{
W2N_L[k] += (relaxv * (PIM[kn] * W1N_L[k + 1] + QIM[kn] - W2N_L[k]));
m = 2;
}
}
}
}
});
range_parallel = (int)(NI / Program.pOptions.MaxDegreeOfParallelism - (ITIME % 3) * 2);
range_parallel = Math.Max(30 - (ITIME % 3) * 2, range_parallel); // min. 30 steps per processor
range_parallel = Math.Min(NI, range_parallel); // if NI < range_parallel
//Iterative solution using an implicit scheme and the TDMA or Thomas-Algorithm
Parallel.For(2, NI, Program.pOptions, i =>
{
int NK_P = NK; int NJ_P = NJ;
double DIM;
double[] PIM = new double[2 * NK_P];
double[] QIM = new double[2 * NK_P];
double help;
for (int j = NJ_P - 1; j >= 2; j--)
{
float relaxv = (float)(Program.RELAXV * Program.Relax_Border_factor[i][j]);
float[] AE2_L = Program.AE2[i][j];
float[] AN2_L = Program.AN2[i][j];
float[] AIM_L = Program.AIM[i][j];
float[] AREAZX_L = Program.AREAZX[i][j];
float[] AREAZY_L = Program.AREAZY[i][j];
float[] AS1_L = Program.AS1[i][j];
float[] AW1_L = Program.AW1[i][j];
float[] BIM_L = Program.BIM[i][j];
float[] CIM_L = Program.CIM[i][j];
float[] F1W_L = Program.F1W[i][j];
float[] F2W_L = Program.F2W[i][j];
float[] RHO_L = Program.RHO[i][j];
double[] W1N_L = Program.W1N[i][j]; double[] W1Ni_L = Program.W1N[i + 1][j]; double[] W1NJ_P_L = Program.W1N[i][j + 1];
double[] W2N_L = Program.W2N[i][j]; double[] W2Ni_L = Program.W2N[i - 1][j]; double[] W2NJ_P_L = Program.W2N[i][j - 1];
float USTxUSTV = (float)(Program.UST[i][j] * Program.USTV[i][j]);
int m = 2;
for (int kn = 1; kn <= 2 * (NK_P - 1); kn++)
{
int k = 1 + kn >> 1; // (int) (kn * 0.5F + 0.5F)
//Coefficients for the lower half-cell
if (m == 2)
{
DIM = AW1_L[k] * W2Ni_L[k] + AS1_L[k] * W2NJ_P_L[k] + F1W_L[kn];
if (k == 1)
{
DIM -= RHO_L[k] * W1N_L[k] * USTxUSTV * MathF.Sqrt(Pow2(AREAZX_L[k]) + Pow2(AREAZY_L[k]));
}
//Recurrence formula
if (k > 1)
{
help = 1 / (AIM_L[kn] - CIM_L[kn] * PIM[kn - 1]);
PIM[kn] = BIM_L[kn] * help;
QIM[kn] = (DIM + CIM_L[kn] * QIM[kn - 1]) * help;
}
else
{
help = 1 / AIM_L[kn];
PIM[kn] = BIM_L[kn] * help;
QIM[kn] = DIM * help;
}
m--;
}
//Coefficients for the upper half-cell
else
{
DIM = AE2_L[k] * W1Ni_L[k] + AN2_L[k] * W1NJ_P_L[k] + F2W_L[kn];
if (k == 1)
{
DIM -= RHO_L[k] * W2N_L[k] * USTxUSTV * MathF.Sqrt(Pow2(AREAZX_L[k]) + Pow2(AREAZY_L[k]));
}
//Recurrence formula
help = 1 / (AIM_L[kn] - CIM_L[kn] * PIM[kn - 1]);
PIM[kn] = BIM_L[kn] * help;
QIM[kn] = (DIM + CIM_L[kn] * QIM[kn - 1]) * help;
m = 2;
}
}
//Obtain new W-components
m = 1;
for (int kn = 2 * (NK_P - 1); kn >= 1; kn--)
{
int k = 1 + kn >> 1; // (int) (kn * 0.5F + 0.5F)
if (m == 2)
{
W1N_L[k] += (relaxv * (PIM[kn] * W2N_L[k] + QIM[kn] - W1N_L[k]));
m--;
}
else
{
W2N_L[k] += (relaxv * (PIM[kn] * W1N_L[k + 1] + QIM[kn] - W2N_L[k]));
m = 2;
}
}
}
});
range_parallel = (int)(NJ / Program.pOptions.MaxDegreeOfParallelism - (ITIME % 3) * 2);
range_parallel = Math.Max(30 - (ITIME % 3) * 2, range_parallel); // min. 30 steps per processor
range_parallel = Math.Min(NJ, range_parallel); // if NI < range_parallel
//Iterative solution using an implicit scheme and the TDMA or Thomas-Algorithm
//Parallel.For(2, NJ, Program.pOptions, jh =>
Parallel.ForEach(Partitioner.Create(2, NJ, range_parallel), range =>
{
int NK_P = NK; int NI_P = NI;
double DIM;
double[] PIM = new double[2 * NK_P];
double[] QIM = new double[2 * NK_P];
double help;
for (int jh = range.Item1; jh < range.Item2; jh++)
{
int j = NJ + 1 - jh;
for (int i = 2; i <= NI_P - 1; i++)
{
float relaxv = (float)(Program.RELAXV * Program.Relax_Border_factor[i][j]);
float[] AE2_L = Program.AE2[i][j];
float[] AN2_L = Program.AN2[i][j];
float[] AIM_L = Program.AIM[i][j];
float[] AREAZX_L = Program.AREAZX[i][j];
float[] AREAZY_L = Program.AREAZY[i][j];
float[] AS1_L = Program.AS1[i][j];
float[] AW1_L = Program.AW1[i][j];
float[] BIM_L = Program.BIM[i][j];
float[] CIM_L = Program.CIM[i][j];
float[] F1W_L = Program.F1W[i][j];
float[] F2W_L = Program.F2W[i][j];
float[] RHO_L = Program.RHO[i][j];
double[] W1N_L = Program.W1N[i][j]; double[] W1Ni_L = Program.W1N[i + 1][j]; double[] W1NJ_P_L = Program.W1N[i][j + 1];
double[] W2N_L = Program.W2N[i][j]; double[] W2Ni_L = Program.W2N[i - 1][j]; double[] W2NJ_P_L = Program.W2N[i][j - 1];
float USTxUSTV = (float)(Program.UST[i][j] * Program.USTV[i][j]);
int m = 2;
for (int kn = 1; kn <= 2 * (NK_P - 1); kn++)
{
int k = 1 + kn >> 1; // (int) (kn * 0.5F + 0.5F)
//Coefficients for the lower half-cell
if (m == 2)
{
DIM = AW1_L[k] * W2Ni_L[k] + AS1_L[k] * W2NJ_P_L[k] + F1W_L[kn];
if (k == 1)
{
DIM -= RHO_L[k] * W1N_L[k] * USTxUSTV * MathF.Sqrt(Pow2(AREAZX_L[k]) + Pow2(AREAZY_L[k]));
}
//Recurrence formula
if (k > 1)
{
help = 1 / (AIM_L[kn] - CIM_L[kn] * PIM[kn - 1]);
PIM[kn] = BIM_L[kn] * help;
QIM[kn] = (DIM + CIM_L[kn] * QIM[kn - 1]) * help;
}
else
{
help = 1 / AIM_L[kn];
PIM[kn] = BIM_L[kn] * help;
QIM[kn] = DIM * help;
}
m--;
}
//Coefficients for the upper half-cell
else
{
DIM = AE2_L[k] * W1Ni_L[k] + AN2_L[k] * W1NJ_P_L[k] + F2W_L[kn];
if (k == 1)
{
DIM -= RHO_L[k] * W2N_L[k] * USTxUSTV * MathF.Sqrt(Pow2(AREAZX_L[k]) + Pow2(AREAZY_L[k]));
}
//Recurrence formula
help = 1 / (AIM_L[kn] - CIM_L[kn] * PIM[kn - 1]);
PIM[kn] = BIM_L[kn] * help;
QIM[kn] = (DIM + CIM_L[kn] * QIM[kn - 1]) * help;
m = 2;
}
}
//Obtain new W-components
m = 1;
for (int kn = 2 * (NK_P - 1); kn >= 1; kn--)
{
int k = 1 + kn >> 1; // (int) (kn * 0.5F + 0.5F)
if (m == 2)
{
W1N_L[k] += (relaxv * (PIM[kn] * W2N_L[k] + QIM[kn] - W1N_L[k]));
m--;
}
else
{
W2N_L[k] += (relaxv * (PIM[kn] * W1N_L[k + 1] + QIM[kn] - W2N_L[k]));
m = 2;
}
}
}
}
});
range_parallel = (int)(NJ / Program.pOptions.MaxDegreeOfParallelism - (ITIME % 3) * 2);
range_parallel = Math.Max(30 - (ITIME % 3) * 2, range_parallel); // min. 30 steps per processor
range_parallel = Math.Min(NJ, range_parallel); // if NI < range_parallel
//Iterative solution using an implicit scheme and the TDMA or Thomas-Algorithm
//Parallel.For(2, NJ, Program.pOptions, j =>
Parallel.ForEach(Partitioner.Create(2, NJ, range_parallel), range =>
{
int NK_P = NK; int NI_P = NI;
double DIM;
double[] PIM = new double[2 * NK_P];
double[] QIM = new double[2 * NK_P];
double help;
for (int j = range.Item1; j < range.Item2; j++)
{
for (int i = 2; i <= NI_P - 1; i++)
{
float relaxv = (float)(Program.RELAXV * Program.Relax_Border_factor[i][j]);
float[] AE2_L = Program.AE2[i][j];
float[] AN2_L = Program.AN2[i][j];
float[] AIM_L = Program.AIM[i][j];
float[] AREAZX_L = Program.AREAZX[i][j];
float[] AREAZY_L = Program.AREAZY[i][j];
float[] AS1_L = Program.AS1[i][j];
float[] AW1_L = Program.AW1[i][j];
float[] BIM_L = Program.BIM[i][j];
float[] CIM_L = Program.CIM[i][j];
float[] F1W_L = Program.F1W[i][j];
float[] F2W_L = Program.F2W[i][j];
float[] RHO_L = Program.RHO[i][j];
double[] W1N_L = Program.W1N[i][j]; double[] W1Ni_L = Program.W1N[i + 1][j]; double[] W1NJ_P_L = Program.W1N[i][j + 1];
double[] W2N_L = Program.W2N[i][j]; double[] W2Ni_L = Program.W2N[i - 1][j]; double[] W2NJ_P_L = Program.W2N[i][j - 1];
float USTxUSTV = (float)(Program.UST[i][j] * Program.USTV[i][j]);
int m = 2;
for (int kn = 1; kn <= 2 * (NK_P - 1); kn++)
{
int k = 1 + kn >> 1; // (int) (kn * 0.5F + 0.5F)
//Coefficients for the lower half-cell
if (m == 2)
{
DIM = AW1_L[k] * W2Ni_L[k] + AS1_L[k] * W2NJ_P_L[k] + F1W_L[kn];
if (k == 1)
{
DIM -= RHO_L[k] * W1N_L[k] * USTxUSTV * MathF.Sqrt(Pow2(AREAZX_L[k]) + Pow2(AREAZY_L[k]));
}
//Recurrence formula
if (k > 1)
{
help = 1 / (AIM_L[kn] - CIM_L[kn] * PIM[kn - 1]);
PIM[kn] = BIM_L[kn] * help;
QIM[kn] = (DIM + CIM_L[kn] * QIM[kn - 1]) * help;
}
else
{
help = 1 / AIM_L[kn];
PIM[kn] = BIM_L[kn] * help;
QIM[kn] = DIM * help;
}
m--;
}
//Coefficients for the upper half-cell
else
{
DIM = AE2_L[k] * W1Ni_L[k] + AN2_L[k] * W1NJ_P_L[k] + F2W_L[kn];
if (k == 1)
{
DIM -= RHO_L[k] * W2N_L[k] * USTxUSTV * MathF.Sqrt(Pow2(AREAZX_L[k]) + Pow2(AREAZY_L[k]));
}
//Recurrence formula
help = 1 / (AIM_L[kn] - CIM_L[kn] * PIM[kn - 1]);
PIM[kn] = BIM_L[kn] * help;
QIM[kn] = (DIM + CIM_L[kn] * QIM[kn - 1]) * help;
m = 2;
}
}
//Obtain new W-components
m = 1;
for (int kn = 2 * (NK_P - 1); kn >= 1; kn--)
{
int k = 1 + kn >> 1; // (int) (kn * 0.5F + 0.5F)
if (m == 2)
{
W1N_L[k] += (relaxv * (PIM[kn] * W2N_L[k] + QIM[kn] - W1N_L[k]));
m--;
}
else
{
W2N_L[k] += (relaxv * (PIM[kn] * W1N_L[k + 1] + QIM[kn] - W2N_L[k]));
m = 2;
}
}
}
}
});
}
}
public static IEnumerable <object[]> AggregateExceptionData(int[] counts)
{
foreach (object[] results in UnorderedSources.Ranges(counts.Cast <int>()))
{
Labeled <ParallelQuery <int> > query = (Labeled <ParallelQuery <int> >)results[0];
if (query.ToString().StartsWith("Partitioner"))
{
yield return(new object[] { Labeled.Label(query.ToString(), Partitioner.Create(UnorderedSources.GetRangeArray(0, (int)results[1]), false).AsParallel()), results[1] });
}
else if (query.ToString().StartsWith("Enumerable.Range"))
{
yield return(new object[] { Labeled.Label(query.ToString(), new StrictPartitioner <int>(Partitioner.Create(Enumerable.Range(0, (int)results[1]), EnumerablePartitionerOptions.None), (int)results[1]).AsParallel()), results[1] });
}
else
{
yield return(results);
}
}
}
private QuerySettings _settings; // Settings collected from the query
internal PartitionerQueryOperatorResults(Partitioner <TElement> partitioner, QuerySettings settings)
{
_partitioner = partitioner;
_settings = settings;
}
private void Start()
{
policy = new FrontSpacePolicy();
partitioner = new Partitioner();
partitioner.Init();
}
/// <summary>
/// Selects an item (such as Max or Min).
/// </summary>
/// <param name="fromInclusive">Starting index of the loop.</param>
/// <param name="toExclusive">Ending index of the loop</param>
/// <param name="select">The function to select items over a subset.</param>
/// <param name="reduce">The function to select the item of selection from the subsets.</param>
/// <returns>The selected value.</returns>
public static T Aggregate <T>(int fromInclusive, int toExclusive, Func <int, T> select, Func <T[], T> reduce)
{
if (select == null)
{
throw new ArgumentNullException(nameof(select));
}
if (reduce == null)
{
throw new ArgumentNullException(nameof(reduce));
}
// Special case: no action
if (fromInclusive >= toExclusive)
{
return(reduce(new T[0]));
}
// Special case: single action, inline
if (fromInclusive == toExclusive - 1)
{
return(reduce(new[] { select(fromInclusive) }));
}
// Special case: straight execution without parallelism
if (Control.MaxDegreeOfParallelism < 2)
{
var mapped = new T[toExclusive - fromInclusive];
for (var k = 0; k < mapped.Length; k++)
{
mapped[k] = select(k + fromInclusive);
}
return(reduce(mapped));
}
// Common case
var intermediateResults = new List <T>();
var syncLock = new object();
Parallel.ForEach(
Partitioner.Create(fromInclusive, toExclusive),
CreateParallelOptions(),
() => new List <T>(),
(range, loop, localData) =>
{
var mapped = new T[range.Item2 - range.Item1];
for (var k = 0; k < mapped.Length; k++)
{
mapped[k] = select(k + range.Item1);
}
localData.Add(reduce(mapped));
return(localData);
},
localResult =>
{
lock (syncLock)
{
intermediateResults.Add(reduce(localResult.ToArray()));
}
});
return(reduce(intermediateResults.ToArray()));
}
public async Task Generate()
{
try
{
if (string.IsNullOrEmpty(ProjectFilePath))
{
Log.Exception("ProjectFilePath is empty: " + Project.ToString());
return;
}
ProjectDestinationFolder = GetProjectDestinationPath(Project, SolutionGenerator.SolutionDestinationFolder);
if (ProjectDestinationFolder == null)
{
Log.Exception("Errors evaluating project: " + Project.Id);
return;
}
Log.Write(ProjectDestinationFolder, ConsoleColor.DarkCyan);
ProjectSourcePath = Paths.MakeRelativeToFolder(ProjectFilePath, SolutionGenerator.SolutionSourceFolder);
if (File.Exists(Path.Combine(ProjectDestinationFolder, Constants.DeclaredSymbolsFileName + ".txt")))
{
// apparently someone already generated a project with this assembly name - their assembly wins
Log.Exception(string.Format(
"A project with assembly name {0} was already generated, skipping current project: {1}",
this.AssemblyName,
this.ProjectFilePath), isSevere: false);
return;
}
if (Configuration.CreateFoldersOnDisk)
{
Directory.CreateDirectory(ProjectDestinationFolder);
}
var documents = Project.Documents.Where(IncludeDocument).ToList();
var generationTasks = Partitioner.Create(documents)
.GetPartitions(Environment.ProcessorCount)
.Select(partition =>
Task.Run(async() =>
{
using (partition)
{
while (partition.MoveNext())
{
await GenerateDocument(partition.Current);
}
}
}));
await Task.WhenAll(generationTasks);
foreach (var document in documents)
{
OtherFiles.Add(Paths.GetRelativeFilePathInProject(document));
}
if (Configuration.WriteProjectAuxiliaryFilesToDisk)
{
GenerateProjectFile();
GenerateDeclarations();
GenerateBaseMembers();
GenerateImplementedInterfaceMembers();
GenerateProjectInfo();
GenerateReferencesDataFiles(
this.SolutionGenerator.SolutionDestinationFolder,
ReferencesByTargetAssemblyAndSymbolId);
GenerateSymbolIDToListOfDeclarationLocationsMap(
ProjectDestinationFolder,
SymbolIDToListOfLocationsMap);
GenerateReferencedAssemblyList();
GenerateUsedReferencedAssemblyList();
GenerateProjectExplorer();
GenerateNamespaceExplorer();
GenerateIndex();
}
var compilation = Project.GetCompilationAsync().Result;
var diagnostics = compilation.GetDiagnostics().Select(d => d.ToString()).ToArray();
if (diagnostics.Length > 0)
{
var diagnosticsTxt = Path.Combine(this.ProjectDestinationFolder, "diagnostics.txt");
File.WriteAllLines(diagnosticsTxt, diagnostics);
}
}
catch (Exception ex)
{
Log.Exception(ex, "Project generation failed for: " + ProjectSourcePath);
}
}
/// <summary>
/// 进行Npp条带去除
/// </summary>
/// <param name="srcImgRaster"></param>
/// <param name="i"></param>
/// <param name="srcBandData"></param>
/// <param name="solarZenithData"></param>
/// <param name="srcBlockImgSize"></param>
/// <param name="angleSize"></param>
protected override void DoRadiation(AbstractWarpDataset srcImgRaster, int i, ushort[] srcBandData,
float[] solarZenithData, Size srcBlockImgSize, Size angleSize)
{
//定标功能
Parallel.ForEach(Partitioner.Create(0, srcBandData.Length), range =>
{
float temp = 0;
for (int ii = range.Item1; ii < range.Item2; ii++)
{
if (srcBandData[ii] != 0)
{
temp = srcBandData[ii] * _factors[i * 2] + _factors[i * 2 + 1];
if (temp < 2)
{
srcBandData[ii] = temp < 0 ? (ushort)0 : (ushort)(temp * 1000 + 0.5);
}
else
{
srcBandData[ii] = (ushort)(temp * 10 + 0.5);
}
}
}
});
//监测0值的上下值，求平均
int height = srcBlockImgSize.Height;
int width = srcBlockImgSize.Width;
var timer = System.Diagnostics.Stopwatch.StartNew();
if (false)
{
Parallel.ForEach(Partitioner.Create(0, srcBlockImgSize.Width), range =>
{
ushort[] temp = new ushort[height];
List <ushort> fillValue = new List <ushort>();
for (int ii = range.Item1; ii < range.Item2; ii++)
{
int noValuePixelCount = 0;
for (int j = 0; j < height; j++)
{
temp[j] = srcBandData[j * width + ii];
if (temp[j] == 0)
{
noValuePixelCount++;
}
}
if (noValuePixelCount == 0)
{
continue;
}
for (int k = 0; k < 4; k++)
{
for (int t = 0; t < height; t++)
{
if (temp[t] != 0)
{
continue;
}
if (t == 0)
{
if (temp[t + 1] != 0)
{
temp[t] = temp[t + 1];
}
}
else if (t == height - 1)
{
if (temp[t - 1] != 0)
{
temp[t] = temp[t - 1];
}
}
else
{
if (temp[t + 1] != 0)
{
temp[t] = temp[t + 1];
}
else if (temp[t - 1] != 0)
{
temp[t] = temp[t - 1];
}
}
}
}
//结束修改
for (int j = 0; j < height; j++)
{
srcBandData[j * width + ii] = temp[j];
}
}
temp = null;
});
}
else
{
for (int t = 0; t < 4; t++)
{
int validCount = 0;
double validSum = 0;
for (int ii = 1; ii < height - 1; ii++)
{
for (int jj = 1; jj < width - 1; jj++)
{
if (srcBandData[ii * width + jj] == 0)
{
validCount = 0;
validSum = 0;
for (int q = -1; q <= 1; q++)
{
for (int w = -1; w <= 1; w++)
{
if (q != 0 && w != 0 && srcBandData[(ii + q) * width + jj + w] != 0)
{
validCount++;
validSum += srcBandData[(ii + q) * width + jj + w];
}
}
}
if (validCount != 0)
{
srcBandData[ii * width + jj] = (ushort)(validSum / validCount + 0.5);
}
}
}
}
}
{
int ii = 0;
int jj = 0;
int validCount = 0;
double validSum = 0;
//第一行
for (jj = 1; jj < width - 1; jj++)
{
if (srcBandData[ii * width + jj] == 0)
{
validCount = 0;
validSum = 0;
for (int q = 0; q <= 1; q++)
{
for (int w = -1; w <= 1; w++)
{
if (q != 0 && w != 0 && srcBandData[(ii + q) * width + jj + w] != 0)
{
validCount++;
validSum += srcBandData[(ii + q) * width + jj + w];
}
}
}
if (validCount != 0)
{
srcBandData[ii * width + jj] = (ushort)(validSum / validCount + 0.5);
}
}
}
ii = height - 1;
//最后一行
for (jj = 1; jj < width - 1; jj++)
{
if (srcBandData[ii * width + jj] == 0)
{
validCount = 0;
validSum = 0;
for (int q = -1; q <= 0; q++)
{
for (int w = -1; w <= 1; w++)
{
if (q != 0 && w != 0 && srcBandData[(ii + q) * width + jj + w] != 0)
{
validCount++;
validSum += srcBandData[(ii + q) * width + jj + w];
}
}
}
if (validCount != 0)
{
srcBandData[ii * width + jj] = (ushort)(validSum / validCount + 0.5);
}
}
}
jj = 0;
//第一列
for (ii = 1; ii < height - 1; ii++)
{
if (srcBandData[ii * width + jj] == 0)
{
validCount = 0;
validSum = 0;
for (int q = -1; q <= 1; q++)
{
for (int w = 0; w <= 1; w++)
{
if (q != 0 && w != 0 && srcBandData[(ii + q) * width + jj + w] != 0)
{
validCount++;
validSum += srcBandData[(ii + q) * width + jj + w];
}
}
}
if (validCount != 0)
{
srcBandData[ii * width + jj] = (ushort)(validSum / validCount + 0.5);
}
}
}
//最后一列
jj = width - 1;
for (ii = 1; ii < height - 1; ii++)
{
if (srcBandData[ii * width + jj] == 0)
{
validCount = 0;
validSum = 0;
for (int q = -1; q <= 1; q++)
{
for (int w = -1; w <= 0; w++)
{
if (q != 0 && w != 0 && srcBandData[(ii + q) * width + jj + w] != 0)
{
validCount++;
validSum += srcBandData[(ii + q) * width + jj + w];
}
}
}
if (validCount != 0)
{
srcBandData[ii * width + jj] = (ushort)(validSum / validCount + 0.5);
}
}
}
}
}
//Console.WriteLine("花费时间" + timer.ElapsedMilliseconds);
}
public QuartzEndpointDefinition(QuartzConfiguration configuration)
{
_configuration = configuration;
Partition = new Partitioner(_configuration.ConcurrentMessageLimit, new Murmur3UnsafeHashGenerator());
}
/// <summary>
/// Loads all scan data from a Thermo .raw file.
/// </summary>
public static ThermoRawFileReaderData LoadAllStaticData(string filePath, IFilteringParams filterParams = null, int maxThreads = -1)
{
if (!File.Exists(filePath))
{
throw new FileNotFoundException();
}
Loaders.LoadElements();
// I don't know why this line needs to be here, but it does...
var temp = RawFileReaderAdapter.FileFactory(filePath);
var threadManager = RawFileReaderFactory.CreateThreadManager(filePath);
var rawFileAccessor = threadManager.CreateThreadAccessor();
if (!rawFileAccessor.IsOpen)
{
throw new MzLibException("Unable to access RAW file!");
}
if (rawFileAccessor.IsError)
{
throw new MzLibException("Error opening RAW file!");
}
if (rawFileAccessor.InAcquisition)
{
throw new MzLibException("RAW file still being acquired!");
}
rawFileAccessor.SelectInstrument(Device.MS, 1);
var msDataScans = new MsDataScan[rawFileAccessor.RunHeaderEx.LastSpectrum];
Parallel.ForEach(Partitioner.Create(0, msDataScans.Length), new ParallelOptions {
MaxDegreeOfParallelism = maxThreads
}, (fff, loopState) =>
{
IRawDataPlus myThreadDataReader = threadManager.CreateThreadAccessor();
myThreadDataReader.SelectInstrument(Device.MS, 1);
for (int s = fff.Item1; s < fff.Item2; s++)
{
try
{
var scan = GetOneBasedScan(myThreadDataReader, filterParams, s + 1);
msDataScans[s] = scan;
}
catch (Exception ex)
{
throw new MzLibException("Error reading scan " + (s + 1) + ": " + ex.Message);
}
}
});
rawFileAccessor.Dispose();
string sendCheckSum;
using (FileStream stream = File.OpenRead(filePath))
{
using (SHA1Managed sha = new SHA1Managed())
{
byte[] checksum = sha.ComputeHash(stream);
sendCheckSum = BitConverter.ToString(checksum)
.Replace("-", string.Empty);
}
}
SourceFile sourceFile = new SourceFile(
@"Thermo nativeID format",
@"Thermo RAW format",
sendCheckSum,
@"SHA-1",
filePath,
Path.GetFileNameWithoutExtension(filePath));
return(new ThermoRawFileReaderData(msDataScans, sourceFile));
}
/// <inheritdoc />
public override unsafe void DoStepOpenCL(OpenCLDispatcher dispatcher, OpenCLDevice device)
{
var timerTotal = Stopwatch.StartNew();
OpenCLKernelSet kernelSet = dispatcher.Compile(device, "CellBasedSim.cl");
currentStep++;
// Increase random seed
randomSeed++;
int cellsLength = Current.Cells.Length;
int junctionsLength = Current.Junctions.Length;
int generatorsLength = Current.Generators.Length;
int carsLength = Current.Cars.Length;
// Reset waiting count on every junction
Parallel.ForEach(Partitioner.Create(0, Current.Junctions.Length), range => {
for (int i = range.Item1; i < range.Item2; i++)
{
Current.Junctions[i].WaitingCount = 0;
}
});
fixed(Cell *cellsPtr = Current.Cells)
fixed(CellToCar * cellsToCarPtr = Current.CellsToCar)
fixed(Junction * junctionsPtr = Current.Junctions)
fixed(Generator * generatorsPtr = Current.Generators)
fixed(Car * carsPtr = Current.Cars)
fixed(float *randomPtr = random)
{
var timer = Stopwatch.StartNew();
// Process all cars
kernelSet["DoStepCar"]
.BindBuffer(cellsPtr, sizeof(Cell) * cellsLength, true)
.BindBuffer(cellsToCarPtr, sizeof(CellToCar) * cellsLength, false)
.BindValue(cellsLength)
.BindBuffer(junctionsPtr, sizeof(Junction) * junctionsLength, false)
.BindValue(junctionsLength)
.BindBuffer(carsPtr, sizeof(Car) * carsLength, false)
.BindValue(carsLength)
.BindBuffer(randomPtr, sizeof(float) * randomLength, true)
.BindValue(randomLength)
.BindValue(randomSeed)
.Run(carsLength)
.Finish();
LastTimeCars = timer.Elapsed;
timer.Restart();
// Process all generators
if ((flags & SimulationFlags.NoSpawn) == 0)
{
kernelSet["SpawnCars"]
.BindBuffer(cellsPtr, sizeof(Cell) * cellsLength, true)
.BindBuffer(cellsToCarPtr, sizeof(CellToCar) * cellsLength, false)
.BindValue(cellsLength)
.BindBuffer(generatorsPtr, sizeof(Generator) * generatorsLength, false)
.BindValue(generatorsLength)
.BindBuffer(carsPtr, sizeof(Car) * carsLength, false)
.BindValue(carsLength)
.BindBuffer(randomPtr, sizeof(float) * randomLength, true)
.BindValue(randomLength)
.BindValue(randomSeed)
.Run(generatorsLength)
.Finish();
}
LastTimeGenerators = timer.Elapsed;
}
LastTimeTotal = timerTotal.Elapsed;
}
public TEntity[] CreateEntities <TEntity>(DataTable data, QueryBuilder <TEntity> builder) where TEntity : Entity, new()
{
var fieldCount = builder.PropertySetter.Length;
var arrayFieldCount = 0;
var classFieldCount = 0;
var structFieldCount = 0;
if (data == null || data.Rows.Count == 0)
{
return(new TEntity[0]);
}
var entity = new TEntity();
for (var i = 0; i < builder.Properties.Length; i++)
{
if (builder.Properties[i].PropertyType.IsArray)
{
var arr = builder.Properties[i].GetValue(new TEntity()) as Array;
arrayFieldCount += arr.Length - 1;
}
else if (builder.Properties[i].PropertyType.IsCustomClass())
{
classFieldCount += builder.Properties[i].PropertyType.GetReadWriteProperties().Length - 1;
}
else if (builder.Properties[i].PropertyType.IsCustomStruct())
{
structFieldCount += builder.Properties[i].PropertyType.GetFields(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly).Length - 1;
}
}
if (data.Columns.Count != (fieldCount + arrayFieldCount + classFieldCount + structFieldCount))
{
Trace.TraceError(string.Format("Table '{0}' (Column/Property count mismatch)", Pluralize <TEntity>()));
Trace.TraceError(string.Format("Columns '{0}'", data.Columns.Count));
Trace.TraceError(string.Format("Properties '{0}'", fieldCount + arrayFieldCount + classFieldCount + structFieldCount));
Trace.WriteLine("Press a key to continue loading.");
Console.ReadKey(true);
return(new TEntity[0]);
}
for (var i = 0; i < fieldCount; i++)
{
if (builder.Properties[i].PropertyType == typeof(bool) || builder.Properties[i].PropertyType.IsArray || builder.Properties[i].PropertyType.IsCustomClass() || builder.Properties[i].PropertyType.IsCustomStruct())
{
continue;
}
// Return an empty list if any column/property type mismatches
if (!data.Columns[i].DataType.IsEquivalentTo(builder.Properties[i].PropertyType.IsEnum ?
builder.Properties[i].PropertyType.GetEnumUnderlyingType() : builder.Properties[i].PropertyType))
{
Trace.TraceError(string.Format("Table '{0}' (Column/Property type mismatch)", Pluralize <TEntity>()));
Trace.TraceError(string.Format("Column '{0}' ({1})", data.Columns[i].ColumnName, data.Columns[i].DataType));
Trace.TraceError(string.Format("Property '{0}' ({1})", builder.Properties[i].Name, builder.Properties[i].PropertyType.IsEnum ?
builder.Properties[i].PropertyType.GetEnumUnderlyingType() : builder.Properties[i].PropertyType));
Trace.WriteLine("Press a key to continue loading.");
Console.ReadKey(true);
return(new TEntity[0]);
}
}
var entities = new TEntity[data.Rows.Count];
var datapPartitioner = Partitioner.Create(0, data.Rows.Count);
// Create one test object for foreign key assignment check
var foreignKeys = typeof(TEntity).GetProperties().Where(p => p.GetMethod.IsVirtual).ToArray();
// Key: GroupStartIndex, Value: GroupCount
var groups = new ConcurrentDictionary <int, int>();
var lastGroupName = "";
var lastGroupStartIndex = 0;
// Get Groups
for (var i = 0; i < fieldCount; i++)
{
var group = builder.Properties[i].GetCustomAttribute <GroupAttribute>();
if (group != null)
{
if (group.Name == lastGroupName)
{
groups[lastGroupStartIndex] += 1;
}
else
{
lastGroupName = group.Name;
lastGroupStartIndex = i;
groups.TryAdd(lastGroupStartIndex, 1);
}
}
}
if (entity.AutoAssignForeignKeys && foreignKeys.Length > 0)
{
// TODO: Optimize foreign key assignment (slow atm...)
Parallel.ForEach(datapPartitioner, (dataRange, loopState) =>
{
for (var i = dataRange.Item1; i < dataRange.Item2; i++)
{
entities[i] = new TEntity();
for (var j = 0; j < fieldCount; j++)
{
if (!builder.Properties[j].PropertyType.IsArray)
{
if (builder.Properties[j].PropertyType.IsCustomClass())
{
var instanceFields = builder.Properties[j].PropertyType.GetReadWriteProperties();
var instance = Activator.CreateInstance(builder.Properties[j].PropertyType);
for (var f = 0; f < instanceFields.Length; f++)
{
instanceFields[f].SetValue(instance, Convert.IsDBNull(data.Rows[i][j + f]) ? "" : data.Rows[i][j + f].ChangeTypeGet(builder.Properties[j].PropertyType));
}
builder.PropertySetter[j].SetValue(entities[i], instance);
}
else if (builder.Properties[j].PropertyType.IsCustomStruct())
{
var instanceFields = builder.Properties[j].PropertyType.GetFields(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly).ToArray();
var instance = Activator.CreateInstance(builder.Properties[j].PropertyType);
for (var f = 0; f < instanceFields.Length; f++)
{
instanceFields[f].SetValue(instance, Convert.IsDBNull(data.Rows[i][j + f]) ? "" : data.Rows[i][j + f].ChangeTypeGet(builder.Properties[j + f].PropertyType));
}
builder.PropertySetter[j].SetValue(entities[i], instance);
}
else
{
builder.PropertySetter[j].SetValue(entities[i], Convert.IsDBNull(data.Rows[i][j]) ? "" : data.Rows[i][j].ChangeTypeGet(builder.Properties[j].PropertyType));
}
}
else
{
var groupCount = 0;
if (groups.TryGetValue(j, out groupCount))
{
for (var c = 0; c < groupCount; c++, j++)
{
var arr = builder.Properties[j].GetValue(new TEntity()) as Array;
for (var k = 0; k < arr.Length; k++)
{
arr.SetValue(data.Rows[i][j + (k * groupCount)], k);
}
builder.PropertySetter[j].SetValue(entities[i], arr);
}
}
else
{
var arr = builder.Properties[j].GetValue(new TEntity()) as Array;
for (var k = 0; k < arr.Length; k++)
{
arr.SetValue(data.Rows[i][j + k], k);
}
builder.PropertySetter[j].SetValue(entities[i], arr);
}
}
}
// TODO Fix group assignment in foreign keys.
if (groups.Count == 0)
{
parentDb.AssignForeignKeyData(entities[i], foreignKeys, groups);
}
entities[i].InitializeNonTableProperties();
}
});
}
else
{
Parallel.ForEach(datapPartitioner, (dataRange, loopState) =>
{
for (var i = dataRange.Item1; i < dataRange.Item2; i++)
{
entities[i] = new TEntity();
for (var j = 0; j < fieldCount; j++)
{
if (!builder.Properties[j].PropertyType.IsArray)
{
if (builder.Properties[j].PropertyType.IsCustomClass())
{
var instanceFields = builder.Properties[j].PropertyType.GetReadWriteProperties();
var instance = Activator.CreateInstance(builder.Properties[j].PropertyType);
for (var f = 0; f < instanceFields.Length; f++)
{
instanceFields[f].SetValue(instance, Convert.IsDBNull(data.Rows[i][j + f]) ? "" : data.Rows[i][j + f]);
}
builder.PropertySetter[j].SetValue(entities[i], instance);
}
else if (builder.Properties[j].PropertyType.IsCustomStruct())
{
var instanceFields = builder.Properties[j].PropertyType.GetFields(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly).ToArray();
var instance = Activator.CreateInstance(builder.Properties[j].PropertyType);
for (var f = 0; f < instanceFields.Length; f++)
{
instanceFields[f].SetValue(instance, Convert.IsDBNull(data.Rows[i][j + f]) ? "" : data.Rows[i][j + f].ChangeTypeGet(builder.Properties[j + f].PropertyType));
}
builder.PropertySetter[j].SetValue(entities[i], instance);
}
else
{
builder.PropertySetter[j].SetValue(entities[i], Convert.IsDBNull(data.Rows[i][j]) ? "" : data.Rows[i][j].ChangeTypeGet(builder.Properties[j].PropertyType));
}
}
else
{
var groupCount = 0;
if (groups.TryGetValue(j, out groupCount))
{
for (var c = 0; c < groupCount; c++, j++)
{
var arr = builder.Properties[j].GetValue(entities[i]) as Array;
for (var k = 0; k < arr.Length; k++)
{
arr.SetValue(data.Rows[i][j + (k * groupCount)], k);
}
builder.PropertySetter[j].SetValue(entities[i], arr);
}
}
else
{
var arr = builder.Properties[j].GetValue(entities[i]) as Array;
for (var k = 0; k < arr.Length; k++)
{
arr.SetValue(data.Rows[i][j + k], k);
}
builder.PropertySetter[j].SetValue(entities[i], arr);
}
}
}
entities[i].InitializeNonTableProperties();
}
});
}
return(entities);
}
private void SeparateRenderables(RenderContext context, bool invalidateSceneGraph, bool invalidatePerFrameRenderables)
{
Clear(invalidateSceneGraph, invalidatePerFrameRenderables);
if (invalidateSceneGraph)
{
viewportRenderables.AddRange(Viewport.Renderables);
renderer.UpdateSceneGraph(RenderContext, viewportRenderables, perFrameFlattenedScene);
#if DEBUG
Debug.WriteLine("Flatten Scene Graph");
#endif
}
int sceneCount = perFrameFlattenedScene.Count;
if (invalidatePerFrameRenderables)
{
#if DEBUG
Debug.WriteLine("Get PerFrameRenderables");
#endif
for (int i = 0; i < sceneCount;)
{
var renderable = perFrameFlattenedScene[i];
renderable.Value.Update(context);
var type = renderable.Value.RenderType;
if (!renderable.Value.IsRenderable)
{
//Skip scene graph depth larger than current node
int depth = renderable.Key;
++i;
for (; i < sceneCount; ++i)
{
if (perFrameFlattenedScene[i].Key <= depth)
{
break;
}
i += perFrameFlattenedScene[i].Value.ItemsInternal.Count;
}
continue;
}
if (renderable.Value.RenderCore.NeedUpdate) // Run update function at the beginning of actual rendering.
{
needUpdateCores.Add(renderable.Value.RenderCore);
}
++i;
switch (type)
{
case RenderType.Opaque:
opaqueNodes.Add(renderable.Value);
break;
case RenderType.Light:
lightNodes.Add(renderable.Value);
break;
case RenderType.Transparent:
transparentNodes.Add(renderable.Value);
break;
case RenderType.Particle:
particleNodes.Add(renderable.Value);
break;
case RenderType.PreProc:
preProcNodes.Add(renderable.Value);
break;
case RenderType.PostProc:
postProcNodes.Add(renderable.Value);
break;
case RenderType.ScreenSpaced:
screenSpacedNodes.Add(renderable.Value);
break;
}
}
if (RenderConfiguration.EnableRenderOrder)
{
for (int i = 0; i < preProcNodes.Count; ++i)
{
preProcNodes[i].UpdateRenderOrderKey();
}
preProcNodes.Sort();
for (int i = 0; i < opaqueNodes.Count; ++i)
{
opaqueNodes[i].UpdateRenderOrderKey();
}
opaqueNodes.Sort();
for (int i = 0; i < postProcNodes.Count; ++i)
{
postProcNodes[i].UpdateRenderOrderKey();
}
postProcNodes.Sort();
for (int i = 0; i < particleNodes.Count; ++i)
{
particleNodes[i].UpdateRenderOrderKey();
}
particleNodes.Sort();
}
opaquePartitioner = opaqueNodes.Count > 0 ? Partitioner.Create(0, opaqueNodes.Count, FrustumPartitionSize) : null;
transparentPartitioner = transparentNodes.Count > 0 ? Partitioner.Create(0, transparentNodes.Count, FrustumPartitionSize) : null;
SetupFrustumTestFunctions();
}
else
{
for (int i = 0; i < sceneCount;)
{
var renderable = perFrameFlattenedScene[i];
renderable.Value.Update(context);
if (!renderable.Value.IsRenderable)
{
//Skip scene graph depth larger than current node
int depth = renderable.Key;
++i;
for (; i < sceneCount; ++i)
{
if (perFrameFlattenedScene[i].Key <= depth)
{
break;
}
i += perFrameFlattenedScene[i].Value.ItemsInternal.Count;
}
continue;
}
if (renderable.Value.RenderCore.NeedUpdate) // Run update function at the beginning of actual rendering.
{
needUpdateCores.Add(renderable.Value.RenderCore);
}
++i;
}
}
}
private int OnExecute()
{
InputFile = Path.GetFullPath(InputFile);
if (OutputFile != null)
{
OutputFile = Path.GetFullPath(OutputFile);
OutputFile = FixPathSlashes(OutputFile);
}
if (FileFilter != null)
{
FileFilter = FixPathSlashes(FileFilter);
}
if (ExtFilter != null)
{
ExtFilterList = ExtFilter.Split(',');
}
var paths = new List <string>();
if (Directory.Exists(InputFile))
{
if (OutputFile != null && File.Exists(OutputFile))
{
Console.Error.WriteLine("Output path is an existing file, but input is a folder.");
return(1);
}
IsInputFolder = true;
var dirs = Directory
.EnumerateFiles(InputFile, "*.*", RecursiveSearch ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly)
.Where(s => s.EndsWith("_c") || s.EndsWith(".vcs"));
if (!dirs.Any())
{
Console.Error.WriteLine(
"Unable to find any \"_c\" compiled files in \"{0}\" folder.{1}",
InputFile,
RecursiveSearch ? " Did you mean to include --recursive parameter?" : string.Empty);
return(1);
}
paths.AddRange(dirs);
}
else if (File.Exists(InputFile))
{
if (RecursiveSearch)
{
Console.Error.WriteLine("File passed in with --recursive option. Either pass in a folder or remove --recursive.");
return(1);
}
paths.Add(InputFile);
}
else
{
Console.Error.WriteLine("Input \"{0}\" is not a file or a folder.", InputFile);
return(1);
}
CurrentFile = 0;
TotalFiles = paths.Count;
if (MaxParallelismThreads > 1)
{
Console.WriteLine("Will use {0} threads concurrently.", MaxParallelismThreads);
var partitioner = Partitioner.Create(paths, EnumerablePartitionerOptions.NoBuffering);
Parallel.ForEach(partitioner, new ParallelOptions {
MaxDegreeOfParallelism = MaxParallelismThreads
}, (path, state) =>
{
ProcessFile(path);
});
}
else
{
foreach (var path in paths)
{
ProcessFile(path);
}
}
if (CollectStats)
{
Console.WriteLine();
Console.WriteLine("Processed resource stats:");
foreach (var stat in stats.OrderByDescending(x => x.Value.Count).ThenBy(x => x.Key))
{
var info = string.IsNullOrEmpty(stat.Value.Info) ? string.Empty : $" ({stat.Value.Info})";
Console.WriteLine($"{stat.Value.Count,5} resources of version {stat.Value.Version} and type {stat.Value.Type}{info}");
foreach (var file in stat.Value.FilePaths)
{
Console.WriteLine($"\t\t{file}");
}
}
Console.WriteLine();
Console.WriteLine("Unique special dependancies:");
foreach (var stat in uniqueSpecialDependancies)
{
Console.WriteLine("{0} in {1}", stat.Key, stat.Value);
}
}
return(0);
}
void Update()
{
Split();
Grow();
int iterations = _convergence;
double totVel;
do
{
Search.Populate(Particles);
if (Mesh != null)
{
var particlesCount = Particles.Count;
var points = new List <Point3d>(particlesCount);
var pullPoints = new Point3d[particlesCount];
for (int i = 0; i < particlesCount; i++)
{
points.Add(Particles[i].Position);
}
Parallel.ForEach(Partitioner.Create(0, particlesCount), range =>
{
var subPoints = points.GetRange(range.Item1, range.Item2 - range.Item1);
var subPulled = Mesh.PullPointsToMesh(subPoints);
int count = 0;
for (int i = range.Item1; i < range.Item2; i++)
{
pullPoints[i] = subPulled[count++];
}
});
// var pullPoints = Mesh.PullPointsToMesh(points);
Parallel.ForEach(Partitioner.Create(0, particlesCount), range =>
{
for (int i = range.Item1; i < range.Item2; i++)
{
Particles[i].Forces(pullPoints[i]);
}
});
}
else
{
Parallel.ForEach(Partitioner.Create(0, Particles.Count), range =>
{
for (int i = range.Item1; i < range.Item2; i++)
{
Particles[i].Forces();
}
});
}
Parallel.ForEach(Partitioner.Create(0, Springs.Count), range =>
{
for (int i = range.Item1; i < range.Item2; i++)
{
Springs[i].Forces(10);
}
});
Parallel.ForEach(Partitioner.Create(0, Particles.Count), range =>
{
for (int i = range.Item1; i < range.Item2; i++)
{
Particles[i].Move();
}
});
Parallel.ForEach(Partitioner.Create(0, Springs.Count), range =>
{
for (int i = range.Item1; i < range.Item2; i++)
{
Springs[i].Update();
}
});
totVel = 0;
foreach (var particle in Particles)
{
totVel += particle.Velocity.SquareLength;
}
} while (totVel > 0.001 && iterations-- > 0);
}
protected virtual void OnSubmitGeometries(DeviceContextProxy deviceContext)
{
if (Geometries == null)
{
VertexBuffer[0].UploadDataToBuffer(deviceContext, EmptyArray, 0);
IndexBuffer?.UploadDataToBuffer(deviceContext, EmptyIntArray, 0);
vertexBufferBindings = new VertexBufferBinding[0];
return;
}
#if OutputBuildTime
var time = System.Diagnostics.Stopwatch.GetTimestamp();
#endif
var totalVertex = 0;
var totalIndices = 0;
var vertRange = new int[Geometries.Length];
var idxRange = new int[Geometries.Length];
for (var i = 0; i < Geometries.Length; ++i)
{
vertRange[i] = totalVertex;
totalVertex += Geometries[i].Geometry.Positions.Count;
if (Geometries[i].Geometry.Indices != null)
{
idxRange[i] = totalIndices;
totalIndices += Geometries[i].Geometry.Indices.Count;
}
}
var tempVerts = new VertStruct[totalVertex];
var tempIndices = new int[totalIndices];
if (Geometries.Length > 50 && totalVertex > 5000)
{
var partitionParams = Partitioner.Create(0, Geometries.Length);
Parallel.ForEach(partitionParams, (range) =>
{
for (var i = range.Item1; i < range.Item2; ++i)
{
var geo = Geometries[i];
var transform = geo.ModelTransform;
var vertStart = vertRange[i];
OnFillVertArray(tempVerts, vertStart, ref geo, ref transform);
if (IndexBuffer != null && geo.Geometry.Indices != null)
{
//Fill Indices, make sure to correct the offset
var count = geo.Geometry.Indices.Count;
var tempIdx = idxRange[i];
for (var j = 0; j < count; ++j, ++tempIdx)
{
tempIndices[tempIdx] = geo.Geometry.Indices[j] + vertStart;
}
}
}
});
}
else
{
var vertOffset = 0;
var indexOffset = 0;
for (var i = 0; i < Geometries.Length; ++i)
{
var geo = Geometries[i];
var transform = geo.ModelTransform;
OnFillVertArray(tempVerts, vertOffset, ref geo, ref transform);
if (IndexBuffer != null && geo.Geometry.Indices != null)
{
//Fill Indices, make sure to correct the offset
var count = geo.Geometry.Indices.Count;
var tempIdx = indexOffset;
for (var j = 0; j < count; ++j, ++tempIdx)
{
tempIndices[tempIdx] = geo.Geometry.Indices[j] + vertOffset;
}
indexOffset += geo.Geometry.Indices.Count;
}
vertOffset += geo.Geometry.Positions.Count;
}
}
#if OutputBuildTime
time = System.Diagnostics.Stopwatch.GetTimestamp() - time;
Console.WriteLine($"Build Batch Time: {(float)time / System.Diagnostics.Stopwatch.Frequency * 1000} ms");
#endif
VertexBuffer[0].UploadDataToBuffer(deviceContext, tempVerts, tempVerts.Length);
IndexBuffer?.UploadDataToBuffer(deviceContext, tempIndices, tempIndices.Length);
vertexBufferBindings = new[] { new VertexBufferBinding(VertexBuffer[0].Buffer, VertexBuffer[0].StructureSize, VertexBuffer[0].Offset) };
}
public unsafe double ParallelizedUnsafeSimdUnrolled()
{
double delta = 0;
var sync = new object();
Partitioner<Tuple<int, int>> partitioner = Partitioner.Create(0, _values.Length);
#if SEQUENTIAL
var range = Tuple.Create(0, _values.Length);
#else
Parallel.ForEach(
partitioner,
range =>
{
#endif
double localDelta = 0;
double avg = this.Mean;
int n = range.Item2;
fixed (double* pArray = _values)
{
int i = range.Item1;
//double* arr = &pArray[i];
double* arr = pArray + i; // is the same as above
if (Vector.IsHardwareAccelerated && (n - i) >= Vector<double>.Count)
{
var avgVec = new Vector<double>(avg);
var deltaVec = new Vector<double>(0);
for (; i < n - 8 * Vector<double>.Count; i += 8 * Vector<double>.Count)
{
Core(arr, 0 * Vector<double>.Count, avgVec, ref deltaVec);
Core(arr, 1 * Vector<double>.Count, avgVec, ref deltaVec);
Core(arr, 2 * Vector<double>.Count, avgVec, ref deltaVec);
Core(arr, 3 * Vector<double>.Count, avgVec, ref deltaVec);
Core(arr, 4 * Vector<double>.Count, avgVec, ref deltaVec);
Core(arr, 5 * Vector<double>.Count, avgVec, ref deltaVec);
Core(arr, 6 * Vector<double>.Count, avgVec, ref deltaVec);
Core(arr, 7 * Vector<double>.Count, avgVec, ref deltaVec);
arr += 8 * Vector<double>.Count;
}
if (i < n - 4 * Vector<double>.Count)
{
Core(arr, 0 * Vector<double>.Count, avgVec, ref deltaVec);
Core(arr, 1 * Vector<double>.Count, avgVec, ref deltaVec);
Core(arr, 2 * Vector<double>.Count, avgVec, ref deltaVec);
Core(arr, 3 * Vector<double>.Count, avgVec, ref deltaVec);
arr += 4 * Vector<double>.Count;
i += 4 * Vector<double>.Count;
}
if (i < n - 2 * Vector<double>.Count)
{
Core(arr, 0 * Vector<double>.Count, avgVec, ref deltaVec);
Core(arr, 1 * Vector<double>.Count, avgVec, ref deltaVec);
arr += 2 * Vector<double>.Count;
i += 2 * Vector<double>.Count;
}
if (i < n - Vector<double>.Count)
{
Core(arr, 0 * Vector<double>.Count, avgVec, ref deltaVec);
i += Vector<double>.Count;
}
for (int j = 0; j < Vector<double>.Count; ++j)
localDelta += deltaVec[j];
}
for (; i < n; ++i)
localDelta += Math.Abs(pArray[i] - avg);
}
lock (sync) delta += localDelta;
#if !SEQUENTIAL
}
);
#endif
return delta / _values.Length;
//-----------------------------------------------------------------
void Core(double* arr, int offset, Vector<double> avgVec, ref Vector<double> deltaVec)
{
Vector<double> vec = VectorHelper.GetVectorUnaligned(arr + offset);
deltaVec += Vector.Abs(vec - avgVec);
}
}
