source: proiecte/swift/trunk/src/swift_scheduler.c @ 176

/*
 * swift_scheduler.c
 *
 * (c) 2009 Ionut Rosoiu <ionut.rosoiu@gmail.com>
 *
 */

#include "swift_scheduler.h"
#include <stdlib.h>
#include <sched.h>

inline
swift_thread_t* swift_get_steal_target(swift_context_t *context, swift_thread_t* thread)
{
        /* round robin */
        ++thread->round_robin_id;
        thread->round_robin_id %= context->thread_num;

        if (thread->round_robin_id == thread->id) {
                ++thread->round_robin_id;
                thread->round_robin_id %= context->thread_num;
        }

        return &context->threads[thread->round_robin_id];
}

inline
swift_frame_t* swift_get_frame(swift_context_t *context, swift_thread_t *thread)
{
        swift_frame_t *frame = NULL;
        swift_thread_t *target = NULL;
        swift_status_t status;

        /* 1. get a frame from the bottom of the workqueue */
        SWIFT_LOG(INFO, "[%d] get_frame_try_deq\n", thread->id);
        frame = swift_deque_pop(&thread->workque, &status);
        if (frame) {
                SWIFT_LOG_FRAME_INFO_STR("deq_bottom", thread, frame);
                goto exit;
        }

        /* 2. try to steal a frame */
        target = swift_get_steal_target(context, thread);
        SWIFT_LOG(INFO, "[%d] get_frame_try_steal %d\n", thread->id, target->id);
        do {
                frame = swift_deque_steal(&target->workque, &status);
        } while (status == SWIFT_DEQUE_ABORT);

        if (frame) {
                SWIFT_LOG_FRAME_INFO_STR("-STOLEN-", thread, frame);
                goto exit;
        }

        //FIXME: experimental!
        sched_yield();

exit:
        return frame;
}

inline
void swift_scheduler_execute(swift_thread_t *thread)
{
        swift_frame_t *frame;

        // execute some work
        SWIFT_LOG(INFO, "[%d] sched_exec\n", thread->id);
        frame = swift_get_frame(thread->context, thread);

        if (frame) {
                SWIFT_LOG_FRAME_INFO_STR("scheduler_execute", thread, frame);
                frame->closure(thread, frame);
        }
        //else {
        //      swift_backoff(thread, status);
        //      SWIFT_LOG(INFO, "[%d] slept %u\n", thread->id, thread->last_sleep_time);
        //}
}

inline
void swift_signal_frame_done(swift_thread_t *thread, swift_frame_t *frame)
{
        swift_status_t status;

        SWIFT_LOG_FRAME_INFO_STR("frame_done_signal_sync", thread, frame);

        /* signal sync */
        // decrement the number of frames needed to be sync'd
        SWIFT_ATOMIC_DECR(*frame->sync_frames_remaining);

        // this is the last frame for the sync
#ifdef LOGGING_ON
        // if this is the last frame before the sync, signal sync done
        if (SWIFT_CAS(*frame->sync_frames_remaining, 0, 0)) {
                SWIFT_LOG_FRAME_INFO_STR("frame_done_signal_sync_FINAL", thread, frame);
        }
#endif

        /* signal dependencies */
        if (frame->dependencies_frame) {
                swift_frame_t *f = frame->dependencies_frame;
                SWIFT_LOG_FRAME_INFO_STR("frame_done_signal_deps", thread, frame);

                SWIFT_ATOMIC_DECR(f->dependencies_no);

                // this is the last frame for the dependent frame
                if (SWIFT_CAS(f->dependencies_no, 0, 0)) {
                        SWIFT_LOG_FRAME_INFO_STR("frame_done_signal_deps_FINAL", thread, frame);
                        swift_deque_push(&thread->workque, f, &status);
                }
        }
}

inline
void swift_frame_done(swift_context_t *context, swift_thread_t *thread, swift_frame_t *frame)
{

        /* the last frame for the parallel region */
        if (SWIFT_FRAME_IS_END_PARALLEL(frame)) {
                SWIFT_LOG_FRAME_INFO_STR("--LAST FRAME DONE!--", thread, frame);
                thread->context->parallel_finished = 1;
        }

        thread->stats += 1;

        swift_retire_frame(thread, frame);
}