/ani/mrses

#define _GNU_SOURCE

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <sched.h>
#include <pthread.h>
#include <errno.h>

#include "msg.h"
#include "hw_sched.h"

#include "mrses_ppu.h"

#ifdef HW_HAVE_SPU
# include <libspe2.h>
# include "mrses_spu.h"

extern spe_program_handle_t mrses_spe;
#endif /* HW_HAVE_SPU */


#define MUTEX_INIT(ctx, name) \
    if (!err) err = pthread_mutex_init(&ctx->name##_mutex, NULL);
    
#define MUTEX_FREE(ctx, name) \
    pthread_mutex_destroy(&ctx->name##_mutex);

#define COND_INIT(ctx, name) \
    MUTEX_INIT(ctx, name##_cond) \
    if (!err) { \
	err = pthread_cond_init(&ctx->name##_cond, NULL); \
	if (err) { MUTEX_FREE(ctx, name##_cond) } \
    }

#define COND_FREE(ctx, name) \
    pthread_cond_destroy(&ctx->name##_cond); \
    MUTEX_FREE(ctx, name##_cond)

HWRunFunction ppu_run[] = {
    (HWRunFunction)mrses_ppu_run,
    (HWRunFunction)mrses_ppu_iterate,
    NULL
};

#ifdef HW_HAVE_SPU
HWRunFunction spu_run[] = {
    (HWRunFunction)mrses_spu_run,
    (HWRunFunction)mrses_spu_iterate,
    NULL
};
#endif /* HW_HAVE_SPU */

HWSched hw_sched_create() {
    int i;
    int err = 0;
    cpu_set_t mask;

    int ppu_count;
    HWSched ctx;
    
#ifdef HW_HAVE_SPU
    int spu_count;
    spe_context_ptr_t spe;
#endif /* HW_HAVE_SPU */

    ctx = (HWSched)malloc(sizeof(HWSchedS));
    if (!ctx) return NULL;

    memset(ctx, 0, sizeof(HWSchedS));

    ctx->status = 1;

    MUTEX_INIT(ctx, data);

    COND_INIT(ctx, compl);
    if (err) {
	MUTEX_FREE(ctx, data);
    }

    COND_INIT(ctx, job);
    if (err) {
	COND_FREE(ctx, compl);
	MUTEX_FREE(ctx, data);
    } else {
	ctx->sync_init = 1;
    }
    
    if (err) {
	fprintf(stderr, "Error initializing conditions and mutexes, errnon: %i\n", errno);
	hw_sched_destroy(ctx);
	return NULL;
    }


    err = sched_getaffinity(getpid(), sizeof(mask), &mask);

#ifdef CPU_COUNT
    ppu_count = CPU_COUNT(&mask);
#else
    for (ppu_count = 0; ppu_count < CPU_SETSIZE; ppu_count++) {
	if (!CPU_ISSET(ppu_count, &mask)) break;
    }
#endif

#ifdef HW_MAX_PPU
    if (ppu_count > HW_MAX_PPU) ppu_count = HW_MAX_PPU;
#endif /* HW_MAX_PPU */

    ctx->n_threads = 0;
    for (i = 0; i < ppu_count; i++) {
	ctx->thread[ctx->n_threads] = hw_thread_create(ctx, ctx->n_threads, NULL, ppu_run, NULL);
	if (ctx->thread[ctx->n_threads]) ++ctx->n_threads;
    }
    
#ifdef HW_HAVE_SPU
    spu_count = spe_cpu_info_get(SPE_COUNT_USABLE_SPES, -1);
    if ((spu_count + ctx->n_threads) > HW_MAX_THREADS) spu_count = HW_MAX_THREADS - ctx->n_threads;

#ifdef HW_MAX_SPU
    if (spu_count > HW_MAX_SPU) spu_count = HW_MAX_SPU;
#endif /* HW_MAX_SPU */

    for (i = 0; i < spu_count; i++) {
	spe = spe_context_create (0, NULL);
	if (spe == NULL) {
    	    reportError("Failed to create SPE context");
	    hw_sched_destroy(ctx);
	    return NULL;
	}
	
	err = spe_program_load (spe, &mrses_spe);
        if (err) {
    	    reportError("Failed to load program into the SPE, error: %i", err);
	    return NULL;
	}

	ctx->thread[ctx->n_threads] = hw_thread_create(ctx, ctx->n_threads, spe, spu_run, (HWFreeFunction)spe_context_destroy);
	if (ctx->thread[ctx->n_threads]) ++ctx->n_threads;
    }

    reportMessage("ppu: %i, spu: %i", ppu_count, spu_count);
#else /* HW_HAVE_SPU */
    reportMessage("threads: %i", ppu_count);
#endif /* HW_HAVE_SPU */


    return ctx;
}

static int hw_sched_wait_threads(HWSched ctx) {
    int i = 0;
    
    hw_sched_lock(ctx, compl_cond);
    while (i < ctx->n_threads) {
        for (; i < ctx->n_threads; i++) {
	    if (ctx->thread[i]->status == HW_THREAD_STATUS_INIT) {
		hw_sched_wait(ctx, compl);
		break;
	    }
	}
	
    }
    hw_sched_unlock(ctx, compl_cond);
    
    ctx->started = 1;

    return 0;
}

void hw_sched_destroy(HWSched ctx) {
    int i;

    if (ctx->n_threads > 0) {
	if (!ctx->started) {
	    hw_sched_wait_threads(ctx);
	}

	ctx->status = 0;
	hw_sched_lock(ctx, job_cond);
	hw_sched_broadcast(ctx, job);
	hw_sched_unlock(ctx, job_cond);
    
	for (i = 0; i < ctx->n_threads; i++) {
	    hw_thread_destroy(ctx->thread[i]);
	}
    }

    if (ctx->sync_init) {
        COND_FREE(ctx, job);
	COND_FREE(ctx, compl);
	MUTEX_FREE(ctx, data);
    }

    free(ctx);
}

int hw_sched_set_sequential_mode(HWSched ctx, int *n_blocks, int *cur_block) {
    ctx->mode = HW_SCHED_MODE_SEQUENTIAL;
    ctx->n_blocks = n_blocks;
    ctx->cur_block = cur_block;
    
    return 0;
}

int hw_sched_get_chunk(HWSched ctx, int thread_id) {
    int block;

    switch (ctx->mode) {
	case HW_SCHED_MODE_PREALLOCATED:
	    if (ctx->thread[thread_id]->status == HW_THREAD_STATUS_IDLE) {
		return thread_id;
	    } else {
		return -1;
	    }
	case HW_SCHED_MODE_SEQUENTIAL:
	    hw_sched_lock(ctx, data);
	    block = *ctx->cur_block;
	    if (block < *ctx->n_blocks) {
		*ctx->cur_block = *ctx->cur_block + 1;
	    } else {
		block = -1;
	    }
	    hw_sched_unlock(ctx, data);
	    return block;
	default:
	    return -1;
    }

    return -1;
}

    
int hw_sched_schedule_task(HWSched ctx, void *appctx, int entry) {
    if (!ctx->started) {
	hw_sched_wait_threads(ctx);
    }
    
    ctx->ctx = appctx;
    ctx->entry = entry;
    
    hw_sched_lock(ctx, compl_cond);

    hw_sched_lock(ctx, job_cond);
    hw_sched_broadcast(ctx, job);
    hw_sched_unlock(ctx, job_cond);

    return 0;
}

int hw_sched_wait_task(HWSched ctx) {
    int i = 0;

    while (i < ctx->n_threads) {
        for (; i < ctx->n_threads; i++) {
	    if (ctx->thread[i]->status == HW_THREAD_STATUS_DONE) {
		ctx->thread[i]->status = HW_THREAD_STATUS_IDLE;
	    } else {
		hw_sched_wait(ctx, compl);
		break;
	    }
	}
	
    }

/*        
    int i, running = 1;

	//wait all threads set running mode

    while (running) {
	hw_sched_wait(ctx, compl);
	
	running = 0;
        for (i = 0; i < ctx->n_threads; i++) {
	    if (ctx->thread[i]->status) {
		if (ctx->thread[i]->status == HW_THREAD_STATUS_DONE) {
		    ctx->thread[i]->status = HW_THREAD_STATUS_IDLE;
		} else {
		    running = 1;
		    break;
		}
	    }
	}
    }
*/

    hw_sched_unlock(ctx, compl_cond);


    return 0;
}