Subversion Repositories shark

/* Project:     OSLib

 * Description: The OS Construction Kit

 * Date:                1.6.2000

 * Idea by:             Luca Abeni & Gerardo Lamastra

 *

 * OSLib is an SO project aimed at developing a common, easy-to-use

 * low-level infrastructure for developing OS kernels and Embedded

 * Applications; it partially derives from the HARTIK project but it

 * currently is independently developed.

 *

 * OSLib is distributed under GPL License, and some of its code has

 * been derived from the Linux kernel source; also some important

 * ideas come from studying the DJGPP go32 extender.

 *

 * We acknowledge the Linux Community, Free Software Foundation,

 * D.J. Delorie and all the other developers who believe in the

 * freedom of software and ideas.

 *

 * For legalese, check out the included GPL license.

 */

/*      Stupid Scheduling Demo  */

#include <ll/i386/cons.h>

#include <ll/i386/tss-ctx.h>

#include <ll/i386/error.h>

#include <ll/sys/ll/ll-instr.h>

#include <ll/sys/ll/ll-func.h>

#include <ll/sys/ll/time.h>

#include <ll/sys/ll/event.h>

#include <ll/stdlib.h>

#define FREE 0

#define IDLE 1

struct ctx {

    WORD ll;

    struct timespec time;

    DWORD cputime;

    DWORD toexec;

    int acc;

    DWORD slice;

    int state;

};

struct trkevt {

    int thread;

    DWORD time;

    int value;

};

struct trkevt track[10000];

DWORD cpu[] = { 5000, 2000, 10000, 500, 5000, 6000, 20000, 1000, 7000 };

DWORD p[] =

    { 100000, 50000, 100000, 5000, 20000, 30000, 200000, 200000, 35000 };

#define STACK_SIZE      100000U /* Stack size in bytes          */

#define USE_FPU         0x0001

WORD th1, thm;

#define T 1000

#if 1

#define TO     ll_context_to

#define FROM   ll_context_from

#else

#define TO     ll_context_load

#define FROM   ll_context_save

#endif

/* For stack allocation checking */

BYTE stacks[STACK_SIZE];

#define N 10

struct ctx context[N];

int exec;

void endProg(void *p)

{

    int i;

    DWORD last[10] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };

    DWORD lasttime, lastthread;

    lasttime = 0;

    lastthread = 0;

    for (i = 0; i < 120; i++) {

        if (last[track[i].thread] != 0) {

            if (lastthread == 3) {

                message("Thread %d <-- time %lu (after %lu), Thread %lu executed for %lu --- %d\n",

                     track[i].thread, track[i].time,

                     track[i].time - last[track[i].thread], lastthread,

                     track[i].time - lasttime, track[i].value);

            }

        }

        lastthread = track[i].thread;

        last[track[i].thread] = track[i].time;

        lasttime = track[i].time;

    }

    ll_abort(110);

}

int schedule(void);

void endBudget(void *p)

{

    struct ctx *c = p;

    struct timespec time, toexec, xcuted, start;

    int newthread;

    ll_gettime(TIME_NEW, &time);

    NULL_TIMESPEC(&toexec);

    ADDNANO2TIMESPEC(c->toexec, &toexec);

    SUBTIMESPEC(&(c->time), &toexec, &start);

    SUBTIMESPEC(&time, &start, &xcuted);

    NULL_TIMESPEC(&toexec);

    ADDNANO2TIMESPEC(c->cputime * 1000, &toexec);

    SUBTIMESPEC(&xcuted, &toexec, &start);

    c->acc += TIMESPEC2NANOSEC(&start);

    newthread = schedule();

    TO(context[newthread].ll);

}

int schedule(void)

{

    static int k = 0;

    int toe;

    int done;

    done = 0;

    while (!done) {

        exec = (exec + 1) % N;

        while (context[exec].state == FREE) {

            exec = (exec + 1) % N;

        }

/*

                track[k].thread = exec;

                track[k].value = context[exec].acc;

                track[k].time = ll_gettime(TIME_NEW, &(context[exec].time));

                k++;

*/

        ll_gettime(TIME_NEW, &(context[exec].time));

        toe = (context[exec].cputime * 1000 - context[exec].acc);

        if (toe <= 0) {

            context[exec].acc -= (context[exec].cputime * 1000);

            k--;

        } else {

            done = 1;

        }

    }

    context[exec].toexec = toe;

    ADDNANO2TIMESPEC(toe, &(context[exec].time));

    event_post(context[exec].time, endBudget, &(context[exec]));

    return exec;

}

void thread(void *p)

{

    int i, ii;

    int position = 0;

    char mark[11];

    int active = 1;

    WORD count = 0;

    i = *(int *) p;

    while (active) {

/*

                printf_xy(10, i * 2 + 1, WHITE, "%c", mark);

*/

        count++;

        position = (position + 1) % 10;

        for (ii = 0; ii < 10; ii++) {

            mark[ii] = ' ';

        }

        mark[10] = 0;

        mark[position] = 'O';

        printf_xy(10, i * 2 + 1, WHITE, "%s", mark);

        printf_xy(25, i * 2 + 1, WHITE, "%d %u", i, count);

        for (ii = 0; ii < 10000; ii++);

        if (count == 1000)

            active = 0;

    }

    printf_xy(20, i * 2 + 1, WHITE, "Finished %d", i);

}

void killer(void)

{

    int th;

    cli();

    context[exec].state = FREE;

    th = schedule();

    sti();

    TO(context[th].ll);

}

int main(int argc, char *argv[])

{

    DWORD sp1, sp2;

    struct ll_initparms parms;

    void *mbi;

    DWORD t, oldt, secs;

    int th;

    int i;

    int pars[N];

    struct timespec endTime;

    sp1 = get_SP();

    cli();

    parms.mode = LL_ONESHOT;

    parms.tick = T;

    mbi = ll_init();

    event_init(&parms);

    if (mbi == NULL) {

        message("Error in LowLevel initialization code...\n");

        sti();

        l1_exit(-1);

    }

    message("LowLevel started...\n");

    for (i = 0; i < N - 1; i++) {

        pars[i] = i;

        context[i].ll =

            ll_context_create(thread, &stacks[STACK_SIZE * (i + 1) / N],

                              &(pars[i]), killer, 0);

        if (context[i].ll == 0) {

            error("Unable to create thread");

            ll_abort(100);

        }

        context[i].state = IDLE;

        context[i].cputime = cpu[i];

        context[i].toexec = cpu[i];

        context[i].acc = 0;

        context[i].slice = p[i];

    }

    context[N - 1].ll = FROM();

    context[N - 1].state = IDLE;

    context[N - 1].cputime = 200;

    context[N - 1].slice = 20000;

    message("All Threads created...\n");

    NULL_TIMESPEC(&endTime);

    endTime.tv_sec = 30;

    event_post(endTime, endProg, NULL);

    sti();

    cli();

    th = schedule();

    sti();

    TO(context[th].ll);

    message("Thread MAIN restartin'\n");

    secs = 0;

    oldt = 0;

    while (secs <= 20) {

        cli();

        t = ll_gettime(TIME_NEW, NULL);

        sti();

        if (t < oldt) {

            message("ARGGGGG! %lu %lu\n", t, oldt);

            ll_abort(99);

        }

        oldt = t;

        if ((t / 1000000) > secs) {

            secs++;

            printf_xy(40, 20, WHITE, "%lu     %lu    ", secs, t);

        }

    }

    message("\n DONE: Secs = %lu\n", secs);

    cli();

    ll_end();

    sp2 = get_SP();

    message("End reached!\n");

    message("Actual stack : %lx - ", sp2);

    message("Begin stack : %lx\n", sp1);

    message("Check if same : %s\n", sp1 == sp2 ? "Ok :-)" : "No :-(");

    return 1;

}