/// <summary>
/// Construct the object, weighted problems.
/// </summary>
/// <param name="optimizer">Optimize to be used.</param>
/// <param name="weightedProblems">Array of weighted problems to be optimized.</param>
/// <param name="numRuns">Number of optimization runs per problem.</param>
/// <param name="maxIterations">Max number of optimization iterations.</param>
public MetaFitness(Optimizer optimizer, WeightedProblem[] weightedProblems, int numRuns, int maxIterations)
: base(maxIterations)
{
Optimizer = optimizer;
NumRuns = numRuns;
ProblemIndex = new ProblemIndex(weightedProblems);
}
private void command_BeforeExecute(Command source, Notation notation, Optimizer optimizer, QueryContext context)
{
this.context = context;
Notation.Record[] recs = notation.Select(Descriptor.Root, 1);
if (recs.Length > 0)
{
Notation.Record[] recsd = notation.Select(recs[0].Arg0, Descriptor.Binding, 1);
if (recsd.Length > 0)
throw new ESQLException("Query parameters is not supported in XQueryConsole", null);
}
if (context.UseSampleData)
{
String path = Path.Combine(
Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "Data");
if (Directory.Exists(path))
context.DatabaseDictionary.SearchPath = path;
}
}
public void ShouldThrowExceptionWhenFileNameIsEmpty()
{
Assert.Throws <ArgumentException>("fileName", () => Optimizer.Compress(string.Empty));
}
private static double evaluate(TorchTensor eval_data, TransformerModel model, Loss criterion, double lr, int bptt, int ntokens, Optimizer optimizer)
{
model.Eval();
var total_loss = 0.0f;
var src_mask = model.GenerateSquareSubsequentMask(bptt);
var batch = 0;
for (int i = 0; i < eval_data.shape[0] - 1; batch++, i += bptt)
{
var(data, targets) = GetBatch(eval_data, i, bptt);
if (data.shape[0] != bptt)
{
src_mask.Dispose();
src_mask = model.GenerateSquareSubsequentMask(data.shape[0]);
}
var output = model.forward(data, src_mask);
var loss = criterion(output.view(-1, ntokens), targets);
total_loss += data.shape[0] * loss.to(Device.CPU).DataItem <float>();
data.Dispose();
targets.Dispose();
GC.Collect();
}
return(total_loss / eval_data.shape[0]);
}
private Expression ReduceCore()
{
//
// First, check to see whether await expressions occur in forbidden places such as the body
// of a lock statement or a filter of a catch clause. This is done using a C# visitor so we
// can analyze the original (non-reduced) intent of the nodes.
//
AwaitChecker.Check(Body);
const int ExprCount = 1 /* new builder */ + 1 /* new state machine */ + 1 /* initial state */ + 1 /* start state machine */;
//
// Next, analyze what kind of async method builder we need by analyzing the return type of
// the async lambda. Based on this we will determine how many expressions we need in the
// rewritten top-level async method which sets up the builder, state machine, and kicks off
// the async logic.
//
var invokeMethod = typeof(TDelegate).GetMethod("Invoke");
var returnType = invokeMethod.ReturnType;
var builderType = default(Type);
var exprs = default(Expression[]);
if (returnType == typeof(void))
{
builderType = typeof(AsyncVoidMethodBuilder);
exprs = new Expression[ExprCount];
}
else if (returnType == typeof(Task))
{
builderType = typeof(AsyncTaskMethodBuilder);
exprs = new Expression[ExprCount + 1];
}
else
{
Debug.Assert(returnType.IsGenericType && returnType.GetGenericTypeDefinition() == typeof(Task <>));
builderType = typeof(AsyncTaskMethodBuilder <>).MakeGenericType(returnType.GetGenericArguments()[0]);
exprs = new Expression[ExprCount + 1];
}
var i = 0;
var builderVar = Expression.Parameter(builderType, "__builder");
var stateMachineVar = Expression.Parameter(typeof(RuntimeAsyncStateMachine), "__statemachine");
var stateVar = Expression.Parameter(typeof(int), "__state");
//
// __builder = ATMB.Create();
//
var builderCreateMethod = builderType.GetMethod("Create", BindingFlags.Public | BindingFlags.Static);
var createBuilder = Expression.Assign(builderVar, Expression.Call(builderCreateMethod));
exprs[i++] = createBuilder;
//
// This is where we rewrite the body of the async lambda into an Action delegate we can pass
// to the runtime async state machine. The collection of variables returned by the rewrite
// step will contain all the variables that need to be hoisted to the heap. We do this by
// simply declaring them in the scope around the rewritten (synchronous) body lambda, thus
// causing the lambda compiler to create a closure.
//
// Note we could take the rewritten body and the variables collection and construct a struct
// implementing IAsyncStateMachine here. However, we don't readily have access to a TypeBuilder
// for the dynamically generated method created by the lambda compiler higher up, so we'd
// have to go through some hoops here. For now, we'll rely on a delegate with a closure that
// consists of a set of StrongBox objects and gets passed to a RuntimeAsyncStateMachine. We
// can decide to optimize this using a struct later (but then it may be worth making closures
// in the lambda compiler a bit cheaper by creating a display class as well).
//
var body = RewriteBody(stateVar, builderVar, stateMachineVar, out IEnumerable <ParameterExpression> variables);
//
// __statemachine = new RuntimeAsyncStateMachine(body);
//
var stateMachineCtor = stateMachineVar.Type.GetConstructor(new[] { typeof(Action) });
var createStateMachine = Expression.Assign(stateMachineVar, Expression.New(stateMachineCtor, body));
exprs[i++] = createStateMachine;
//
// __state = -1;
//
exprs[i++] = Expression.Assign(stateVar, Helpers.CreateConstantInt32(-1));
//
// __builder.Start(ref __statemachine);
//
var startMethod = builderType.GetMethod("Start", BindingFlags.Public | BindingFlags.Instance);
exprs[i++] = Expression.Call(builderVar, startMethod.MakeGenericMethod(typeof(RuntimeAsyncStateMachine)), stateMachineVar);
//
// return __builder.Task;
//
if (returnType != typeof(void))
{
exprs[i] = Expression.Property(builderVar, "Task");
}
//
// The body of the top-level reduced method contains the setup and kick off of the state
// machine. Note the variables returned from the rewrite step of the body are included here
// in order to hoist them to the heap.
//
// REVIEW: Should we ensure all hoisted variables get assigned default values? This could
// matter if the resulting lambda gets inlined in an invocation expression and is
// invoked repeatedly, causing locals to be reused. Or should we assume definite
// assignment here (or enforce it)?
var rewritten = Expression.Block(new[] { builderVar, stateMachineVar, stateVar }.Concat(variables), exprs);
//
// Finally, run a fairly trivial optimizer to reduce excessively nested blocks that were
// introduced by the rewrite steps above. This is strictly optional and we could consider
// an optimization flag of LambdaExpression and AsyncLambdaCSharpExpression that's more
// generally useful (see ExpressionOptimizationExtensions for an early sketch of some of
// these optimizations).
//
var optimized = Optimizer.Optimize(rewritten);
//
// The result is a synchronous lambda that kicks off the async state machine and returns the
// resulting task (if non-void-returning).
//
var res = Expression.Lambda <TDelegate>(optimized, Parameters);
return(res);
}
public int PrepareToFit(FloatTensor input, FloatTensor target, Loss.Loss criterion, Optimizer optimizer, int batch_size)
{
if (input.Shape[0] != target.Shape[0])
{
throw new InvalidDataException("Input and Target tensors don't seem to have the right dims");
}
_input_tensor_origin = input;
_target_tensor_origin = target;
int[] input_buffer_shape = new int[input.Shape.Length];
input_buffer_shape[0] = batch_size;
for (int i = 1; i < input.Shape.Length; i++)
{
input_buffer_shape[i] = input.Shape[i];
}
input_buffer = controller.floatTensorFactory.Create(_shape: input_buffer_shape, _autograd: true);
int[] target_buffer_shape = new int[target.Shape.Length];
target_buffer_shape[0] = batch_size;
for (int i = 1; i < target.Shape.Length; i++)
{
target_buffer_shape[i] = target.Shape[i];
}
target_buffer = controller.floatTensorFactory.Create(_shape: target_buffer_shape, _autograd: true);
this._batch_size = batch_size;
this._criterion = criterion;
this._optimizer = optimizer;
this._input_batch_offset = batch_size;
for (int i = 1; i < input.Shape.Length; i++)
{
this._input_batch_offset *= input.Shape[i];
}
this._target_batch_offset = batch_size;
for (int i = 1; i < target.Shape.Length; i++)
{
this._target_batch_offset *= target.Shape[i];
}
return((int)(input.Shape[0] / batch_size));
}
/*
* URL : https://msdn.microsoft.com/en-us/library/system.reflection.emit.opcodes.Ldflda(v=vs.110).aspx
* Description : Finds the address of a field in the object whose reference is currently on the evaluation stack.
*/
internal override void Execute(Options Config, OpCodeType xOp, MethodBase method, Optimizer Optimizer)
{
if (Optimizer.vStack.Count < 1)
{
throw new Exception("Internal Compiler Error: vStack.Count < 1");
}
var field = ((OpField)xOp).Value;
var offset = Helper.GetFieldOffset(field.DeclaringType, field, Config.TargetPlatform);
/* The stack transitional behavior, in sequential order, is:
* An object reference (or pointer) is pushed onto the stack.
* The object reference (or pointer) is popped from the stack; the address of the specified field in the object is found.
* The address of the specified field is pushed onto the stack.
*/
var item = Optimizer.vStack.Pop();
switch (Config.TargetPlatform)
{
case Architecture.x86:
{
if (!item.SystemStack)
{
throw new Exception(string.Format("UnImplemented-RegisterType '{0}'", msIL));
}
new Add {
DestinationReg = Register.ESP, DestinationIndirect = true, SourceRef = "0x" + offset.ToString("X")
};
}
break;
default:
throw new Exception(string.Format("Unsupported target platform '{0}' for MSIL '{1}'", Config.TargetPlatform, msIL));
}
Optimizer.vStack.Push(new StackItem(typeof(uint)));
Optimizer.SaveStack(xOp.NextPosition);
}
/// <summary>
/// Construct the object.
/// </summary>
/// <param name="optimizer">Optimizer to use.</param>
/// <param name="numRuns">Number of optimization runs to perform.</param>
public RepeatMin(Optimizer optimizer, int numRuns)
: base(optimizer, numRuns)
{
}
/*
* URL : https://msdn.microsoft.com/en-us/library/system.reflection.emit.opcodes.Ldloc(v=vs.110).aspx
* Description : Loads the local variable at a specific index onto the evaluation stack.
*/
internal override void Execute(Options Config, OpCodeType xOp, MethodBase method, Optimizer Optimizer)
{
var index = ((OpVar)xOp).Value;
var body = method.GetMethodBody();
var EBPoffset = Helper.GetVariableOffset(body, index, Config.TargetPlatform);
var varType = body.LocalVariables[index].LocalType;
var size = Helper.GetTypeSize(varType, Config.TargetPlatform);
/* The stack transitional behavior, in sequential order, is:
* The local variable value at the specified index is pushed onto the stack.
*/
switch (Config.TargetPlatform)
{
case Architecture.x86:
{
if (size > 4)
{
throw new Exception("LocalVariable size > 4 not supported");
}
new Push {
DestinationReg = Register.EBP, DestinationIndirect = true, DestinationDisplacement = -EBPoffset
};
}
break;
default:
throw new Exception(string.Format("Unsupported target platform '{0}' for MSIL '{1}'", Config.TargetPlatform, msIL));
}
Optimizer.vStack.Push(new StackItem(varType));
Optimizer.SaveStack(xOp.NextPosition);
}
/*
* URL : https://msdn.microsoft.com/en-us/library/system.reflection.emit.opcodes.Stind_R4(v=vs.110).aspx
* Description : Stores a value of type float32 at a supplied address.
*/
internal override void Execute(Options Config, OpCodeType xOp, MethodBase method, Optimizer Optimizer)
{
if (Optimizer.vStack.Count < 2)
{
throw new Exception("Internal Compiler Error: vStack.Count < 2");
}
/* The stack transitional behavior, in sequential order, is:
* An address is pushed onto the stack.
* A value is pushed onto the stack.
* The value and the address are popped from the stack; the value is stored at the address.
*/
var itemA = Optimizer.vStack.Pop();
var itemB = Optimizer.vStack.Pop();
switch (Config.TargetPlatform)
{
case Architecture.x86:
{
if (!itemA.SystemStack)
{
throw new Exception(string.Format("UnImplemented-RegisterType '{0}'", msIL));
}
if (!itemB.SystemStack)
{
throw new Exception(string.Format("UnImplemented-RegisterType '{0}'", msIL));
}
Stind_I_il.Executex86(4);
}
break;
default:
throw new Exception(string.Format("Unsupported target platform '{0}' for MSIL '{1}'", Config.TargetPlatform, msIL));
}
Optimizer.SaveStack(xOp.NextPosition);
}
public void Fit(DataIter train_data, DataIter eval_data = null, string eval_metric = "acc",
IEpochEndCallback[] epoch_end_callback = null, IBatchEndCallback[] batch_end_callback = null,
string kvstore = "local",
Optimizer optimizer = null, Dictionary <string, object> optimizer_params = null,
IScoreEndCallback[] eval_end_callback = null,
IBatchEndCallback[] eval_batch_end_callback = null, Initializer initializer = null,
NDArrayDict arg_params = null,
NDArrayDict aux_params = null, bool allow_missing = false, bool force_rebind = false,
bool force_init = false, int begin_epoch = 0, int?num_epoch = null, EvalMetric validation_metric = null,
Monitor monitor = null, Func <DataBatch, NDArrayDict> sparse_row_id_fn = null)
{
object val;
object name;
if (optimizer == null)
{
optimizer = new SGD();
}
Debug.Assert(num_epoch != null, "please specify number of epochs");
this.Bind(data_shapes: train_data.ProvideData, label_shapes: train_data.ProvideLabel, for_training: true, force_rebind: force_rebind);
if (monitor != null)
{
this.InstallMonitor(monitor);
}
this.InitParams(initializer: initializer, arg_params: arg_params, aux_params: aux_params, allow_missing: allow_missing, force_init: force_init);
this.InitOptimizer(kvstore: kvstore, optimizer: optimizer, optimizer_params: optimizer_params);
if (validation_metric == null)
{
validation_metric = eval_metric;
}
var eval_metric_func = EvalMetric.Create(eval_metric, null);
//###############################################################################
// training loop
//###############################################################################
foreach (var epoch in Enumerable.Range(begin_epoch, num_epoch.Value - begin_epoch))
{
var tic = DateTime.Now;
eval_metric_func.Reset();
var nbatch = 0;
var data_iter = train_data;
var end_of_batch = false;
var next_data_batch = data_iter.Next();
Dictionary <string, float> eval_name_vals = new Dictionary <string, float>();
while (!end_of_batch)
{
var data_batch = next_data_batch;
if (monitor != null)
{
monitor.Tic();
}
this.ForwardBackward(data_batch);
this.Update();
UpdateMetric(eval_metric_func, data_batch.Label);
try
{
// pre fetch next batch
next_data_batch = data_iter.Next();
this.Prepare(next_data_batch, sparse_row_id_fn: sparse_row_id_fn);
}
catch (StopIteration)
{
end_of_batch = true;
}
if (monitor != null)
{
monitor.TocPrint();
}
if (end_of_batch)
{
eval_name_vals = eval_metric_func.GetGlobalNameValue();
}
if (batch_end_callback != null)
{
foreach (var callback in batch_end_callback)
{
callback.Invoke(epoch: epoch, nbatch: nbatch, eval_metric: eval_metric);
}
}
nbatch += 1;
}
// one epoch of training is finished
foreach (var item in eval_name_vals)
{
name = item.Key;
val = item.Value;
Logger.Info($"Epoch[{epoch}] Train-{name}={val}");
}
var toc = DateTime.Now;
Logger.Info($"Epoch[{epoch}] Time cost={(toc - tic).TotalSeconds}");
// sync aux params across devices
(arg_params, aux_params) = this.GetParams();
this.SetParams(arg_params, aux_params);
if (epoch_end_callback != null)
{
foreach (var callback in epoch_end_callback)
{
callback.Invoke(epoch, this.Symbol, arg_params, aux_params);
}
}
//----------------------------------------
// evaluation on validation set
if (eval_data != null)
{
var res = this.Score(eval_data, validation_metric, score_end_callback: eval_end_callback, batch_end_callback: eval_batch_end_callback, epoch: epoch);
//TODO: pull this into default
foreach (var item in res)
{
name = item.Key;
val = item.Value;
Logger.Info($"Epoch[{epoch}] Validation-{name}={val}");
}
}
// end of 1 epoch, reset the data-iter for another epoch
train_data.Reset();
}
}
/*
* URL : https://msdn.microsoft.com/en-us/library/system.reflection.emit.opcodes.Ldelem_Ref(v=vs.110).aspx
* Description : Loads the element containing an object reference at a specified array index onto the top of the evaluation stack as type O (object reference).
*/
internal override void Execute(Options Config, OpCodeType xOp, MethodBase method, Optimizer Optimizer)
{
if (Optimizer.vStack.Count < 2)
{
throw new Exception("Internal Compiler Error: vStack.Count < 2");
}
/* The stack transitional behavior, in sequential order, is:
* An object reference array is pushed onto the stack.
* An index value index is pushed onto the stack.
* index and array are popped from the stack; the value stored at position index in array is looked up.
* The value is pushed onto the stack.
*/
var itemA = Optimizer.vStack.Pop();
var itemB = Optimizer.vStack.Pop();
switch (Config.TargetPlatform)
{
case Architecture.x86:
{
if (!itemA.SystemStack)
{
throw new Exception(string.Format("UnImplemented-RegisterType '{0}'", msIL));
}
if (!itemB.SystemStack)
{
throw new Exception(string.Format("UnImplemented-RegisterType '{0}'", msIL));
}
Ldelem_il.Executex86(4, false);
Optimizer.vStack.Push(new StackItem(typeof(uint)));
Optimizer.SaveStack(xOp.NextPosition);
}
break;
default:
throw new Exception(string.Format("Unsupported target platform '{0}' for MSIL '{1}'", Config.TargetPlatform, msIL));
}
}
public CodeGenerator(
MethodSymbol method,
BoundStatement boundBody,
ILBuilder builder,
PEModuleBuilder moduleBuilder,
DiagnosticBag diagnostics,
OptimizationLevel optimizations,
bool emittingPdb)
{
Debug.Assert((object)method != null);
Debug.Assert(boundBody != null);
Debug.Assert(builder != null);
Debug.Assert(moduleBuilder != null);
Debug.Assert(diagnostics != null);
_method = method;
_boundBody = boundBody;
_builder = builder;
_module = moduleBuilder;
_diagnostics = diagnostics;
if (!method.GenerateDebugInfo)
{
// Always optimize synthesized methods that don't contain user code.
//
// Specifically, always optimize synthesized explicit interface implementation methods
// (aka bridge methods) with by-ref returns because peverify produces errors if we
// return a ref local (which the return local will be in such cases).
_ilEmitStyle = ILEmitStyle.Release;
}
else
{
if (optimizations == OptimizationLevel.Debug)
{
_ilEmitStyle = ILEmitStyle.Debug;
}
else
{
_ilEmitStyle = IsDebugPlus() ?
ILEmitStyle.DebugFriendlyRelease :
ILEmitStyle.Release;
}
}
// Emit sequence points unless
// - the PDBs are not being generated
// - debug information for the method is not generated since the method does not contain
// user code that can be stepped through, or changed during EnC.
//
// This setting only affects generating PDB sequence points, it shall not affect generated IL in any way.
_emitPdbSequencePoints = emittingPdb && method.GenerateDebugInfo;
try
{
_boundBody = Optimizer.Optimize(
boundBody,
debugFriendly: _ilEmitStyle != ILEmitStyle.Release,
stackLocals: out _stackLocals);
}
catch (BoundTreeVisitor.CancelledByStackGuardException ex)
{
ex.AddAnError(diagnostics);
_boundBody = boundBody;
}
_methodBodySyntaxOpt = (method as SourceMethodSymbol)?.BodySyntax;
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Optimizer obj) {
return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
}
protected override DbDataReader ExecuteDbDataReader(CommandBehavior behavior)
{
if (behavior != CommandBehavior.Default)
throw new NotSupportedException();
Notation notation = new Notation();
YYParser parser = new YYParser(notation);
object result = parser.yyparseSafe(new Tokenizer(_commandText));
QueryContext context = new QueryContext(DatabaseDictionary);
context.DatabaseDictionary.SearchPath = _searchPath;
Optimizer optimizer = new Optimizer(context);
optimizer.Process(notation);
QueryBinder binder = new QueryBinder();
binder.IsServerQuery = optimizer.IsServerQuery;
binder.Process(notation);
optimizer.PostProcess(notation);
if (BeforeExecute != null)
BeforeExecute(this, notation, optimizer, context);
Notation.Record[] recs = notation.Select(Descriptor.Root, 1);
Object[] raw_parameters = null;
if (recs.Length > 0)
{
Notation.Record[] recsd = notation.Select(recs[0].Arg0, Descriptor.Binding, 1);
if (recsd.Length > 0)
{
Symbol[] bindings = Lisp.ToArray<Symbol>(recsd[0].args[0]);
raw_parameters = new object[bindings.Length];
for (int k = 0; k < bindings.Length; k++)
{
recsd = notation.Select(bindings[k], Descriptor.Link, 1);
if (recsd.Length > 0)
{
DataEngine.Parameter p = (DataEngine.Parameter)recsd[0].Arg0;
raw_parameters[k] = _parameters[p.ParameterName].Value;
}
}
}
}
Translator translator = new Translator(context);
QueryNode rootNode = translator.Process(notation);
Resultset rs = rootNode.Get(context, raw_parameters);
optimizer.ProcessResults(rs);
return new DataReader(rs, context);
}
/// <summary>
/// Construct the object.
/// </summary>
/// <param name="optimizer">Optimizer to use.</param>
/// <param name="numRuns">Number of optimization runs.</param>
public Repeat(Optimizer optimizer, int numRuns)
: base()
{
Optimizer = optimizer;
NumRuns = numRuns;
}
public void ShouldThrowExceptionWhenFileIsNull()
{
Assert.Throws <ArgumentNullException>("file", () => Optimizer.Compress((FileInfo)null));
}
public abstract void InitOptimizer(string kvstore = "local", Optimizer optimizer = null,
Dictionary <string, object> optimizer_params = null, bool force_init = false);
public void OptimizerCombinators_ArgumentChecks()
{
AssertEx.ThrowsException <ArgumentNullException>(() => Optimizer.Then(first: null, Optimizer.Nop()), AssertParameterName("first"));
AssertEx.ThrowsException <ArgumentNullException>(() => Optimizer.Nop().Then(second: null), AssertParameterName("second"));
AssertEx.ThrowsException <ArgumentNullException>(() => Optimizer.FixedPoint(optimizer: null), AssertParameterName("optimizer"));
AssertEx.ThrowsException <ArgumentNullException>(() => Optimizer.FixedPoint(optimizer: null, throwOnCycle: true), AssertParameterName("optimizer"));
AssertEx.ThrowsException <ArgumentNullException>(() => Optimizer.FixedPoint(optimizer: null, throwOnCycle: true, maxIterations: 0), AssertParameterName("optimizer"));
AssertEx.ThrowsException <ArgumentOutOfRangeException>(() => Optimizer.Nop().FixedPoint(throwOnCycle: true, maxIterations: -1), AssertParameterName("maxIterations"));
}
// destination with hint in which direction to go
public Tuple <Point, Direction> GetDestination(Man man)
{
var enemies = MenOfRace(Enemy(man.Race)).ToArray();
{
var enimiesDistance = enemies.ToDictionary(e => e, e => e.Position.Distance(man.Position)).ToArray();
var minDistanceAsIs = enimiesDistance.Min(p => p.Value);
Assert.True(minDistanceAsIs > 0, "never enemies on the same position");
if (minDistanceAsIs == 1)
{
// we are in position to attack an enemy, no need to move
return(null);
}
}
// positions in range versus enemies
var inRange = enemies
.SelectMany(e => _map.Directions(e.Position).Select(e.Position.Go))
.ToHashSet()
.ToDictionary(p => p, p => p.Distance(man.Position))
.ToArray()
; // different enemies can have same in range positions
// it could happen that all enemies (ie the only one) are rounded from all sides
// in this way no way to go
if (!inRange.Any())
{
return(null);
}
// simplest strategy: select path with minimal distance
var minDistance = inRange.Min(p => p.Value);
if (minDistance == 0)
{
return(null); // no way to go
}
// more difficult task
var optimizer = new Optimizer(_map, man.Position);
var partialResult = new Dictionary <Point, int>();
int?curMinimalDistance = null;
foreach (var inRangePoint in inRange.OrderBy(p => p.Value))
{
// we try from by air shortest distance
if (curMinimalDistance.HasValue)
{
if (curMinimalDistance.Value < inRangePoint.Value)
{
// the distance already found is less then shortest candidate by air
// we may terminate
break;
}
}
var distance = optimizer.Distance(inRangePoint.Key);
if (distance.HasValue)
{
partialResult.Add(inRangePoint.Key, distance.Value);
curMinimalDistance = curMinimalDistance.HasValue
? Math.Min(curMinimalDistance.Value, distance.Value) : distance.Value;
}
}
if (!curMinimalDistance.HasValue)
{
// no way to connect two points
return(null);
}
var destinationList = partialResult.Where(p => p.Value == curMinimalDistance.Value).Select(p => p.Key);
var selectedDestination = destinationList.OrderBy(p => p.ReadingOrder).First();
var optimizer1 = new Optimizer(_map, selectedDestination);
var options = _map.Directions(man.Position)
.ToDictionary(d => d, d => man.Position.Go(d))
.OrderBy(p => p.Value.ReadingOrder)
.ToArray();
foreach (var o in options)
{
var distance = optimizer1.Distance(o.Value); // decreased distance due to the step ahead to the target
if (distance.HasValue)
{
if ((curMinimalDistance.Value - 1) == distance.Value)
{
// this is the correct direction and expected distance
return(Tuple.Create(selectedDestination, o.Key));
}
}
}
throw new Exception("unexpected processing of options");
}
/// <summary>
/// Call the Optimizer
/// </summary>
private void ShowOptimizer()
{
// Put the Strategy into the Undo Stack
Data.StackStrategy.Push(Data.Strategy.Clone());
var optimizer = new Optimizer {SetParrentForm = this};
optimizer.ShowDialog();
if (optimizer.DialogResult == DialogResult.OK)
{
// We accept the optimized strategy
Text = Path.GetFileNameWithoutExtension(Data.StrategyName) + "* - " + Data.ProgramName;
Data.IsStrategyChanged = true;
RepaintStrategyLayout();
Calculate(true);
}
else
{
// If we cancel the optimizing, we return the original strategy.
UndoStrategy();
}
Data.OptimizerStarts++;
}
/*
* URL : https://msdn.microsoft.com/en-us/library/system.reflection.emit.opcodes.Ldstr(v=vs.110).aspx
* Description : Pushes a new object reference to a string literal stored in the metadata.
*/
internal override void Execute(Options Config, OpCodeType xOp, MethodBase method, Optimizer Optimizer)
{
var str = ((OpString)xOp).Value;
/* The stack transitional behavior, in sequential order, is:
* An object reference to a string is pushed onto the stack.
*/
switch (Config.TargetPlatform)
{
case Architecture.x86:
{
new Push {
DestinationRef = Helper.GetResolvedStringLabel(str)
};
Optimizer.vStack.Push(new StackItem(typeof(string)));
Optimizer.SaveStack(xOp.NextPosition);
}
break;
default:
throw new Exception(string.Format("Unsupported target platform '{0}' for MSIL '{1}'", Config.TargetPlatform, msIL));
}
}
/*
* URL : https://msdn.microsoft.com/en-us/library/system.reflection.emit.opcodes.Blt_Un(v=vs.110).aspx
* Description : Transfers control to a target instruction if the first value is less than the second value, when comparing unsigned integer values or unordered float values.
*/
internal override void Execute(Options Config, OpCodeType xOp, MethodBase method, Optimizer Optimizer)
{
if (Optimizer.vStack.Count < 2)
{
throw new Exception("Internal Compiler Error: vStack.Count < 2");
}
var offset = ((OpBranch)xOp).Value;
var itemA = Optimizer.vStack.Pop();
var itemB = Optimizer.vStack.Pop();
var xTrueLabel = Helper.GetLabel(offset);
var size = Math.Max(Helper.GetTypeSize(itemA.OperandType, Config.TargetPlatform),
Helper.GetTypeSize(itemB.OperandType, Config.TargetPlatform));
/* The stack transitional behavior, in sequential order, is:
* value1 is pushed onto the stack.
* value2 is pushed onto the stack.
* value2 and value1 are popped from the stack; if value1 is less than value2, the branch operation is performed.
*/
switch (Config.TargetPlatform)
{
case Architecture.x86:
{
if (itemA.IsFloat || itemB.IsFloat || size > 4)
{
throw new Exception(string.Format("UnImplemented '{0}'", msIL));
}
if (!itemA.SystemStack || !itemB.SystemStack)
{
throw new Exception(string.Format("UnImplemented-RegisterType '{0}'", msIL));
}
new Pop {
DestinationReg = Register.EAX
};
new Pop {
DestinationReg = Register.EDX
};
new Cmp {
DestinationReg = Register.EDX, SourceReg = Register.EAX
};
new Jmp {
Condition = ConditionalJump.JB, DestinationRef = xTrueLabel
};
Optimizer.SaveStack(offset);
Optimizer.SaveStack(xOp.NextPosition);
}
break;
default:
throw new Exception(string.Format("Unsupported target platform '{0}' for MSIL '{1}'", Config.TargetPlatform, msIL));
}
}
public OptimizerStore(Optimizer optimizer, IStore store)
{
_optimizer = optimizer;
_store = store;
}
/*
* URL : https://msdn.microsoft.com/en-us/library/system.reflection.emit.opcodes.Ldarg(v=vs.110).aspx
* Description : Loads an argument (referenced by a specified index value) onto the stack.
*/
internal override void Execute(Options Config, OpCodeType xOp, MethodBase method, Optimizer Optimizer)
{
var index = ((OpVar)xOp).Value;
int EBPoffset = GetArgumentOffset(Config, method, index);
Type ArgType = null;
if (!method.IsStatic)
{
if (index == 0)
{
ArgType = method.DeclaringType;
if (method.DeclaringType.IsValueType)
{
ArgType = ArgType.MakeByRefType();
}
}
else
{
ArgType = method.GetParameters()[index - 1].ParameterType;
}
}
else
{
ArgType = method.GetParameters()[index].ParameterType;
}
int ArgSize = Helper.GetTypeSize(ArgType, Config.TargetPlatform);
/* The stack transitional behavior, in sequential order, is:
* The argument value at index is pushed onto the stack.
*/
switch (Config.TargetPlatform)
{
case Architecture.x86:
{
if (ArgSize > 4)
{
throw new Exception("Unsupported ArgSize");
}
new Push
{
DestinationReg = Register.EBP,
DestinationDisplacement = EBPoffset,
DestinationIndirect = true
};
}
break;
default:
throw new Exception(string.Format("Unsupported target platform '{0}' for MSIL '{1}'", Config.TargetPlatform, msIL));
}
Optimizer.vStack.Push(new StackItem(ArgType));
Optimizer.SaveStack(xOp.NextPosition);
}
public void ProcessMessages(IReadOnlyCollection <Replicator> messageReplicators, Optimizer optimizer)
{
foreach (var r in messageReplicators)
{
r.Process(false);
}
}
private static void train(int epoch, TorchTensor train_data, TransformerModel model, Loss criterion, int bptt, int ntokens, Optimizer optimizer)
{
model.Train();
var total_loss = 0.0f;
var src_mask = model.GenerateSquareSubsequentMask(bptt);
var batch = 0;
var log_interval = 200;
var tdlen = train_data.shape[0];
for (int i = 0; i < tdlen - 1; batch++, i += bptt)
{
var(data, targets) = GetBatch(train_data, i, bptt);
optimizer.zero_grad();
if (data.shape[0] != bptt)
{
src_mask.Dispose();
src_mask = model.GenerateSquareSubsequentMask(data.shape[0]);
}
var output = model.forward(data, src_mask);
var loss = criterion(output.view(-1, ntokens), targets);
{
loss.backward();
model.parameters().clip_grad_norm(0.5);
optimizer.step();
total_loss += loss.to(Device.CPU).DataItem <float>();
}
GC.Collect();
if (batch % log_interval == 0 && batch > 0)
{
var cur_loss = total_loss / log_interval;
Console.WriteLine($"epoch: {epoch} | batch: {batch} / {tdlen/bptt} | loss: {cur_loss:0.00}");
total_loss = 0;
}
}
}
public void ProcessFacts(IReadOnlyCollection <Replicator> factReplicators, IReadOnlyCollection <Replicator> aggregateReplicators, IReadOnlyCollection <Replicator> messageReplicators, Optimizer optimizer)
{
foreach (var r in factReplicators)
{
r.Process(false);
}
}
public void SetOptimizer(Optimizer se)
{
this.m_optimizer = se;
}
public void ProcessFacts(IReadOnlyCollection <Replicator> factReplicators, IReadOnlyCollection <Replicator> aggregateReplicators, IReadOnlyCollection <Replicator> messageReplicators, Optimizer optimizer)
{
foreach (var r in factReplicators)
{
r.Process(r.SkipCheckFunction.Invoke(optimizer.IsKnownEmpty));
}
}
protected virtual void TrainCore(IChannel ch, RoleMappedData data)
{
Host.AssertValue(ch);
ch.AssertValue(data);
// Compute the number of threads to use. The ctor should have verified that this will
// produce a positive value.
int numThreads = !UseThreads ? 1 : (NumThreads ?? Environment.ProcessorCount);
if (Host.ConcurrencyFactor > 0 && numThreads > Host.ConcurrencyFactor)
{
numThreads = Host.ConcurrencyFactor;
ch.Warning("The number of threads specified in trainer arguments is larger than the concurrency factor "
+ "setting of the environment. Using {0} training threads instead.", numThreads);
}
ch.Assert(numThreads > 0);
NumGoodRows = 0;
WeightSum = 0;
_features = null;
_labels = null;
_weights = null;
if (numThreads > 1)
{
ch.Info("LBFGS multi-threading will attempt to load dataset into memory. In case of out-of-memory " +
"issues, add 'numThreads=1' to the trainer arguments and 'cache=-' to the command line " +
"arguments to turn off multi-threading.");
_features = new VBuffer <float> [1000];
_labels = new float[1000];
if (data.Schema.Weight != null)
{
_weights = new float[1000];
}
}
var cursorFactory = new FloatLabelCursor.Factory(data, CursOpt.Features | CursOpt.Label | CursOpt.Weight);
long numBad;
// REVIEW: This pass seems overly expensive for the benefit when multi-threading is off....
using (var cursor = cursorFactory.Create())
using (var pch = Host.StartProgressChannel("LBFGS data prep"))
{
// REVIEW: maybe it makes sense for the factory to capture the good row count after
// the first successful cursoring?
Double totalCount = data.Data.GetRowCount(true) ?? Double.NaN;
long exCount = 0;
pch.SetHeader(new ProgressHeader(null, new[] { "examples" }),
e => e.SetProgress(0, exCount, totalCount));
while (cursor.MoveNext())
{
WeightSum += cursor.Weight;
if (ShowTrainingStats)
{
ProcessPriorDistribution(cursor.Label, cursor.Weight);
}
PreTrainingProcessInstance(cursor.Label, ref cursor.Features, cursor.Weight);
exCount++;
if (_features != null)
{
ch.Assert(cursor.KeptRowCount <= int.MaxValue);
int index = (int)cursor.KeptRowCount - 1;
Utils.EnsureSize(ref _features, index + 1);
Utils.EnsureSize(ref _labels, index + 1);
if (_weights != null)
{
Utils.EnsureSize(ref _weights, index + 1);
_weights[index] = cursor.Weight;
}
Utils.Swap(ref _features[index], ref cursor.Features);
_labels[index] = cursor.Label;
if (cursor.KeptRowCount >= int.MaxValue)
{
ch.Warning("Limiting data size for multi-threading");
break;
}
}
}
NumGoodRows = cursor.KeptRowCount;
numBad = cursor.SkippedRowCount;
}
ch.Check(NumGoodRows > 0, NoTrainingInstancesMessage);
if (numBad > 0)
{
ch.Warning("Skipped {0} instances with missing features/label/weight during training", numBad);
}
if (_features != null)
{
ch.Assert(numThreads > 1);
// If there are so many threads that each only gets a small number (less than 10) of instances, trim
// the number of threads so each gets a more reasonable number (100 or so). These numbers are pretty arbitrary,
// but avoid the possibility of having no instances on some threads.
if (numThreads > 1 && NumGoodRows / numThreads < 10)
{
int numNew = Math.Max(1, (int)NumGoodRows / 100);
ch.Warning("Too few instances to use {0} threads, decreasing to {1} thread(s)", numThreads, numNew);
numThreads = numNew;
}
ch.Assert(numThreads > 0);
// Divide up the instances among the threads.
_numChunks = numThreads;
_ranges = new int[_numChunks + 1];
int cinstTot = (int)NumGoodRows;
for (int ichk = 0, iinstMin = 0; ichk < numThreads; ichk++)
{
int cchkLeft = numThreads - ichk; // Number of chunks left to fill.
ch.Assert(0 < cchkLeft && cchkLeft <= numThreads);
int cinstThis = (cinstTot - iinstMin + cchkLeft - 1) / cchkLeft; // Size of this chunk.
ch.Assert(0 < cinstThis && cinstThis <= cinstTot - iinstMin);
iinstMin += cinstThis;
_ranges[ichk + 1] = iinstMin;
}
_localLosses = new float[numThreads];
_localGradients = new VBuffer <float> [numThreads - 1];
int size = BiasCount + WeightCount;
for (int i = 0; i < _localGradients.Length; i++)
{
_localGradients[i] = VBufferUtils.CreateEmpty <float>(size);
}
ch.Assert(_numChunks > 0 && _data == null);
}
else
{
// Streaming, single-threaded case.
_data = data;
_cursorFactory = cursorFactory;
ch.Assert(_numChunks == 0 && _data != null);
}
VBuffer <float> initWeights;
ITerminationCriterion terminationCriterion;
Optimizer opt = InitializeOptimizer(ch, cursorFactory, out initWeights, out terminationCriterion);
opt.Quiet = Quiet;
float loss;
try
{
opt.Minimize(DifferentiableFunction, ref initWeights, terminationCriterion, ref CurrentWeights, out loss);
}
catch (Optimizer.PrematureConvergenceException e)
{
if (!Quiet)
{
ch.Warning("Premature convergence occurred. The OptimizationTolerance may be set too small. {0}", e.Message);
}
CurrentWeights = e.State.X;
loss = e.State.Value;
}
ch.Assert(CurrentWeights.Length == BiasCount + WeightCount);
int numParams = BiasCount;
if ((L1Weight > 0 && !Quiet) || ShowTrainingStats)
{
VBufferUtils.ForEachDefined(ref CurrentWeights, (index, value) => { if (index >= BiasCount && value != 0)
{
numParams++;
}
});
if (L1Weight > 0 && !Quiet)
{
ch.Info("L1 regularization selected {0} of {1} weights.", numParams, BiasCount + WeightCount);
}
}
if (ShowTrainingStats)
{
ComputeTrainingStatistics(ch, cursorFactory, loss, numParams);
}
}
public void ProcessMessages(IReadOnlyCollection <Replicator> messageReplicators, Optimizer optimizer)
{
var skipMessageReplicators = messageReplicators.Where(x => x.SkipCheckFunction.Invoke(optimizer.IsKnownEmpty)).ToList();
foreach (var r in messageReplicators.Except(skipMessageReplicators))
{
r.Process(false);
}
}
public void ShouldThrowExceptionWhenStreamIsNull()
{
Assert.Throws <ArgumentNullException>("stream", () => Optimizer.Compress((Stream)null));
}
public void ProcessFacts(IReadOnlyCollection <Replicator> factReplicators, IReadOnlyCollection <Replicator> aggregateReplicators, IReadOnlyCollection <Replicator> messageReplicators, Optimizer optimizer)
{
var skipFactReplicators = factReplicators.Where(x => x.SkipCheckFunction.Invoke(optimizer.IsKnownEmpty)).ToList();
foreach (var r in skipFactReplicators)
{
r.Process(true);
}
var skipAggregateReplicators = aggregateReplicators.Where(x => x.SkipCheckFunction.Invoke(optimizer.IsKnownEmpty)).ToList();
foreach (var r in skipAggregateReplicators)
{
r.Process(true);
}
var skipMessageReplicators = messageReplicators.Where(x => x.SkipCheckFunction.Invoke(optimizer.IsKnownEmpty)).ToList();
var actualAggregateTypes = new HashSet <Type>(messageReplicators.Except(skipMessageReplicators).SelectMany(x => x.Dependencies));
var inactualAggregateReplicators = aggregateReplicators.Where(x => !actualAggregateTypes.Contains(x.DataObjectType)).ToList();
var actualFactTypes = new HashSet <Type>(aggregateReplicators.Except(skipAggregateReplicators).Except(inactualAggregateReplicators).SelectMany(x => x.Dependencies));
var inactualFactReplicators = factReplicators.Where(x => !actualFactTypes.Contains(x.DataObjectType)).ToList();
foreach (var r in factReplicators.Except(skipFactReplicators).Except(inactualFactReplicators))
{
r.Process(false);
}
}
/*
* URL : https://msdn.microsoft.com/en-us/library/system.reflection.emit.opcodes.Newarr(v=vs.110).aspx
* Description : Pushes an object reference to a new zero-based, one-dimensional array whose elements are of a specific type onto the evaluation stack.
*/
internal override void Execute(Options Config, OpCodeType xOp, MethodBase method, Optimizer Optimizer)
{
if (Optimizer.vStack.Count < 1)
{
throw new Exception("Internal Compiler Error: vStack.Count < 1");
}
var type = ((OpType)xOp).Value;
var size = Helper.GetTypeSize(type, Config.TargetPlatform);
/* The stack transitional behavior, in sequential order, is:
* The number of elements in the array is pushed onto the stack.
* The number of elements is popped from the stack and the array is created.
* An object reference to the new array is pushed onto the stack.
*/
var item = Optimizer.vStack.Pop();
switch (Config.TargetPlatform)
{
case Architecture.x86:
{
if (!item.SystemStack)
{
throw new Exception(string.Format("UnImplemented-RegisterType '{0}'", msIL));
}
new Mov {
DestinationReg = Register.ESI, SourceReg = Register.ESP, SourceIndirect = true
};
new Mov {
DestinationReg = Register.EAX, SourceRef = "0x" + size.ToString()
};
new Mul {
DestinationReg = Register.ESI
};
new Add {
DestinationReg = Register.EAX, SourceRef = "0x10"
};
new Push {
DestinationReg = Register.EAX
};
new Call {
DestinationRef = Helper.Heap_Label, IsLabel = true
};
new Test {
DestinationReg = Register.ECX, SourceRef = "0xFFFFFFFF"
};
new Jmp {
Condition = ConditionalJump.JNZ, DestinationRef = xOp.HandlerRef
};
new Pop {
DestinationReg = Register.ESI
};
new Mov {
DestinationReg = Register.EAX, DestinationIndirect = true, SourceRef = "0x" + type.GetHashCode().ToString("X")
};
new Mov {
DestinationReg = Register.EAX, DestinationIndirect = true, DestinationDisplacement = 4, SourceRef = "0x2"
};
new Mov {
DestinationReg = Register.EAX, DestinationIndirect = true, DestinationDisplacement = 8, SourceReg = Register.ESI
};
new Mov {
DestinationReg = Register.EAX, DestinationIndirect = true, DestinationDisplacement = 12, SourceRef = "0x" + size.ToString("X")
};
new Push {
DestinationReg = Register.EAX
};
Optimizer.vStack.Push(new StackItem(typeof(Array)));
Optimizer.SaveStack(xOp.NextPosition);
}
break;
default:
throw new Exception(string.Format("Unsupported target platform '{0}' for MSIL '{1}'", Config.TargetPlatform, msIL));
}
}
/// <summary>
/// Construct the object, un-weighted problems.
/// </summary>
/// <param name="optimizer">Optimize to be used.</param>
/// <param name="problems">Array of problems to be optimized.</param>
/// <param name="numRuns">Number of optimization runs per problem.</param>
/// <param name="maxIterations">Max number of optimization iterations.</param>
public MetaFitness(Optimizer optimizer, Problem[] problems, int numRuns, int maxIterations)
: base(optimizer, problems, numRuns, maxIterations)
{
}
public void SetOptimizer(Optimizer se)
{
this._optimizer = se;
}
private void StartOptimize()
{
uiWeeklyData_superGridControlTable.PrimaryGrid.DataSource = null;
var optimizer = new Optimizer(_strategy, OptimizationParameters.Instance.Parameters, uiStrategy_dateTimeAdvOISStart.Value, uiStrategy_dateTimeAdvOISEnd.Value);
optimizer.ProgressEvent += OptimizeProgressIncrement;
optimizer.StartOptimize(uiSummary_dataGridViewBT, uiBTSummaryChart, uiBTSummaryGroupPanel);
Invoke((Action)delegate
{
Report("In Sample/Out Of Sample procedure completed.", InformerMessageType.Success);
uiStrategy_buttonXStart.Enabled = true;
uiStrategy_buttonXStop.Enabled = false;
});
}
public IReadOnlyCollection <Version.ValidationResult> Execute(long orderId, ICheckModeDescriptor checkModeDescriptor)
{
// todo: можно использовать checkModeDescriptor для дальнейшей оптимизации
var optimization = new Optimizer();
Func <IStore, IStore> wrap = store => new OptimizerStore(optimization, store);
using (Probe.Create("Execute"))
using (var erm = new HashSetStoreFactory())
using (var store = new PersistentTableStoreFactory(_lockManager, _schemaManager))
using (var messages = new HashSetStoreFactory())
{
IReadOnlyCollection <Replicator> factReplicators;
IReadOnlyCollection <Replicator> aggregateReplicators;
IReadOnlyCollection <Replicator> messageReplicators;
using (Probe.Create("Initialization"))
{
factReplicators = CreateReplicators(_factAccessorTypes, erm.CreateQuery(), wrap(store.CreateStore()));
aggregateReplicators = CreateReplicators(_aggregateAccessorTypes, store.CreateQuery(), wrap(store.CreateStore()));
messageReplicators = CreateReplicators(_messageAccessorTypes, store.CreateQuery(), wrap(messages.CreateStore()))
.Where(x => x.DataObjectType == typeof(Version.ValidationResult) && checkModeDescriptor.Rules.ContainsKey(x.Rule)).ToArray();
var predicates = factReplicators.Concat(aggregateReplicators).Concat(messageReplicators).SelectMany(x => x.DependencyPredicates);
optimization.PrepareToUse(predicates.Distinct());
}
ErmDataLoader.ResolvedOrderSummary orderSummary;
using (Probe.Create("Erm -> Erm slice"))
{
ReadErmSlice(orderId, wrap(erm.CreateStore()), out orderSummary);
}
using (Probe.Create("Rulesets -> Facts"))
{
ReadRulesetsSlice(orderSummary, wrap(store.CreateStore()));
}
using (Probe.Create("Erm slice -> Facts"))
{
_strategy.ProcessFacts(factReplicators, aggregateReplicators, messageReplicators, optimization);
}
using (Probe.Create("Facts -> Aggregates"))
{
_strategy.ProcessAggregates(aggregateReplicators, messageReplicators, optimization);
}
using (Probe.Create("Aggregates -> Messages"))
{
_strategy.ProcessMessages(messageReplicators, optimization);
}
var validationPeriodStart = GetValidationPeriodStart(erm.CreateQuery(), orderId, checkModeDescriptor);
using (Probe.Create("Query result"))
{
return(messages.CreateQuery()
.For <Version.ValidationResult>()
.Where(x => x.OrderId == orderId && checkModeDescriptor.Rules.Keys.Contains((MessageTypeCode)x.MessageType) && x.PeriodEnd >= validationPeriodStart)
.ToArray());
}
}
}
/// <summary>
/// Create an OptimizerWrapper-object.
/// </summary>
/// <remarks>
/// This is very similar to ProblemWrapper but C# does not allow
/// for multiple inheritance and we need this class to inherit from
/// Optimizer and therefore cannot make it inherit from ProblemWrapper
/// as well.
/// </remarks>
/// <param name="optimizer">Optimizer-object being wrapped.</param>
public OptimizerWrapper(Optimizer optimizer)
: base()
{
Optimizer = optimizer;
}
/// <summary>
/// Construct the object, weighted problems.
/// </summary>
/// <param name="optimizer">Optimize to be used.</param>
/// <param name="weightedProblems">Array of weighted problems to be optimized.</param>
/// <param name="numRuns">Number of optimization runs per problem.</param>
/// <param name="maxIterations">Max number of optimization iterations.</param>
public MetaFitness(Optimizer optimizer, WeightedProblem[] weightedProblems, int numRuns, int maxIterations)
: base(optimizer, weightedProblems, numRuns, maxIterations)
{
}
/*
* URL : https://msdn.microsoft.com/en-us/library/system.reflection.emit.opcodes.Shr_Un(v=vs.110).aspx
* Description : Shifts an unsigned integer value (in zeroes) to the right by a specified number of bits, pushing the result onto the evaluation stack.
*/
internal override void Execute(Options Config, OpCodeType xOp, MethodBase method, Optimizer Optimizer)
{
if (Optimizer.vStack.Count < 2)
{
throw new Exception("Internal Compiler Error: vStack.Count < 2");
}
var itemA = Optimizer.vStack.Pop();
var itemB = Optimizer.vStack.Pop();
var size = Math.Max(Helper.GetTypeSize(itemA.OperandType, Config.TargetPlatform),
Helper.GetTypeSize(itemB.OperandType, Config.TargetPlatform));
/* The stack transitional behavior, in sequential order, is:
* A value is pushed onto the stack.
* The amount of bits to be shifted is pushed onto the stack.
* The number of bits to be shifted and the value are popped from the stack; the value is shifted right by the specified number of bits.
* The result is pushed onto the stack.
*/
switch (Config.TargetPlatform)
{
case Architecture.x86:
{
if (itemA.IsFloat || itemB.IsFloat || size > 4)
{
throw new Exception(string.Format("UnImplemented '{0}'", msIL));
}
if (!itemA.SystemStack || !itemB.SystemStack)
{
throw new Exception(string.Format("UnImplemented-RegisterType '{0}'", msIL));
}
new Pop {
DestinationReg = Register.ECX
};
new Shr {
DestinationReg = Register.ESP, SourceReg = Register.CL, DestinationIndirect = true
};
Optimizer.vStack.Push(new StackItem(itemB.OperandType));
Optimizer.SaveStack(xOp.NextPosition);
}
break;
default:
throw new Exception(string.Format("Unsupported target platform '{0}' for MSIL '{1}'", Config.TargetPlatform, msIL));
}
}