model-net-synthetic.c 11.4 KB
Newer Older
1
2
3
4
5
6
7
8
/*
 * Copyright (C) 2015 University of Chicago.
 * See COPYRIGHT notice in top-level directory.
 *
 */

/*
* The test program generates some synthetic traffic patterns for the model-net network models.
9
* currently it only support the dragonfly network model uniform random and nearest neighbor traffic patterns.
10
11
12
13
14
15
16
17
*/

#include "codes/model-net.h"
#include "codes/lp-io.h"
#include "codes/codes.h"
#include "codes/codes_mapping.h"
#include "codes/configuration.h"
#include "codes/lp-type-lookup.h"
18
#include "codes/net/dragonfly.h"
19

20
#define PAYLOAD_SZ 2048
21
22
23
24
25
26
27

static int net_id = 0;
static int traffic = 1;
static double arrival_time = 1000.0;

/* whether to pull instead of push */
static int num_servers_per_rep = 0;
28
29
30
31
static int num_routers_per_grp = 0;
static int num_nodes_per_grp = 0;
static int num_groups = 0;
static int num_nodes = 0;
32

33
34
35
36
37
static char lp_io_dir[256] = {'\0'};
static lp_io_handle io_handle;
static unsigned int lp_io_use_suffix = 0;
static int do_lp_io = 0;
static int num_msgs = 20;
38
39
static unsigned int sampling_interval = 800000;
static unsigned int sampling_end_time = 1600000;
40

41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
typedef struct svr_msg svr_msg;
typedef struct svr_state svr_state;

/* global variables for codes mapping */
static char group_name[MAX_NAME_LENGTH];
static char lp_type_name[MAX_NAME_LENGTH];
static int group_index, lp_type_index, rep_id, offset;

/* type of events */
enum svr_event
{
    KICKOFF,	   /* kickoff event */
    REMOTE,        /* remote event */
    LOCAL      /* local event */
};

/* type of synthetic traffic */
enum TRAFFIC
{
60
61
62
	UNIFORM = 1, /* sends message to a randomly selected node */
	NEAREST_GROUP = 2, /* sends message to the node connected to the neighboring router */
	NEAREST_NEIGHBOR = 3 /* sends message to the next node (potentially connected to the same router) */
63
64
65
66
67
68
69
70
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
};

struct svr_state
{
    int msg_sent_count;   /* requests sent */
    int msg_recvd_count;  /* requests recvd */
    int local_recvd_count; /* number of local messages received */
    tw_stime start_ts;    /* time that we started sending requests */
    tw_stime end_ts;      /* time that we ended sending requests */
};

struct svr_msg
{
    enum svr_event svr_event_type;
    tw_lpid src;          /* source of this request or ack */
    int incremented_flag; /* helper for reverse computation */
};

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);

tw_lptype svr_lp = {
    (init_f) svr_init,
    (pre_run_f) NULL,
    (event_f) svr_event,
    (revent_f) svr_rev_event,
103
    (commit_f) NULL,
104
105
106
107
108
    (final_f)  svr_finalize,
    (map_f) codes_mapping,
    sizeof(svr_state),
};

109
110
111
112
/* setup for the ROSS event tracing
 * can have a different function for  rbev_trace_f and ev_trace_f
 * but right now it is set to the same function for both
 */
113
void svr_event_collect(svr_msg *m, tw_lp *lp, char *buffer, int *collect_flag)
114
115
116
117
118
{
    int type = (int) m->svr_event_type;
    memcpy(buffer, &type, sizeof(type));
}

119
120
st_trace_type svr_trace_types[] = {
    {(rbev_trace_f) svr_event_collect,
121
     sizeof(int),
122
     (ev_trace_f) svr_event_collect,
123
     sizeof(int)},
124
125
126
    {0}
};

127
static const st_trace_type  *svr_get_trace_types(void)
128
{
129
    return(&svr_trace_types[0]);
130
131
}

132
void svr_register_trace()
133
{
134
    trace_type_register("server", svr_get_trace_types());
135
136
}

137
138
139
const tw_optdef app_opt [] =
{
        TWOPT_GROUP("Model net synthetic traffic " ),
140
141
    	TWOPT_UINT("traffic", traffic, "UNIFORM RANDOM=1, NEAREST NEIGHBOR=2 "),
    	TWOPT_UINT("num_messages", num_msgs, "Number of messages to be generated per terminal "),
142
143
    	TWOPT_UINT("sampling-interval", sampling_interval, "the sampling interval "),
    	TWOPT_UINT("sampling-end-time", sampling_end_time, "sampling end time "),
144
145
146
	    TWOPT_STIME("arrival_time", arrival_time, "INTER-ARRIVAL TIME"),
        TWOPT_CHAR("lp-io-dir", lp_io_dir, "Where to place io output (unspecified -> no output"),
        TWOPT_UINT("lp-io-use-suffix", lp_io_use_suffix, "Whether to append uniq suffix to lp-io directory (default 0)"),
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
        TWOPT_END()
};

const tw_lptype* svr_get_lp_type()
{
            return(&svr_lp);
}

static void svr_add_lp_type()
{
  lp_type_register("server", svr_get_lp_type());
}

static void issue_event(
    svr_state * ns,
    tw_lp * lp)
{
    tw_event *e;
    svr_msg *m;
    tw_stime kickoff_time;

    /* each server sends a dummy event to itself that will kick off the real
     * simulation
     */

    /* skew each kickoff event slightly to help avoid event ties later on */
173
    kickoff_time = 1.1 * g_tw_lookahead + tw_rand_exponential(lp->rng, arrival_time);
174
175
176
177
178
179
180
181
182
183
184

    e = tw_event_new(lp->gid, kickoff_time, lp);
    m = tw_event_data(e);
    m->svr_event_type = KICKOFF;
    tw_event_send(e);
}

static void svr_init(
    svr_state * ns,
    tw_lp * lp)
{
185
186
    ns->start_ts = 0.0;

187
188
189
190
191
192
193
194
195
196
    issue_event(ns, lp);
    return;
}

static void handle_kickoff_rev_event(
            svr_state * ns,
            tw_bf * b,
            svr_msg * m,
            tw_lp * lp)
{
197
198
199
    if(m->incremented_flag)
        return;

200
201
    if(b->c1)
        tw_rand_reverse_unif(lp->rng);
202

203
    model_net_event_rc(net_id, lp, PAYLOAD_SZ);
204
	ns->msg_sent_count--;
205
    tw_rand_reverse_unif(lp->rng);
206
}
207
208
209
210
211
212
static void handle_kickoff_event(
	    svr_state * ns,
	    tw_bf * b,
	    svr_msg * m,
	    tw_lp * lp)
{
213
    if(ns->msg_sent_count >= num_msgs)
214
215
216
217
    {
        m->incremented_flag = 1;
        return;
    }
218
219
220
221

    m->incremented_flag = 0;

    char anno[MAX_NAME_LENGTH];
222
    tw_lpid local_dest = -1, global_dest = -1;
223

224
225
226
227
228
229
230
231
232
233
234
    svr_msg * m_local = malloc(sizeof(svr_msg));
    svr_msg * m_remote = malloc(sizeof(svr_msg));

    m_local->svr_event_type = LOCAL;
    m_local->src = lp->gid;

    memcpy(m_remote, m_local, sizeof(svr_msg));
    m_remote->svr_event_type = REMOTE;

    assert(net_id == DRAGONFLY); /* only supported for dragonfly model right now. */
    ns->start_ts = tw_now(lp);
235
236
    codes_mapping_get_lp_info(lp->gid, group_name, &group_index, lp_type_name, &lp_type_index, anno, &rep_id, &offset);
    int local_id = codes_mapping_get_lp_relative_id(lp->gid, 0, 0);
237

238
239
240
   /* in case of uniform random traffic, send to a random destination. */
   if(traffic == UNIFORM)
   {
241
    b->c1 = 1;
242
243
   	local_dest = tw_rand_integer(lp->rng, 0, num_nodes - 1);
   }
244
   else if(traffic == NEAREST_GROUP)
245
   {
246
247
	local_dest = (local_id + num_nodes_per_grp) % num_nodes;
	//printf("\n LP %ld sending to %ld num nodes %d ", local_id, local_dest, num_nodes);
248
   }
249
250
   else if(traffic == NEAREST_NEIGHBOR)
   {
251
	local_dest =  (local_id + 1) % num_nodes;
252
253
//	 printf("\n LP %ld sending to %ld num nodes %d ", rep_id * 2 + offset, local_dest, num_nodes);
   }
254
   assert(local_dest < num_nodes);
255
256
//   codes_mapping_get_lp_id(group_name, lp_type_name, anno, 1, local_dest / num_servers_per_rep, local_dest % num_servers_per_rep, &global_dest);
   global_dest = codes_mapping_get_lpid_from_relative(local_dest, group_name, lp_type_name, NULL, 0);
257
258
   ns->msg_sent_count++;
   model_net_event(net_id, "test", global_dest, PAYLOAD_SZ, 0.0, sizeof(svr_msg), (const void*)m_remote, sizeof(svr_msg), (const void*)m_local, lp);
259

260
261
262
263
264
   issue_event(ns, lp);
   return;
}

static void handle_remote_rev_event(
265
            svr_state * ns,
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
            tw_bf * b,
            svr_msg * m,
            tw_lp * lp)
{
        ns->msg_recvd_count--;
}

static void handle_remote_event(
	    svr_state * ns,
	    tw_bf * b,
	    svr_msg * m,
	    tw_lp * lp)
{
	ns->msg_recvd_count++;
}

static void handle_local_rev_event(
                svr_state * ns,
                tw_bf * b,
                svr_msg * m,
                tw_lp * lp)
{
	ns->local_recvd_count--;
}

static void handle_local_event(
                svr_state * ns,
                tw_bf * b,
                svr_msg * m,
                tw_lp * lp)
{
    ns->local_recvd_count++;
}
/* convert ns to seconds */
static tw_stime ns_to_s(tw_stime ns)
{
    return(ns / (1000.0 * 1000.0 * 1000.0));
}

/* convert seconds to ns */
static tw_stime s_to_ns(tw_stime ns)
{
    return(ns * (1000.0 * 1000.0 * 1000.0));
}

static void svr_finalize(
    svr_state * ns,
    tw_lp * lp)
{
    ns->end_ts = tw_now(lp);

    printf("server %llu recvd %d bytes in %f seconds, %f MiB/s sent_count %d recvd_count %d local_count %d \n", (unsigned long long)lp->gid, PAYLOAD_SZ*ns->msg_recvd_count, ns_to_s(ns->end_ts-ns->start_ts),
        ((double)(PAYLOAD_SZ*ns->msg_sent_count)/(double)(1024*1024)/ns_to_s(ns->end_ts-ns->start_ts)), ns->msg_sent_count, ns->msg_recvd_count, ns->local_recvd_count);
    return;
}

static void svr_rev_event(
    svr_state * ns,
    tw_bf * b,
    svr_msg * m,
    tw_lp * lp)
{
    switch (m->svr_event_type)
    {
	case REMOTE:
		handle_remote_rev_event(ns, b, m, lp);
		break;
	case LOCAL:
		handle_local_rev_event(ns, b, m, lp);
		break;
	case KICKOFF:
		handle_kickoff_rev_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->svr_event_type)
    {
        case REMOTE:
            handle_remote_event(ns, b, m, lp);
            break;
        case LOCAL:
            handle_local_event(ns, b, m, lp);
            break;
	case KICKOFF:
	    handle_kickoff_event(ns, b, m, lp);
	    break;
        default:
            printf("\n Invalid message type %d ", m->svr_event_type);
            assert(0);
        break;
    }
}

int main(
    int argc,
    char **argv)
{
    int nprocs;
    int rank;
    int num_nets;
    int *net_ids;

    tw_opt_add(app_opt);
    tw_init(&argc, &argv);

    if(argc < 2)
    {
            printf("\n Usage: mpirun <args> --sync=2/3 mapping_file_name.conf (optional --nkp) ");
            MPI_Finalize();
            return 0;
    }

    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    MPI_Comm_size(MPI_COMM_WORLD, &nprocs);

    configuration_load(argv[2], MPI_COMM_WORLD, &config);

    model_net_register();
    svr_add_lp_type();

396
397
    if (g_st_ev_trace)
        svr_register_trace();
398

399
400
401
    codes_mapping_setup();

    net_ids = model_net_configure(&num_nets);
402
    //assert(num_nets==1);
403
404
405
    net_id = *net_ids;
    free(net_ids);

406
407
    /* 5 days of simulation time */
    g_tw_ts_end = s_to_ns(5 * 24 * 60 * 60);
408
    model_net_enable_sampling(sampling_interval, sampling_end_time);
409

410
    if(net_id != DRAGONFLY)
411
    {
412
413
414
	printf("\n The test works with dragonfly model configuration only! ");
        MPI_Finalize();
        return 0;
415
    }
416
417
    num_servers_per_rep = codes_mapping_get_lp_count("MODELNET_GRP", 1, "server",
            NULL, 1);
418
    configuration_get_value_int(&config, "PARAMS", "num_routers", NULL, &num_routers_per_grp);
419

420
421
422
    num_groups = (num_routers_per_grp * (num_routers_per_grp/2) + 1);
    num_nodes = num_groups * num_routers_per_grp * (num_routers_per_grp / 2);
    num_nodes_per_grp = num_routers_per_grp * (num_routers_per_grp / 2);
423

Misbah Mubarak's avatar
Misbah Mubarak committed
424
425
    assert(num_nodes);

426
    if(lp_io_dir[0])
427
    {
428
429
430
431
        do_lp_io = 1;
        int flags = lp_io_use_suffix ? LP_IO_UNIQ_SUFFIX : 0;
        int ret = lp_io_prepare(lp_io_dir, flags, &io_handle, MPI_COMM_WORLD);
        assert(ret == 0 || !"lp_io_prepare failure");
432
433
    }
    tw_run();
434
435
436
    if (do_lp_io){
        int ret = lp_io_flush(io_handle, MPI_COMM_WORLD);
        assert(ret == 0 || !"lp_io_flush failure");
437
    }
438
    model_net_report_stats(net_id);
439
440
441
442
    tw_end();
    return 0;
}

Jonathan Jenkins's avatar
Jonathan Jenkins committed
443
444
445
446
447
448
449
450
/*
 * Local variables:
 *  c-indent-level: 4
 *  c-basic-offset: 4
 * End:
 *
 * vim: ft=c ts=8 sts=4 sw=4 expandtab
 */