def tryStartPstats(self):
        """ Starts the 'text-stats' PStatClient and connects to that client, in order
        to make pstats generate timings """
        self.procHandle = None

        if not PStatClient.getGlobalPstats().isConnected() and self.startDummyPstats:
            self.debug("Starting dummy pstats (text-stats)")
            nullFile = open(os.devnull, 'w')
            self.procHandle = subprocess.Popen(["text-stats"], stdout=nullFile, stderr=nullFile)
            atexit.register(self.stopPstats)
            PStatClient.connect()
        else:
            self.debug("PStats already running")
    def updateTimings(self):


        client = PStatClient.getGlobalPstats()
        gpuData = Globals.base.win.getGsg().getPstatsGpuData()
        numEvents = gpuData.getNumEvents()
        # gpuData.sortTime()

        if numEvents < 1:
            # Somehow pstats didn't start, nothing we can do about that
            self.numSamples = 0
            self.averagedEntries = [("~Please start & connect to pstats!", 0)]
            return

        dataset = {}
        lastStarts = {}


        for eventIdx in xrange(gpuData.getNumEvents()):
            collectorIdx = gpuData.getTimeCollector(eventIdx)
            collector = client.getCollector(collectorIdx)
            fname = collector.getFullname()

            if fname.count(":") >= 2:
                eventTime = gpuData.getTime(eventIdx)
                isStart = gpuData.isStart(eventIdx)
                
                if isStart:
                    lastStarts[fname] = eventTime
                else:
                    if fname not in lastStarts or lastStarts[fname] < 0:
                        print "ERROR: Overlapping time"

                    start = lastStarts[fname]
                    dur = eventTime - start
                    if fname in dataset:
                        dataset[fname] += dur
                    else:
                        dataset[fname] = dur

                    lastStarts[fname] = -1

        entries = []
        for key, val in dataset.iteritems():
            entries.append((key, val))

        # Create sum
        ftime = 0.0
        for key, dur in entries:
            ftime += dur

        entries.append(("~Total GPU Time", ftime))

        # Compute averages
        for name, dur in entries:
            if name in self.averages:
                self.averages[name] = self.averages[name][1:] + [dur]
            else:
                self.averages[name] = [0.0] * self.avgSamples
        # Generate list 
        self.averagedEntries = []

        for key, val in self.averages.iteritems():
            avg = sum(val) / float(self.avgSamples)
            self.averagedEntries.append((key, avg))

        self.averagedEntries.sort(key=lambda x: -x[1])