/* Determine whether an instruction has an internal storage. This
* is used to determine if temporary storage has to be allocated in
* various places. If an instruction already has storage by itself
* (e.g. in the statetable) then temporary storage does not need to
* be allocated.
*
* If the language supports first class arrays, then temporary storage
* never needs to be allocated to store intermediate results. For other
* languages however, temporary storage needs to be allocated for
* anything that is multidimensional and does not have a representation
* in the statetable. A special case is a InstructionVariable which
* can optionally carry a slice. If there is such a slice and it is
* not continuous, then the instruction does not have internal storage.
*/
private bool InstructionHasStorage(Cdn.Instruction instruction, Context context)
{
if (context.SupportsFirstClassArrays)
{
return(true);
}
var v = instruction as Cdn.InstructionVariable;
if (v != null)
{
// Check for slice
if (!v.HasSlice)
{
return(true);
}
// Only needs storage if indices are not continuous
Cdn.Dimension dim;
return(!Context.IndicesAreContinuous(v.GetSlice(out dim)));
}
var i = instruction as Cdn.InstructionIndex;
if (i != null && i.IndexType == Cdn.InstructionIndexType.Offset)
{
return(true);
}
return(context.Program.StateTable.Contains(instruction));
}
public bool Equal(Cdn.Instruction i2, bool asstring)
{
bool raw_ret = cdn_instruction_equal(Handle, i2 == null ? IntPtr.Zero : i2.Handle, asstring);
bool ret = raw_ret;
return(ret);
}
private void Resolve(Node node, Cdn.Instruction instruction, HashSet <Cdn.Expression> seen, Dictionary <object, State> mapping)
{
InstructionVariable variable;
InstructionRand rand;
InstructionCustomOperator cusop;
InstructionCustomFunction cusfn;
if (As(instruction, out variable))
{
Resolve(node, variable.Variable, seen, mapping);
}
else if (As(instruction, out rand))
{
AddDependency(node, rand, null);
}
else if (As(instruction, out cusfn))
{
Resolve(node, cusfn.Function.Expression, seen, mapping);
}
else if (As(instruction, out cusop))
{
var fn = cusop.Operator.PrimaryFunction;
if (fn != null)
{
Resolve(node, fn.Expression, seen, mapping);
}
AddDependency(node, cusop, null);
}
}
public void Generate()
{
Profile.Do("load network", () => {
LoadNetwork();
});
if (Options.Instance.Validate)
{
d_validator = new Validator(d_network);
}
if (Options.Instance.DelayTimeStep > 0)
{
Cdn.Expression expr = new Cdn.Expression(Options.Instance.DelayTimeStep.ToString("R"));
Cdn.Instruction[] instr = new Cdn.Instruction[1];
instr[0] = new Cdn.InstructionNumber(Options.Instance.DelayTimeStep);
expr.Instructions = instr;
d_network.Integrator.AddVariable(new Cdn.Variable("delay_dt", expr, Cdn.VariableFlags.Out));
}
Profile.Do("initialize knowledge", () => {
// Initialize the knowledge
Knowledge.Initialize(d_network);
});
if (!Options.Instance.NoSparsity)
{
Profile.Do("sparsity", () => {
var sparsity = new Sparsity();
sparsity.Optimize();
});
}
var t = Profile.Begin("collect");
// Collect all the equations
Tree.Collectors.Result collection = Collect();
t.End();
t = Profile.Begin("filter");
// Filter conflicts and resolve final embeddings
Tree.Embedding[] embeddings = Filter(collection);
t.End();
t = Profile.Begin("resolve equations");
// Resolve final equations
Dictionary <State, Tree.Node> equations = ResolveEquations(embeddings);
t.End();
// Create program
t = Profile.Begin("create program");
Programmer.Program program = new Programmer.Program(ProgrammerOptions(), embeddings, equations);
t.End();
bool outistemp = false;
// Write program
if (Options.Instance.Validate || Options.Instance.Compile)
{
// Create a new temporary directory for the output files
string path = Path.GetTempFileName();
File.Delete(path);
Directory.CreateDirectory(path);
program.Options.Output = path;
outistemp = true;
}
else
{
Directory.CreateDirectory(program.Options.Output);
}
t = Profile.Begin("write program");
d_writtenFiles = Options.Instance.Formatter.Write(program);
t.End();
if (Options.Instance.PrintCompileSource)
{
foreach (string filename in d_writtenFiles)
{
Console.WriteLine("File: {0}", filename);
Console.WriteLine(File.ReadAllText(filename));
}
}
if (Options.Instance.Validate && !Options.Instance.PrintCompileSource)
{
try
{
d_validator.Validate(program, d_writtenFiles);
}
catch (Exception e)
{
Console.Error.WriteLine(e.Message);
Directory.Delete(program.Options.Output, true);
Environment.Exit(1);
}
}
else if (Options.Instance.Compile)
{
var files = Options.Instance.Formatter.Compile(Options.Instance.Verbose);
if (Options.Instance.Verbose)
{
Log.WriteLine("Compiled {0}...", String.Join(", ", Array.ConvertAll <string, string>(files, a => Path.GetFileName(a))));
}
if (!String.IsNullOrEmpty(Options.Instance.Output))
{
try
{
Directory.CreateDirectory(Options.Instance.Output);
}
catch
{
}
}
foreach (var f in files)
{
var dest = Path.GetFileName(f);
if (!String.IsNullOrEmpty(Options.Instance.Output))
{
dest = Path.Combine(Options.Instance.Output, dest);
}
try
{
File.Delete(dest);
} catch {}
File.Move(f, dest);
}
}
if (outistemp)
{
try
{
Directory.Delete(program.Options.Output, true);
} catch {};
}
}
public static ExpressionTreeIter NewFromInstructionTake(Cdn.Instruction instruction)
{
ExpressionTreeIter result = new ExpressionTreeIter(cdn_expression_tree_iter_new_from_instruction_take(instruction == null ? IntPtr.Zero : instruction.Handle));
return(result);
}
public ExpressionTreeIter(Cdn.Instruction instruction)
{
Raw = cdn_expression_tree_iter_new_from_instruction(instruction == null ? IntPtr.Zero : instruction.Handle);
}
public static bool IsPlaceholder(Cdn.Instruction instruction)
{
return(InstructionCode(instruction)[0] == PlaceholderCode);
}
