Example #1
0
    def testJoining(self):
        for traceFile in [testTrace1, testTrace2]:
            trace = self.loadTrace(traceFile)

            l = len(trace.events)
            a = TraceOperations.extract(trace, 0, l / 2)
            b = TraceOperations.extract(trace, l / 2, l)

            assert len(a.events) + len(b.events) == l

            newTrace = TraceOperations.join(a, b)
            self.assertEqualEventLists(newTrace.events, trace.events)

            for i, event in enumerate(newTrace.events):
                self.assertEqual(event.seq, i)
Example #2
0
 def testJoining(self):
   for traceFile in [testTrace1, testTrace2]:
     trace = self.loadTrace(traceFile)
      
     l = len(trace.events)
     a = TraceOperations.extract(trace, 0, l / 2)
     b = TraceOperations.extract(trace, l / 2, l)
      
     assert len(a.events) + len(b.events) == l
      
     newTrace = TraceOperations.join(a, b)
     self.assertEqualEventLists(newTrace.events, trace.events)
      
     for i, event in enumerate(newTrace.events):
       self.assertEqual(event.seq, i)
Example #3
0
    def playTrace(self,
                  traceName,
                  eventRange=None,
                  profile=False,
                  saveFrames=False,
                  checkCoherence=True,
                  synchronize=False):
        """
    Play back a trace file using a generated trace player.
    
    @param traceName:       Trace to play.
    @param eventRange:      Range of events to play, or all events by default.
    @param profile:         Should instrumentation data be collected or not.
    @param saveFrames:      Should frame buffer snapshots be saved or not.
    @param checkCoherence:  Verify that the trace is properly normalized before playing.
    @param sychronize:      Attempt to match the original trace timings.
    """
        if not traceName in self.analyzer.traces:
            self.analyzer.fail("Trace not found: %s" % traceName)

        trace = self.analyzer.traces[traceName]
        traceFileName = self.analyzer.traceFiles.get(traceName, None)
        profile = self.analyzer.parseBoolean(profile)
        saveFrames = self.analyzer.parseBoolean(saveFrames)
        checkCoherence = self.analyzer.parseBoolean(checkCoherence)
        synchronize = self.analyzer.parseBoolean(synchronize)

        # Create a temporary trace that only contains the needed events
        if eventRange is not None:
            firstEvent, lastEvent = self.analyzer.parseEventRange(
                trace, eventRange)
            traceFileName = None
            trace = TraceOperations.extract(trace, firstEvent, lastEvent)

        # Create a player
        player = Player.createPlayer(self.analyzer)

        # Play it
        self.analyzer.reportInfo("Playing trace.")
        logFile = player.play(trace,
                              traceFileName,
                              profile=profile,
                              saveFrames=saveFrames,
                              checkCoherence=checkCoherence,
                              synchronize=synchronize)

        # Load the instrumentation data if it exists
        if profile and logFile:
            Instrumentation.loadInstrumentationData(self.analyzer, trace,
                                                    logFile)
            self.analyzer.reportInfo(
                "Instrumentation data loaded for trace %s." % traceName)
Example #4
0
    def testExtraction(self):
        for traceFile in [testTrace1, testTrace2]:
            trace = self.loadTrace(traceFile)

            newTrace = TraceOperations.extract(trace, 10, 20)

            assert len(newTrace.events) == 10
            assert newTrace.events[0].time == 0
            assert newTrace.events[0].seq == 0
            assert newTrace.events[9].seq == 9

            self.assertEqualEventLists(newTrace.events, trace.events[10:20])

            newTrace.events[0].name = "foo"
            assert trace.events[0].name != "foo"
Example #5
0
 def testExtraction(self):
   for traceFile in [testTrace1, testTrace2]:
     trace = self.loadTrace(traceFile)
     
     newTrace = TraceOperations.extract(trace, 10, 20)
     
     assert len(newTrace.events) == 10
     assert newTrace.events[0].time == 0
     assert newTrace.events[0].seq  == 0
     assert newTrace.events[9].seq  == 9
     
     self.assertEqualEventLists(newTrace.events, trace.events[10:20])
     
     newTrace.events[0].name = "foo"
     assert trace.events[0].name != "foo"
Example #6
0
  def extractTrace(self, traceName, eventRange, traceNameOut = None):
    """
    Extract a portion of a trace to form a new trace.
    
    @param traceName:     Name of the source trace
    @param eventRange:    Event range to extract
    @param traceNameOut:  Name under which the resulting trace is saved, or the original trace by default.
    """
    if not traceName in self.analyzer.traces:
      self.analyzer.fail("Trace not found: %s" % traceName)
      
    if traceNameOut is None:
      traceNameOut = traceName

    trace = self.analyzer.traces[traceName]
    firstEvent, lastEvent = self.analyzer.parseEventRange(trace, eventRange)
    trace = TraceOperations.extract(trace, firstEvent, lastEvent)
    self.analyzer.traces[traceNameOut] = trace
    
    self.reportInfo("%d events extracted from trace %s to trace %s." % (len(trace.events), traceName, traceNameOut))
    return trace
Example #7
0
  def playTrace(self, traceName, eventRange = None, profile = False, saveFrames = False, checkCoherence = True,
                synchronize = False):
    """
    Play back a trace file using a generated trace player.
    
    @param traceName:       Trace to play.
    @param eventRange:      Range of events to play, or all events by default.
    @param profile:         Should instrumentation data be collected or not.
    @param saveFrames:      Should frame buffer snapshots be saved or not.
    @param checkCoherence:  Verify that the trace is properly normalized before playing.
    @param sychronize:      Attempt to match the original trace timings.
    """
    if not traceName in self.analyzer.traces:
      self.analyzer.fail("Trace not found: %s" % traceName)
    
    trace          = self.analyzer.traces[traceName]
    traceFileName  = self.analyzer.traceFiles.get(traceName, None)
    profile        = self.analyzer.parseBoolean(profile)
    saveFrames     = self.analyzer.parseBoolean(saveFrames)
    checkCoherence = self.analyzer.parseBoolean(checkCoherence)
    synchronize    = self.analyzer.parseBoolean(synchronize)
    
    # Create a temporary trace that only contains the needed events
    if eventRange is not None:
      firstEvent, lastEvent = self.analyzer.parseEventRange(trace, eventRange)
      traceFileName = None
      trace = TraceOperations.extract(trace, firstEvent, lastEvent)
      
    # Create a player
    player = Player.createPlayer(self.analyzer)

    # Play it
    self.analyzer.reportInfo("Playing trace.")
    logFile = player.play(trace, traceFileName, profile = profile, saveFrames = saveFrames, 
                          checkCoherence = checkCoherence, synchronize = synchronize)
    
    # Load the instrumentation data if it exists
    if profile and logFile:
      Instrumentation.loadInstrumentationData(self.analyzer, trace, logFile)
      self.analyzer.reportInfo("Instrumentation data loaded for trace %s." % traceName)
Example #8
0
    def extractTrace(self, traceName, eventRange, traceNameOut=None):
        """
    Extract a portion of a trace to form a new trace.
    
    @param traceName:     Name of the source trace
    @param eventRange:    Event range to extract
    @param traceNameOut:  Name under which the resulting trace is saved, or the original trace by default.
    """
        if not traceName in self.analyzer.traces:
            self.analyzer.fail("Trace not found: %s" % traceName)

        if traceNameOut is None:
            traceNameOut = traceName

        trace = self.analyzer.traces[traceName]
        firstEvent, lastEvent = self.analyzer.parseEventRange(
            trace, eventRange)
        trace = TraceOperations.extract(trace, firstEvent, lastEvent)
        self.analyzer.traces[traceNameOut] = trace

        self.reportInfo("%d events extracted from trace %s to trace %s." %
                        (len(trace.events), traceName, traceNameOut))
        return trace