' + + '' + + _("Hide Search Matches") + + "
" + ) + ); + }, + + /** + * helper function to hide the search marks again + */ + hideSearchWords: () => { + document + .querySelectorAll("#searchbox .highlight-link") + .forEach((el) => el.remove()); + document + .querySelectorAll("span.highlighted") + .forEach((el) => el.classList.remove("highlighted")); + localStorage.removeItem("sphinx_highlight_terms") + }, + + initEscapeListener: () => { + // only install a listener if it is really needed + if (!DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS) return; + + document.addEventListener("keydown", (event) => { + // bail for input elements + if (BLACKLISTED_KEY_CONTROL_ELEMENTS.has(document.activeElement.tagName)) return; + // bail with special keys + if (event.shiftKey || event.altKey || event.ctrlKey || event.metaKey) return; + if (DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS && (event.key === "Escape")) { + SphinxHighlight.hideSearchWords(); + event.preventDefault(); + } + }); + }, +}; + +_ready(() => { + /* Do not call highlightSearchWords() when we are on the search page. + * It will highlight words from the *previous* search query. + */ + if (typeof Search === "undefined") SphinxHighlight.highlightSearchWords(); + SphinxHighlight.initEscapeListener(); +}); diff --git a/html/genindex.html b/html/genindex.html new file mode 100644 index 0000000..cb27947 --- /dev/null +++ b/html/genindex.html @@ -0,0 +1,950 @@ + + + + + + +| + | + |
| + | + |
| + | + |
| + | + |
| + | + |
| + | + |
| + | + |
| + |
| + | + |
| + |
| + | + |
| + |
| + |
This document provides comprehensive documentation for all the modules in the GameTime framework.
+Bases: object
Contains methods and variables that allow a user to import +GameTime as a module.
+Methods
+
|
+
|
+
project_config – object that represents the configuration of a GameTime project.
+configuration provided.
+Bases: object
Maintains information about the code being analyzed, such as +the name of the file that contains the code being analyzed +and the basis paths of the code.
+project_config – Object that represents the configuration of a GameTime project.
+Methods
+
|
+Adds the edges provided to the list of path-bundled constraints, if not already present. |
+
| + | Adds the edges provided to the list of path-exclusive constraints, if not already present. |
+
| + | Creates the DAG corresponding to the code being analyzed and dumps the DAG, in DOT format, to a temporary file for further analysis. |
+
| + | Estimates the weights on the edges of the DAG, using the values of the basis "Path" objects. |
+
| + | Generates a list of "Path" objects, each of which represents a basis path of the code being analyzed. |
+
| + | Generates an overcomplete basis so that each feasible path can be |
+
| + | Generates overcomplete basis such the lenth of the longest |
+
|
+Loads the DAG that corresponds to the code being analyzed from a DOT file. |
+
| + | Measure all generated BASIS_PATHS again |
+
|
+Measure the Path if never measured before. |
+
|
+Measure the list of PATHS. |
+
| + | Resets the path-bundled constraints. |
+
| + | Resets the path-exclusive constraints. |
+
generate_paths |
++ |
Adds the edges provided to the list of path-bundled +constraints, if not already present. These edges must +be taken together if at least one of them is taken along +a path through the DAG.
+edges (List[Tuple[str, str]] :) – List of edges to add to the list of path-bundled constraints.
+Adds the edges provided to the list of path-exclusive +constraints, if not already present. These edges must not +be taken together along any path through the DAG.
+edges (List[Tuple[str, str]] :) – List of edges to add to the list of path-exclusive constraints.
+Basis matrix.
+Creates the DAG corresponding to the code being analyzed +and dumps the DAG, in DOT format, to a temporary file for further +analysis. This method also stores a local copy in a data +structure that represents the DAG.
+Estimates the weights on the edges of the DAG, using the values +of the basis “Path” objects. The result is stored in the instance +variable “edgeWeights”.
+Precondition: The basis paths have been generated and have values.
+Generates a list of “Path” objects, each of which represents +a basis path of the code being analyzed. The basis “Path” objects +are regenerated each time this method is called.
+List of basis paths of the code being analyzed, each
represented by an object of the “Path” class.
written as a liner combination of the paths in the basis so that the +L1 norm is at most ‘k’. This method is for testing purposes +only as it exhaustively generates all_temp_files paths in the graph!. Use the +function below for a scalable version.
+k (int :) – Maximum value of L1 norm.
+feasible path is at most ‘k’. The basis is computed by iteratively +extending the basis with the longest path. Parameter ‘initial_paths’ +specifies the set of paths the iterative algorithm begins with. This +can be any set of paths, in practice we use the paths generated by +the standard algorithm.
+initial_paths (List[List[Tuple[str, str]]] :) – A list of initial paths to begin with.
k (int :) – Maximum value of L1 norm.
The set of basis paths.
+Loads the DAG that corresponds to the code being analyzed from a DOT file.
+location (str :) – Location of the file.
+Measure all generated BASIS_PATHS again
+Measure the Path if never measured before. If no name was set, the parameter output_name is used.
+path (Path :) – The path object
output_name (str :) – Name for this path.
Measured cycle count for PATH.
+Measure the list of PATHS. Using prefix and index as name if none is given.
+paths (list[Path] :) – List of paths to measure.
output_name_prefix (str :) – Prefix to use for the name of each path
List of measured values for the paths.
+List whose elements are lists of edges that must be taken together, +if at least one is taken along a path through the DAG. For example, +the element [e1, e2] means “if you take e1, then you take e2”.
+Dimension of the vector representing each path.
+Set whose elements are lists of edges that must not be taken +together along any path through the DAG. For example, the element +[e1, e2] means “if you take e1, you cannot take e2” and +“if you take e2, you cannot take e1”.
+ProjectConfiguration object
+that represents the configuration of a GameTime project.
Resets the path-bundled constraints.
+Resets the path-exclusive constraints.
+Functions to help interacting with clang on the command +line. Allows creation of dags
+Compile the LLVM bitcode program into executable in OUTPUT_FILE_FOLDER.
+bc_filepath (str :) – Path to the input bitcode program.
output_folder (str :) – Storage folder for generated file.
output_name (str :) – Name for generated executable.
extra_libs (List[str] :) – Extra libraries needed for compilation. (Default value = [])
extra_flags (List[str] :) – Extra flags needed for compilation. (Default value = [])
The path to executable.
+str
+Compile the C program into bitcode in OUTPUT_FILE_FOLDER using -O0 option to preserve maximum structure.
+c_filepath (str :) – Path to the input C program.
output_file_folder (str :) – Storage folder for generated file.
output_name (str :) – Name for generated bc.
extra_libs (List[str] :) – Extra libraries needed for compilation. (Default value = [])
extra_flags (List[str] :) – Extra flags needed for compilation. (Default value = [])
readable (bool :) – If set to true, also generate readable LL file. (Default value = False)
The path to bc.
+str
+Compile the C program into bitcode in OUTPUT_FILE_FOLDER.
+c_filepath (str :) – Path to the input C program. Main function should be defined.
output_file_folder (str :) – Storage folder for generated file.
output_name (str :) – Name for generated bc.
extra_libs (List[str] :) – Extra libraries needed for compilation. (Default value = [])
extra_flags (List[str] :) – Extra flags needed for compilation. (Default value = [])
readable (bool :) – If set to true, also generate readable LL file. (Default value = False)
The path to bc.
+str
+Dump the .o file to OUTPUT_NAME.dmp
+object_filepath (str :) – The name of the .o file to dump
output_folder (str :) – The folder path where .dmp files will be stored
output_name (str :) – Name for dumped .dmp files.
Path of the output OUTPUT_NAME.dmp file
+str
+Create dag from .bc file using opt through executing shell commands
+bc_filename (str :) – location of the compiled llvm .bc file
bc_file_folder (str :) – the folder path where .bc files is stored and where .main.dot file will be stored
output_name (str :) – Name of the generated dot file (Default value = “main”)
Path of the output .dot file
+str
+Unrolls the provided input file and output the unrolled version in +the output file using llvm’s opt utility. Could be unreliable if input_file +is not compiled with compile_to_llvm_for_analysis function. If that is the case, the +user might want to generate their own unrolled .bc/.ll file rather than +relying on this built-in function.
+bc_filepath (str :) – Input .bc/.ll function to loop unroll
output_file_folder (str :) – folder to write unrolled .bc file. Outputs in a +human-readable form already.
output_name (str :) – file to write unrolled .bc file. Outputs in a +human-readable form already.
Path of the output .bc file
+str
+Removes the temporary files created by CIL during its analysis.
+project_config – ProjectConfiguration this helper is calling from.
all_temp_files – True if all files in temperary directory should be removed.
Unrolls the provided input file and output the unrolled version in +the output file using llvm’s opt utility. Could be unreliable if input_file +is not compiled with compile_to_llvm_for_analysis function. If that is the case, the +user might want to generate their own unrolled .bc/.ll file rather than +relying on this built-in function.
+input_file (str :) – Input .bc/.ll function to loop unroll
output_file_folder (str :) – folder to write unrolled .bc file. Outputs in a +human-readable form already.
output_name (str :) – file to write unrolled .bc file. Outputs in a +human-readable form already.
project_config (ProjectConfiguration :) – ProjectConfiguration this helper is calling from.
Path of the output .bc file
+str
+Initializes the various variables, used in different +submodules of GameTime, with default values.
+Default GametimeConfiguration object
+that represents the configuration of GameTime.
Default configuration YAML file.
+Default directory that contains the GameTime GUI.
+Default directory that contains the source files of GameTime.
+Exposes miscellaneous functions to perform operations +on files and directories, such as creation, removal and movement.
+Creates the leaf directory in the path specified, along with any
+intermediate-level directories needed to contain the directory.
+This is a wrapper around the makedirs() function of
+the os module, but does not raise an exception if
+the directory is already present,
location (str :) – Location of the directory to be created
+Moves the files, whose names match any of the patterns in the list +provided, from the source directory whose location is provided to +the destination directory whose location is provided. If a file in +the destination directory has the same name as a file that is being moved +from the source directory, the former is overwritten if overwrite is +set to True; otherwise, the latter will not be moved.
+patterns (List[str] :) – List of patterns to match filenames against
source_dir (str :) – Location of the source directory
dest_dir (str :) – Location of the destination directory
overwrite (bool :) – Whether to overwrite a file in the destination directory that has the same name as a file that is being moved from the source directory. (Default value = True)
Removes all_temp_files of the files and directories from the directory whose +location is provided, except for those files whose names match any +of the patterns in the list provided.
+patterns (List[str] :) – List of patterns to match filenames against
dir_location (str :) – Location of the directory to remove files from
Removes the file at the provided location. This is a wrapper around
+the remove() function of the os module, but does not
location (str :) – Location of the file to be removed
+Removes the files from the directory whose location is provided, +whose names match any of the patterns in the list provided.
+patterns (List[str] :) – List of patterns to match filenames against
dir_location (str :) – Location of the directory to remove files from
Bases: object
This class represents the endianness of the target machine.
+Bases: object
Stores information necessary to configure GameTime.
+Creates GametimeConfiguration from yaml files
+yaml_config_path (str :) – path of the yaml config file that contains
+GametimeConfiguration object that contains information from YAML file at yaml_config_path
+Defines the error that GameTime can throw.
+Bases: Exception
Error that GameTime can throw.
+Bases: Warning
Warning that GameTime can throw.
+Exposes functions to create, and interact with, a histogram +computed from the values of feasible paths generated by GameTime.
+Computes a histogram from the values of a list of
+feasible paths generated by GameTime. This function is
+a wrapper around the function histogram() from
+the module numpy. Refer to the documentation of this
+function for more information about the computed histogram.
paths (list[Path] :) – List of feasible paths generated by GameTime, each represented by a ~gametime.src.path.Path object.
bins – Same purpose as the same-named argument of the function numpy.histogram().
path_value_range – Same purpose as the range argument of the function numpy.histogram(). (Default value = None)
measured – True if, and only if, the values that will be used for the histogram are the measured values of the feasible paths. (Default value = False)
Tuple, whose first element is an array of the values of the histogram, and whose second element is an array of the left edges of the bins.
+Tuple
+Create a histogram and write it to location.
+location – The stored folder for histogram file
paths (list[Path] :) – List of feasible paths generated by GameTime, each represented by a ~gametime.src.path.Path object.
bins – Same purpose as the same-named argument of the function numpy.histogram().
path_value_range – Same purpose as the range argument of the function numpy.histogram(). (Default value = None)
measured – True if, and only if, the values that will be used for the histogram are the measured values of the feasible paths. (Default value = False)
Defines a class that maintains a representation of, +and information about, an interval of values.
+Bases: object
Maintains a representation of, and information about, +an interval of values.
+lower_boundReturns ——- Lower bound of the interval represented by this object, or None if the interval has no finite lower bound.
+upper_boundReturns ——- Upper bound of the interval represented by this object, or None if the interval has no finite upper bound.
+Methods
+| + |
|
+
| + |
|
+
True if, and only if, the represented interval has a finite lower bound.
+True if, and only if, the represented interval has a finite upper bound.
+rtype: Lower bound of the interval represented by this object, or None if the interval has no finite lower bound.
+rtype: Upper bound of the interval represented by this object, or None if the interval has no finite upper bound.
+Exposes functions to interact with, and modify an object of,
+the logging Python class.
Initializes the logger provided with +~logging.Formatter and ~logging.StreamHandler +objects appropriate for GameTime.
+logger (logging.Logger :) – Logger to initialize
+Exposes classes and functions to supplement those provided by +the NetworkX graph package.
+Bases: DiGraph
Maintains information about the directed acyclic graph (DAG) +of the code being analyzed. It is a subclass of +the ~networkx.DiGraph class of the NetworkX graph package, +and stores additional information relevant to the GameTime analysis, +such as the special ‘default’ edges in the DAG.
+Graph adjacency object holding the neighbors of each node.
+This object is a read-only dict-like structure with node keys +and neighbor-dict values. The neighbor-dict is keyed by neighbor +to the edge-data-dict. So G.adj[3][2][‘color’] = ‘blue’ sets +the color of the edge (3, 2) to “blue”.
+Iterating over G.adj behaves like a dict. Useful idioms include +for nbr, datadict in G.adj[n].items():.
+The neighbor information is also provided by subscripting the graph. +So for nbr, foovalue in G[node].data(‘foo’, default=1): works.
+For directed graphs, G.adj holds outgoing (successor) info.
+A DegreeView for the Graph as G.degree or G.degree().
+The node degree is the number of edges adjacent to the node. +The weighted node degree is the sum of the edge weights for +edges incident to that node.
+This object provides an iterator for (node, degree) as well as +lookup for the degree for a single node.
+The view will only report edges incident to these nodes.
+The name of an edge attribute that holds the numerical value used +as a weight. If None, then each edge has weight 1. +The degree is the sum of the edge weights adjacent to the node.
+If multiple nodes are requested (the default), returns a DiDegreeView +mapping nodes to their degree. +If a single node is requested, returns the degree of the node as an integer.
+in_degree, out_degree
+>>> G = nx.DiGraph() # or MultiDiGraph
+>>> nx.add_path(G, [0, 1, 2, 3])
+>>> G.degree(0) # node 0 with degree 1
+1
+>>> list(G.degree([0, 1, 2]))
+[(0, 1), (1, 2), (2, 2)]
+An OutEdgeView of the DiGraph as G.edges or G.edges().
+edges(self, nbunch=None, data=False, default=None)
+The OutEdgeView provides set-like operations on the edge-tuples +as well as edge attribute lookup. When called, it also provides +an EdgeDataView object which allows control of access to edge +attributes (but does not provide set-like operations). +Hence, G.edges[u, v][‘color’] provides the value of the color +attribute for edge (u, v) while +for (u, v, c) in G.edges.data(‘color’, default=’red’): +iterates through all the edges yielding the color attribute +with default ‘red’ if no color attribute exists.
+The view will only report edges from these nodes.
+The edge attribute returned in 3-tuple (u, v, ddict[data]). +If True, return edge attribute dict in 3-tuple (u, v, ddict). +If False, return 2-tuple (u, v).
+Value used for edges that don’t have the requested attribute. +Only relevant if data is not True or False.
+A view of edge attributes, usually it iterates over (u, v) +or (u, v, d) tuples of edges, but can also be used for +attribute lookup as edges[u, v][‘foo’].
+in_edges, out_edges
+Nodes in nbunch that are not in the graph will be (quietly) ignored. +For directed graphs this returns the out-edges.
+>>> G = nx.DiGraph() # or MultiDiGraph, etc
+>>> nx.add_path(G, [0, 1, 2])
+>>> G.add_edge(2, 3, weight=5)
+>>> [e for e in G.edges]
+[(0, 1), (1, 2), (2, 3)]
+>>> G.edges.data() # default data is {} (empty dict)
+OutEdgeDataView([(0, 1, {}), (1, 2, {}), (2, 3, {'weight': 5})])
+>>> G.edges.data("weight", default=1)
+OutEdgeDataView([(0, 1, 1), (1, 2, 1), (2, 3, 5)])
+>>> G.edges([0, 2]) # only edges originating from these nodes
+OutEdgeDataView([(0, 1), (2, 3)])
+>>> G.edges(0) # only edges from node 0
+OutEdgeDataView([(0, 1)])
+An InDegreeView for (node, in_degree) or in_degree for single node.
+The node in_degree is the number of edges pointing to the node. +The weighted node degree is the sum of the edge weights for +edges incident to that node.
+This object provides an iteration over (node, in_degree) as well as +lookup for the degree for a single node.
+The view will only report edges incident to these nodes.
+The name of an edge attribute that holds the numerical value used +as a weight. If None, then each edge has weight 1. +The degree is the sum of the edge weights adjacent to the node.
+If a single node is requested +deg : int
+++In-degree of the node
+
OR if multiple nodes are requested +nd_iter : iterator
+++The iterator returns two-tuples of (node, in-degree).
+
degree, out_degree
+>>> G = nx.DiGraph()
+>>> nx.add_path(G, [0, 1, 2, 3])
+>>> G.in_degree(0) # node 0 with degree 0
+0
+>>> list(G.in_degree([0, 1, 2]))
+[(0, 0), (1, 1), (2, 1)]
+A view of the in edges of the graph as G.in_edges or G.in_edges().
+in_edges(self, nbunch=None, data=False, default=None):
+The view will only report edges incident to these nodes.
+The edge attribute returned in 3-tuple (u, v, ddict[data]). +If True, return edge attribute dict in 3-tuple (u, v, ddict). +If False, return 2-tuple (u, v).
+Value used for edges that don’t have the requested attribute. +Only relevant if data is not True or False.
+A view of edge attributes, usually it iterates over (u, v) +or (u, v, d) tuples of edges, but can also be used for +attribute lookup as edges[u, v][‘foo’].
+>>> G = nx.DiGraph()
+>>> G.add_edge(1, 2, color='blue')
+>>> G.in_edges()
+InEdgeView([(1, 2)])
+>>> G.in_edges(nbunch=2)
+InEdgeDataView([(1, 2)])
+edges
+nameString identifier of the graph.
+A NodeView of the Graph as G.nodes or G.nodes().
+Can be used as G.nodes for data lookup and for set-like operations. +Can also be used as G.nodes(data=’color’, default=None) to return a +NodeDataView which reports specific node data but no set operations. +It presents a dict-like interface as well with G.nodes.items() +iterating over (node, nodedata) 2-tuples and G.nodes[3][‘foo’] +providing the value of the foo attribute for node 3. In addition, +a view G.nodes.data(‘foo’) provides a dict-like interface to the +foo attribute of each node. G.nodes.data(‘foo’, default=1) +provides a default for nodes that do not have attribute foo.
+The node attribute returned in 2-tuple (n, ddict[data]). +If True, return entire node attribute dict as (n, ddict). +If False, return just the nodes n.
+Value used for nodes that don’t have the requested attribute. +Only relevant if data is not True or False.
+Allows set-like operations over the nodes as well as node +attribute dict lookup and calling to get a NodeDataView. +A NodeDataView iterates over (n, data) and has no set operations. +A NodeView iterates over n and includes set operations.
+When called, if data is False, an iterator over nodes. +Otherwise an iterator of 2-tuples (node, attribute value) +where the attribute is specified in data. +If data is True then the attribute becomes the +entire data dictionary.
+If your node data is not needed, it is simpler and equivalent
+to use the expression for n in G, or list(G).
There are two simple ways of getting a list of all nodes in the graph:
+>>> G = nx.path_graph(3)
+>>> list(G.nodes)
+[0, 1, 2]
+>>> list(G)
+[0, 1, 2]
+To get the node data along with the nodes:
+>>> G.add_node(1, time="5pm")
+>>> G.nodes[0]["foo"] = "bar"
+>>> list(G.nodes(data=True))
+[(0, {'foo': 'bar'}), (1, {'time': '5pm'}), (2, {})]
+>>> list(G.nodes.data())
+[(0, {'foo': 'bar'}), (1, {'time': '5pm'}), (2, {})]
+>>> list(G.nodes(data="foo"))
+[(0, 'bar'), (1, None), (2, None)]
+>>> list(G.nodes.data("foo"))
+[(0, 'bar'), (1, None), (2, None)]
+>>> list(G.nodes(data="time"))
+[(0, None), (1, '5pm'), (2, None)]
+>>> list(G.nodes.data("time"))
+[(0, None), (1, '5pm'), (2, None)]
+>>> list(G.nodes(data="time", default="Not Available"))
+[(0, 'Not Available'), (1, '5pm'), (2, 'Not Available')]
+>>> list(G.nodes.data("time", default="Not Available"))
+[(0, 'Not Available'), (1, '5pm'), (2, 'Not Available')]
+If some of your nodes have an attribute and the rest are assumed +to have a default attribute value you can create a dictionary +from node/attribute pairs using the default keyword argument +to guarantee the value is never None:
+>>> G = nx.Graph()
+>>> G.add_node(0)
+>>> G.add_node(1, weight=2)
+>>> G.add_node(2, weight=3)
+>>> dict(G.nodes(data="weight", default=1))
+{0: 1, 1: 2, 2: 3}
+An OutDegreeView for (node, out_degree)
+The node out_degree is the number of edges pointing out of the node. +The weighted node degree is the sum of the edge weights for +edges incident to that node.
+This object provides an iterator over (node, out_degree) as well as +lookup for the degree for a single node.
+The view will only report edges incident to these nodes.
+The name of an edge attribute that holds the numerical value used +as a weight. If None, then each edge has weight 1. +The degree is the sum of the edge weights adjacent to the node.
+If a single node is requested +deg : int
+++Out-degree of the node
+
OR if multiple nodes are requested +nd_iter : iterator
+++The iterator returns two-tuples of (node, out-degree).
+
degree, in_degree
+>>> G = nx.DiGraph()
+>>> nx.add_path(G, [0, 1, 2, 3])
+>>> G.out_degree(0) # node 0 with degree 1
+1
+>>> list(G.out_degree([0, 1, 2]))
+[(0, 1), (1, 1), (2, 1)]
+An OutEdgeView of the DiGraph as G.edges or G.edges().
+edges(self, nbunch=None, data=False, default=None)
+The OutEdgeView provides set-like operations on the edge-tuples +as well as edge attribute lookup. When called, it also provides +an EdgeDataView object which allows control of access to edge +attributes (but does not provide set-like operations). +Hence, G.edges[u, v][‘color’] provides the value of the color +attribute for edge (u, v) while +for (u, v, c) in G.edges.data(‘color’, default=’red’): +iterates through all the edges yielding the color attribute +with default ‘red’ if no color attribute exists.
+The view will only report edges from these nodes.
+The edge attribute returned in 3-tuple (u, v, ddict[data]). +If True, return edge attribute dict in 3-tuple (u, v, ddict). +If False, return 2-tuple (u, v).
+Value used for edges that don’t have the requested attribute. +Only relevant if data is not True or False.
+A view of edge attributes, usually it iterates over (u, v) +or (u, v, d) tuples of edges, but can also be used for +attribute lookup as edges[u, v][‘foo’].
+in_edges, out_edges
+Nodes in nbunch that are not in the graph will be (quietly) ignored. +For directed graphs this returns the out-edges.
+>>> G = nx.DiGraph() # or MultiDiGraph, etc
+>>> nx.add_path(G, [0, 1, 2])
+>>> G.add_edge(2, 3, weight=5)
+>>> [e for e in G.edges]
+[(0, 1), (1, 2), (2, 3)]
+>>> G.edges.data() # default data is {} (empty dict)
+OutEdgeDataView([(0, 1, {}), (1, 2, {}), (2, 3, {'weight': 5})])
+>>> G.edges.data("weight", default=1)
+OutEdgeDataView([(0, 1, 1), (1, 2, 1), (2, 3, 5)])
+>>> G.edges([0, 2]) # only edges originating from these nodes
+OutEdgeDataView([(0, 1), (2, 3)])
+>>> G.edges(0) # only edges from node 0
+OutEdgeDataView([(0, 1)])
+Graph adjacency object holding the predecessors of each node.
+This object is a read-only dict-like structure with node keys +and neighbor-dict values. The neighbor-dict is keyed by neighbor +to the edge-data-dict. So G.pred[2][3][‘color’] = ‘blue’ sets +the color of the edge (3, 2) to “blue”.
+Iterating over G.pred behaves like a dict. Useful idioms include +for nbr, datadict in G.pred[n].items():. A data-view not provided +by dicts also exists: for nbr, foovalue in G.pred[node].data(‘foo’): +A default can be set via a default argument to the data method.
+Graph adjacency object holding the successors of each node.
+This object is a read-only dict-like structure with node keys +and neighbor-dict values. The neighbor-dict is keyed by neighbor +to the edge-data-dict. So G.succ[3][2][‘color’] = ‘blue’ sets +the color of the edge (3, 2) to “blue”.
+Iterating over G.succ behaves like a dict. Useful idioms include +for nbr, datadict in G.succ[n].items():. A data-view not provided +by dicts also exists: for nbr, foovalue in G.succ[node].data(‘foo’): +and a default can be set via a default argument to the data method.
+The neighbor information is also provided by subscripting the graph. +So for nbr, foovalue in G[node].data(‘foo’, default=1): works.
+For directed graphs, G.adj is identical to G.succ.
+Methods
+
|
+Add an edge between u and v. |
+
|
+Add all the edges in ebunch_to_add. |
+
|
+Add a single node node_for_adding and update node attributes. |
+
|
+Add multiple nodes. |
+
|
+Add weighted edges in ebunch_to_add with specified weight attr |
+
|
+Returns an iterator over (node, adjacency dict) tuples for all nodes. |
+
|
+alias of |
+
|
+alias of |
+
|
+Remove all nodes and edges from the graph. |
+
|
+Remove all edges from the graph without altering nodes. |
+
|
+Returns a copy of the graph. |
+
|
+alias of |
+
|
+Returns the subgraph induced by the specified edges. |
+
|
+Returns the attribute dictionary associated with edge (u, v). |
+
|
+
|
+
|
+gets node label from node ID |
+
|
+alias of |
+
|
+Returns True if the edge (u, v) is in the graph. |
+
|
+Returns True if the graph contains the node n. |
+
|
+Returns True if node u has predecessor v. |
+
|
+Returns True if node u has successor v. |
+
|
+Returns True if graph is directed, False otherwise. |
+
|
+Returns True if graph is a multigraph, False otherwise. |
+
| + | Loads the instance variables of this object with appropriate values. |
+
|
+Returns an iterator over nodes contained in nbunch that are also in the graph. |
+
|
+Returns an iterator over successor nodes of n. |
+
|
+alias of |
+
|
+alias of |
+
|
+Returns the number of edges between two nodes. |
+
|
+Returns the number of nodes in the graph. |
+
|
+Returns the number of nodes in the graph. |
+
|
+Returns an iterator over predecessor nodes of n. |
+
|
+Remove the edge between u and v. |
+
|
+Remove all edges specified in ebunch. |
+
|
+Remove node n. |
+
|
+Remove multiple nodes. |
+
| + | Resets the weights assigned to the edges of the DAG. |
+
|
+Returns the reverse of the graph. |
+
|
+Returns the number of edges or total of all edge weights. |
+
|
+Returns a SubGraph view of the subgraph induced on nodes. |
+
|
+Returns an iterator over successor nodes of n. |
+
|
+Returns a directed representation of the graph. |
+
|
+Returns the class to use for empty directed copies. |
+
|
+Returns an undirected representation of the digraph. |
+
|
+Returns the class to use for empty undirected copies. |
+
|
+Update the graph using nodes/edges/graphs as input. |
+
initialize_dictionaries |
++ |
List of edges in the DAG.
+List of nodes in the DAG.
+List of the weights assigned to the edges in the DAG, arranged +in the same order as the edges are in the list of all_temp_files edges.
+Dictionary that maps edges to their indices in the list of all_temp_files edges. +This is maintained for efficiency purposes.
+List of non-special edges in the DAG.
+Dictionary that maps non-special edges to their indices in the +list of all_temp_files edges. This is maintained for efficiency purposes.
+nodes (List[str] :) – Nodes of a path in the directed acyclic graph
+List of edges that lie along the path.
+gets node label from node ID
+node (int :) – ID of the node of interest
+label corresponding to the node. (code corresponding to the node in LLVM IR)
+Loads the instance variables of this object with appropriate +values. This method is useful when the DAG is loaded from a DOT file.
+List of nodes in the DAG that are not the sink. +We assume that there is only one sink. +This is maintained for efficiency purposes.
+Dictionary that maps nodes (except the sink) to their indices in +the list of all_temp_files nodes (except the sink). This is maintained for +efficiency purposes.
+List of nodes in the DAG that are neither the source nor the sink. +We assume that there is only one source and one sink. This is +maintained for efficiency purposes.
+Dictionary that maps nodes (except the source and the sink) to their +indices in the list of all_temp_files nodes (except the source and the sink). +This is maintained for efficiency purposes.
+Dictionary that maps nodes to their indices in the list of all_temp_files nodes. +This is maintained for efficiency purposes.
+Number of edges in the DAG.
+Number of nodes in the DAG.
+Number of paths in the DAG.
+Resets the weights assigned to the edges of the DAG.
+Sink of the DAG.
+Dictionary that maps nodes to the special (‘default’) edges.
+Constructs a ~gametime.nxHelper.Dag object to represent +the directed acyclic graph described in DOT format in the file provided.
+location (str :) – Path to the file describing a directed acyclic graph in DOT format
+Object that represents the directed acyclic graph.
+~gametime.src.nx_helper.Dag
+G – The graph to find root node in
+Root node of G or None if one doesn’t exist.
+Node
+dag (Dag :) – DAG represented by a ~gametime.src.nx_helper.Dag object.
source (str :) – source to start path with
sink (str :) – sink to end path with
Random path in the DAG provided from the input source node to +the input sink node, represented as a list of nodes arranged in +order of traversal from source to sink.
+List[str]
+dag (Dag :) – DAG represented by a dag
+True if, and only if, the DAG provided has cycles.
+bool
+dag – DAG represented by a ~gametime.src.nx_helper.Dag object.
source – Source node.
sink – Sink node.
Number of paths in the DAG provided. Note: Passed in DAG must be actually acyclic.
+int
+Remove all back edges from G to make it a DAG. Assuming G is connected and rooted at ROOT.
+G – The graph to remove root edges
root – The root node of G to start DFS with
DAG version of G with all back edges removed.
+Writes the directed acyclic graph provided to a file in DOT format.
+dag (Dag :) – Dag to save to dot
location (str :) – Location of the file.
dag_name (str :) – Name of the directed acyclic graph, as will be written to +the file. If this argument is not provided, the directed +acyclic graph will not have a name. (Default value = “”)
edges_to_labels (Dict[Tuple[str, str], str]:) – Dictionary that maps an edge to the label that will annotate +the edge when the DOT file is processed by a visualization tool. +If this argument is not provided, these annotations will not +be made. (Default value = None)
highlighted_edges (List[Tuple[str, str]]:) – List of edges that will be highlighted when the DOT file is +processed by a visualization tool. If this argument +is not provided, no edges will be highlighted. (Default value = None)
highlight_color (str:) – Color of the highlighted edges. This argument can be any value +that is legal in the DOT format. If the highlightedEdges argument +is not provided, this argument is ignored. (Default value = “red”)
Bases: object
Methods
+
|
+run the entire simulation on the given path |
+
Defines classes and methods to generate objects of the “Path” class +that represent different types of feasible paths in the code being analyzed, +such as those with the worst-case values.
+Bases: object
Exposes static methods to generate objects of the Path class that
+represent different types of feasible paths in the code being analyzed.
This class is closely related to the Analyzer class: except
+for the private helper methods, all of the static methods
+can also be accessed as instance methods of an Analyzer object.
These methods are maintained in this class to keep the codebase cleaner +and more modular. Instances of this class should not need to be made.
+Methods
+
|
+Generates a list of feasible paths of the code being analyzed, each represented by an object of the |
+
Generates a list of feasible paths of the code being analyzed,
+each represented by an object of the Path class.
The type of the generated paths is determined by the path_type
+argument, which is a class variable of the PathType class.
+By default, this argument is PathType.WORST_CASE. For
+a description of the types, refer to the documentation of
+the PathType class.
The num_paths argument is an upper bound on how many paths should
+be generated, which is 5 by default. This argument is ignored if
+this method is used to generate all of the feasible paths of the code
+being analyzed.
The interval argument is an Interval object that represents
+the interval of values that the generated paths can have. If
+no Interval object is provided, the interval of values is
+considered to be all real numbers.
This method is idempotent: a second call to this method will produce
+the same list of Path objects as the first call, assuming that
+nothing has changed between the two calls.
Precondition: The basis Path objects of the input Analyzer
+object have values associated with them. Refer to either the method
+loadBasisValuesFromFile or the method loadBasisValues in
+the Analyzer class.
analyzer – Analyzer object that maintains information about
+the code being analyzed.
num_paths – Upper bound on the number of paths to generate.
path_type – Type of paths to generate, represented by a class variable of
+the PathType class. The different types of paths are
+described in the documentation of the PathType class.
interval – Interval object that represents the interval of
+values that the generated paths can have. If no
+Interval object is provided, the interval of values
+is considered to be all real numbers.
use_ob_extraction – Boolean value specifiying whether to use overcomplete +basis extraction algorithm
List of feasible paths of the code being analyzed, each
+represented by an object of the Path class.
List[Path]
+Bases: object
Represents the type of paths that can be generated.
+Methods
+
|
+
|
+
All feasible paths, arranged in decreasing order of value.
+All feasible paths, arranged in increasing order of value.
+Best-case feasible paths, arranged in increasing order of value.
+Random feasible paths.
+Worst-case feasible paths, arranged in decreasing order of value.
+path_type – One of the predefined path types
+One-word description of the path type provided.
+Defines a class that maintains a representation of, and information about, +a single path in the code that is being analyzed.
+Bases: object
Maintains a representation of, and information about, +a single path in the code that is being analyzed.
+Methods
+| + |
|
+
| + |
|
+
| + |
|
+
| + |
|
+
| + |
|
+
| + |
|
+
|
+
|
+
| + |
|
+
| + |
|
+
| + |
|
+
| + |
|
+
|
+Reads, from a file, information about the expressions associated with the temporary index variables of aggregate accesses along a path. |
+
|
+Reads information about the array accesses made in conditions along a path from a file. |
+
|
+Reads, from a file, the assignments to variables that would drive an execution of the code under analysis along a path. |
+
|
+Reads the numbers of the conditions along a path, and the edges that are associated with the conditions, from a file. |
+
|
+Reads the line numbers of the conditional points in the code being analyzed, along with their truth values along a path, from a file. |
+
|
+Reads the conditions along a path from a file. |
+
|
+Reads the line numbers of the source-level statements that lie along a path from a file. |
+
|
+Reads the measured value of a path from a file. |
+
|
+Reads the IDs of the nodes in a directed acyclic graph along a path from a file. |
+
|
+Reads the predicted value of a path from a file. |
+
|
+Sets the measured value (runtime, energy consumption, etc.) of this path. |
+
|
+Sets the predicted value (runtime, energy consumption, etc.) of this path. |
+
|
+Writes information about the expressions associated with the temporary index variables of aggregate accesses along this path to a file. |
+
|
+Writes information about the array accesses made in conditions along this path to a file. |
+
|
+Writes the assignments to variables that would drive an execution of the code under analysis along this path to a file. |
+
|
+Writes the numbers of the conditions along this path, and the edges that are associated with the conditions, to a file. |
+
|
+Writes the line numbers of the conditional points in the code being analyzed, along with their truth values, to a file. |
+
|
+Writes the conditions along this path to a file. |
+
|
+Writes, to an LP file, the integer linear programming problem that, when solved, produced this path. |
+
|
+Writes the line numbers of the source-level statements that lie along this path to a file. |
+
|
+Writes the measured value of this path to a file. |
+
|
+Writes the IDs of the nodes in a directed acyclic graph along this path to a file. |
+
|
+Writes the predicted value of this path to a file. |
+
Information about the expressions associated with the temporary
+index variables of aggregate accesses along this path, represented
+as a dictionary that maps the number of a temporary index variable
+to an IndexExpression object.
Information about array accesses made in conditions along this path, +represented as a dictionary that maps the name of an array to a +list of tuples, each of which contains the numbers of the temporary +index variables in an array access.
+Dictionary of assignments to variables that would drive an execution +of the code along this path.
+Dictionary that associates the number of a condition with +the edge in the directed acyclic graph that is associated with +the condition. The edge is represented as a tuple.
+Dictionary that associates the line numbers of the conditional points +in the code being analyzed with their truth values.
+Conditions along this path, represented as a list of strings.
+String representation of the expressions associated +with the temporary index variables of aggregate accesses +along a path.
+str
+String representation of the array accesses made in +conditions along this path.
+str
+String representation of the assignments to variables +that would drive an execution of the code under analysis +along this path.
+str
+String representation of the numbers of the conditions along +this path, and the edges that are associated with the conditions.
+str
+String representation of the line numbers of the conditional points +in the code being analyzed, along with their truth values.
+str
+String representation of the conditions along this path.
+str
+condition_nums (List[int] :) – List of conditions
+List of the edges that are associated with the conditions +(along this path) whose numbers are provided. Each edge is +represented as a tuple, and appears only once in the list.
+List[Tuple[str]]
+String representation of the line numbers of +the source-level statements that lie along this path.
+str
+String representation of the measured value +(runtime, energy consumption, etc.) of this path.
+str
+String representation of the IDs of the nodes in +a directed acyclic graph along this path.
+str
+String representation of the predicted value +(runtime, energy consumption, etc.) of this path.
+str
+Integer linear programming problem that, when solved, produced
+this path, represented as an IlpProblem object.
Line numbers of the source-level statements along this path, +represented as a list of positive integers.
+Measured value (runtime, energy consumption, etc.) +of this path, represented as a number (either +an integer or a floating-point number).
+IDs of the nodes in a directed acyclic graph along this path, +represented as a list of strings.
+Predicted value (runtime, energy consumption, etc.) +of this path, represented as a number (either +an integer or a floating-point number).
+Reads, from a file, information about the expressions associated with +the temporary index variables of aggregate accesses along a path.
+location (str :) – Location of the file
+Dictionary that maps the number of a temporary index
+variable to an IndexExpression object.
Dict[int, IndexExpression]
+Reads information about the array accesses made in conditions +along a path from a file.
+location (str :) – Location of the file
+Dictionary that maps an array name to a list of tuples, each of +which contains the numbers of the temporary index variables +in an array access.
+Dict[str, List[Tuple[int, int]]]
+Reads, from a file, the assignments to variables that would +drive an execution of the code under analysis along a path.
+location (str :) – Location of the file
+Dictionary of assignments to variables that would +drive an execution of the code under analysis along a path.
+Dict[str, str]
+Reads the numbers of the conditions along a path, and +the edges that are associated with the conditions, from a file.
+location (str :) – Location of the file
+Dictionary that associates the number of a condition with +the edge in the directed acyclic graph that is associated with +the condition. The edge is represented as a tuple.
+Dict[int, Tuple[str]]
+Reads the line numbers of the conditional points in the code +being analyzed, along with their truth values along a path, +from a file.
+location (str :) – Location of the file
+Dictionary that associates the line numbers of +the conditional points in the code being analyzed with +their truth values.
+Dict[int, bool]
+Reads the conditions along a path from a file.
+location (str :) – Location of the file
+Conditions along a path, represented as a list of strings.
+List[str]
+Reads the line numbers of the source-level statements that +lie along a path from a file.
+location (str :) – Location of the file
+Line numbers of the source-level statements along this path, +represented as a list of positive integers.
+List[int]
+Reads the measured value of a path from a file.
+location (str :) – Location of the file
+Measured value of a path, represented as a number +(either an integer or a floating-point number).
+float
+Reads the IDs of the nodes in a directed acyclic graph +along a path from a file.
+location (str :) – Location of the file
+IDs of the nodes in a directed acyclic graph along a path, +represented as a list of strings.
+List[str]
+Reads the predicted value of a path from a file.
+location (str :) – Location of the file
+Predicted value of a path, represented as a number +(either an integer or a floating-point number).
+float
+Sets the measured value (runtime, energy consumption, etc.) +of this path.
+value (float :) – Value to set as the measured value of this path
+Sets the predicted value (runtime, energy consumption, etc.) +of this path.
+value (float :) – Value to set as the predicted value of this path
+Writes information about the expressions associated with the +temporary index variables of aggregate accesses along this path +to a file.
+location (str :) – Location of the file
+Writes information about the array accesses made in conditions +along this path to a file.
+location (str :) – Location of the file
+Writes the assignments to variables that would drive an execution +of the code under analysis along this path to a file.
+location (str :) – Location of the file
+Writes the numbers of the conditions along this path, and +the edges that are associated with the conditions, to a file.
+location (str :) – Location of the file
+Writes the line numbers of the conditional points in the code +being analyzed, along with their truth values, to a file.
+location (str :) – Location of the file
+Writes the conditions along this path to a file.
+location (str :) – Location of the file
+Writes, to an LP file, the integer linear programming problem that, +when solved, produced this path.
+location – Location of the file
+Writes the line numbers of the source-level statements that +lie along this path to a file.
+location (str:) – Location of the file
+Writes the measured value of this path to a file.
+location (str :) – Location of the file
+Writes the IDs of the nodes in a directed acyclic graph +along this path to a file.
+location (str :) – Location of the file
+Writes the predicted value of this path to a file.
+Location of the file
+Bases: object
Methods
+
|
+
|
+
configuration_file_path (str :) – Path to configuration file
+ProjectConfiguration object corresponding to file.
+Bases: ConfigurationParser
Methods
+
|
+
|
+
configuration_file_path (str :) – Path to configuration file
+ProjectConfiguration object corresponding to file.
+Gets a list of directory paths from the string provided, where +the directory paths are separated by whitespaces or commas.
+Directory to which the directory paths may be relative (Default value = None)
+Gets a list of file paths from the string provided, where the file +paths are separated by whitespaces or commas. The paths can also be +Unix-style globs.
+file_paths_str (str :) – String of file paths
dir_location (str :) – Directory to which the file paths may be relative (Default value = None)
List of file paths in the string.
+List[str]
+Bases: object
Stores debugging configuration information, which +determines the debugging information that is shown and +the temporary files that are dumped.
+Dump information about all_temp_files of the paths that have been traced +during analysis to a file.
+Dump information about all_temp_files of the SMT queries that +have been made during analysis to a file.
+Dump information produced when an IR-level instruction +is traced backward.
+Dump the Phoenix intermediate representation of the function +under analysis to a file.
+Dump information about the path being traced.
+Dump information produced when an SMT query is created.
+Keep the temporary files that CIL generates during its analysis.
+Keep debugging information and files produced by +the integer linear programming solver.
+Keep the debugging information and the temporary files +produced by the parser.
+Keep the temporary files produced by a simulator when +measuring the value of a path.
+Bases: object
Stores information necessary to configure a GameTime project.
+Methods
+
|
+Return path of file with name and extension. |
+
|
+Return path of temporary file with name and extension. |
+
|
+
|
+
Return path of file with name and extension. Extension should +be preceded by a period. For example, calling this function with extension +“.bc” should return something like “…. /main.bc”
+extension (str :) – extension of the file
name (str :) – name of the file (defaults to self.nameOrigNoExtension) (Default value = None)
path of the file in the original directory.
+str
+Return path of temporary file with name and extension. Extension should +be preceded by a period. For example, calling this function with extension +“.bc” should return something like “…. maingt/main.bc”
+extension (str :) – extension of the temporary file name
name (str :) – name of the temporary file (defaults to self.nameOrigNoExtension) (Default value = None)
path of the temporary file
+str
+ilp_solver_name (str:) – ILP solver name to use
+Exposes functions to interact with different +linear programming solvers through the PuLP package.
+Bases: object
Represents the extremum that needs to be determined.
+Find the longest path.
+Find the shortest path.
+Bases: LpProblem
Maintains information about an integer linear programming problem. +It is a subclass of the ~pulp.LpProblem class of the PuLP +package, and stores additional information relevant to the GameTime +analysis, such as the value of the objective function of the problem.
+Methods
+
|
+Adds a variable to the problem before a constraint is added |
+
|
+Adds variables to the problem before a constraint is added |
+
|
+Sets the status of the model after solving. |
+
|
+Checks if there are at least two variables with the same name :return: 1 :raises const.PulpError: if there ar duplicates |
+
|
+Checks if variables have names smaller than max_length :param int max_length: max size for variable name :return: :raises const.PulpError: if there is at least one variable that has a long name |
+
|
+Make a copy of self. |
+
|
+Make a copy of self. |
+
|
+extends an LpProblem by adding constraints either from a dictionary a tuple or another LpProblem object. |
+
|
+Takes a dictionary with all necessary information to build a model. |
+
|
+Creates a new Lp Problem from a json file with information |
+
|
+Takes a dictionary with all necessary information to build a model. |
+
|
+Creates a new Lp Problem from a json file with information |
+
|
+
|
+
|
+
|
+
|
+resolves an Problem using the same solver as previously |
+
|
+Rounds the lp variables |
+
|
+Solve the given Lp problem with several objective functions. |
+
|
+Sets the input variable as the objective function. |
+
|
+Sets the Solver for this problem useful if you are using resolve |
+
|
+Solve the given Lp problem. |
+
|
+initializes properties with the current time |
+
|
+updates time wall time and cpu time |
+
|
+creates a dictionary from the model with as much data as possible. |
+
|
+Creates a json file from the LpProblem information |
+
|
+creates a dictionary from the model with as much data as possible. |
+
|
+Creates a json file from the LpProblem information |
+
|
+Returns the problem variables |
+
|
+Write the given Lp problem to a .lp file. |
+
|
+Writes an mps files from the problem information |
+
add |
++ |
addConstraint |
++ |
assignConsPi |
++ |
assignConsSlack |
++ |
assignVarsDj |
++ |
assignVarsVals |
++ |
coefficients |
++ |
fixObjective |
++ |
fromMPS |
++ |
getSense |
++ |
get_dummyVar |
++ |
infeasibilityGap |
++ |
isMIP |
++ |
normalisedNames |
++ |
restoreObjective |
++ |
unusedConstraintName |
++ |
valid |
++ |
variablesDict |
++ |
Value of the objective function, stored for efficiency purposes.
+Determines either the longest or the shortest path through the DAG
+with the constraints stored in the Analyzer object provided.
analyzer – Analyzer object that maintains information about
+the code being analyzed.
extremum – Type of extreme path to calculate.
interval – Interval object that represents the interval of values
+that the generated paths can have. If no Interval object
+is provided, the interval of values is considered to be
+all_temp_files real numbers.
Tuple whose first element is the longest or the shortest path
through the DAG, as a list of nodes along the path (ordered
by traversal from source to sink), and whose second element is
the integer linear programming problem that was solved to obtain
the path, as an object of the IlpProblem class.
If no such path is feasible, given the constraints stored in
the Analyzer object and the Interval object provided,
the first element of the tuple is an empty list, and the second
element of the tuple is an IlpProblem object whose obj_al
instance variable is None.
pi = a_1 b_1 + … + a_n b_n
+of paths b_i from basis. This function returns the least number c +such that every path can be expressed as a linear combination of basis +paths b_i such that the sum of absolute value of coefficients is at +most c:
+++
analyzer – Analyzer object that maintains information about
+the code being analyzed.
paths – List of paths that we want to find out how well can be +expressed as a linear combination of paths in basis
basis – List of paths that are used to express paths as a linear +combination of
The number c as described in the paragraph above.
+specified by ‘analyzer’, that is feasible with the given set of +measurements as specified by ‘paths’. The method does not take into +account which paths are feasible and which not; it considers all_temp_files the +paths in the graph.
+analyzer – Analyzer object that maintains information about
+the code being analyzed.
paths – List of paths used in the measurements. Each path is a list of +edges in the order in which they are visited by the path
A floating point value—the least delta compatible with the +measurements
+float
+measured lengths of paths, as given in ‘paths’, such the actual +lengths are within ‘delta’ of the measured lengths
+analyzer – Analyzer object that maintains information about
+the code being analyzed.
paths – List of paths used in the measurements. Each path is a list of +edges in the order in which they are visited by the path
delta – the maximal limit by which the length of a measured path is +allowed to differ from the measured value
extremum – Specifies whether we are calculating Extremum.LONGEST or +Extremum.SHORTEST
Pair consisting of the resulting path and the ILP problem used to
calculate the path
smallest set of ‘basis paths’ with the following property: Each path pi +in `paths’, can be expressed as a linear combination
+++pi = a_1 b_1 + … + a_n b_n
+
of paths b_i from basis. This function finds the set of basis paths +such that every path can be expressed as a linear combination of basis +paths b_i such that the sum of absolute value of coefficients is at +most ‘k’:
+++
analyzer – Analyzer object that maintains information about
+the code being analyzed.
paths – List of paths that we want to find out how well can be +expressed as a linear combination of paths in basis
k – bound on how well the ‘paths’ can be expressed as a linear +combination of the calculated basis paths
List of paths satisfying the condition stated above
+assuming the lengths of all_temp_files measured paths are between -1 and 1.
+analyzer – Analyzer object that maintains information about
+the code being analyzed.
paths – List of paths used in the measurements. Each path is a list of +edges in the order in which they are visited by the path
bound –
???
+Triple consisting of the length of the longsest path, the path itself
and the ILP solved to find the path.
This function actually constructs the ILP to find the longest path +in the graph specified by ‘analyzer’ using the set of measured paths given +by ‘paths’.
+analyzer – Analyzer object that maintains information about
+the code being analyzed. Among others, contains the underlying
+DAG or the collection of infeasible paths.
paths – List of paths used in the measurements. Each path is a list of +edges in the order in which they are visited by the path
pathFunctionUpper – Function of type: path -> float that for a given path should +return the upper bound on the length of the given path. The +input ‘path’ is always from ‘paths’
pathFunctionLower – Function of type: path -> float that for a given path should +return the upper bound on the length of the given path. The +input ‘path’ is always from ‘paths’
weightsPositive – Boolean value specifying whether the individual edge weight are +required to be at least 0 (if set to True) or can be arbitrary +real value (if set to False)
printProblem – Boolean value used for debugging. If set to true, the generated +ILP is printed.
extremum – Specifies whether we are calculating Extremum.LONGEST or +Extremum.SHORTEST
Triple consisting of the length of the longest path found, the actual
path and the ILP problem generated.
ilp_solver_name (str :) – Name of the integer linear programming solver
project_config (ProjectConfiguration :) – ProjectConfiguration object that represents the configuration of a GameTime project
PuLP solver object that can interface with the integer
linear programming solver whose name is provided, or None, if
no such object can be found.
ilp_solver (pulp.LpSolver :) – Object of a PuLP solver class
+Name, as used by GameTime, of the integer linear programming +solver that the input PuLP solver object can interface with, +or None, if no such name can be found.
+str, Optional
+List of the names of the supported integer linear programming solvers.
+List[str]
+List of proper names of the supported integer linear programming +solvers, for display purposes.
+List[str]
+ilp_solver_name (str :) – Name of an integer linear programming solver used by GameTime
+Proper name of an integer linear programming solver, +for display purposes.
+str
+name (str :) – Possible name of an integer linear programming solver
+True if, and only if, the name provided is the name of a supported +integer linear programming solver.
+bool
+Compact means that if in the original graph, there is a simple +path without any branching between two nodes, then in the resulting +graph the entire simple path is replaced by only one edge
+dag – The graph that get compactified
+A mapping (vertex, vertex) -> edge_number so that the edge
(vertex, vertex) in the original graph ‘dag’ gets mapped to
the edge with number ‘edge_number’. All edges on a simple path
without branching get mapped to the same ‘edge_number’
Exposes classes and functions to maintain a representation of, and +to interact with, a backend, which will be used to measure values +that correspond to different paths in the code that is being analyzed.
+Bases: object
Maintains a representation of a backend, which will be used +to measure values that correspond to different paths in the code +that is being analyzed.
+Methods
+
|
+Perform measurement using the backend. |
+
Perform measurement using the backend.
+inputs (str:) – the inputs to drive down a PATH in a file
measure_folder (str :) – all generated files will be stored in MEASURE_FOLDER/{name of backend}
The measured value of path
+Name of the backend that this object represents.
+GameTime project configuration for the code that is being analyzed.
+Bases: Backend
Methods
+
|
+Modifies the input program to use INPUTS and generates the executable code. |
+
|
+Perform measurement using the backend. |
+
|
+Runs the executable in EXECUTABLE_PATH in host machine and extracts the outputs from program. |
+
Modifies the input program to use INPUTS and generates the executable code. Stored at MEASURE_FOLDER/driver
+filepath (str :) – Path to C file to modify with inputs.
func_name (str :) – Name of function being analyzed.
inputs (str :) – Path to the INPUTS file containing output of symbolic solver.
measure_folder (str :) – The folder to store generated executable.
Path to the executable code.
+Perform measurement using the backend.
+inputs (str:) – the inputs to drive down a PATH in a file
measure_folder (str :) – all generated files will be stored in MEASURE_FOLDER/{name of backend}
The measured value of path
+Runs the executable in EXECUTABLE_PATH in host machine and extracts the outputs from program. +Temperaries are stored in STORED_FOLDER.
+stored_folder (str :) – Folder to put all the generated tempraries.
executable_path (str :) – Path to executable.
Measured cycle count for EXECUTABLE_PATH.
+Bases: Backend
Methods
+
|
+Use same Make file mechanism as Flexpret to generate .mem file from .c |
+
|
+Modifies the input program to use INPUTS and returns path to modifed C program. |
+
|
+Perform measurement using the backend. |
+
|
+Run simulation on the .mem file generated. |
+
Use same Make file mechanism as Flexpret to generate .mem file from .c
+stored_folder (str :) – Folder to put all the generated tempraries.
file_name (str :) – Name of function being analyzed.
c_filepath (str :) – Path to C file being executed.
Measured cycle count for C_FILEPATH.
+Modifies the input program to use INPUTS and returns path to modifed C program.
+filepath (str :) – Path to C file to modify with inputs.
func_name (str :) – Name of function being analyzed.
inputs (str :) – Path to the INPUTS file containing output of symbolic solver.
measure_folder (str :) – The folder to store generated C code.
Path to the modified C file.
+Perform measurement using the backend.
+inputs (str:) – the inputs to drive down a PATH in a file
measure_folder (str :) – all generated files will be stored in MEASURE_FOLDER/{name of backend}
The measured value of path
+Run simulation on the .mem file generated. The measurements are stored in measure.out +Equivalent to: os.system(f”(cd {dir path of .mem file} && fp-emu –measure +ispm={file_name}.mem)”)
+stored_folder (str :) – Folder to put all the generated tempraries.
mem_filepath (str :) – Path to the .mem file +:return the measurement value
Measured cycle count for MEM_FILEPATH.
+Bases: Backend
Methods
+
|
+Modifies the input program to use INPUTS and generates the executable code. |
+
|
+Perform measurement using the backend. |
+
|
+Runs the executable in EXECUTABLE_PATH in host machine and extracts the outputs from program. |
+
Modifies the input program to use INPUTS and generates the executable code. Stored at MEASURE_FOLDER/driver
+filepath (str :) – Path to C file to modify with inputs.
func_name (str :) – Name of function being analyzed.
inputs (str :) – Path to the INPUTS file containing output of symbolic solver.
measure_folder (str :) – The folder to store generated executable.
Path to the executable code.
+Perform measurement using the backend.
+inputs (str:) – the inputs to drive down a PATH in a file
measure_folder (str :) – all generated files will be stored in MEASURE_FOLDER/{name of backend}
The measured value of path
+Runs the executable in EXECUTABLE_PATH in host machine and extracts the outputs from program. +Temperaries are stored in STORED_FOLDER.
+stored_folder (str :) – Folder to put all the generated tempraries.
executable_path (str :) – Path to executable.
Measured cycle count for EXECUTABLE_PATH.
++ Searching for multiple words only shows matches that contain + all words. +
+ + + + + + + + +