예제 #1
0
파일: BcTest.c 프로젝트: taysom/tau
void
BcTest16(void)
{
	enum { NUM_KEYS = ONE_MILLION };
	static Key key[NUM_KEYS];
	VAR_LUMP(v, MAX_DATA);
	Bc t;
	Key a;
	bool found;
	u64 start, dt;
	u64 i;

	printf("%s\n", __FUNCTION__);
	RandLump(v);
	init_twister(17);
	BcInit(&t, KEY_LEN);
	for (i = 0; i < NUM_KEYS; i++) {
		a = RandKey();
		key[i] = a;
		BcPut(&t, a.s, v);
	}
	start = nsecs();
	for (i = 0; i < NUM_KEYS; i++) {
		a = key[i];
		BcGet(&t, a.s, &found);
		if (!found) fatal("didn't find %s", a.s);
	}
	dt = nsecs() - start;
	printf("%llu nsecs  %g nsecs/get op\n", dt, (double)dt/(double)i);
	BcFree(&t);
}
예제 #2
0
파일: BcTest.c 프로젝트: taysom/tau
void
BcTest7(void)
{
	enum { NUM_RECS = 20 };
	VAR_LUMP(v, MAX_DATA);
	Key key = {{0}};
	Bc t;

	printf("%s\n", __FUNCTION__);
	init_twister(17);
	BcInit(&t, KEY_LEN);
	for (u64 i = 0; i < NUM_RECS; i++) {
		RandLump(v);
		BcPut(&t, RandKey().s, v);
	}
	BcDump(__FUNCTION__, &t);
	for (;;) {
		bool done;

		BcNext(&t, key.s, key.s, &done);
		if (done) {
			break;
		}
		BcDelete(&t, key.s);
	}
	BcDelete(&t, key.s);
	BcDump("Should be empty", &t);
	BcReport(__FUNCTION__, BcDoAudit(&t));
	if (0) aver(t.root == NULL);
	BcFree(&t);
}
예제 #3
0
파일: BcTest.c 프로젝트: taysom/tau
void
BcTest14(void)
{
	enum { NUM_RECS = 200, NUM_ITER = 100 * ONE_THOUSAND };
	VAR_LUMP(v, MAX_DATA);
	Bc *t = emalloc(sizeof(*t) * NUM_ITER);
	u64 start, dt;
	u64 i, j;

	printf("%s\n", __FUNCTION__);
	init_twister(17);
	RandLump(v);
	start = nsecs();
	for (j = 0; j < NUM_ITER; j++) {
		BcInit(&t[j], KEY_LEN);
		for (i = 0; i < NUM_RECS; i++) {
			BcPut(&t[j], RandKey().s, v);
		}
	}
	dt = nsecs() - start;
	printf("%llu nsecs  %g nsecs/op\n", dt, (double)dt/(double)(i * j));
	BcReport(__FUNCTION__, BcDoAudit(&t[0]));
	for (j = 0; j < NUM_ITER; j++) {
		BcDoAudit(&t[j]);
		BcFree(&t[j]);
	}
}
예제 #4
0
파일: Time.c 프로젝트: taysom/tau
void TestPrTime(void) {
	init_twister(nsecs());
	for (int i = 0; i < 50; i++) {
		u64 t = twister_urand(1ull<<i);
		printf("%3d. %16lld %s\n", i, t, TimeStringer(t).s);
	}
}
예제 #5
0
파일: BcTest.c 프로젝트: taysom/tau
void
BcTest6(void)
{
	enum { NUM_RECS = 2000, NUM_TRIALS = ONE_MILLION };
	Bc t;
	VAR_LUMP(v, MAX_DATA);
	Key a[NUM_RECS];
	u64 n = 0;
	u64 puts = 0;
	u64 deletes = 0;

	printf("%s\n", __FUNCTION__);
	init_twister(37);
	BcInit(&t, KEY_LEN);
	for (u64 j = 0; j < NUM_TRIALS; j++) {
		Key key;
		bool found;
		if (Prob(((NUM_RECS - n) * 100) / NUM_RECS)) {
			aver(n < NUM_RECS);
			key = IntKey(twister_urand(10000));
			BcGet(&t, key.s, &found);
			if (!found) {
				a[n++] = key;
				RandLump(v);
				BcPut(&t, key.s, v);
				++puts;
			}
			if (0 || Prob(2)) Audit("Put", &t, a, n, j);
		} else {
			aver(0 < n);
			u64 i = twister_urand(n);
			key = a[i];
			BcGet(&t, key.s, &found);
			if (!found) {
				BcDump("not found", &t);
				fatal("didn't find %s %llu %llu", key.s, puts, deletes);
			}
			BcDelete(&t, key.s);
			BcGet(&t, key.s, &found);
			if (found) {
				BcDump("found", &t);
				fatal("found %llu", key);
			}
			a[i] = a[--n];
			++deletes;
			if (0 || Prob(2)) Audit("Delete", &t, a, n, j);
		}
	}
	BcDoAudit(&t);
	printf("\tputs=%llu deletes=%llu\n", puts, deletes);
	BcReport(__FUNCTION__, BcDoAudit(&t));
	BcDump(__FUNCTION__, &t);
	BcFree(&t);
}
예제 #6
0
파일: BbTest.c 프로젝트: taysom/tau
void
BbTest17(void)
{
	enum { NUM_KEYS = ONE_MILLION };
	static Key key[NUM_KEYS];
	VAR_LUMP(v, MAX_DATA);
	Bb t;
	BB_ITER(iter, sizeof(Key));
	bool found;
	u64 start, dt;
	u64 i;

	printf("%s\n", __FUNCTION__);
	RandLump(v);
	init_twister(17);
	BbInit(&t, KEY_LEN);
	for (i = 0; i < NUM_KEYS; i++) {
		key[i] = RandKey();
	}

	start = nsecs();
	for (i = 0; i < NUM_KEYS; i++) {
		BbPut(&t, key[i].s, v);
	}
	dt = nsecs() - start;
	printf("BbPut: %llu nsecs  %g nsecs/put op\n", dt, (double)dt/(double)i);

	start = nsecs();
	for (i = 0; i < NUM_KEYS; i++) {
		BbGet(&t, key[i].s, &found);
		if (!found) fatal("didn't find %s", key[i].s);
	}
	dt = nsecs() - start;
	printf("BbGet: %llu nsecs  %g nsecs/get op\n", dt, (double)dt/(double)i);

	//BbIter *iter = BbIterNew(&t);
	BbIterInit(iter, &t);
	start = nsecs();
	for (i = 0; i < NUM_KEYS; i++) {
		if (!BbIterNext(iter)) fatal("didn't find %s", iter->key);
	}
	dt = nsecs() - start;
	//BbIterFree(iter);
	printf("BbIter: %llu nsecs  %g nsecs/get op\n", dt, (double)dt/(double)i);

	start = nsecs();
	for (i = 0; i < NUM_KEYS; i++) {
		BbDelete(&t, key[i].s);
	}
	dt = nsecs() - start;
	printf("BbDelete: %llu nsecs  %g nsecs/delete op\n", dt, (double)dt/(double)i);
	BbFree(&t);
}
예제 #7
0
파일: BaTest.c 프로젝트: taysom/tau
void
BaTest6(void)
{
    enum { NUM_RECS = 2000, NUM_TRIALS = ONE_MILLION };
    Ba t;
    u64 a[NUM_RECS];
    u64 n = 0;
    u64 puts = 0;
    u64 deletes = 0;

    printf("%s\n", __FUNCTION__);
    init_twister(17);
    BaInit(&t);
    for (u64 j = 0; j < NUM_TRIALS; j++) {
        u64 key;
        bool found;

        if (Prob(((NUM_RECS - n) * 100) / NUM_RECS)) {
            aver(n < NUM_RECS);
            key = twister_urand(10000);
            BaGet(&t, key, &found);
            if (!found) {
                a[n++] = key;
                BaPut(&t, key);
                ++puts;
            }
            if (0 || twister_urand(100) < 2) Audit("Put", &t, a, n, j);
        } else {
            aver(0 < n);
            u64 i = twister_urand(n);
            key = a[i];
            BaGet(&t, key, &found);
            if (!found) {
                BaDump("not found", &t);
                fatal("didn't find %llu %llu %llu", key, puts, deletes);
            }
            BaDelete(&t, key);
            BaGet(&t, key, &found);
            if (found) {
                BaDump("found", &t);
                fatal("found %llu", key);
            }
            a[i] = a[--n];
            ++deletes;
            if (0 || twister_urand(100) < 2) Audit("Delete", &t, a, n, j);
        }
    }
    BaDoAudit(&t);
    printf("\tputs=%llu deletes=%llu\n", puts, deletes);
    BaReportAudit(__FUNCTION__, BaDoAudit(&t));
    BaDump(__FUNCTION__, &t);
}
예제 #8
0
파일: BcTest.c 프로젝트: taysom/tau
void
BcTest18(void)
{
	enum { NUM_KEYS = 1000 * ONE_THOUSAND };
	static BigKey key[NUM_KEYS];
	BigKey startKey = {{ 0 }};
	VAR_LUMP(v, MAX_DATA);
	Bc t;
	BB_ITER(iter, sizeof(key[0]));
	bool found;
	u64 start, dt;
	u64 i;

	printf("%s\n", __FUNCTION__);
	RandLump(v);
	init_twister(17);
	BcInit(&t, sizeof(key[0]));
	for (i = 0; i < NUM_KEYS; i++) {
		key[i] = RandBigKey();
	}

	start = nsecs();
	for (i = 0; i < NUM_KEYS; i++) {
		BcPut(&t, key[i].s, v);
	}
	dt = nsecs() - start;
	printf("BcPut: %llu nsecs  %g nsecs/put op\n", dt, (double)dt/(double)i);

	start = nsecs();
	for (i = 0; i < NUM_KEYS; i++) {
		BcGet(&t, key[i].s, &found);
		if (!found) fatal("didn't find %s", key[i].s);
	}
	dt = nsecs() - start;
	printf("BcGet: %llu nsecs  %g nsecs/get op\n", dt, (double)dt/(double)i);

	BcIterInit(iter, &t, startKey.s);
	start = nsecs();
	for (i = 0; i < NUM_KEYS; i++) {
		if (!BcIterNext(iter)) fatal("didn't find %u. %s", i, iter->key);
	}
	dt = nsecs() - start;
	printf("BcIter: %llu nsecs  %g nsecs/get op\n", dt, (double)dt/(double)i);

	start = nsecs();
	for (i = 0; i < NUM_KEYS; i++) {
		BcDelete(&t, key[i].s);
	}
	dt = nsecs() - start;
	printf("BcDelete: %llu nsecs  %g nsecs/delete op\n", dt, (double)dt/(double)i);
	BcFree(&t);
}
예제 #9
0
파일: BaTest.c 프로젝트: taysom/tau
void
BaTest4(void)
{
    enum { NUM_RECS = 20 };
    Ba t;
    bool found;

    printf("%s\n", __FUNCTION__);
    init_twister(17);
    BaInit(&t);
    for (u64 i = 0; i < NUM_RECS; i++) {
        BaPut(&t, twister_random());
    }
    init_twister(17);
    for (u64 i = 0; i < NUM_RECS; i++) {
        BaGet(&t, twister_random(), &found);
        if (!found) {
            fatal("didn't find %llu", i);
        }
    }
    BaDump(__FUNCTION__, &t);
}
예제 #10
0
파일: BaTest.c 프로젝트: taysom/tau
void
BaTest2(void)
{
    enum { NUM_RECS = 20 };
    Ba t;

    printf("%s\n", __FUNCTION__);
    init_twister(17);
    BaInit(&t);
    for (u64 i = 0; i < NUM_RECS; i++) {
        BaPut(&t, twister_random());
    }
    BaDump(__FUNCTION__, &t);
}
예제 #11
0
파일: BcTest.c 프로젝트: taysom/tau
void
BcTest8(void)
{
	/*
	 * Extensive test of all functions. Want to cover most code paths.
	 * 1. Dynamically adjust number of records by a factor of 100.
	 * 2. Randomly pick operations.
	 * 3. Test iteration intermixed with other operations.
	 */
	enum { MAX_RECS = 100 * ONE_THOUSAND };

	Bc t;
	u64 key;
	u64 keys[MAX_RECS];
	u64 numKeys = 0;
	u64 numPuts = 0;
	u64 numDeletes = 0;
	VAR_LUMP(v, MAX_DATA);

	init_twister(37);
	BcInit(&t, KEY_LEN);
	RandLump(v);
	for (u64 i = 0; i < 10; i++) {
		u64 maxKeys = twister_urand(MAX_RECS);
		PRu(maxKeys);
		while (numKeys != maxKeys) {
			aver(numKeys <= MAX_RECS);
			if (numKeys < maxKeys && Prob(75)) {
				key = twister_random();
				keys[numKeys++] = key;
				BcPut(&t, IntKey(key).s, v);
				++numPuts;
			} else {
				if (numKeys) {
					u64 j = twister_urand(numKeys);
					key = keys[j];
					keys[j] = keys[--numKeys];
					BcDelete(&t, IntKey(key).s);
					++numDeletes;
				}
			}
		}
	}
	aver(numPuts - numDeletes == numKeys);
	PRu(numPuts);
	PRu(numDeletes);
	PRu(numKeys);
	BcReport(__FUNCTION__, BcDoAudit(&t));
}
예제 #12
0
파일: BzTest.c 프로젝트: taysom/tau
void
BzTest2(void)
{
	enum { NUM_RECS = 100 };
	VAR_LUMP(v, MAX_DATA);
	Bz t;

	printf("%s\n", __FUNCTION__);
	init_twister(17);
	BzInit(&t, KEY_LEN);
	for (u64 i = 0; i < NUM_RECS; i++) {
		if (1) IntLump(v, i);
		else IntLump(v, twister_urand(1000));
		if (0) BzPut(&t, RandKey().s, v);
		else BzPut(&t, IntKey(twister_urand(1000)).s, v);
	}
	BzDump(__FUNCTION__, &t);
}
예제 #13
0
파일: BaTest.c 프로젝트: taysom/tau
void
BaTest13(void)
{
    enum { NUM_RECS = 10 * ONE_MILLION / 10 };
    Ba t;
    u64 start, dt;
    u64 i;

    printf("%s\n", __FUNCTION__);
    init_twister(17);
    BaInit(&t);
    start = nsecs();
    for (i = 0; i < NUM_RECS; i++) {
        BaPut(&t, twister_random());
    }
    dt = nsecs() - start;
    printf("%llu nsecs  %g nsecs/op\n", dt, (double)dt/(double)i);
    BaReportAudit(__FUNCTION__, BaDoAudit(&t));
}
예제 #14
0
파일: BzTest.c 프로젝트: taysom/tau
void
BzTest17(void)
{
	enum { NUM_KEYS = ONE_MILLION };
	static Key key[NUM_KEYS];
	VAR_LUMP(v, MAX_DATA);
	Bz t;
	bool found;
	u64 start, dt;
	u64 i;

	printf("%s\n", __FUNCTION__);
	RandLump(v);
	init_twister(17);
	BzInit(&t, KEY_LEN);
	for (i = 0; i < NUM_KEYS; i++) {
		key[i] = RandKey();
	}

	start = nsecs();
	for (i = 0; i < NUM_KEYS; i++) {
		BzPut(&t, key[i].s, v);
	}
	dt = nsecs() - start;
	printf("%llu nsecs  %g nsecs/put op\n", dt, (double)dt/(double)i);

	start = nsecs();
	for (i = 0; i < NUM_KEYS; i++) {
		BzGet(&t, key[i].s, &found);
		if (!found) fatal("didn't find %s", key[i].s);
	}
	dt = nsecs() - start;
	printf("%llu nsecs  %g nsecs/get op\n", dt, (double)dt/(double)i);

	start = nsecs();
	for (i = 0; i < NUM_KEYS; i++) {
		BzDelete(&t, key[i].s);
	}
	dt = nsecs() - start;
	printf("%llu nsecs  %g nsecs/delete op\n", dt, (double)dt/(double)i);
}
예제 #15
0
파일: BzTest.c 프로젝트: taysom/tau
void
BzTest13(void)
{
	enum { NUM_RECS = 10 * ONE_MILLION / 10 };
	VAR_LUMP(v, MAX_DATA);
	Bz t;
	u64 start, dt;
	u64 i;

	printf("%s\n", __FUNCTION__);
	init_twister(17);
	BzInit(&t, KEY_LEN);
	RandLump(v);
	start = nsecs();
	for (i = 0; i < NUM_RECS; i++) {
		BzPut(&t, RandKey().s, v);
	}
	dt = nsecs() - start;
	printf("%llu nsecs  %g nsecs/op\n", dt, (double)dt/(double)i);
	BzReportAudit(__FUNCTION__, BzDoAudit(&t));
}
예제 #16
0
파일: BaTest.c 프로젝트: taysom/tau
void
BaTest14(void)
{
    enum { NUM_RECS = 200, NUM_ITER = 100 * ONE_THOUSAND };
    Ba t;
    u64 start, dt;
    u64 i, j;

    printf("%s\n", __FUNCTION__);
    init_twister(17);
    start = nsecs();
    for (j = 0; j < NUM_ITER; j++) {
        BaInit(&t);
        for (i = 0; i < NUM_RECS; i++) {
            BaPut(&t, twister_random());
        }
    }
    dt = nsecs() - start;
    printf("%llu nsecs  %g nsecs/op\n", dt, (double)dt/(double)(i * j));
    BaReportAudit(__FUNCTION__, BaDoAudit(&t));
}
예제 #17
0
파일: BaTest.c 프로젝트: taysom/tau
void
BaTest17(void)
{
    enum { NUM_KEYS = ONE_MILLION };
    static u64 key[NUM_KEYS];
    Ba t;
    bool found;
    u64 start, dt;
    u64 i;

    printf("%s\n", __FUNCTION__);
    init_twister(17);
    BaInit(&t);
    for (i = 0; i < NUM_KEYS; i++) {
        key[i] = twister_random();
    }

    start = nsecs();
    for (i = 0; i < NUM_KEYS; i++) {
        BaPut(&t, key[i]);
    }
    dt = nsecs() - start;
    printf("%llu nsecs  %g nsecs/put op\n", dt, (double)dt/(double)i);

    start = nsecs();
    for (i = 0; i < NUM_KEYS; i++) {
        BaGet(&t, key[i], &found);
        if (!found) fatal("didn't find %llu", key[i]);
    }
    dt = nsecs() - start;
    printf("%llu nsecs  %g nsecs/get op\n", dt, (double)dt/(double)i);

    start = nsecs();
    for (i = 0; i < NUM_KEYS; i++) {
        BaDelete(&t, key[i]);
    }
    dt = nsecs() - start;
    printf("%llu nsecs  %g nsecs/delete op\n", dt, (double)dt/(double)i);
}
예제 #18
0
파일: BzTest.c 프로젝트: taysom/tau
void
BzTest14(void)
{
	enum { NUM_RECS = 200, NUM_ITER = 100 * ONE_THOUSAND };
	VAR_LUMP(v, MAX_DATA);
	Bz t;
	u64 start, dt;
	u64 i, j;

	printf("%s\n", __FUNCTION__);
	init_twister(17);
	RandLump(v);
	start = nsecs();
	for (j = 0; j < NUM_ITER; j++) {
		BzInit(&t, KEY_LEN);
		for (i = 0; i < NUM_RECS; i++) {
			BzPut(&t, RandKey().s, v);
		}
	}
	dt = nsecs() - start;
	printf("%llu nsecs  %g nsecs/op\n", dt, (double)dt/(double)(i * j));
	BzReportAudit(__FUNCTION__, BzDoAudit(&t));
}
예제 #19
0
파일: BcTest.c 프로젝트: taysom/tau
void
BcTest5(void)
{
	enum { NUM_RECS = 20 };
	VAR_LUMP(v, MAX_DATA);
	Key key = {{0}};
	Lump a, b;
	Bc t;
	bool found;

	printf("%s\n", __FUNCTION__);
	init_twister(17);
	BcInit(&t, KEY_LEN);
	for (u64 i = 0; i < NUM_RECS; i++) {
		IntLump(v, i);
		BcPut(&t, RandKey().s, v);
	}
	BcDump(__FUNCTION__, &t);
	for (u64 i = 0;;i++) {
		bool done;

		a = BcNext(&t, key.s, key.s, &done);
		if (done) {
			if (i != NUM_RECS) fatal("Didn't find all the keys %llu %u", i, NUM_RECS);
			break;
		}
		b = BcGet(&t, key.s, &found);
		if (!found) {
			fatal("didn't find %llu", key);
		}
		aver(a.len == b.len);
		aver(strcmp(a.p, b.p) == 0);
	}
	BcDump(__FUNCTION__, &t);
	BcFree(&t);
}
예제 #20
0
파일: BzTest.c 프로젝트: taysom/tau
void
BzTest15(void)
{
	enum { NUM_RECS = 200, NUM_ITER = 100 * ONE_THOUSAND };
	VAR_LUMP(v, MAX_DATA);
	Bz t[NUM_ITER];
	bool found;
	u64 start, dt;
	u64 i, j;

	printf("%s\n", __FUNCTION__);

	RandLump(v);
	init_twister(17);
	start = nsecs();
	for (j = 0; j < NUM_ITER; j++) {
		BzInit(&t[j], KEY_LEN);
		for (i = 0; i < NUM_RECS; i++) {
			BzPut(&t[j], RandKey().s, v);
		}
	}
	dt = nsecs() - start;
	printf("put %llu nsecs  %g nsecs/op\n", dt, (double)dt/(double)(i * j));

	init_twister(17);
	start = nsecs();
	for (j = 0; j < NUM_ITER; j++) {
		for (i = 0; i < NUM_RECS; i++) {
			BzGet(&t[j], RandKey().s, &found);
			if (!found) {
				fatal("Didn't find key for iter %llu rec %llu", j, i);
			}
		}
	}
	dt = nsecs() - start;
	printf("get %llu nsecs  %g nsecs/op\n", dt, (double)dt/(double)(i * j));

	start = nsecs();
	for (j = 0; j < NUM_ITER; j++) {
		for (i = 0; i < NUM_RECS; i++) {
			Key key;
			bool isEof;
			BzNext(&t[j], RandKey().s, key.s, &isEof);
			if (!found) {
				fatal("Didn't find key for iter %llu rec %llu", j, i);
			}
		}
	}
	dt = nsecs() - start;
	printf("next %llu nsecs  %g nsecs/op\n", dt, (double)dt/(double)(i * j));

	init_twister(17);
	start = nsecs();
	for (j = 0; j < NUM_ITER; j++) {
		for (i = 0; i < NUM_RECS; i++) {
			RandKey();
		}
	}
	dt = nsecs() - start;
	printf("overhead %llu nsecs  %g nsecs/op\n", dt, (double)dt/(double)(i * j));
}
예제 #21
0
파일: jobshop.c 프로젝트: gunnarrb/isal
int
main ()				/* Main function. */
{
    /* Open input and output files. */

    infile = fopen ("jobshop.in", "r");
    outfile = fopen ("jobshop.out", "w");

    /* Read input parameters. */

    fscanf (infile, "%d %d %lg %lg", &num_stations, &num_job_types, &mean_interarrival, &length_simulation);
    for (j = 1; j <= num_stations; ++j)
        fscanf (infile, "%d", &num_machines[j]);
    for (i = 1; i <= num_job_types; ++i)
        fscanf (infile, "%d", &num_tasks[i]);
    for (i = 1; i <= num_job_types; ++i)
    {
        for (j = 1; j <= num_tasks[i]; ++j)
            fscanf (infile, "%d", &route[i][j]);
        for (j = 1; j <= num_tasks[i]; ++j)
            fscanf (infile, "%lg", &mean_service[i][j]);
    }
    for (i = 1; i <= num_job_types; ++i)
        fscanf (infile, "%lg", &prob_distrib_job_type[i]);

    /* Write report heading and input parameters. */

    fprintf (outfile, "Job-shop model\n\n");
    fprintf (outfile, "Number of work stations%21d\n\n", num_stations);
    fprintf (outfile, "Number of machines in each station     ");
    for (j = 1; j <= num_stations; ++j)
        fprintf (outfile, "%5d", num_machines[j]);
    fprintf (outfile, "\n\nNumber of job types%25d\n\n", num_job_types);
    fprintf (outfile, "Number of tasks for each job type      ");
    for (i = 1; i <= num_job_types; ++i)
        fprintf (outfile, "%5d", num_tasks[i]);
    fprintf (outfile, "\n\nDistribution function of job types  ");
    for (i = 1; i <= num_job_types; ++i)
        fprintf (outfile, "%8.3f", prob_distrib_job_type[i]);
    fprintf (outfile, "\n\nMean interarrival time of jobs%14.2f hours\n\n", mean_interarrival);
    fprintf (outfile, "Length of the simulation%20.1f eight-hour days\n\n\n", length_simulation);
    fprintf (outfile, "Job type     Work stations on route");
    for (i = 1; i <= num_job_types; ++i)
    {
        fprintf (outfile, "\n\n%4d        ", i);
        for (j = 1; j <= num_tasks[i]; ++j)
            fprintf (outfile, "%5d", route[i][j]);
    }
    fprintf (outfile, "\n\n\nJob type     ");
    fprintf (outfile, "Mean service time (in hours) for successive tasks");
    for (i = 1; i <= num_job_types; ++i)
    {
        fprintf (outfile, "\n\n%4d    ", i);
        for (j = 1; j <= num_tasks[i]; ++j)
            fprintf (outfile, "%9.2f", mean_service[i][j]);
    }

    /* Initialize rndlib */
    init_twister();

    /* Initialize all machines in all stations to the idle state. */

    for (j = 1; j <= num_stations; ++j)
        num_machines_busy[j] = 0;

    /* Initialize simlib */

    init_simlib ();

    /* Set maxatr = max(maximum number of attributes per record, 4) */

    maxatr = 4;			/* NEVER SET maxatr TO BE SMALLER THAN 4. */

    /* Schedule the arrival of the first job. */

    event_schedule (expon (mean_interarrival, STREAM_INTERARRIVAL), EVENT_ARRIVAL);

    /* Schedule the end of the simulation.  (This is needed for consistency of
       units.) */

    event_schedule (8 * length_simulation, EVENT_END_SIMULATION);

    /* Run the simulation until it terminates after an end-simulation event
       (type EVENT_END_SIMULATION) occurs. */

    do
    {

        /* Determine the next event. */

        timing ();

        /* Invoke the appropriate event function. */

        switch (next_event_type)
        {
        case EVENT_ARRIVAL:
            arrive (1);
            break;
        case EVENT_DEPARTURE:
            depart ();
            break;
        case EVENT_END_SIMULATION:
            report ();
            break;
        }

        /* If the event just executed was not the end-simulation event (type
           EVENT_END_SIMULATION), continue simulating.  Otherwise, end the
           simulation. */

    }
    while (next_event_type != EVENT_END_SIMULATION);

    fclose (infile);
    fclose (outfile);

    return 0;
}
예제 #22
0
파일: isal.c 프로젝트: gunnarrb/isal
int main()
{
    // load datafiles
    parse_input("adal_inntak.in","velar_og_bidradir.in");
	
    // initialize arrays and variables
    if((fail_list = malloc(sizeof(breakdown)*NUM_MACHINES+1))==NULL) {
	printf("Allocation Error\n");
	exit(1);
    }
   
    for (failure_nr = min_no_failures; failure_nr<= max_no_failures; failure_nr++) {
	stream = (unsigned int)time(NULL) % 100;   
		
	memset( is_machine_busy,0, NUM_MACHINES +1 );
	memset( machine_broken,0, NUM_MACHINES +1);
	memset( queue_max_lengths,0, NUM_MACHINES +1);
	memset( fail_list,0, sizeof(breakdown)*(NUM_MACHINES+1));
	fail_index = 0;
	skaut_throughput = 0;
	sampst_delays = number_of_machines +1;
	throughput_time = number_of_machines +2;
		
	skaut_id = 1;
	skaut_throughput = 0;
		
		
	// Initialize rndlib
	init_twister();
		
	// Initialize simlib
	init_simlib();
		
	maxatr = 6; // how many attributes do we need?
		
	/* Schedule first wagen arrival */
	event_schedule( 10.0, EVENT_WAGEN_UNLOAD_ARRIVAL );
		
	/* Schedule end of warmup time */
	event_schedule( end_warmup_time, EVENT_END_WARMUP );
	event_schedule(end_warmup_time, EVENT_GENERATE_FAILURES );	
	/* Schedule simulation termination */
	event_schedule(end_simulation_time , EVENT_END_SIMULATION );
		
	next_event_type = 0;
		
        
	while (next_event_type != EVENT_END_SIMULATION) {
			
	    timing();
			
	    switch (next_event_type) {
	    case EVENT_WAGEN_UNLOAD_ARRIVAL:
		wagen_unload_arrival();
		break;
	    case EVENT_SKAUT_ARRIVAL:
		skaut_arrival();
		break;
	    case EVENT_SKAUT_DEPARTURE:
		skaut_departure();
		break;
	    case EVENT_MACHINE_FAILURE:
		machine_failure();
		break;
	    case EVENT_MACHINE_FIXED:
		machine_fixed();
		break;
	    case EVENT_END_WARMUP:
		end_warmup();
		break;
	    case EVENT_END_SIMULATION:
		report();
		break;
	    case EVENT_GENERATE_FAILURES:
		create_machine_fail_events();
		break;
					
	    }
	}
		
    }
}