public virtual InstructionGraph Clone(
out IDictionary instructionMap,
out IDictionary valueMap)
{
InstructionGraph clone = new InstructionGraph();
instructionMap = new Hashtable();
valueMap = new Hashtable();
IList instructionNodes = GetInstructionNodes();
IList valueNodes = GetValueNodes();
foreach (InstructionNode instr in instructionNodes) {
InstructionNode cloneInstr = (InstructionNode) instr.Clone();
clone.AddNode(cloneInstr);
instructionMap[instr] = cloneInstr;
}
foreach (ValueNode val in valueNodes) {
ValueNode cloneVal = (ValueNode) val.Clone();
clone.AddNode(cloneVal);
valueMap[val] = cloneVal;
}
foreach (ValueNode val in inputValues)
clone.inputValues.Add(valueMap[val]);
foreach (ValueNode val in outputValues)
clone.outputValues.Add(valueMap[val]);
foreach (ValueNode val in valueNodes) {
if (val is RegisterValueNode) {
RegisterSet assignableRegs =
(RegisterSet) assignableRegisters[val];
clone.assignableRegisters[valueMap[val]] =
assignableRegs.Clone();
}
}
IDictionary valueProcessed = new Hashtable();
foreach (ValueNode val in valueNodes)
valueProcessed[val] = false;
foreach (ValueNode val in outputValues) {
CloneEdgesForValue(val, clone, instructionMap, valueMap,
valueProcessed);
}
foreach (ValueNode val in cyclicDependencies.Keys) {
clone.cyclicDependencies[valueMap[val]] =
valueMap[cyclicDependencies[val]];
}
return clone;
}
public virtual bool Optimize(
out InstructionGraph instructionGraph,
out RegisterAssignment registerAssignment,
out InstructionSchedule instructionSchedule)
{
return selector.Optimize(out instructionGraph,
out registerAssignment,
out instructionSchedule);
}
public virtual bool Optimize(
out InstructionGraph instructionGraph,
out RegisterAssignment registerAssignment,
out InstructionSchedule instructionSchedule)
{
Run();
if (Done != null)
Done(this);
if (BestGenome.IsValid) {
instructionGraph = BestGenome.InstructionGraph;
registerAssignment = BestGenome.RegisterAssignment;
instructionSchedule = BestGenome.InstructionSchedule;
return true;
} else {
instructionGraph = null;
instructionSchedule = null;
registerAssignment = null;
return false;
}
}
protected virtual void CloneEdgesForValue(
ValueNode val,
InstructionGraph clone,
IDictionary instructionMap,
IDictionary valueMap,
IDictionary valueProcessed)
{
if (!(bool) valueProcessed[val] && !val.IsInputValue()) {
valueProcessed[val] = true;
ValueNode cloneResValue = (ValueNode) valueMap[val];
InstructionNode cloneInstr =
(InstructionNode) instructionMap[val.ProducingInstruction];
clone.AddEdge(cloneInstr, cloneResValue);
foreach (ValueNode opVal in val.ProducingInstruction.OperandValues) {
ValueNode cloneOpVal = (ValueNode) valueMap[opVal];
clone.AddEdge(cloneOpVal, cloneInstr);
CloneEdgesForValue(opVal, clone, instructionMap, valueMap,
valueProcessed);
}
}
}
protected virtual void InitializeBase(
MachineDescription machineDescription,
InstructionGraph instructionGraph)
{
this.machineDescription = machineDescription;
this.instructionGraph = instructionGraph;
instructionNodes = instructionGraph.GetInstructionNodes();
instructionsOnExUnit =
new IList[machineDescription.ExecutionUnits];
for (int i = 0; i < machineDescription.ExecutionUnits; i++) {
instructionsOnExUnit[i] =
instructionGraph.GetInstructionNodesOnExUnit(i);
}
valueNodes = instructionGraph.GetValueNodes();
registerValues = new ArrayList();
foreach (ValueNode vNode in valueNodes) {
if (vNode is RegisterValueNode)
registerValues.Add(vNode);
}
}
public virtual void Initialize(
MachineDescription machineDescription,
InstructionGraph instructionGraph,
SchedulingGenome initGenome)
{
InitializeBase(machineDescription, instructionGraph);
InitializeDependencies();
population = new SchedulingGenomePopulation(
PopulationSize, this, initGenome, 1);
InitializePopulation();
InitializeGA();
bestObjectiveMonitor = new double[MonitoredGenerations];
if (Initialized != null)
Initialized(this);
}
public virtual void Initialize()
{
IDictionary valueInitialized = new Hashtable();
foreach (ValueNode val in ValueNodes)
valueInitialized[val] = false;
foreach (ValueNode val in ProgramGraph.OutputValues)
InitializeValue(val, valueInitialized);
instructionSchedule = null;
registerAssignment = null;
instructionGraph = null;
/*
bestSchedulingGenome = null;
*/
}
public virtual void Copy(IGenome otherGenome)
{
SelectionGenome other = (SelectionGenome) otherGenome;
population = other.population;
isValid = other.isValid;
modified = other.modified;
objective = other.objective;
if (other.instructionGraph != null) {
IDictionary instructionMap;
IDictionary valueMap;
instructionGraph =
other.instructionGraph.Clone(
out instructionMap, out valueMap);
if (other.registerAssignment != null &&
other.instructionSchedule != null) {
registerAssignment =
other.registerAssignment.Clone(valueMap);
instructionSchedule =
other.instructionSchedule.Clone(instructionMap);
/*
bestSchedulingGenome =
other.bestSchedulingGenome.Clone(
instructionMap, valueMap);
*/
} else {
registerAssignment = null;
instructionSchedule = null;
/*
bestSchedulingGenome = null;
*/
}
} else {
instructionGraph = null;
}
foreach (OperationNode op in OperationNodes)
selection[op] = other.selection[op];
}
public virtual void BuildInstructionGraph()
{
IDictionary valueProcessed = new Hashtable();
foreach (ValueNode val in ValueNodes)
valueProcessed[val] = false;
instructionGraph = new InstructionGraph();
IDictionary valueNodeMap = new Hashtable();
foreach (ValueNode val in ProgramGraph.GetValueNodes()) {
if (val.OutNodes.Count == 0) {
BuildInstructionGraphForValue(
val, valueProcessed, valueNodeMap);
}
}
foreach (ValueNode val in ProgramGraph.InputValues)
instructionGraph.InputValues.Add(valueNodeMap[val]);
foreach (ValueNode val in ProgramGraph.OutputValues)
instructionGraph.OutputValues.Add(valueNodeMap[val]);
ComputeAssignableRegisters();
foreach (ValueNode val in ProgramGraph.CyclicDependencies.Keys) {
ValueNode depVal = (ValueNode)
ProgramGraph.CyclicDependencies[val];
instructionGraph.CyclicDependencies[
valueNodeMap[val]] = valueNodeMap[depVal];
}
InsertCyclicTransferInstructions();
}
