internal static void AssertThrows(ExpressionOptimizer optimizer, Expression original, Type exceptionType)
{
var res = optimizer.Visit(original);
Assert.AreEqual(ExpressionType.Throw, res.NodeType);
Assert.AreEqual(exceptionType, ((UnaryExpression)res).Operand.Type);
}
/// <summary>
/// 実際に実行する部分。
/// </summary>
protected virtual object ExecuteCore(TextReader stream, string filename)
{
Contract.Requires <ArgumentNullException>(stream != null);
Contract.Requires <ArgumentNullException>(filename != null);
Initialize();
Func <Scope, object> program;
{
// Compile
var sw = Stopwatch.StartNew();
var token = Tokenizer.Tokenize(stream, filename);
var ast = Parser.Parse(token, filename);
var expr = ExpressionGenerator.Generate(ast, this.Factory, filename);
expr = ExpressionOptimizer.Analyze(expr);
program = CompilerHelpers.Compile(expr, true);
//program = expr.Compile();
sw.Stop();
var ev = OnCompiled;
if (ev != null)
{
ev(this, new EngineEventArgs(sw.ElapsedMilliseconds));
}
}
{
// Execute
var sw = Stopwatch.StartNew();
var result = program(this.Global);
sw.Stop();
var ev = OnExecuted;
if (ev != null)
{
ev(this, new EngineEventArgs(sw.ElapsedMilliseconds));
}
return(result);
}
}
static void Main(string[] args)
{
var procElementsNumber = 4;
while (true)
{
Console.WriteLine("Enter expression:");
var expression = Console.ReadLine();
try {
var result = Parser.Parse(expression);
if (result == null)
{
Console.WriteLine("FAILED");
continue;
}
Console.WriteLine("OK");
Console.WriteLine($"Result : {result.Eval()}");
Console.WriteLine($"Height : {result.GetHeight()}");
result.Print();
Console.WriteLine("Optimized:");
var optimized = ExpressionOptimizer.Optimize(result);
Console.WriteLine($"Result : {optimized.Eval()}");
Console.WriteLine($"Height : {optimized.GetHeight()}");
optimized.Print();
Console.WriteLine("Data Flow:");
PrintHeader("SEQUENTIAL");
var sequentialSystem = DataFlowSystem.BuildSystem(optimized, 1);
DataFlowHelper.PrintSystem(sequentialSystem);
var sequentialSystemResult = sequentialSystem.Start();
DataFlowHelper.PrintSystemResult(sequentialSystemResult);
PrintHeader("PARALLEL");
var parallelSystem = DataFlowSystem.BuildSystem(optimized, procElementsNumber);
DataFlowHelper.PrintSystem(parallelSystem);
var parallelSystemResult = parallelSystem.Start();
DataFlowHelper.PrintSystemResult(parallelSystemResult);
Console.WriteLine();
var acceleration = (double)sequentialSystemResult.Ticks / parallelSystemResult.Ticks;
var efficient = (double)acceleration / procElementsNumber;
PrintHeader($"ACCELERATION: {acceleration}, EFFICIENT: {efficient}");
}
catch (Exception e) {
Console.WriteLine(e);
}
}
}
public void Optimize_Fails(string input, string expected)
{
ITokenizer tokenizer = new Tokenizer(input);
IParser parser = new Parser(tokenizer, _context);
IExpressionVisitor <IExpression> optimizer = new ExpressionOptimizer(_context);
IExpression parsedExpr = parser.Parse();
IExpression optimizedExpr = optimizer.Visit(parsedExpr);
string actual = optimizedExpr.ToString();
Assert.AreNotEqual(expected, actual);
}
public void NewArrayInit_AllConstant()
{
var o = new ExpressionOptimizer(new MetadataSemanticProvider {
PureMembers = PureMemberCatalog.All, ConstParameters = ConstParameterCatalog.All, ImmutableTypes = ImmutableTypeCatalog.All
}, new DefaultEvaluatorFactory());
var e =
Expression.Call(
typeof(Convert).GetMethod(nameof(Convert.ToBase64String), new[] { typeof(byte[]) }),
Expression.NewArrayInit(
typeof(byte),
Expression.Constant((byte)1, typeof(byte)),
Expression.Constant((byte)2, typeof(byte))
)
);
var r = o.Visit(e);
Assert.IsTrue(r is ConstantExpression c && c.Value is string s && s == Convert.ToBase64String(new byte[] { 1, 2 }));
}
public MathEBNFGrammarCompiler(IStartSymbol startSymbol)
: base(startSymbol)
{
this.optimizer = new ExpressionOptimizer(15);
}
internal static void AssertOptimized(ExpressionOptimizer optimizer, Expression original, Expression expected)
{
var res = optimizer.Visit(original);
AreEqual(expected, res);
}
public ExpressionOptimizerTests()
{
this.expressionOptimizer2 = new ExpressionOptimizer(15);
}
