Method printInternal

runtime/TimeTrace.cc:213–338

* This private method does most of the work for both printToLog and * getTrace. * * \param buffers * Contains one or more TimeTrace::Buffers, whose contents will be merged * in the resulting output. Note: some of the buffers may extend * farther back in time than others. The output will cover only the * time period covered by *all* of the traces, ignoring older entries

 *      time trace. If NULL, the trace will be printed on the system log.
 */
void
TimeTrace::printInternal(std::vector<TimeTrace::Buffer*>* buffers, string* s)
{
    bool printedAnything = false;
    for (uint32_t i = 0; i < buffers->size(); i++) {
        buffers->at(i)->activeReaders.add(1);
    }

    // Initialize file for writing
    FILE* output = NULL;
    if (s == NULL)
        output = filename ? fopen(filename, "a") : stdout;

    // Holds the index of the next event to consider from each trace.
    std::vector<int> current;

    // Find the first (oldest) event in each trace. This will be events[0]
    // if we never completely filled the buffer, otherwise events[nextIndex+1].
    // This means we don't print the entry at nextIndex; this is convenient
    // because it simplifies boundary conditions in the code below.
    for (uint32_t i = 0; i < buffers->size(); i++) {
        TimeTrace::Buffer* buffer = buffers->at(i);
        int index = (buffer->nextIndex + 1) % Buffer::BUFFER_SIZE;
        if (buffer->events[index].format != NULL) {
            current.push_back(index);
        } else {
            current.push_back(0);
        }
    }

    // Decide on the time of the first event to be included in the output.
    // This is most recent of the oldest times in all the traces (an empty
    // trace has an "oldest time" of 0). The idea here is to make sure
    // that there's no missing data in what we print (if trace A goes back
    // farther than trace B, skip the older events in trace A, since there
    // might have been related events that were once in trace B but have since
    // been overwritten).
    uint64_t startTime = 0;
    for (uint32_t i = 0; i < buffers->size(); i++) {
        Event* event = &buffers->at(i)->events[current[i]];
        if ((event->format != NULL) && (event->timestamp > startTime)) {
            startTime = event->timestamp;
        }
    }

    // Skip all events before the starting time.
    for (uint32_t i = 0; i < buffers->size(); i++) {
        TimeTrace::Buffer* buffer = buffers->at(i);
        while ((buffer->events[current[i]].format != NULL) &&
                (buffer->events[current[i]].timestamp < startTime) &&
                (current[i] != buffer->nextIndex)) {
            current[i] = (current[i] + 1) % Buffer::BUFFER_SIZE;
        }
    }

    // Each iteration through this loop processes one event (the one with
    // the earliest timestamp).
    double prevTime = 0.0;