Commit 11a81432 authored by Philip Carns's avatar Philip Carns

skeleton for workload gen test program

parent 05f4addb
check_PROGRAMS += tests/lp-io-test
check_PROGRAMS += tests/lp-io-test \
tests/codes-workload-test
TESTS += tests/lp-io-test.sh
EXTRA_DIST += tests/lp-io-test.sh
......@@ -9,3 +10,7 @@ testlib = src/libcodes-base.a
tests_lp_io_test_LDADD = $(testlib) ${ROSS_LIBS}
tests_lp_io_test_LDFLAGS = ${ROSS_LDFLAGS}
tests_lp_io_test_SOURCES = tests/lp-io-test.c
tests_codes_workload_test_LDADD = $(testlib) ${ROSS_LIBS}
tests_codes_workload_test_LDFLAGS = ${ROSS_LDFLAGS}
tests_codes_workload_test_SOURCES = tests/codes-workload-test.c
/*
* Copyright (C) 2013 University of Chicago.
* See COPYRIGHT notice in top-level directory.
*
*/
/* SUMMARY:
*
* This is a test harness for the codes workload API. It sets up two LP
* types: clients (which consume operations from the workload generator) and
* servers (which service operations submitted by clients).
*
*/
#include <string.h>
#include <assert.h>
#include <ross.h>
#include "codes/lp-io.h"
#include "codes/codes.h"
#define NUM_SERVERS 16 /* number of servers */
#define NUM_CLIENTS 48 /* number of clients */
typedef struct svr_msg svr_msg;
typedef struct svr_state svr_state;
typedef struct client_msg client_msg;
typedef struct client_state client_state;
enum client_event_type
{
CLIENT_KICKOFF, /* initial event */
};
enum svr_event_type
{
SVR_OP,
};
struct client_state
{
};
struct svr_state
{
};
struct client_msg
{
enum client_event_type event_type;
};
struct svr_msg
{
enum svr_event_type event_type;
tw_lpid src; /* source of this request or ack */
};
const tw_optdef app_opt[] = {
TWOPT_GROUP("CODES Workload Test Model"),
TWOPT_END()
};
static void svr_init(
svr_state * ns,
tw_lp * lp);
static void svr_event(
svr_state * ns,
tw_bf * b,
svr_msg * m,
tw_lp * lp);
static void svr_rev_event(
svr_state * ns,
tw_bf * b,
svr_msg * m,
tw_lp * lp);
static void svr_finalize(
svr_state * ns,
tw_lp * lp);
static tw_peid node_mapping(
tw_lpid gid);
tw_lptype svr_lp = {
(init_f) svr_init,
(event_f) svr_event,
(revent_f) svr_rev_event,
(final_f) svr_finalize,
(map_f) node_mapping,
sizeof(svr_state),
};
static void handle_client_kickoff_rev_event(
client_state * ns,
tw_bf * b,
client_msg * m,
tw_lp * lp);
static void handle_client_kickoff_event(
client_state * ns,
tw_bf * b,
client_msg * m,
tw_lp * lp);
static void client_init(
client_state * ns,
tw_lp * lp);
static void client_event(
client_state * ns,
tw_bf * b,
client_msg * m,
tw_lp * lp);
static void client_rev_event(
client_state * ns,
tw_bf * b,
client_msg * m,
tw_lp * lp);
static void client_finalize(
client_state * ns,
tw_lp * lp);
static tw_peid node_mapping(
tw_lpid gid);
tw_lptype client_lp = {
(init_f) client_init,
(event_f) client_event,
(revent_f) client_rev_event,
(final_f) client_finalize,
(map_f) node_mapping,
sizeof(client_state),
};
int main(
int argc,
char **argv)
{
int nprocs;
int rank;
int lps_per_proc;
int i;
int ret;
lp_io_handle handle;
g_tw_ts_end = 60*60*24*365;
tw_opt_add(app_opt);
tw_init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
if((NUM_SERVERS + NUM_CLIENTS) % nprocs)
{
fprintf(stderr, "Error: number of server LPs (%d total) is not evenly divisible by the number of MPI processes (%d)\n", NUM_SERVERS+NUM_CLIENTS, nprocs);
exit(-1);
}
lps_per_proc = (NUM_SERVERS+NUM_CLIENTS) / nprocs;
tw_define_lps(lps_per_proc, 512, 0);
for(i=0; i<lps_per_proc; i++)
{
if((rank*lps_per_proc + i) < NUM_CLIENTS)
tw_lp_settype(i, &client_lp);
else
tw_lp_settype(i, &svr_lp);
}
g_tw_lookahead = 100;
ret = lp_io_prepare("codes-workload-test-results", LP_IO_UNIQ_SUFFIX, &handle, MPI_COMM_WORLD);
if(ret < 0)
{
return(-1);
}
tw_run();
ret = lp_io_flush(handle, MPI_COMM_WORLD);
assert(ret == 0);
tw_end();
return 0;
}
static void client_init(
client_state * ns,
tw_lp * lp)
{
tw_event *e;
client_msg *m;
tw_stime kickoff_time;
memset(ns, 0, sizeof(*ns));
/* each client sends a dummy event to itself */
/* skew each kickoff event slightly to help avoid event ties later on */
kickoff_time = g_tw_lookahead + tw_rand_unif(lp->rng);
e = codes_event_new(lp->gid, kickoff_time, lp);
m = tw_event_data(e);
m->event_type = CLIENT_KICKOFF;
tw_event_send(e);
return;
}
static void svr_init(
svr_state * ns,
tw_lp * lp)
{
memset(ns, 0, sizeof(*ns));
return;
}
static void client_event(
client_state * ns,
tw_bf * b,
client_msg * m,
tw_lp * lp)
{
switch (m->event_type)
{
case CLIENT_KICKOFF:
handle_client_kickoff_event(ns, b, m, lp);
break;
default:
assert(0);
break;
}
}
static void svr_event(
svr_state * ns,
tw_bf * b,
svr_msg * m,
tw_lp * lp)
{
switch (m->event_type)
{
default:
assert(0);
break;
}
}
static void client_rev_event(
client_state * ns,
tw_bf * b,
client_msg * m,
tw_lp * lp)
{
switch (m->event_type)
{
case CLIENT_KICKOFF:
handle_client_kickoff_rev_event(ns, b, m, lp);
break;
default:
assert(0);
break;
}
return;
}
static void svr_rev_event(
svr_state * ns,
tw_bf * b,
svr_msg * m,
tw_lp * lp)
{
switch (m->event_type)
{
default:
assert(0);
break;
}
return;
}
static void client_finalize(
client_state * ns,
tw_lp * lp)
{
return;
}
static void svr_finalize(
svr_state * ns,
tw_lp * lp)
{
#if 0
char buffer[256];
int ret;
sprintf(buffer, "LP %ld finalize data\n", (long)lp->gid);
/* test having everyone write to same identifier */
ret = lp_io_write(lp->gid, "node_state_pointers", strlen(buffer)+1, buffer);
assert(ret == 0);
/* test having only one lp write to a particular identifier */
if(lp->gid == 3)
{
ret = lp_io_write(lp->gid, "subset_example", strlen(buffer)+1, buffer);
assert(ret == 0);
}
/* test having one lp write two buffers to the same id */
if(lp->gid == 5)
{
sprintf(buffer, "LP %ld finalize data (intentional duplicate)\n", (long)lp->gid);
ret = lp_io_write(lp->gid, "node_state_pointers", strlen(buffer)+1, buffer);
assert(ret == 0);
}
#endif
return;
}
static tw_peid node_mapping(
tw_lpid gid)
{
return (tw_peid) gid / g_tw_nlp;
}
static void handle_client_kickoff_rev_event(
client_state * ns,
tw_bf * b,
client_msg * m,
tw_lp * lp)
{
assert(0);
return;
}
/* handle initial event */
static void handle_client_kickoff_event(
client_state * ns,
tw_bf * b,
client_msg * m,
tw_lp * lp)
{
printf("handle_client_kickoff_event(), lp %llu.\n", (unsigned long long)lp->gid);
/* do nothing */
}
/*
* Local variables:
* c-indent-level: 4
* c-basic-offset: 4
* End:
*
* vim: ft=c ts=8 sts=4 sw=4 expandtab
*/
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment