예제 #1
0
    /**
     * Interpret successive calls.
     */
    void
    runLeg(trace::Call *call) {

        /* Consume successive calls for this thread. */
        do {

            assert(call);
            assert(call->thread_id == leg);

            retraceCall(call);
            delete call;
            call = parser->parse_call();

        } while (call && call->thread_id == leg);

        if (call) {
            /* Pass the baton */
            assert(call->thread_id != leg);
            flushRendering();
            race->passBaton(call);
        } else {
            /* Reached the finish line */
            if (0) std::cerr << "finished on leg " << leg << "\n";
            if (leg) {
                /* Notify the fore runner */
                race->finishLine();
            } else {
                /* We are the fore runner */
                finished = true;
            }
        }
    }
예제 #2
0
    /**
     * Interpret successive calls.
     */
    void
    runLeg(trace::Call *call) {

        /* Consume successive calls for this thread. */
        do {
            bool callEndsFrame = false;
            static trace::ParseBookmark frameStart;

            assert(call);
            assert(call->thread_id == leg);

            if (loopCount && call->flags & trace::CALL_FLAG_END_FRAME) {
                callEndsFrame = true;
                parser.getBookmark(frameStart);
            }

            retraceCall(call);
            delete call;
            call = parser.parse_call();

            /* Restart last frame if looping is requested. */
            if (loopCount) {
                if (!call) {
                    parser.setBookmark(lastFrameStart);
                    call = parser.parse_call();
                    if (loopCount > 0) {
                        --loopCount;
                    }
                } else if (callEndsFrame) {
                    lastFrameStart = frameStart;
                }
            }

        } while (call && call->thread_id == leg);

        if (call) {
            /* Pass the baton */
            assert(call->thread_id != leg);
            flushRendering();
            race->passBaton(call);
        } else {
            /* Reached the finish line */
            if (0) std::cerr << "finished on leg " << leg << "\n";
            if (leg) {
                /* Notify the fore runner */
                race->finishLine();
            } else {
                /* We are the fore runner */
                finished = true;
            }
        }
    }
예제 #3
0
    /**
     * Thread main loop.
     */
    void
    runRace(void) {
        os::unique_lock<os::mutex> lock(mutex);

        while (1) {
            while (!finished && !baton) {
                wake_cond.wait(lock);
            }

            if (finished) {
                break;
            }

            assert(baton);
            trace::Call *call = baton;
            baton = 0;

            runLeg(call);
        }

        if (0) std::cerr << "leg " << leg << " actually finishing\n";

        if (leg == 0) {
            race->stopRunners();
        }
    }
예제 #4
0
static void
mainLoop() {
    addCallbacks(retracer);

    long long startTime = 0; 
    frameNo = 0;

    startTime = os::getTime();

    if (singleThread) {
        trace::Call *call;
        while ((call = parser->parse_call())) {
            retraceCall(call);
            delete call;
        }
    } else {
        RelayRace race;
        race.run();
    }
    finishRendering();

    long long endTime = os::getTime();
    float timeInterval = (endTime - startTime) * (1.0 / os::timeFrequency);

    if ((retrace::verbosity >= -1) || (retrace::profiling)) {
        std::cout << 
            "Rendered " << frameNo << " frames"
            " in " <<  timeInterval << " secs,"
            " average of " << (frameNo/timeInterval) << " fps\n";
    }

    if (waitOnFinish) {
        waitForInput();
    } else {
        return;
    }
}
예제 #5
0
static void
mainLoop() {
    addCallbacks(retracer);

    long long startTime = 0; 
    frameNo = 0;

    startTime = os::getTime();

    if (singleThread) {
        trace::Call *call;
        while ((call = parser.parse_call())) {
            retraceCall(call);
            delete call;
        };
    } else {
        RelayRace race;
        race.run();
    }
    finishRendering();

    long long endTime = os::getTime();
    float timeInterval = (endTime - startTime) * (1.0 / os::timeFrequency);

    if ((retrace::verbosity >= -1) || (retrace::profiling)) {
        std::cout << 
            "Rendered " << frameNo << " frames"
            " in " <<  timeInterval << " secs,"
            " average of " << (frameNo/timeInterval) << " fps\n";

        std::cout << std::endl;
        std::cout <<
            "Total number of calls: " << nCalls.tot() << std::endl;
        std::cout <<
            "Average number of calls: " << nCalls.avg() << std::endl;
        std::cout <<
            "Minimum number of calls: " << nCalls.min() << std::endl;
        std::cout <<
            "Maximum number of calls: " << nCalls.max() << std::endl;

        std::cout << std::endl;
        std::cout <<
            "Total number of render calls: " << nRenderCalls.tot() << std::endl;
        std::cout <<
            "Average number of render calls: " << nRenderCalls.avg() << std::endl;
        std::cout <<
            "Minimum number of render calls: " << nRenderCalls.min() << std::endl;
        std::cout <<
            "Maximum number of render calls: " << nRenderCalls.max() << std::endl;

        std::cout << std::endl;
        std::cout <<
            "Total texel uploads: " << texUploads.tot() << std::endl;
        std::cout <<
            "Average texel uploads: " << texUploads.avg() << std::endl;
        std::cout <<
            "Minimum texel uploads: " << texUploads.min() << std::endl;
        std::cout <<
            "Maximum texel uploads: " << texUploads.max() << std::endl;

        std::cout << std::endl;
        std::cout <<
            "Total number of triangles: " << nTriangles.tot() << std::endl;
        std::cout <<
            "Average number of triangles: " << nTriangles.avg() << std::endl;
        std::cout <<
            "Minimum number of triangles: " << nTriangles.min() << std::endl;
        std::cout <<
            "Maximum number of triangles: " << nTriangles.max() << std::endl;

        std::cout << std::endl;
        std::cout <<
            "Total number of vertices: " << nVertices.tot() << std::endl;
        std::cout <<
            "Average number of vertices: " << nVertices.avg() << std::endl;
        std::cout <<
            "Minimum number of vertices: " << nVertices.min() << std::endl;
        std::cout <<
            "Maximum number of vertices: " << nVertices.max() << std::endl;
    }

    if (waitOnFinish) {
        waitForInput();
    } else {
        return;
    }
}