test-workload-method.c 2.88 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11
/*
 * Copyright (C) 2013 University of Chicago.
 * See COPYRIGHT notice in top-level directory.
 *
 */

/* Example of a workload generator that plugs into the codes workload
 * generator API.  This example just produces a hard-coded pattern for
 * testing/validation purposes.
 */

12 13
#include <assert.h>

14 15 16 17 18
#include "ross.h"
#include "codes/codes-workload.h"
#include "codes-workload-method.h"

int test_workload_load(const char* params, int rank);
19
void test_workload_get_next(int rank, struct codes_workload_op *op);
20

21 22 23 24 25 26 27 28 29 30 31 32
/* state information for each rank that is retrieving requests */
struct wkload_stream_state
{
    int rank;
    struct wkload_stream_state* next;
    struct codes_workload_op op_array[16];
    int op_array_len;
    int op_array_index;
};

struct wkload_stream_state* wkload_streams = NULL;

33 34 35 36 37 38 39 40 41 42 43 44
struct codes_workload_method test_workload_method = 
{
    .method_name = "test",
    .codes_workload_load = test_workload_load,
    .codes_workload_get_next = test_workload_get_next,
};

int test_workload_load(const char* params, int rank)
{
    /* no params in this case; this example will work with any number of
     * ranks
     */
45 46 47 48 49 50 51 52
    struct wkload_stream_state* new;

    new = malloc(sizeof(*new));
    if(!new)
        return(-1);

    new->rank = rank;

Philip Carns's avatar
Philip Carns committed
53 54
    /* synthetic workload for testing */
    new->op_array_len = 2;
55 56 57 58
    new->op_array_index = 0;
    new->op_array[0].op_type = CODES_WK_OPEN;
    new->op_array[0].u.open.file_id = 3;
    new->op_array[0].u.open.create_flag = 1;
Philip Carns's avatar
Philip Carns committed
59 60 61
    new->op_array[1].op_type = CODES_WK_BARRIER;
    new->op_array[1].u.barrier.root = 0;
    new->op_array[1].u.barrier.count = -1; /* all ranks */
62 63 64 65 66

    /* add to front of list of streams that we are tracking */
    new->next = wkload_streams;
    wkload_streams = new;

67
    return(0);
68 69
}

70
void test_workload_get_next(int rank, struct codes_workload_op *op)
71
{
72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115
    struct wkload_stream_state* tmp = wkload_streams;
    struct wkload_stream_state* tmp2 = wkload_streams;

    /* find stream associated with this rank */
    while(tmp)
    {
        if(tmp->rank == rank)
            break;
        tmp = tmp->next;
    }

    assert(tmp);
    assert(tmp->rank == rank);

    if(tmp->op_array_index < tmp->op_array_len)
    {
        *op = tmp->op_array[tmp->op_array_index];
        tmp->op_array_index++;
    }
    else
    {
        /* no more operations */
        op->op_type = CODES_WK_END;

        /* destroy this instance */
        if(wkload_streams == tmp)
        {
            wkload_streams = tmp->next;
        }
        else
        {
            while(tmp2)
            {
                if(tmp2->next == tmp)
                {
                    tmp2->next = tmp->next;
                    break;
                }
                tmp2 = tmp2->next;
            }
        }

        free(tmp);
    }
116 117 118 119 120 121 122 123 124 125 126 127

    return;
}

/*
 * Local variables:
 *  c-indent-level: 4
 *  c-basic-offset: 4
 * End:
 *
 * vim: ft=c ts=8 sts=4 sw=4 expandtab
 */