def routeStreamPath(self, path, s, curTime):
nodeA = path[0]
as_nodeA = sg.gnGraph.netGraph.node[nodeA]
for nodeB in path[1:]:
as_nodeB = sg.gnGraph.netGraph.node[nodeB]
link_AB = sg.gnGraph.netGraph[nodeA][nodeB]
if 'p2p_link' not in link_AB:
if sg.gnGraph.isAccessNode(
as_nodeA['type']
) or sg.gnGraph.isAccessNode(
as_nodeB['type']
):
link_AB['p2p_link'] = \
nl.netLink(
sg.BACKBONE_LINK_BANDWIDTH,
nodeA,
nodeB
)
else:
link_AB['p2p_link'] = \
nl.netLink(
sg.FAST_BACKBONE_LINK_BANDWIDTH,
nodeA,
nodeB
)
s.links.append(link_AB['p2p_link'])
nodeA = nodeB
as_nodeA = sg.gnGraph.netGraph.node[nodeA]
if s.streamType == sg.STREAM_NOISE and not sg.simRef.simulatorReady:
for l in s.links:
l.netDataStreams.append(s)
self.initStreamsList.append(s)
else:
sg.simRef.eventPush(
se.event(
curTime + sg.PROPAGATION_DELAY*len(path),
id(s),
sg.EVENT_STREAM_START,
s
)
)
return
def __init__(self, cr, sip, dip, s, cnl=None, strType=sg.STREAM_NORMAL):
self.transmitRate = 0
self.bottleneckLinkID = None
if cr is None:
return
# fields up to this point are necessary for calcFairThroughput
self.bottleneckLink = None
self.useParallel = True
self.tSeq = 0.0
self.tParal = 0.0
self.downloadedBit = 0
self.sizeBit = s
self.transmitPoint = None
self.consumeRate = float(cr)
self.srcIP = sip
self.dstIP = dip
self.links = []
self.id = 0
self.beingConsumed = False
self.beingTransmitted = False
self.consumePoint = 0
self.consumedBit = 0
self.bufferingBegin = 0.0
self.eventRef_trComplete = None
self.eventRef_consBegin = None
self.eventRef_consComplete = None
self.eventRef_bufferEmpty = None
self.eventRef_expand = None
self.eventRef_toLiveTRate = None
self.stats_startTime = None
self.stats_bufferingTime = 0.0
self.stats_bufferingEvents = 0
self.stats_bitRates = []
self.collectBitrateStats = False
self.stats_lastTransmitRate_time = 0
self.stats_transmitRate_sumRates = 0
self.stats_transmitRate_sumTime = 0
self.interestingResult = False
self.stats_events = []
self.streamType = strType
if strType == sg.STREAM_NORMAL or strType == sg.STREAM_NOISE:
self.links.append(nl.netLink(sg.LAN_LINK_RATE, None, None))
self.channel = cnl
self.connectedToCache = False # true when a stream is getting the data
# from a cache node
self.upCacheRef = None # link to the upped level cache, the one
# from which the stream gets its data
self.downCacheRef = None # link to the lower level cache, used to
# enable cache hierarchy
self.transmitingLive = False
return
def __init__(self, cr, sip, dip, s, cnl=None, strType=sg.STREAM_NORMAL):
self.transmitRate = 0
self.bottleneckLinkID = None
if cr is None:
return
# fields up to this point are necessary for calcFairThroughput
self.bottleneckLink = None
self.useParallel = True
self.tSeq = 0.0
self.tParal = 0.0
self.downloadedBit = 0
self.sizeBit = s
self.transmitPoint = None
self.consumeRate = float(cr)
self.srcIP = sip
self.dstIP = dip
self.links = []
self.id = 0
self.beingConsumed = False
self.beingTransmitted = False
self.consumePoint = 0
self.consumedBit = 0
self.bufferingBegin = 0.0
self.eventRef_trComplete = None
self.eventRef_consBegin = None
self.eventRef_consComplete = None
self.eventRef_bufferEmpty = None
self.eventRef_expand = None
self.eventRef_toLiveTRate = None
self.stats_startTime = None
self.stats_bufferingTime = 0.0
self.stats_bufferingEvents = 0
self.stats_bitRates = []
self.collectBitrateStats = False
self.stats_lastTransmitRate_time = 0
self.stats_transmitRate_sumRates = 0
self.stats_transmitRate_sumTime = 0
self.interestingResult = False
self.stats_events = []
self.streamType = strType
if strType == sg.STREAM_NORMAL or strType == sg.STREAM_NOISE:
self.links.append(nl.netLink(sg.LAN_LINK_RATE, None, None))
self.channel = cnl
self.connectedToCache = False # true when a stream is getting the data
# from a cache node
self.upCacheRef = None # link to the upped level cache, the one
# from which the stream gets its data
self.downCacheRef = None # link to the lower level cache, used to
# enable cache hierarchy
self.transmitingLive = False
return
def routeStreamPath_inclCache(self, path, s, curTime, first=True):
cacheOnDemand = sg.args.ondemandCache
nodeA = path[0]
as_nodeA = sg.gnGraph.netGraph.node[nodeA]
for nodeB in path[1:]:
link_AB = sg.gnGraph.netGraph[nodeA][nodeB]
# Creating a link between node A and B, if it does not exist yet
if 'p2p_link' not in link_AB:
# if one of the nodes is an 'access' AS node then the link
# speed is set to BACKBONE_LINK_BANDWIDTH
if sg.gnGraph.isAccessNode(
as_nodeA['type']
) or sg.gnGraph.isAccessNode(
sg.gnGraph.netGraph.node[nodeB]['type']
):
link_AB['p2p_link'] = \
nl.netLink(
sg.BACKBONE_LINK_BANDWIDTH,
nodeA,
nodeB
)
else:
link_AB['p2p_link'] = \
nl.netLink(
sg.FAST_BACKBONE_LINK_BANDWIDTH,
nodeA,
nodeB
)
if nodeA == path[0] or not sg.LOCAL_CACHE_ONLY:
# increase the cache-init counter and check the threshold
if 'nCacheRequests' not in as_nodeA:
as_nodeA['nCacheRequests'] = [0] * sg.NUMBER_CHANNELS
as_nodeA['nCacheRequests'][s.channel] += 1
if as_nodeA['nCacheRequests'][s.channel] >= \
sg.args.cachethreshold:
# threshold passed, add a cache
# (all checks are inside the 'addCacheToAS')
cache = None
if 'static_cache' in as_nodeA:
cache = self.addCacheToAS(
nodeA,
curTime,
s.channel,
static=True
)
elif cacheOnDemand and first:
cache = self.addCacheToAS(nodeA, curTime, s.channel)
if cache is not None\
and cache != s.downCacheRef \
and cache.attachNetDataStream(s, curTime):
# 'attachNetDataStream' returns False if cache is not
# ready yet, if connected -> stop routing
break
# if the stream is not connected to a
# cache @ node A (or there is no cache @ node A)
if not s.connectedToCache:
# add the link from node A to node B to the stream path
# (! this does not mean adding stream to all links along
# the path, this is done later)
s.links.append(link_AB['p2p_link'])
nodeA = nodeB
as_nodeA = sg.gnGraph.netGraph.node[nodeA]
# background noise streams: adding stream to all links along
# the path at init time
if not sg.simRef.simulatorReady and s.streamType == sg.STREAM_NOISE:
for l in s.links:
l.netDataStreams.append(s)
self.initStreamsList.append(s)
else:
# schedule 'start streaming' events
if not s.connectedToCache:
sg.simRef.eventPush(
se.event(
curTime + sg.PROPAGATION_DELAY*len(path),
id(s),
sg.EVENT_STREAM_START,
s
)
)
return
