model-net.h 7.33 KB
Newer Older
1
/*
Philip Carns's avatar
Philip Carns committed
2
 * Copyright (C) 2013 University of Chicago.
3
 * See COPYRIGHT notice in top-level directory.
Philip Carns's avatar
Philip Carns committed
4
 *
5
6
7
8
9
10
 */

#ifndef MODELNET_H
#define MODELNET_H

#include "ross.h"
11
#include "codes/lp-type-lookup.h"
12
#include "codes/configuration.h"
13
#include "codes/lp-io.h"
14
#include <stdint.h>
15
16

#define MAX_NAME_LENGTH 256
17
18
#define CATEGORY_NAME_MAX 16
#define CATEGORY_MAX 12
19

20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
/* HACK: there is currently no scheduling fidelity across multiple
 * model_net_event calls. Hence, problems arise when some LP sends multiple
 * messages as part of an event and expects FCFS ordering. A proper fix which
 * involves model-net LP-level scheduling of requests is ideal, but not 
 * feasible for now (would basically have to redesign model-net), so expose
 * explicit start-sequence and stop-sequence markers as a workaround */
extern int in_sequence;
extern tw_stime mn_msg_offset;
#define MN_START_SEQ() do {\
    in_sequence = 1; \
    mn_msg_offset = 0.0; \
} while (0)
#define MN_END_SEQ() do {\
    in_sequence = 0;\
} while (0)


37
typedef struct simplenet_param simplenet_param;
38
typedef struct simplewan_param simplewan_param;
39
40
typedef struct dragonfly_param dragonfly_param;
typedef struct torus_param torus_param;
Philip Carns's avatar
Philip Carns committed
41
typedef struct loggp_param loggp_param;
42
typedef struct mn_stats mn_stats;
43
44
45
46

enum NETWORKS
{
  SIMPLENET,
47
  SIMPLEWAN,
48
  TORUS,
49
50
51
  DRAGONFLY,
  LOGGP,
  MAX_NETS, /* sentinal value, this must be last in the enumeration */
52
53
};

54
55
56
57
58
59
60
61
62
63
64
65
66
/* data structure for tracking network statistics */
struct mn_stats
{
    char category[CATEGORY_NAME_MAX];
    long send_count;
    long send_bytes;
    tw_stime send_time;
    long recv_count;
    long recv_bytes;
    tw_stime recv_time;
    long max_event_size;
};

Philip Carns's avatar
Philip Carns committed
67
68
69
70
71
72
/* structs for initializing a network/ specifying network parameters */
struct loggp_param
{
  char* net_config_file; /* file with loggp parameter table */
};

73
74
75
76
77
78
79
80
/* structs for initializing a network/ specifying network parameters */
struct simplenet_param
{
  double net_startup_ns; /*simplenet startup cost*/
  double net_bw_mbps; /*Link bandwidth per byte*/
  int num_nics;
};

81
82
83
84
85
86
struct simplewan_param
{
    char bw_filename[MAX_NAME_LENGTH];
    char startup_filename[MAX_NAME_LENGTH];
};

87
88
89
struct dragonfly_param
{
  int num_routers; /*Number of routers in a group*/
90
91
92
93
94
95
96
97
  double local_bandwidth;/* bandwidth of the router-router channels within a group */
  double global_bandwidth;/* bandwidth of the inter-group router connections */
  double cn_bandwidth;/* bandwidth of the compute node channels connected to routers */
  int num_vcs; /* number of virtual channels */
  int local_vc_size; /* buffer size of the router-router channels */
  int global_vc_size; /* buffer size of the global channels */
  int cn_vc_size; /* buffer size of the compute node channels */
  short routing; /* minimal or non-minimal routing */
98
99
100
101
};

struct torus_param
{
102
  int n_dims; /*Dimension of the torus network, 5-D, 7-D or any other*/
103
  int* dim_length; /*Length of each torus dimension*/
104
105
106
107
  double link_bandwidth;/* bandwidth for each torus link */
  int buffer_size; /* number of buffer slots for each vc in flits*/
  int num_vc; /* number of virtual channels for each torus link */
  float mean_process;/* mean process time for each flit  */
108
  int chunk_size; /* chunk is the smallest unit--default set to 32 */
109
};
110
 /* In general we need to figure out how to pass configuration information to
111
112
113
114
115
116
117
 * the methods and we need to be able to calculate ross event message size.
 */
/*Initialize the network by specifying the network parameters. The 
 * underlying model-net.c function call will set the network parameters 
 * according to the network name specified*/
// return an integer being the identifier for the type of network
// call modelnet setup 1 time for a torus and retur value is 0 for e.g.
118
119
120
121
122

/* call set params for configuring the network parameters from the config file*/
int model_net_set_params();

// setup the modelnet parameters
123
int model_net_setup(char* net_name, uint64_t packet_size, const void* net_params);
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
/* allocate and transmit a new event that will pass through model_net to 
 * arrive at its destination:
 *
 * - category: category name to associate with this communication
 *   - OPTIONAL: callers can set this to NULL if they don't want to use it,
 *     and model_net methods can ignore it if they don't support it
 * - final_dest_lp: the LP that the message should be delivered to.
 *   - NOTE: this is _not_ the LP of an underlying network method (for
 *     example, it is not a torus or dragonfly LP), but rather the LP of an
 *     MPI process or storage server that you are transmitting to.
 * - message_size: this is the size of the message (in bytes) that modelnet
 *     will simulate transmitting to the final_dest_lp.  It can be any size
 *     (i.e. it is not constrained by transport packet size).
 * - remote_event_size: this is the size of the ROSS event structure that
 *     will be delivered to the final_dest_lp.
 * - remote_event: pointer ot data to be used as the remove event message
 * - self_event_size: this is the size of the ROSS event structure that will
 *     be delivered to the calling LP once local completion has occurred for
 *     the network transmission.
 *     - NOTE: "local completion" in this sense means that model_net has
 *       transmitted the data off of the local node, but it does not mean that
 *       the data has been (or even will be) delivered.  Once this event is
 *       delivered the caller is free to re-use its buffer.
 * - self_event: pionter to data to be used as the self event message
 * - sender: pointer to the tw_lp structure of the API caller.  This is
 *     identical to the sender argument to tw_event_new().
 */
// first argument becomes the network ID
void model_net_event(
    int net_id,
    char* category, 
    tw_lpid final_dest_lp, 
156
    uint64_t message_size, 
157
158
159
160
161
162
    int remote_event_size,
    const void* remote_event,
    int self_event_size,
    const void* self_event,
    tw_lp *sender);

163
164
165
166
167
168
/* model_net_find_local_device()
 *
 * returns the LP id of the network card attached to the calling LP
 */
tw_lpid model_net_find_local_device(int net_id, tw_lp *sender);

169
170
171
172
173
174
175
176
177
178
179
180
181
/* model_net_event_rc()
 *
 * This function does reverse computation for the model_net_event_new()
 * function.
 * - sender: pointer to the tw_lp structure of the API caller.  This is
 *   identical to the sender argument to tw_event_new().
 */
/* NOTE: we may end up needing additoinal arguments here to track state for
 * reverse computation; add as needed 
 */
void model_net_event_rc(
    int net_id,
    tw_lp *sender,
182
    uint64_t message_size);
183
184
185
186

/* returns pointer to LP information for simplenet module */
const tw_lptype* model_net_get_lp_type(int net_id);

187
uint64_t model_net_get_packet_size(int net_id);
188
189

void model_net_add_lp_type(int net_id);
190

191
192
193
/* used for reporting overall network statistics for e.g. average latency ,
 * maximum latency, total number of packets finished during the entire
 * simulation etc. */
194
void model_net_report_stats(int net_id);
195

196
/* writing model-net statistics on a per LP basis */
197
198
void model_net_write_stats(tw_lpid lpid, mn_stats* stat);

199
/* printing model-net statistics on a per LP basis */
200
201
202
203
void model_net_print_stats(tw_lpid lpid, mn_stats mn_stats_array[]);

/* find model-net statistics */
mn_stats* model_net_find_stats(const char* category, mn_stats mn_stats_array[]);
204
205
206
207
208
209
210
211
212
213
#endif /* MODELNET_H */

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