Uses of Class
at.dms.kjc.flatgraph.FlatNode

Packages that use FlatNode

at.dms.kjc.cluster	The cluster backend for StreamIt generates a set of threads that can be executed on a cluster of networked computers or a SMP.
at.dms.kjc.common
at.dms.kjc.flatgraph	FlatNode basics
at.dms.kjc.raw
at.dms.kjc.rstream
at.dms.kjc.sir.lowering	Provides compiler passes that analyze or optimize the SIR, primarily within the code of each filter.
at.dms.kjc.spacedynamic

Uses of FlatNode in at.dms.kjc.cluster

Methods in at.dms.kjc.cluster that return FlatNode

static FlatNode	NodeEnumerator.getFlatNode(int nodeID) Get the FlatNode associated with a number.
static FlatNode	ClusterFusion.getLocalMaster(FlatNode node) Get node that the passed node was fused to.
static FlatNode	ClusterFusion.getMaster(FlatNode node) Get node that the passed node was fused to.

Methods in at.dms.kjc.cluster that return types with arguments of type FlatNode

static Set<FlatNode>

ClusterFusion.fusedWith(FlatNode node) Pass a Flatnode and get back a set of nodes that the passed node is fused with.

Methods in at.dms.kjc.cluster with parameters of type FlatNode

static void	DetectConst.detect(FlatNode node)
static Set<FlatNode>	ClusterFusion.fusedWith(FlatNode node) Pass a Flatnode and get back a set of nodes that the passed node is fused with.
static void	FlatIRToCluster.generateCode(FlatNode node) Code generation for a SIRFilter FlatNode.
static void	ClusterCode.generateCode(FlatNode topLevel) Generate and emit code for all nodes in FlatGraph
static void	ClusterCode.generateJoiner(FlatNode node) Generate and emit code for a joiner
static void	ClusterCode.generateSlidingWindow(FlatNode node, int n, int m)
static void	ClusterCode.generateSplitter(FlatNode node) Generate and emit code for a splitter.
static int	NodeEnumerator.getFlatNodeId(FlatNode f) Get the id number assigned to a FlatNode
static int	NodeEnumerator.getIdOffset(int nodeID, FlatNode[] arr) Get offset of node in array or -1 if not there.
static FlatNode	ClusterFusion.getLocalMaster(FlatNode node) Get node that the passed node was fused to.
static FlatNode	ClusterFusion.getMaster(FlatNode node) Get node that the passed node was fused to.
static String	ClusterFusion.getPartition(FlatNode node) Returns partition that should execute on.
static void	RegisterStreams.init(FlatNode top) Set up Tape objects for all non-0-weight edges and set up vectors of edges (including nulls for 0-weight edges) for all incoming and outgoing edges for all filters, splitters, and joiners in graph.
static void	NodeEnumerator.init(FlatNode top) Set up static data structures for NodeEnumerator
static boolean	ClusterFusion.isEliminated(FlatNode node) Has passed node been eliminated in favor of some other representative of fused region?
protected ClusterStaticStreamGraph	ClusterStreamGraph.new_StaticStreamGraph(StreamGraph sg, FlatNode realTop) Use in place of "new StaticStreamGraph" for subclassing.
void	ClusterFusion.visitNode(FlatNode node) Cluster partitioning.

Constructors in at.dms.kjc.cluster with parameters of type FlatNode

ClusterStaticStreamGraph(StreamGraph sg, FlatNode realTop)
create a static stream graph with realTop as the first node.

ClusterStreamGraph(FlatNode top)

Uses of FlatNode in at.dms.kjc.common

Methods in at.dms.kjc.common with parameters of type FlatNode

static void	RemoveUnusedVars.doit(FlatNode node) Remove dead variables from all code in .
static void	StructureIncludeFile.doit(SIRStructure[] structs, FlatNode toplevel) Create structures include file in current directory.
static void	StructureIncludeFile.doit(SIRStructure[] structs, FlatNode toplevel, String dir) Create structures include file in directory .
static int	RawUtil.getCount(HashMap counts, FlatNode node) get the execution Count of the previous node
static int	RawUtil.getCountPrev(HashMap counts, FlatNode prev, FlatNode node) get the execution count of the previous node
static CType	CommonUtils.getJoinerType(FlatNode joiner) Get the output type of a joiner in a Flatnode representation.
static CType	CommonUtils.getOutputType(FlatNode node) Get the output type of any FlatNode element (filter, splitter, joiner).
static double	RawUtil.getRRSplitterWeight(FlatNode prev, FlatNode node)
static HashSet<Serializable>	VariablesDefUse.getVars(FlatNode node)
static HashSet<Serializable>	VariablesUsed.getVars(FlatNode node, boolean countComplexAssignments) Return a hashset of all the variables that are used in flatnode, meaning all the variables that it is important to keep because they are not dead.
void	StructureIncludeFile.visitNode(FlatNode node) Don't even think of it! Only public to avoid using an inner class.
void	RemoveUnusedVars.visitNode(FlatNode node)

Uses of FlatNode in at.dms.kjc.flatgraph

Fields in at.dms.kjc.flatgraph declared as FlatNode

FlatNode[]	FlatNode.incoming The incoming edges of this FlatNode
protected FlatNode[]	StaticStreamGraph.inputs arrays representing the inputs and output of this ssg from top to bottom (left to right)...
protected FlatNode[]	StaticStreamGraph.outputs
FlatNode	GraphFlattener.top the toplevel, entry, FlatNode of the constructed Flat graph
protected FlatNode	StaticStreamGraph.topLevel the top level FlatNode Used in debugging from subclasses.

Fields in at.dms.kjc.flatgraph with type parameters of type FlatNode

protected LinkedList<FlatNode>	StaticStreamGraph.flatNodes
protected HashMap<FlatNode,Integer>	ScheduledStaticStreamGraph.initExecutionCounts
static LinkedList<FlatNode>	GraphFlattener.needsToBeSched Used by --sync (synch removal) to reschedule the flat graph
HashMap<FlatNode,StaticStreamGraph>	StreamGraph.parentMap map of flat nodes to parent ssg.
protected HashMap<FlatNode,Integer>	ScheduledStaticStreamGraph.steadyExecutionCounts

Methods in at.dms.kjc.flatgraph that return FlatNode

FlatNode[]	FlatNode.getEdges()
FlatNode	GraphFlattener.getFlatNode(SIROperator key) Given an SIROperator, key, return the FlatNode that was created to represent key, or null if one was not created.
FlatNode	StaticStreamGraph.getNext(FlatNode flatNode) given a dynamic sink for this SSG, get the node in the downstream SSG that it connects to
FlatNode	FlatWeight.getNode() Get the node at the end of the current edge.
FlatNode[]	StaticStreamGraph.getOutputs() get the dynamic outputs of this ssg *
FlatNode	StaticStreamGraph.getPrev(FlatNode flatNode) give a dynamic source for this SSG, get the node in the upstream SSG that it connects to
FlatNode	StaticStreamGraph.getTopLevel() get the top level flatnode of this SSG*

Methods in at.dms.kjc.flatgraph that return types with arguments of type FlatNode

HashMap<FlatNode,Integer>	ScheduledStaticStreamGraph.getExecutionCounts(boolean init) get the multiplicity map for the give stage as FlatNode -> int
HashMap<FlatNode,int[]>	ScheduledStaticStreamGraph.getFlatNodeExecutions(boolean init) get the multiplicity map for a given stage as FlatNode -> int[]
List<FlatNode>	StaticStreamGraph.getFlatNodes() return a list of the flatnodes of this SSG *
Map<FlatNode,StaticStreamGraph>	StaticStreamGraph.getParentMap() returns a map of flatnodes to this SSG, so that others can remember the parent mapping of flat nodes.
static LinkedList<FlatNode>	WorkSorted.getSortedList(FlatNode top, WorkEstimate workEstimates)
static LinkedList<FlatNode>	DataFlowTraversal.getTraversal(FlatNode top) Starting at top, return a traversal of the graph where that guarantees that for each node n in the traversal, we have visited every node upstream of n.

Methods in at.dms.kjc.flatgraph with parameters of type FlatNode

void	FlatNode.addEdges(FlatNode to) Add a outgoing edge from this node to to.
static void	FlatNode.addEdges(FlatNode from, FlatNode to) Add an edge between from to to.
void	FlatNode.addEdgeTo(FlatNode to) Add an edge at this FlatNode to to.
void	FlatNode.addIncomingFrom(FlatNode from) Add an incoming edge at this node from from.
void	StaticStreamGraph.addNext(FlatNode node, FlatNode next) When constructing this SSG, add a new connection from node->next to the nexts hash map and add the
void	StaticStreamGraph.addPrev(FlatNode node, FlatNode source) When constructing this SSG, add a new connection from node->source to the prevs hash map and add node to the inputs array
void	DumpGraph.dumpGraph(FlatNode toplevel, String filename, HashMap<FlatNode,Integer> initExeCounts, HashMap<FlatNode,Integer> steadyExeCounts) Creates the dot file representing the flattened graph and stores it in filename.
void	DumpSymbolicGraph.dumpGraph(SIRStream str, FlatNode toplevel, String filename, HashMap<FlatNode,Integer> initExeCounts, HashMap<FlatNode,Integer> steadyExeCounts) Creates the output file representing the flattened graph and stores it in filename.
int	FlatNode.getIncomingWay(FlatNode prev) Return the index into the incoming weights and edges structures that holds the edge with source prev.
int	FlatNode.getIncomingWeight(FlatNode prev) return The incoming weight that is associated with the incoming edge that connects from prev.
int	StaticStreamGraph.getInputNum(FlatNode node) given an input, source, for this SSG, get the input number, index to inputs[] and inputSSGEdges[]
CType	StaticStreamGraph.getInputType(FlatNode node) get the input type for a node of this SSG, we want to use this because we set the input type of the head of this SSG to null, even though it may receive data over the dynamic network
static int	FlatNode.getItemsPushed(FlatNode from, FlatNode to) Return the number of items pushed from *from* to *to* on each iteration of *from*.
static CType	GraphFlattener.getJoinerType(FlatNode joiner) Return the data type of items that flow through joiner.
int	ScheduledStaticStreamGraph.getMult(FlatNode node, boolean init) get the multiplicity for
static int	GraphFlattener.getMult(FlatNode node, boolean init, HashMap<FlatNode,Integer> initExecutionCounts, HashMap<FlatNode,Integer> steadyExecutionCounts) Return the multiplicity of node in the schedule determined by init.
FlatNode	StaticStreamGraph.getNext(FlatNode flatNode) given a dynamic sink for this SSG, get the node in the downstream SSG that it connects to
int	StaticStreamGraph.getOutputNum(FlatNode node) given an output (sink) for this SSG, get the output number, index to outputs[] and outputSSGEdges[]
CType	StaticStreamGraph.getOutputType(FlatNode node) get the output type for
static CType	GraphFlattener.getOutputType(FlatNode node) Return the output type of the FlatNode node.
StaticStreamGraph	StreamGraph.getParentSSG(FlatNode node) get the parent SSG of
FlatNode	StaticStreamGraph.getPrev(FlatNode flatNode) give a dynamic source for this SSG, get the node in the upstream SSG that it connects to
static LinkedList<FlatNode>	WorkSorted.getSortedList(FlatNode top, WorkEstimate workEstimates)
static LinkedList<FlatNode>	DataFlowTraversal.getTraversal(FlatNode top) Starting at top, return a traversal of the graph where that guarantees that for each node n in the traversal, we have visited every node upstream of n.
int	FlatNode.getWay(FlatNode to) Return the index into the outgoing weights and edges structures that holds the edge to to.
int	FlatNode.getWeight(FlatNode to) Return the outgoing weight that is associated with the outgoing edge that points to to.
boolean	StaticStreamGraph.isInput(FlatNode node) is node a dynamic source for this SSG *
boolean	StaticStreamGraph.isOutput(FlatNode node) is node a dynamic sink for this SSG *
double	FlatNode.joiningRatio(FlatNode in) Return the ratio items that gets joined from the node in.
protected StaticStreamGraph	StreamGraph.new_StaticStreamGraph(StreamGraph sg, FlatNode realTop) Use in place of "new StaticStreamGraph" for subclassing.
protected ScheduledStaticStreamGraph	ScheduledStreamGraph.new_StaticStreamGraph(StreamGraph sg, FlatNode realTop) Use in place of "new StaticStreamGraph" for subclassing.
void	FlatNode.removeBackEdge(FlatNode from) Remove the incoming edge to this Flatnode from from.
void	FlatNode.removeForwardEdge(FlatNode to) Remove the outgoing edge to the Flatnode to.
void	FlatNode.setEdge(int offset, FlatNode newEdge) Set an edge in the outgoing edges.
void	FlatNode.setEdges(FlatNode[] edges) Replace all of the outgoing edges.
double	FlatNode.splittingRatio(FlatNode out) Return the ratio of itms that gets split to the node out.
void	WorkSorted.visitNode(FlatNode node)
void	FlatVisitor.visitNode(FlatNode node) The visitor must define this method that will be called once on each FlatNode that is down stream of the accepting node.
void	DumpSymbolicGraph.visitNode(FlatNode node) This function should not be called by the outside world.
void	DumpGraph.visitNode(FlatNode node) This function should not be called by the outside world.

Method parameters in at.dms.kjc.flatgraph with type arguments of type FlatNode

void	FlatNode.accept(FlatVisitor v, HashSet<FlatNode> set, boolean reset) Accept a FlatVisitor v, that will visit this node.
void	DumpGraph.dumpGraph(FlatNode toplevel, String filename, HashMap<FlatNode,Integer> initExeCounts, HashMap<FlatNode,Integer> steadyExeCounts) Creates the dot file representing the flattened graph and stores it in filename.
void	DumpGraph.dumpGraph(FlatNode toplevel, String filename, HashMap<FlatNode,Integer> initExeCounts, HashMap<FlatNode,Integer> steadyExeCounts) Creates the dot file representing the flattened graph and stores it in filename.
void	DumpSymbolicGraph.dumpGraph(SIRStream str, FlatNode toplevel, String filename, HashMap<FlatNode,Integer> initExeCounts, HashMap<FlatNode,Integer> steadyExeCounts) Creates the output file representing the flattened graph and stores it in filename.
void	DumpSymbolicGraph.dumpGraph(SIRStream str, FlatNode toplevel, String filename, HashMap<FlatNode,Integer> initExeCounts, HashMap<FlatNode,Integer> steadyExeCounts) Creates the output file representing the flattened graph and stores it in filename.
static int	GraphFlattener.getMult(FlatNode node, boolean init, HashMap<FlatNode,Integer> initExecutionCounts, HashMap<FlatNode,Integer> steadyExecutionCounts) Return the multiplicity of node in the schedule determined by init.
static int	GraphFlattener.getMult(FlatNode node, boolean init, HashMap<FlatNode,Integer> initExecutionCounts, HashMap<FlatNode,Integer> steadyExecutionCounts) Return the multiplicity of node in the schedule determined by init.

Constructors in at.dms.kjc.flatgraph with parameters of type FlatNode

FlatGraphToSIR(FlatNode top)
Create a new FlatGraphToSIR with top as the entry-point to the FlatGraph and construct an SIR graph from the flat graph.

ScheduledStaticStreamGraph(StreamGraph sg, FlatNode realTop)
create a static stream graph with realTop as the first node.

ScheduledStreamGraph(FlatNode top)

StaticStreamGraph(StreamGraph sg, FlatNode realTop)
create a static stream graph with realTop as the first node that the implicit splitter points to

StreamGraph(FlatNode top)
Create the static stream graph for the application that has

Constructor parameters in at.dms.kjc.flatgraph with type arguments of type FlatNode

FlatWeights(Vector<FlatNode> nodeEdges, int[] weights)
Set up data for later use by iterator.

Uses of FlatNode in at.dms.kjc.raw

Fields in at.dms.kjc.raw declared as FlatNode

FlatNode	SimulatorEvent.node
static FlatNode	NumberGathering.sink
FlatNode	Simulator.toplevel

Fields in at.dms.kjc.raw with type parameters of type FlatNode

static HashMap<FlatNode,HashSet>	JoinerSimulator.buffers
List<FlatNode>	SimulatorEvent.dests
static HashSet<FlatNode>	FileReaderVisitor.fileReaders
static HashMap<FlatNode,Integer>	RawBackend.initExecutionCounts
static HashMap<FlatNode,JoinerScheduleNode>	Simulator.initJoinerCode
static HashMap<FlatNode,Integer>	SimulationCounter.maxJoinerBufferSize
static HashMap<FlatNode,JoinerScheduleNode>	JoinerSimulator.schedules
static HashMap<FlatNode,Integer>	RawBackend.steadyExecutionCounts
static HashMap<FlatNode,JoinerScheduleNode>	Simulator.steadyJoinerCode
static HashSet<FlatNode>	JoinerRemoval.unnecessary

Methods in at.dms.kjc.raw that return FlatNode

FlatNode	SwitchScheduleNode.getDest(int i)
static FlatNode	Layout.getNode(Coordinate coord)

Methods in at.dms.kjc.raw that return types with arguments of type FlatNode

static HashSet<FlatNode>	Util.getAssignedEdges(FlatNode node)
static LinkedList<FlatNode>	DFTraversal.getDFTraversal(FlatNode top)
static HashSet<FlatNode>	Layout.getIdentities()
static HashSet<FlatNode>	Layout.getJoiners()
static LinkedList<FlatNode>	BreadthFirstTraversal.getTraversal(FlatNode top)

Methods in at.dms.kjc.raw with parameters of type FlatNode

void	SwitchScheduleNode.addDest(FlatNode to)
void	SimulationCounter.addJoinerReceiveBuffer(FlatNode node, String buffer)
static void	BlockExecutionCounts.calcBlockCounts(FlatNode top)
boolean	WorkBasedSimulator.canFire(FlatNode node, HashMap<FlatNode,Integer> executionCounts, SimulationCounter counters)
abstract boolean	Simulator.canFire(FlatNode node, HashMap<FlatNode,Integer> executionCounts, SimulationCounter counters)
boolean	FineGrainSimulator.canFire(FlatNode node, HashMap<FlatNode,Integer> executionCounts, SimulationCounter counters)
static void	JoinerSimulator.createJoinerSchedules(FlatNode top)
void	SimulationCounter.decrementArcCountOutgoing(FlatNode node, int way)
void	SimulationCounter.decrementBufferCount(FlatNode node, int val)
void	SimulationCounterPush.decrementCount(FlatNode node, int way)
void	SimulationCounterPop.decrementCount(FlatNode node, int inputN)
void	JoinerCounter.decrementCount(FlatNode node, int inputN)
void	SimulationCounter.decrementJoinerBufferCount(FlatNode node, String buf)
static void	SinkUnroller.doit(FlatNode top)
static void	RemoveGlobals.doit(FlatNode top)
static void	RawExecutionCode.doit(FlatNode top)
static boolean	RateMatch.doit(FlatNode top)
static boolean	NumberGathering.doit(FlatNode top)
static void	RemovePrintStatements.doIt(FlatNode top)
static boolean	NumberGathering.doit(FlatNode top, HashMap[] executionCounts)
static void	SwitchCode.generate(FlatNode top)
static void	TileCode.generateCode(FlatNode topLevel)
static void	FlatIRToC.generateCode(FlatNode node)
static void	MagicNetworkSchedule.generateSchedules(FlatNode top)
int	SimulationCounter.getArcCountOutgoing(FlatNode node, int way)
static HashSet<FlatNode>	Util.getAssignedEdges(FlatNode node)
static int	BlockExecutionCounts.getBlockCount(FlatNode node)
int	SimulationCounter.getBufferCount(FlatNode node)
int	SimulationCounterPush.getCount(FlatNode node, int way)
int	SimulationCounterPop.getCount(FlatNode node, int inputN)
int	JoinerCounter.getCount(FlatNode node, int inputN)
static int	Util.getCount(HashMap<FlatNode,Integer> counts, FlatNode node)
static int	Util.getCountPrev(HashMap<FlatNode,Integer> counts, FlatNode prev, FlatNode node)
static LinkedList<FlatNode>	DFTraversal.getDFTraversal(FlatNode top)
static HashSet<Object>	Util.getDirectDownstream(FlatNode node)
int	WorkEstimatesMap.getEstimate(FlatNode node)
int	EventHeap.getItemId(FlatNode node)
String	SimulationCounter.getJoinerBuffer(FlatNode node)
int	SimulationCounter.getJoinerBufferCount(FlatNode node, String buf)
String	SimulationCounter.getJoinerReceiveBuffer(FlatNode node)
static int	RawBackend.getMult(FlatNode node, boolean init)
static LinkedList<Coordinate>	Router.getRoute(FlatNode from, FlatNode to)
static double	Util.getRRSplitterWeight(FlatNode prev, FlatNode node)
static Coordinate	Layout.getTile(FlatNode str)
static int	Layout.getTileNumber(FlatNode node)
static LinkedList<FlatNode>	BreadthFirstTraversal.getTraversal(FlatNode top)
static void	Layout.handAssign(FlatNode node)
boolean	SimulationCounter.hasFired(FlatNode node)
void	SimulationCounter.incrementBufferCount(FlatNode node)
void	SimulationCounter.incrementJoinerBufferCount(FlatNode node, String buf)
void	SimulationCounter.incrementJoinerSchedule(FlatNode node)
static void	FileVisitor.init(FlatNode top)
static void	FileReaderVisitor.init(FlatNode top)
static boolean	Layout.isAssigned(FlatNode node)
static void	Router.printRoute(FlatNode from, FlatNode to, List route)
void	SimulationCounter.resetArcCountOutgoing(FlatNode node, int way)
void	SimulationCounterPush.resetCount(FlatNode node, int way)
void	SimulationCounterPop.resetCount(FlatNode node, int inputN)
void	JoinerCounter.resetCount(FlatNode node, int inputN)
static void	JoinerRemoval.run(FlatNode top)
void	SimulationCounter.setFired(FlatNode node)
static void	Layout.simAnnealAssign(FlatNode node)
void	WorkBasedSimulator.simulate(FlatNode top)
abstract void	Simulator.simulate(FlatNode top)
static SwitchScheduleNode	PushSimulator.simulate(FlatNode top)
static SwitchScheduleNode	PopSimulator.simulate(FlatNode top)
void	FineGrainSimulator.simulate(FlatNode top)
static boolean	IMEMEstimation.testMe(FlatNode top) Returns true iff all filters in fit in IMEM.
String	SwitchScheduleNode.toAssembly(FlatNode node, boolean send)
void	WorkEstimatesMap.visitNode(FlatNode node)
void	WorkBasedSimulator.visitNode(FlatNode node)
void	TileCode.visitNode(FlatNode node)
void	SinkUnroller.visitNode(FlatNode node)
void	RemovePrintStatements.visitNode(FlatNode node)
void	RemoveGlobals.visitNode(FlatNode node)
void	RawExecutionCode.visitNode(FlatNode node)
void	RateMatch.visitNode(FlatNode node)
void	Layout.visitNode(FlatNode node)
void	JoinerRemoval.visitNode(FlatNode node)
void	IMEMEstimation.visitNode(FlatNode node)
void	FineGrainSimulator.visitNode(FlatNode node)
void	FileVisitor.visitNode(FlatNode node)
void	FileReaderVisitor.visitNode(FlatNode node)
void	DFTraversal.visitNode(FlatNode node)
void	BlockExecutionCounts.visitNode(FlatNode node)

Method parameters in at.dms.kjc.raw with type arguments of type FlatNode

boolean	WorkBasedSimulator.canFire(FlatNode node, HashMap<FlatNode,Integer> executionCounts, SimulationCounter counters)
abstract boolean	Simulator.canFire(FlatNode node, HashMap<FlatNode,Integer> executionCounts, SimulationCounter counters)
boolean	FineGrainSimulator.canFire(FlatNode node, HashMap<FlatNode,Integer> executionCounts, SimulationCounter counters)
static int	Util.getCount(HashMap<FlatNode,Integer> counts, FlatNode node)
static int	Util.getCountPrev(HashMap<FlatNode,Integer> counts, FlatNode prev, FlatNode node)

Constructors in at.dms.kjc.raw with parameters of type FlatNode

SimulatorEvent(String type, int time, FlatNode node, List<FlatNode> dests, int itemID, boolean isLast)

WorkEstimatesMap(FlatNode top)

Constructor parameters in at.dms.kjc.raw with type arguments of type FlatNode

SimulationCounter(HashMap<FlatNode,JoinerScheduleNode> joinerSchedules)

SimulatorEvent(String type, int time, FlatNode node, List<FlatNode> dests, int itemID, boolean isLast)

Uses of FlatNode in at.dms.kjc.rstream

Fields in at.dms.kjc.rstream declared as FlatNode

protected FlatNode

FusionState.node the flatnode that this object represents

Fields in at.dms.kjc.rstream with type parameters of type FlatNode

protected static HashMap<FlatNode,FusionState>	FusionState.fusionState a hashmap of all fusionstates created so far, indexed by flatnode
static HashMap<FlatNode,Integer>	StrToRStream.initExecutionCounts
static HashMap<FlatNode,Integer>	StrToRStream.steadyExecutionCounts

Methods in at.dms.kjc.rstream that return FlatNode

FlatNode

FusionState.getNode() Return the FlatNode associated with this FusionState

Methods in at.dms.kjc.rstream with parameters of type FlatNode

static void	IDDoLoops.doit(FlatNode top) The entry point of this class, given a stream *top* and everything downstream of it, classify the for loop in each method of each filter as to whether they can be converted to do loops.
static void	RemoveDeadDoLoops.doit(FlatNode node, HashMap loops) Remove dead for loops and remove the header for loops that will execute exactly once.
static void	ExecutionCode.doit(FlatNode top, HashMap[] executionCounts) This static method creates the main function as described in the class comment.
static void	GenerateCCode.generate(FlatNode top) The entry point of the code generation pass.
int	SplitterFusionState.getBufferSize(FlatNode prev, boolean init) return the outgoing buffersize
int	JoinerFusionState.getBufferSize(FlatNode prev, boolean init) return the buffer size for the incoming buffer from *prev* to this node
abstract int	FusionState.getBufferSize(FlatNode prev, boolean init) get the size of the buffer from *prev* to this node
abstract int	FilterFusionState.getBufferSize(FlatNode prev, boolean init) return the incoming buffer size for this filter
int	FFSPeekBuffer.getBufferSize(FlatNode prev, boolean init) Deprecated.
int	FFSNoPeekBuffer.getBufferSize(FlatNode prev, boolean init) return the incoming buffer (pop buffer) size
JVariableDefinition	SplitterFusionState.getBufferVar(FlatNode prev, boolean init) return the outgoing buffer var for this splitter
JVariableDefinition	JoinerFusionState.getBufferVar(FlatNode node, boolean init) return the var def of the incoming (pop) buffer from *node* to this joiner
abstract JVariableDefinition	FusionState.getBufferVar(FlatNode prev, boolean init) Return the JVariableDefinition associated with the incoming buffer from *prev* to this node.
JVariableDefinition	FilterFusionState.getBufferVar(FlatNode prev, boolean init) return the buffer var representing the incoming buffer for this filter
static FusionState	FusionState.getFusionState(FlatNode node) Given FlatNode *node*, return the fusion state object representing it.
static int	Util.getItemsPushed(FlatNode from, FlatNode to) return the number of items pushed from *from* to *to* on each iteration of *from*.
static int	StrToRStream.getMult(FlatNode node, boolean init)
int	SplitterFusionState.getRemaining(FlatNode prev, boolean isInit) return the items remaining on the incoming buffer after the init stage
int	JoinerFusionState.getRemaining(FlatNode prev, boolean isInit) return the items remaining (after the init stage) on the incoming buffer from *prev* to this node.
abstract int	FusionState.getRemaining(FlatNode prev, boolean init) get the number of items remaining after the init stage on the incoming buffer from *prev* to this node
int	FilterFusionState.getRemaining(FlatNode prev, boolean isInit) return the number of items remaining on the pop buffer after this filter has fired in the initialization stage
void	RemoveDeadDoLoops.visitNode(FlatNode node)
void	IDDoLoops.visitNode(FlatNode node) Visit a flat node and iterate over all the methods if this is a filter flat node and check for do loops.

Constructors in at.dms.kjc.rstream with parameters of type FlatNode

FFSNoPeekBuffer(FlatNode fnode)
this will create both the init and the steady buffer

FFSPeekBuffer(FlatNode fnode)
Deprecated.

FilterFusionState(FlatNode fnode)
this will create both the init and the steady buffer

FusionState(FlatNode node)
create a new FusionState object that represents *node*, note one should never create fusionstates, they are created using getFusionState().

JoinerFusionState(FlatNode node)

SplitterFusionState(FlatNode node)

Uses of FlatNode in at.dms.kjc.sir.lowering

Methods in at.dms.kjc.sir.lowering with parameters of type FlatNode

void	BlockFlattener.visitNode(FlatNode node)

Uses of FlatNode in at.dms.kjc.spacedynamic

Fields in at.dms.kjc.spacedynamic declared as FlatNode

FlatNode	SimulatorEvent.node
protected FlatNode	Simulator.toplevel

Fields in at.dms.kjc.spacedynamic with type parameters of type FlatNode

HashMap<FlatNode,HashSet>	JoinerSimulator.buffers
protected HashMap<FlatNode,JoinerScheduleNode>	Simulator.currentJoinerCode the curent node in the joiner schedule we are working on
List<FlatNode>	SimulatorEvent.dests
HashSet<FlatNode>	NumberGathering.fileWriters the file writers of the application
HashMap<FlatNode,Integer>	NumberGathering.index holds the index of each filewriter
HashMap<FlatNode,JoinerScheduleNode>	Simulator.initJoinerCode FlatNode->JoinerScheduleNode, the receiving/sending schedule for the joiner for init
protected HashMap<FlatNode,JoinerScheduleNode>	Simulator.joinerCode the current joiner code we are working on (steady or init)
static HashMap<FlatNode,Integer>	SimulationCounter.maxJoinerBufferSize
static HashMap<FlatNode,JoinerScheduleNode>	JoinerSimulator.schedules
HashMap<FlatNode,Integer>	NumberGathering.skip holds the number of items each fw writes in init
HashMap<FlatNode,Integer>	NumberGathering.steady holds the number of items each fw writes in steady state
HashMap<FlatNode,JoinerScheduleNode>	Simulator.steadyJoinerCode FlatNode->JoinerScheduleNode, the receiving/sending schedule for the joiner for steady

Methods in at.dms.kjc.spacedynamic that return FlatNode

FlatNode	FileReaderDevice.getDest()
static FlatNode	Util.getFilterDownstreamAssigned(Layout layout, FlatNode node) Given a filter flatnode , return the closest downstream node that is assigned to a tile or ioport.
static FlatNode	Util.getFilterUpstreamAssigned(Layout layout, FlatNode node) Given a filter flatnode , return the closest upstream node that is assigned to a tile or ioport.
FlatNode	FileWriterDevice.getFlatNode()
FlatNode	FileReaderDevice.getFlatNode()
FlatNode	RateMatch.getNextNode()
FlatNode	Layout.getNode(RawTile tile) Return the flatNode assigned to this
static FlatNode[]	Util.getSendingSchedule(Layout layout, FlatNode node) Given a flatnode of a joiner or a filter that is mapped, get the schedule of mapped nodes that it pushes to (so disregard unmapped splitters and joiners).
FlatNode	CircularSchedule.next()

Methods in at.dms.kjc.spacedynamic that return types with arguments of type FlatNode

static HashSet<FlatNode>	Util.getAssignedEdges(Layout layout, FlatNode node)
static LinkedList<FlatNode>	DFTraversal.getDFTraversal(FlatNode top)
HashSet<FlatNode>	Layout.getIdentities()
HashSet<FlatNode>	Layout.getJoiners()
static LinkedList<FlatNode>	BreadthFirstTraversal.getTraversal(FlatNode top)

Methods in at.dms.kjc.spacedynamic with parameters of type FlatNode

void	WorkEstimatesMap.addEstimate(FlatNode node)
protected void	Simulator.addJoinerCode(FlatNode fire, JoinerScheduleNode code)
void	SimulationCounter.addJoinerReceiveBuffer(FlatNode node, String buffer)
static boolean	Layout.assignedJoiner(FlatNode node) Decide whether this joiner should be assigned to a tile.
static boolean	Layout.assignToAComputeNode(FlatNode node) Return true if this flatnode is or should be assigned to a compute node (a tile or a port)
static boolean	Layout.assignToATile(FlatNode node) return true if this flatnode is or should be assigned to tile *
boolean	WorkBasedSimulator.canFire(FlatNode node, HashMap<FlatNode,Integer> executionCounts, SimulationCounter counters)
abstract boolean	Simulator.canFire(FlatNode node, HashMap<FlatNode,Integer> executionCounts, SimulationCounter counters)
boolean	SimpleSimulator.canFire(FlatNode node, HashMap<FlatNode,Integer> executionCounts, SimulationCounter counters)
boolean	NoSimulator.canFire(FlatNode node, HashMap<FlatNode,Integer> executionCounts, SimulationCounter counters)
boolean	FineGrainSimulator.canFire(FlatNode node, HashMap<FlatNode,Integer> executionCounts, SimulationCounter counters)
static SpdStreamGraph	SpdStreamGraph.constructStreamGraph(FlatNode node) create a stream graph with only one filter (thus one SSG), it's not laid out yet.
protected int	Simulator.consumedItems(FlatNode fire, SimulationCounter counters, HashMap<FlatNode,Integer> executionCounts) return how many items a node consumes (pop's) for one firing given the current state of the simulation
void	SimulationCounter.decrementArcCountOutgoing(FlatNode node, int way)
void	SimulationCounter.decrementBufferCount(FlatNode node, int val)
void	SimulationCounterPush.decrementCount(FlatNode node, int way)
void	SimulationCounterPop.decrementCount(FlatNode node, int inputN)
void	JoinerCounter.decrementCount(FlatNode node, int inputN)
protected void	Simulator.decrementExecutionCounts(FlatNode fire, HashMap<FlatNode,Integer> executionCounts, SimulationCounter counters) Give that a node has just fired, update the simulation state
void	SimulationCounter.decrementJoinerBufferCount(FlatNode node, String buf)
static void	SinkUnroller.doit(FlatNode top)
static void	RemoveGlobals.doit(FlatNode top)
static void	RemovePrintStatements.doIt(FlatNode top)
static boolean	DirectCommunication.doit(SpdStaticStreamGraph SSG, FlatNode node) See if we can generate input communication channel code without using a buffer.
static void	ConvertLonelyReceives.doit(SpdStaticStreamGraph ssg, FlatNode node)
protected int	WorkBasedSimulator.fireJoiner(FlatNode fire, SimulationCounter counters, HashMap<FlatNode,Integer> executionCounts)
protected abstract int	Simulator.fireJoiner(FlatNode fire, SimulationCounter counters, HashMap<FlatNode,Integer> executionCounts) this method should fire a joiner, assuming the joiner can fire, and update the simulation state
protected int	SimpleSimulator.fireJoiner(FlatNode fire, SimulationCounter counters, HashMap<FlatNode,Integer> executionCounts)
protected int	NoSimulator.fireJoiner(FlatNode fire, SimulationCounter counters, HashMap<FlatNode,Integer> executionCounts)
protected int	FineGrainSimulator.fireJoiner(FlatNode fire, SimulationCounter counters, HashMap<FlatNode,Integer> executionCounts)
protected int	Simulator.fireMe(FlatNode fire, SimulationCounter counters, HashMap<FlatNode,Integer> executionCounts) consume the data and return the number of items produced
static void	FlatIRToC.generateCode(SpdStaticStreamGraph SSG, FlatNode node)
protected void	Simulator.generateSwitchCode(FlatNode fire, List<FlatNode> dests) generate the switch code for 1 data item given the list of destinations we do not want to duplicate items until neccessary, so we have to keep track of all the routes and then generate the switch code this way we can route multiple dests per route instruction
int	SimulationCounter.getArcCountOutgoing(FlatNode node, int way)
static HashSet<FlatNode>	Util.getAssignedEdges(Layout layout, FlatNode node)
int	SimulationCounter.getBufferCount(FlatNode node)
ComputeNode	Layout.getComputeNode(FlatNode node) return the compute node (tile or ioport) assigned to
int	SimulationCounterPush.getCount(FlatNode node, int way)
int	SimulationCounterPop.getCount(FlatNode node, int inputN)
int	JoinerCounter.getCount(FlatNode node, int inputN)
static int	Util.getCount(HashMap counts, FlatNode node)
static int	Util.getCountPrev(HashMap counts, FlatNode prev, FlatNode node)
static LinkedList<FlatNode>	DFTraversal.getDFTraversal(FlatNode top)
static HashSet<Object>	Util.getDirectDownstream(FlatNode node)
int	WorkEstimatesMap.getEstimate(FlatNode node)
FileWriterDevice	FileState.getFileWriterDevice(FlatNode fw) get the FileWriterDevice that implements this SIRFileWriter.
static FlatNode	Util.getFilterDownstreamAssigned(Layout layout, FlatNode node) Given a filter flatnode , return the closest downstream node that is assigned to a tile or ioport.
static FlatNode	Util.getFilterUpstreamAssigned(Layout layout, FlatNode node) Given a filter flatnode , return the closest upstream node that is assigned to a tile or ioport.
int	EventHeap.getItemId(FlatNode node)
static int	Util.getItemsProduced(FlatNode node) Return the number of items node produces during one firing during steady-state.
String	SimulationCounter.getJoinerBuffer(FlatNode node)
int	SimulationCounter.getJoinerBufferCount(FlatNode node, String buf)
String	SimulationCounter.getJoinerReceiveBuffer(FlatNode node)
static double	Util.getRRSplitterWeight(FlatNode prev, FlatNode node)
static FlatNode[]	Util.getSendingSchedule(Layout layout, FlatNode node) Given a flatnode of a joiner or a filter that is mapped, get the schedule of mapped nodes that it pushes to (so disregard unmapped splitters and joiners).
int	WorkEstimatesMap.getSteadyEstimate(FlatNode node) return the work estimate multiplied by the number of times the node executes in the steady state
RawTile	Layout.getTile(FlatNode str) Returns the tile number assignment for
int	Layout.getTileNumber(FlatNode node) Return the tile number for the
static LinkedList<FlatNode>	BreadthFirstTraversal.getTraversal(FlatNode top)
boolean	SimulationCounter.hasFired(FlatNode node)
void	SimulationCounter.incrementBufferCount(FlatNode node)
void	SimulationCounter.incrementJoinerBufferCount(FlatNode node, String buf)
void	SimulationCounter.incrementJoinerSchedule(FlatNode node)
boolean	Layout.isAssigned(FlatNode node)
protected int	Simulator.itemsNeededToFire(FlatNode fire, SimulationCounter counters, HashMap<FlatNode,Integer> executionCounts) given a node
protected SpdStaticStreamGraph	SpdStreamGraph.new_StaticStreamGraph(StreamGraph sg, FlatNode realTop) Use in place of "new StaticStreamGraph" for subclassing.
void	YXRouter.printRoute(FlatNode from, FlatNode to, List route)
void	SimulationCounter.resetArcCountOutgoing(FlatNode node, int way)
void	SimulationCounterPush.resetCount(FlatNode node, int way)
void	SimulationCounterPop.resetCount(FlatNode node, int inputN)
void	JoinerCounter.resetCount(FlatNode node, int inputN)
void	SimulationCounter.setFired(FlatNode node)
static boolean	IMEMEstimation.testMe(SpdStaticStreamGraph ssg, FlatNode top) Returns true iff all filters in
void	WorkEstimatesMap.visitNode(FlatNode node)
void	TileCode.visitNode(FlatNode node)
void	SinkUnroller.visitNode(FlatNode node)
void	RemovePrintStatements.visitNode(FlatNode node)
void	RemoveGlobals.visitNode(FlatNode node)
void	RawExecutionCode.visitNode(FlatNode node)
void	RateMatch.visitNode(FlatNode node) Visit each flatnode in the static stream graph and find the joiners.
void	Layout.visitNode(FlatNode node) visit each flatnode and decide whether is should be assigned *
void	IMEMEstimation.visitNode(FlatNode node)
void	FileState.visitNode(FlatNode node) If we have a file reader or writer, create the device and connect it to the raw chip
void	DFTraversal.visitNode(FlatNode node)

Method parameters in at.dms.kjc.spacedynamic with type arguments of type FlatNode

boolean	WorkBasedSimulator.canFire(FlatNode node, HashMap<FlatNode,Integer> executionCounts, SimulationCounter counters)
abstract boolean	Simulator.canFire(FlatNode node, HashMap<FlatNode,Integer> executionCounts, SimulationCounter counters)
boolean	SimpleSimulator.canFire(FlatNode node, HashMap<FlatNode,Integer> executionCounts, SimulationCounter counters)
boolean	NoSimulator.canFire(FlatNode node, HashMap<FlatNode,Integer> executionCounts, SimulationCounter counters)
boolean	FineGrainSimulator.canFire(FlatNode node, HashMap<FlatNode,Integer> executionCounts, SimulationCounter counters)
protected int	Simulator.consumedItems(FlatNode fire, SimulationCounter counters, HashMap<FlatNode,Integer> executionCounts) return how many items a node consumes (pop's) for one firing given the current state of the simulation
protected void	Simulator.decrementExecutionCounts(FlatNode fire, HashMap<FlatNode,Integer> executionCounts, SimulationCounter counters) Give that a node has just fired, update the simulation state
protected int	WorkBasedSimulator.fireJoiner(FlatNode fire, SimulationCounter counters, HashMap<FlatNode,Integer> executionCounts)
protected abstract int	Simulator.fireJoiner(FlatNode fire, SimulationCounter counters, HashMap<FlatNode,Integer> executionCounts) this method should fire a joiner, assuming the joiner can fire, and update the simulation state
protected int	SimpleSimulator.fireJoiner(FlatNode fire, SimulationCounter counters, HashMap<FlatNode,Integer> executionCounts)
protected int	NoSimulator.fireJoiner(FlatNode fire, SimulationCounter counters, HashMap<FlatNode,Integer> executionCounts)
protected int	FineGrainSimulator.fireJoiner(FlatNode fire, SimulationCounter counters, HashMap<FlatNode,Integer> executionCounts)
protected int	Simulator.fireMe(FlatNode fire, SimulationCounter counters, HashMap<FlatNode,Integer> executionCounts) consume the data and return the number of items produced
protected void	Simulator.generateSwitchCode(FlatNode fire, List<FlatNode> dests) generate the switch code for 1 data item given the list of destinations we do not want to duplicate items until neccessary, so we have to keep track of all the routes and then generate the switch code this way we can route multiple dests per route instruction
protected int	Simulator.itemsNeededToFire(FlatNode fire, SimulationCounter counters, HashMap<FlatNode,Integer> executionCounts) given a node

Constructors in at.dms.kjc.spacedynamic with parameters of type FlatNode

BufferedDynamicCommunication(SpdStaticStreamGraph ssg, FlatNode node)

BufferedStaticCommunication(SpdStaticStreamGraph ssg, FlatNode node, int bottomPeek, int remaining, int initFire)
Create a new BufferedStaticCommunication Generator for:

CircularSchedule(FlatNode[] objs)

FileReaderDevice(StreamGraph sg, FlatNode node)

FileWriterDevice(StreamGraph sg, FlatNode node)

SimulatorEvent(String type, int time, FlatNode node, List<FlatNode> dests, int itemID, boolean isLast)

SpdStaticStreamGraph(StreamGraph sg, FlatNode realTop)
create a static stream graph with realTop as the first node that the implicit splitter points to

SpdStreamGraph(FlatNode top, RawChip rawChip)
Create the static stream graph for the application that has

WorkEstimatesMap(SpdStreamGraph sg, FlatNode top)

Constructor parameters in at.dms.kjc.spacedynamic with type arguments of type FlatNode

SimulationCounter(HashMap<FlatNode,JoinerScheduleNode> joinerSchedules)

SimulatorEvent(String type, int time, FlatNode node, List<FlatNode> dests, int itemID, boolean isLast)