def reset(self):
"""Reset the fault injection component manager"""
ComponentManager.reset(self)
import ProbeLT32
self.__probeClass = ProbeLT32.ProbeLT32
self.__probeID = 0
self.__locationDescriptors = self.__loadComponentFaultLocationDescriptors()
self.__architectureFaultLocations = []
self.__probes = {}
def __init__(self, components):
"""Constructor for the fault injection component manager"""
ComponentManager.__init__(self, components) # init the standard component manager
import ProbeLT32
self.__probeClass = ProbeLT32.ProbeLT32
self.__probeID = 0 #id used for probes
self.__locationDescriptors = self.__loadComponentFaultLocationDescriptors() #load the decriptors of the fault location of each component.
self.__architectureFaultLocations = [] #fault locations for the current architecture
#probes connected to the current architecture
# the key is a tuple containing the names of the involved source and target ports. The value is a ProbleConnectionNode object
self.__probes = {}
self.__fi = None
def connectPorts(self, source, sourcePort, target, targetPort, enableProbe = True):
"""Connects two specified components on the specified ports. The references of the components and the ports to be connected
are required. Moreover, if specified, a probe is introduced on the connection, i.e., the source component is connected to the target
port of the probe and the target component is connected to the initiator port of the probe"""
#check if ports are already connected
key = (sourcePort.name(),targetPort.name())
if self.__probes.has_key(key):
return
if ComponentManager.areConnected(self, source, sourcePort, target, targetPort):
return
if enableProbe:
#instantiate the probe
probeInst = self.__probeClass('probe_'+str(self.__probeID))
self.__probeID = self.__probeID + 1
probeInPort = helper.getTLMInPort(probeInst)
if len(probeInPort) != 1:
raise exceptions.Exception('The probe must have exactly one target port')
probeOutPort = helper.getTLMOutPort(probeInst)
if len(probeOutPort) != 1:
raise exceptions.Exception('The probe must have exactly one initiator port')
#interconnect the components
ComponentManager.connectPorts(self, source, sourcePort, probeInst, probeInPort[0])
ComponentManager.connectPorts(self, probeInst, probeOutPort[0], target, targetPort)
#keep track of the connected probe
key = (sourcePort.name(), targetPort.name())
self.__probes[key] = ProbeConnectionNode(probeInst, source.name(), sourcePort.name(), target.name(), targetPort.name())
return probeInst
else:
ComponentManager.connectPorts(self, source, sourcePort, target, targetPort)
def registerComponent(self, component, attributes=None):
"""Registers a component instantiated in the architecture in the fault location list. It is possible to specify the attribute
to register; if no attribute is specified, all the possible attribute are registered"""
#check if component is a valid object
if not(helper.isSystemCComponent(component) and ComponentManager.getInstantiatedComponents(self).count(component.name()) == 1):
raise exception.Exception(str(component) + ' is not a valid SystemC component instantiated in the architecture')
#it is necessary to create a descriptor for each instance of the component
if self.__locationDescriptors.has_key(component.__class__):
#check if specified attributes exist in the component class
compAttributes = []
for currLocationsDescriptor in self.__locationDescriptors[component.__class__]:
compAttributes.append(currLocationsDescriptor.getAttribute())
if attributes == None:
attributes = compAttributes
else:
for currAttr in attributes:
if compAttributes.count(currAttr) == 0:
raise exceptions.Exception(str(currAttr) + ' is not a valid attribute for component ' + str(component))
#generate location descriptors for the specified component
for currLocationsDescriptor in self.__locationDescriptors[component.__class__]:
if attributes.count(currLocationsDescriptor.getAttribute()):
attribute = currLocationsDescriptor.getAttribute()
lines = currLocationsDescriptor.getLines()
wordSize = currLocationsDescriptor.getWordSize()
wrapperClass = currLocationsDescriptor.getWrapperClass()
#get the number of lines.
#it may be a number or also the name of a function to be called in order to load the value dinamically
try:
#the number of lines is specified into the file
lines = long(lines)
except:
#the number of lines is retrieved dinamically by reading an attribute or calling a method of the object
try:
pars = lines.split('.')
parRef = component
for nextParStr in pars:
parRef = getattr(parRef,nextParStr)
if callable(parRef):
lines = parRef()
else:
lines = parRef
except:
raise exceptions.Exception(str(lines) + ' attribute has not been found in component ' + str(component))
#get the word size.
#it may be a number or also the name of a function to be called in order to load the value dinamically
try:
wordSize = long(wordSize)
except:
try:
pars = lines.split('.')
parRef = component
for nextParStr in pars:
parRef = getattr(parRef,nextParStr)
if callable(parRef):
wordSize = parRef()
else:
wordSize = parRef
except:
raise exceptions.Exception(str(lines) + ' attribute has not been found in component ' + str(component))
#create the location descriptor
ld = locationDescriptor(component.name(), attribute, wrapperClass, lines, wordSize)
self.__architectureFaultLocations.append(ld)
