| public static PreIncrementAssign ( Expression expression ) : UnaryExpression | ||
| expression | Expression | An |
| return | UnaryExpression | |
public Expr ToExpression()
{
var exitLabel = Expr.Label();
var loopBody = Expr.Block(Body.ToExpression(), Expr.PreIncrementAssign(Iterator.ToExpression()));
return(Expr.Loop(Expr.IfThenElse(Expr.LessThan(Iterator.ToExpression(), UpperBound.ToExpression()), loopBody, Expr.Break(exitLabel)), exitLabel));
}
public void For(int Begin, int End, Action <LinqExpr> Body)
{
LinqExpr i = DeclInit <int>(AnonymousName(), Begin);
LinqExpr end = LinqExpr.Constant(End);
For(() => { },
LinqExpr.LessThan(i, end),
() => Add(LinqExpr.PreIncrementAssign(i)),
() => Body(i));
}
private UnaryExpression UnaryExpression(
ExpressionType nodeType, System.Type type, JObject obj)
{
var operand = this.Prop(obj, "operand", this.Expression);
var method = this.Prop(obj, "method", this.Method);
switch (nodeType)
{
case ExpressionType.ArrayLength: return(Expr.ArrayLength(operand));
case ExpressionType.Convert: return(Expr.Convert(operand, type, method));
case ExpressionType.ConvertChecked: return(Expr.ConvertChecked(operand, type, method));
case ExpressionType.Decrement: return(Expr.Decrement(operand, method));
case ExpressionType.Increment: return(Expr.Increment(operand, method));
case ExpressionType.IsFalse: return(Expr.IsFalse(operand, method));
case ExpressionType.IsTrue: return(Expr.IsTrue(operand, method));
case ExpressionType.Negate: return(Expr.Negate(operand, method));
case ExpressionType.NegateChecked: return(Expr.NegateChecked(operand, method));
case ExpressionType.Not: return(Expr.Not(operand, method));
case ExpressionType.OnesComplement: return(Expr.OnesComplement(operand, method));
case ExpressionType.PostDecrementAssign: return(Expr.PostDecrementAssign(operand, method));
case ExpressionType.PostIncrementAssign: return(Expr.PostIncrementAssign(operand, method));
case ExpressionType.PreDecrementAssign: return(Expr.PreDecrementAssign(operand, method));
case ExpressionType.PreIncrementAssign: return(Expr.PreIncrementAssign(operand, method));
case ExpressionType.Quote: return(Expr.Quote(operand));
case ExpressionType.Throw: return(Expr.Throw(operand, type));
case ExpressionType.TypeAs: return(Expr.TypeAs(operand, type));
case ExpressionType.UnaryPlus: return(Expr.UnaryPlus(operand, method));
case ExpressionType.Unbox: return(Expr.Unbox(operand, type));
default: throw new NotSupportedException();
}
}
public override Expr ToExpression()
{
var loopBody = new List <Expr>();
if (ReadExpression.Count > 0)
{
loopBody.Add(Expr.Assign(AccessExpression, ReadExpression[0]));
}
foreach (var child in Children)
{
loopBody.Add(child.ToExpression());
}
loopBody.Add(Expr.PreIncrementAssign(Iterator));
var loopExitLabel = Expr.Label();
var loopCode = Expr.Loop(Expr.IfThenElse(LoopCondition, Expr.Block(loopBody), Expr.Break(loopExitLabel)), loopExitLabel);
return(Expr.Block(new[] { Iterator }, IteratorInitializer, loopCode));
}
protected override object VisitIncrement(Increment A)
{
target.Add(LinqExpr.PreIncrementAssign(target.LookUp(A.Assign)));
return(null);
}
// The resulting lambda processes N samples, using buffers provided for Input and Output:
// void Process(int N, double t0, double T, double[] Input0 ..., double[] Output0 ...)
// { ... }
private Delegate DefineProcess()
{
// Map expressions to identifiers in the syntax tree.
List <KeyValuePair <Expression, LinqExpr> > inputs = new List <KeyValuePair <Expression, LinqExpr> >();
List <KeyValuePair <Expression, LinqExpr> > outputs = new List <KeyValuePair <Expression, LinqExpr> >();
// Lambda code generator.
CodeGen code = new CodeGen();
// Create parameters for the basic simulation info (N, t, Iterations).
ParamExpr SampleCount = code.Decl <int>(Scope.Parameter, "SampleCount");
ParamExpr t = code.Decl(Scope.Parameter, Simulation.t);
// Create buffer parameters for each input...
foreach (Expression i in Input)
{
inputs.Add(new KeyValuePair <Expression, LinqExpr>(i, code.Decl <double[]>(Scope.Parameter, i.ToString())));
}
// ... and output.
foreach (Expression i in Output)
{
outputs.Add(new KeyValuePair <Expression, LinqExpr>(i, code.Decl <double[]>(Scope.Parameter, i.ToString())));
}
// Create globals to store previous values of inputs.
foreach (Expression i in Input.Distinct())
{
AddGlobal(i.Evaluate(t_t0));
}
// Define lambda body.
// int Zero = 0
LinqExpr Zero = LinqExpr.Constant(0);
// double h = T / Oversample
LinqExpr h = LinqExpr.Constant(TimeStep / (double)Oversample);
// Load the globals to local variables and add them to the map.
foreach (KeyValuePair <Expression, GlobalExpr <double> > i in globals)
{
code.Add(LinqExpr.Assign(code.Decl(i.Key), i.Value));
}
foreach (KeyValuePair <Expression, LinqExpr> i in inputs)
{
code.Add(LinqExpr.Assign(code.Decl(i.Key), code[i.Key.Evaluate(t_t0)]));
}
// Create arrays for linear systems.
int M = Solution.Solutions.OfType <NewtonIteration>().Max(i => i.Equations.Count(), 0);
int N = Solution.Solutions.OfType <NewtonIteration>().Max(i => i.UnknownDeltas.Count(), 0) + 1;
LinqExpr JxF = code.DeclInit <double[][]>("JxF", LinqExpr.NewArrayBounds(typeof(double[]), LinqExpr.Constant(M)));
for (int j = 0; j < M; ++j)
{
code.Add(LinqExpr.Assign(LinqExpr.ArrayAccess(JxF, LinqExpr.Constant(j)), LinqExpr.NewArrayBounds(typeof(double), LinqExpr.Constant(N))));
}
// for (int n = 0; n < SampleCount; ++n)
ParamExpr n = code.Decl <int>("n");
code.For(
() => code.Add(LinqExpr.Assign(n, Zero)),
LinqExpr.LessThan(n, SampleCount),
() => code.Add(LinqExpr.PreIncrementAssign(n)),
() =>
{
// Prepare input samples for oversampling interpolation.
Dictionary <Expression, LinqExpr> dVi = new Dictionary <Expression, LinqExpr>();
foreach (Expression i in Input.Distinct())
{
LinqExpr Va = code[i];
// Sum all inputs with this key.
IEnumerable <LinqExpr> Vbs = inputs.Where(j => j.Key.Equals(i)).Select(j => j.Value);
LinqExpr Vb = LinqExpr.ArrayAccess(Vbs.First(), n);
foreach (LinqExpr j in Vbs.Skip(1))
{
Vb = LinqExpr.Add(Vb, LinqExpr.ArrayAccess(j, n));
}
// dVi = (Vb - Va) / Oversample
code.Add(LinqExpr.Assign(
Decl <double>(code, dVi, i, "d" + i.ToString().Replace("[t]", "")),
LinqExpr.Multiply(LinqExpr.Subtract(Vb, Va), LinqExpr.Constant(1.0 / (double)Oversample))));
}
// Prepare output sample accumulators for low pass filtering.
Dictionary <Expression, LinqExpr> Vo = new Dictionary <Expression, LinqExpr>();
foreach (Expression i in Output.Distinct())
{
code.Add(LinqExpr.Assign(
Decl <double>(code, Vo, i, i.ToString().Replace("[t]", "")),
LinqExpr.Constant(0.0)));
}
// int ov = Oversample;
// do { -- ov; } while(ov > 0)
ParamExpr ov = code.Decl <int>("ov");
code.Add(LinqExpr.Assign(ov, LinqExpr.Constant(Oversample)));
code.DoWhile(() =>
{
// t += h
code.Add(LinqExpr.AddAssign(t, h));
// Interpolate the input samples.
foreach (Expression i in Input.Distinct())
{
code.Add(LinqExpr.AddAssign(code[i], dVi[i]));
}
// Compile all of the SolutionSets in the solution.
foreach (SolutionSet ss in Solution.Solutions)
{
if (ss is LinearSolutions)
{
// Linear solutions are easy.
LinearSolutions S = (LinearSolutions)ss;
foreach (Arrow i in S.Solutions)
{
code.DeclInit(i.Left, i.Right);
}
}
else if (ss is NewtonIteration)
{
NewtonIteration S = (NewtonIteration)ss;
// Start with the initial guesses from the solution.
foreach (Arrow i in S.Guesses)
{
code.DeclInit(i.Left, i.Right);
}
// int it = iterations
LinqExpr it = code.ReDeclInit <int>("it", Iterations);
// do { ... --it } while(it > 0)
code.DoWhile((Break) =>
{
// Solve the un-solved system.
Solve(code, JxF, S.Equations, S.UnknownDeltas);
// Compile the pre-solved solutions.
if (S.KnownDeltas != null)
{
foreach (Arrow i in S.KnownDeltas)
{
code.DeclInit(i.Left, i.Right);
}
}
// bool done = true
LinqExpr done = code.ReDeclInit("done", true);
foreach (Expression i in S.Unknowns)
{
LinqExpr v = code[i];
LinqExpr dv = code[NewtonIteration.Delta(i)];
// done &= (|dv| < |v|*epsilon)
code.Add(LinqExpr.AndAssign(done, LinqExpr.LessThan(LinqExpr.Multiply(Abs(dv), LinqExpr.Constant(1e4)), LinqExpr.Add(Abs(v), LinqExpr.Constant(1e-6)))));
// v += dv
code.Add(LinqExpr.AddAssign(v, dv));
}
// if (done) break
code.Add(LinqExpr.IfThen(done, Break));
// --it;
code.Add(LinqExpr.PreDecrementAssign(it));
}, LinqExpr.GreaterThan(it, Zero));
//// bool failed = false
//LinqExpr failed = Decl(code, code, "failed", LinqExpr.Constant(false));
//for (int i = 0; i < eqs.Length; ++i)
// // failed |= |JxFi| > epsilon
// code.Add(LinqExpr.OrAssign(failed, LinqExpr.GreaterThan(Abs(eqs[i].ToExpression().Compile(map)), LinqExpr.Constant(1e-3))));
//code.Add(LinqExpr.IfThen(failed, ThrowSimulationDiverged(n)));
}
}
// Update the previous timestep variables.
foreach (SolutionSet S in Solution.Solutions)
{
foreach (Expression i in S.Unknowns.Where(i => globals.Keys.Contains(i.Evaluate(t_t0))))
{
code.Add(LinqExpr.Assign(code[i.Evaluate(t_t0)], code[i]));
}
}
// Vo += i
foreach (Expression i in Output.Distinct())
{
LinqExpr Voi = LinqExpr.Constant(0.0);
try
{
Voi = code.Compile(i);
}
catch (Exception Ex)
{
Log.WriteLine(MessageType.Warning, Ex.Message);
}
code.Add(LinqExpr.AddAssign(Vo[i], Voi));
}
// Vi_t0 = Vi
foreach (Expression i in Input.Distinct())
{
code.Add(LinqExpr.Assign(code[i.Evaluate(t_t0)], code[i]));
}
// --ov;
code.Add(LinqExpr.PreDecrementAssign(ov));
}, LinqExpr.GreaterThan(ov, Zero));
// Output[i][n] = Vo / Oversample
foreach (KeyValuePair <Expression, LinqExpr> i in outputs)
{
code.Add(LinqExpr.Assign(LinqExpr.ArrayAccess(i.Value, n), LinqExpr.Multiply(Vo[i.Key], LinqExpr.Constant(1.0 / (double)Oversample))));
}
// Every 256 samples, check for divergence.
if (Vo.Any())
{
code.Add(LinqExpr.IfThen(LinqExpr.Equal(LinqExpr.And(n, LinqExpr.Constant(0xFF)), Zero),
LinqExpr.Block(Vo.Select(i => LinqExpr.IfThenElse(IsNotReal(i.Value),
ThrowSimulationDiverged(n),
LinqExpr.Assign(i.Value, RoundDenormToZero(i.Value)))))));
}
});
// Copy the global state variables back to the globals.
foreach (KeyValuePair <Expression, GlobalExpr <double> > i in globals)
{
code.Add(LinqExpr.Assign(i.Value, code[i.Key]));
}
LinqExprs.LambdaExpression lambda = code.Build();
Delegate ret = lambda.Compile();
return(ret);
}
private static TDelegate Simdize <T, TDelegate>(LambdaExpression expr)
where T : unmanaged
where TDelegate : Delegate
{
if (_cache.TryGetValue(expr, out var value))
{
return((TDelegate)value);
}
var simdVisitor = new SimdVisitor <T>(expr);
var simdBody = simdVisitor.Visit(expr.Body);
var i = Expr.Parameter(typeof(int), "i");
var len = Expr.Parameter(typeof(int), "len");
var xMemories = expr.Parameters.Select(p => Expr.Parameter(typeof(ReadOnlyMemory <T>), p.Name)).ToArray();
var resultMemory = Expr.Parameter(typeof(Memory <T>), "result");
var xSpans = xMemories.Select(p => Expr.Variable(typeof(ReadOnlySpan <T>), $"{p.Name}Span")).ToArray();
var resultSpan = Expr.Variable(typeof(Span <T>), "resultSpan");
var xVecSpans = xMemories.Select(p => Expr.Variable(typeof(ReadOnlySpan <Vector <T> >), $"{p.Name}VecSpan")).ToArray();
var resultVecSpan = Expr.Variable(typeof(Span <Vector <T> >), "resultVecSpan");
var xSpanGetters = xSpans.Select(p => Expr.Call(null, MemberTable._ReadOnlySpan <T> .GetItem, p, i)).ToArray();
var xVecSpanGetters = xVecSpans.Select(p => Expr.Call(null, MemberTable._ReadOnlySpan <Vector <T> > .GetItem, p, i)).ToArray();
var exprCall = new LambdaArgsVisitor(expr.Parameters.Zip(xSpanGetters).ToDictionary(tpl => tpl.Item1, tpl => (Expr)tpl.Item2)).Visit(expr.Body);
var simdCall = new LambdaArgsVisitor(simdVisitor.NewArguments.Zip(xVecSpanGetters).ToDictionary(tpl => tpl.Item1, tpl => (Expr)tpl.Item2)).Visit(simdBody);
var resultSpanSetter = Expr.Call(null, MemberTable._Span <T> .SetItem, resultSpan, i, exprCall);
var resultVecSpanSetter = Expr.Call(null, MemberTable._Span <Vector <T> > .SetItem, resultVecSpan, i, simdCall);
var parameters = xMemories.Concat(new[] { resultMemory });
var variables = xSpans.Concat(xVecSpans).Concat(new[] { i, len, resultSpan, resultVecSpan });
var block = new List <Expr>();
// xSpan = xMemory.Span;
block.AddRange(xMemories.Zip(xSpans, (memory, span) =>
Expr.Assign(
span,
Expr.Property(memory, MemberTable._ReadOnlyMemory <T> .Span)
)
));
// xVecSpan = MemoryMarshal.Cast<T, Vector<T>>(xSpan);
block.AddRange(xSpans.Zip(xVecSpans, (span, vSpan) =>
Expr.Assign(
vSpan,
Expr.Call(null, MemberTable._MemoryMarshal.Cast <T, Vector <T> > .ForReadOnlySpan, span)
)
));
// resultSpan = resultMemory.Span;
block.Add(
Expr.Assign(
resultSpan,
Expr.Property(resultMemory, MemberTable._Memory <T> .Span)
)
);
// resultVecSpan = MemoryMarshal.Cast<T, Vector<T>>(resultSpan);
block.Add(
Expr.Assign(
resultVecSpan,
Expr.Call(null, MemberTable._MemoryMarshal.Cast <T, Vector <T> > .ForSpan, resultSpan)
)
);
// for(i = 0, len = resultVecSpan.Length & ~0b1111; i < len; )
// {
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x0
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x1
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x2
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x3
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x4
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x5
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x6
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x7
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x8
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x9
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0xA
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0xB
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0xC
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0xD
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0xE
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0xF
// }
block.Add(
ExpressionEx.For(
Expr.Block(
Expr.Assign(i, Expr.Constant(0)),
Expr.Assign(
len,
Expr.And(Expr.Property(resultVecSpan, MemberTable._Span <Vector <T> > .Length), Expr.Constant(~0b1111))
)
),
Expr.LessThan(i, len),
Expr.Empty(),
Expr.Block(
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0x0
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0x1
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0x2
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0x3
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0x4
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0x5
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0x6
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0x7
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0x8
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0x9
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0xA
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0xB
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0xC
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0xD
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0xE
resultVecSpanSetter, Expr.PreIncrementAssign(i) // 0xF
)
)
);
// if(i < (resultVecSpan.Length & ~0b111))
// {
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x0
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x1
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x2
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x3
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x4
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x5
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x6
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x7
// }
block.Add(
Expr.IfThen(
Expr.LessThan(
i,
Expr.And(Expr.Property(resultVecSpan, MemberTable._Span <Vector <T> > .Length), Expr.Constant(~0b111))
),
Expr.Block(
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0x0
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0x1
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0x2
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0x3
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0x4
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0x5
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0x6
resultVecSpanSetter, Expr.PreIncrementAssign(i) // 0x7
)
)
);
// if(i < (resultVecSpan.Length & ~0b11))
// {
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x0
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x1
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x2
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x3
// }
block.Add(
Expr.IfThen(
Expr.LessThan(
i,
Expr.And(Expr.Property(resultVecSpan, MemberTable._Span <Vector <T> > .Length), Expr.Constant(~0b11))
),
Expr.Block(
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0x0
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0x1
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0x2
resultVecSpanSetter, Expr.PreIncrementAssign(i) // 0x3
)
)
);
// if(i < (resultVecSpan.Length & ~0b1))
// {
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x0
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x1
// }
block.Add(
Expr.IfThen(
Expr.LessThan(
i,
Expr.And(Expr.Property(resultVecSpan, MemberTable._Span <Vector <T> > .Length), Expr.Constant(~0b1))
),
Expr.Block(
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0x0
resultVecSpanSetter, Expr.PreIncrementAssign(i) // 0x1
)
)
);
// if(i < resultVecSpan.Length)
// {
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x0
// }
block.Add(
Expr.IfThen(
Expr.LessThan(
i,
Expr.Property(resultVecSpan, MemberTable._Span <Vector <T> > .Length)
),
Expr.Block(
resultVecSpanSetter, Expr.PreIncrementAssign(i) // 0x0
)
)
);
// for(i = Vector<T>.Count * resultVecSpan.Length; i < resultSpan.Length; )
// {
// resultSpan[i] = exprCall(xSpan[i], ...); ++i;
// }
block.Add(
ExpressionEx.For(
Expr.Assign(
i,
Expr.Multiply(
Expr.Constant(Vector <T> .Count),
Expr.Property(resultVecSpan, MemberTable._Span <Vector <T> > .Length)
)
),
Expr.LessThan(i, Expr.Property(resultSpan, MemberTable._Span <T> .Length)),
Expr.Empty(),
Expr.Block(
resultSpanSetter, Expr.PreIncrementAssign(i)
)
)
);
var retval = Expr.Lambda <TDelegate>(Expr.Block(variables, block), parameters).Compile();
_cache.TryAdd(expr, retval);
return(retval);
}
