Commit bd8f90c6 authored by Jonathan Jenkins's avatar Jonathan Jenkins

simplewan -> simplep2p

Tired of explaining that it's not a good representation of a WAN. Instead, it's
now a simple point-to-point latency/bandwidth model.
parent b4eba540
......@@ -80,25 +80,25 @@ models for high-performance networking, with an HPC bent.
Configuration files for each model can be found in tests/conf, under the name
"model-net-test*.conf".
== Simplenet/Simplewan
== Simplenet/SimpleP2P
The Simplenet and Simplewan models (model-net LP names "simplenet" and
"simplewan") are basic queued point-to-point latency/bandwidth models, assuming
The Simplenet and SimpleP2P models (model-net LP names "simplenet" and
"simplep2p") are basic queued point-to-point latency/bandwidth models, assuming
infinite packet buffering when routing. These are best used for models that
require little fidelity out of the network performance. Simplewan is the same
require little fidelity out of the network performance. SimpleP2P is the same
model as Simplenet, except it provides heterogeneous link capacities from point
to point. Rather than a single entry, it requires files containing a matrix of
point-to-point bandwidths and latencies.
Simplenet models require two configuration parameters: "net_startup_ns" and
"net_bw_mbps", which define the startup and bandwidth costs in nanoseconds and
megabytes per second, respectively. Simplewan requires two configuration files
for the startup and bandwidth costs: "net_startup_ns_file" and
megabytes per second, respectively. SimpleP2P requires two configuration files
for the latency and bandwidth costs: "net_latency_ns_file" and
"net_bw_mbps_file".
More details about the models can be found at
src/models/networks/model-net/doc/README.simplenet.txt and
src/models/networks/model-net/doc/README.simplewan.txt, respectively.
src/models/networks/model-net/doc/README.simplep2p.txt, respectively.
== LogGP
......
......@@ -20,7 +20,7 @@
#include "net/dragonfly.h"
#include "net/loggp.h"
#include "net/simplenet-upd.h"
#include "net/simplewan.h"
#include "net/simplep2p.h"
#include "net/torus.h"
extern int model_net_base_magic;
......@@ -115,7 +115,7 @@ typedef struct model_net_wrap_msg {
terminal_message m_dfly; // dragonfly
loggp_message m_loggp; // loggp
sn_message m_snet; // simplenet
sw_message m_swan; // simplewan
sp_message m_sp2p; // simplep2p
nodes_message m_torus; // torus
// add new ones here
} msg;
......
......@@ -44,7 +44,7 @@ typedef struct mn_stats mn_stats;
// last value is sentinel
#define NETWORK_DEF \
X(SIMPLENET, "modelnet_simplenet", "simplenet", &simplenet_method)\
X(SIMPLEWAN, "modelnet_simplewan", "simplewan", &simplewan_method)\
X(SIMPLEP2P, "modelnet_simplep2p", "simplep2p", &simplep2p_method)\
X(TORUS, "modelnet_torus", "torus", &torus_method)\
X(DRAGONFLY, "modelnet_dragonfly", "dragonfly", &dragonfly_method)\
X(LOGGP, "modelnet_loggp", "loggp", &loggp_method)\
......
......@@ -4,24 +4,24 @@
*
*/
#ifndef SIMPLEWAN_H
#define SIMPLEWAN_H
#ifndef SIMPLEP2P_H
#define SIMPLEP2P_H
typedef struct sw_message sw_message;
typedef struct sp_message sp_message;
enum sw_event_type
enum sp_event_type
{
SW_MSG_READY = 1, /* sender has transmitted msg to receiver */
SW_MSG_START, /* initiate a transmission */
SP_MSG_READY = 1, /* sender has transmitted msg to receiver */
SP_MSG_START, /* initiate a transmission */
};
struct sw_message
struct sp_message
{
int magic; /* magic number */
enum sw_event_type event_type;
enum sp_event_type event_type;
tw_lpid src_gid; /* who transmitted this msg? */
tw_lpid final_dest_gid; /* who is eventually targetted with this msg? */
/* relative ID of the sending simplewan message (for latency/bandwidth lookup) */
/* relative ID of the sending simplep2p message (for latency/bandwidth lookup) */
int src_mn_rel_id;
int dest_mn_rel_id; /* included to make rc easier */
uint64_t net_msg_size_bytes; /* size of modeled network message */
......@@ -44,7 +44,7 @@ struct sw_message
tw_stime recv_prev_idle_all_saved;
};
#endif /* end of include guard: SIMPLEWAN_H */
#endif /* end of include guard: SIMPLEP2P_H */
/*
* Local variables:
......
......@@ -11,7 +11,7 @@ EXTRA_DIST += \
src/models/networks/model-net/doc/README.dragonfly.txt \
src/models/networks/model-net/doc/README.loggp.txt \
src/models/networks/model-net/doc/README.simplenet.txt \
src/models/networks/model-net/doc/README.simplewan.txt \
src/models/networks/model-net/doc/README.simplep2p.txt \
src/models/networks/model-net/MN_TODO
......@@ -23,7 +23,7 @@ nobase_include_HEADERS = \
codes/net/dragonfly.h \
codes/net/loggp.h \
codes/net/simplenet-upd.h \
codes/net/simplewan.h \
codes/net/simplep2p.h \
codes/net/torus.h
src_libcodes_net_a_SOURCES = \
......@@ -32,7 +32,7 @@ src_libcodes_net_a_SOURCES = \
src/models/networks/model-net/torus.c \
src/models/networks/model-net/dragonfly.c \
src/models/networks/model-net/loggp.c \
src/models/networks/model-net/simplewan.c \
src/models/networks/model-net/simplep2p.c \
src/models/networks/model-net/model-net-lp.c \
src/models/networks/model-net/model-net-sched.c \
src/models/networks/model-net/model-net-sched-impl.h \
......
"Simplewan"
"SimpleP2P"
----------
Model overview:
---------------
Simplewan is an extension of simplenet to allow for arbitrary point-to-point
SimpleP2P is an extension of simplenet to allow for arbitrary point-to-point
capacities.
Simplewan has nearly the same duplex queued transmission semantics as
SimpleP2P has nearly the same duplex queued transmission semantics as
simplenet, though with a few important differences. First, point-to-point
latencies and bandwidths are different. Second, each unique link is given its
own queue that do not interfere with the others. The use case for this model is
a set of sites with internal networks, with each site communicating via
simplewan; we assume the internal network is capable of servicing all
simplep2p; we assume the internal network is capable of servicing all
outgoing/incoming WAN transmissions at their full capacities.
Additional configuration is needed to initialize the link latencies/capacities.
In the codes-configuration file, the variables "net_startup_ns_file" and
In the codes-configuration file, the variables "net_latency_ns_file" and
"net_bw_mbps_file" must be set under the PARAMS group. They point (in a path
relative to the configuration file) to configurations for the startup and
relative to the configuration file) to configurations for the latency and
bandwidth costs, respectively.
Each of the latency/bandwidth configuration files have the same format, based
......@@ -32,7 +32,7 @@ N:1 N:2 ... N:N
where x:y is the latency or bandwidth between components x and y. Whitespace is
ignored, but linebreaks are not, and delimit rows of the matrix. The relative
simplewan identifiers 1..N are assigned to simplewan LPs in the order of
simplep2p identifiers 1..N are assigned to simplep2p LPs in the order of
their appearance in the codes-configuration file. It is expected that all i:i
entries are 0 - modelnet currently doesn't handle self messages.
......@@ -51,13 +51,13 @@ Caveats:
--------
The model-net statistics are slightly more complex than in other model-net
implementations because there are in essence multiple queues per simplewan
implementations because there are in essence multiple queues per simplep2p
instance. In particular, the "send time" and "recv time" stats are computed as
ranges of time in which the simplewan LP is actively sending/receiving data
ranges of time in which the simplep2p LP is actively sending/receiving data
from *any* link. Hence, simple bandwidth calculations (send bytes / send time)
may not be accurate due to skew in message issuance.
Having more than one category in simplewan will cause the times in the
Having more than one category in simplep2p will cause the times in the
derived "all" category to be off. "all" is currently implemented as the sum of
the various categories, which doesn't work when times in certain categories may
overlap.
......@@ -223,8 +223,8 @@ void model_net_base_configure(){
// set up offsets - doesn't matter if they are actually used or not
msg_offsets[SIMPLENET] =
offsetof(model_net_wrap_msg, msg.m_snet);
msg_offsets[SIMPLEWAN] =
offsetof(model_net_wrap_msg, msg.m_swan);
msg_offsets[SIMPLEP2P] =
offsetof(model_net_wrap_msg, msg.m_sp2p);
msg_offsets[TORUS] =
offsetof(model_net_wrap_msg, msg.m_torus);
msg_offsets[DRAGONFLY] =
......@@ -461,7 +461,7 @@ void handle_sched_next(
// currently, loggp is the only network implementing the
// callback-based scheduling loop, all others schedule the next packet
// immediately
else if (ns->net_id == SIMPLEWAN || ns->net_id == TORUS){
else if (ns->net_id == SIMPLEP2P || ns->net_id == TORUS){
tw_event *e = codes_event_new(lp->gid,
poffset+codes_local_latency(lp), lp);
model_net_wrap_msg *m_wrap = tw_event_data(e);
......@@ -487,7 +487,7 @@ void handle_sched_next_rc(
if (b->c0){
*in_sched_loop = 1;
}
else if (ns->net_id == SIMPLEWAN || ns->net_id == TORUS){
else if (ns->net_id == SIMPLEP2P || ns->net_id == TORUS){
codes_local_latency_reverse(lp);
}
}
......
......@@ -18,7 +18,7 @@
#define PROC_TIME 10.0
extern struct model_net_method simplenet_method;
extern struct model_net_method simplewan_method;
extern struct model_net_method simplep2p_method;
extern struct model_net_method torus_method;
extern struct model_net_method dragonfly_method;
extern struct model_net_method loggp_method;
......
......@@ -15,33 +15,33 @@
#include "codes/model-net-lp.h"
#include "codes/codes_mapping.h"
#include "codes/codes.h"
#include "codes/net/simplewan.h"
#include "codes/net/simplep2p.h"
#define CATEGORY_NAME_MAX 16
#define CATEGORY_MAX 12
#define SIMPLEWAN_DEBUG 0
#define SIMPLEP2P_DEBUG 0
#define LP_CONFIG_NM (model_net_lp_config_names[SIMPLEWAN])
#define LP_METHOD_NM (model_net_method_names[SIMPLEWAN])
#define LP_CONFIG_NM (model_net_lp_config_names[SIMPLEP2P])
#define LP_METHOD_NM (model_net_method_names[SIMPLEP2P])
// parameters for simplewan configuration
struct simplewan_param
// parameters for simplep2p configuration
struct simplep2p_param
{
double * net_startup_ns_table;
double * net_latency_ns_table;
double * net_bw_mbps_table;
int mat_len;
int num_lps;
};
typedef struct simplewan_param simplewan_param;
typedef struct simplep2p_param simplep2p_param;
/*Define simplewan data types and structs*/
typedef struct sw_state sw_state;
/*Define simplep2p data types and structs*/
typedef struct sp_state sp_state;
typedef struct category_idles_s category_idles;
struct category_idles_s{
/* each simplewan "NIC" actually has N connections, so we need to track
/* each simplep2p "NIC" actually has N connections, so we need to track
* idle times across all of them to correctly do stats */
tw_stime send_next_idle_all;
tw_stime send_prev_idle_all;
......@@ -50,68 +50,68 @@ struct category_idles_s{
char category[CATEGORY_NAME_MAX];
};
struct sw_state
struct sp_state
{
/* next idle times for network card, both inbound and outbound */
tw_stime *send_next_idle;
tw_stime *recv_next_idle;
const char * anno;
const simplewan_param * params;
const simplep2p_param * params;
int id; /* logical id for matrix lookups */
/* Each simplewan "NIC" actually has N connections, so we need to track
/* Each simplep2p "NIC" actually has N connections, so we need to track
* idle times across all of them to correctly do stats.
* Additionally need to track different idle times across different
* categories */
category_idles idle_times_cat[CATEGORY_MAX];
struct mn_stats sw_stats_array[CATEGORY_MAX];
struct mn_stats sp_stats_array[CATEGORY_MAX];
};
/* annotation-specific parameters (unannotated entry occurs at the
* last index) */
static uint64_t num_params = 0;
static simplewan_param * all_params = NULL;
static simplep2p_param * all_params = NULL;
static const config_anno_map_t * anno_map = NULL;
static int sw_magic = 0;
static int sp_magic = 0;
/* returns a pointer to the lptype struct to use for simplewan LPs */
static const tw_lptype* sw_get_lp_type(void);
/* returns a pointer to the lptype struct to use for simplep2p LPs */
static const tw_lptype* sp_get_lp_type(void);
/* set model parameters:
* - startup_fname - path containing triangular matrix of net latencies, in ns
* - latency_fname - path containing triangular matrix of net latencies, in ns
* - bw_fname - path containing triangular matrix of bandwidths in MB/s.
* note that this merely stores the files, they will be parsed later
*/
static void sw_set_params(
const char * startup_fname,
static void sp_set_params(
const char * latency_fname,
const char * bw_fname,
simplewan_param * params);
simplep2p_param * params);
static void sw_configure();
static void sp_configure();
/* retrieve the size of the portion of the event struct that is consumed by
* the simplewan module. The caller should add this value to the size of
* the simplep2p module. The caller should add this value to the size of
* its own event structure to get the maximum total size of a message.
*/
static int sw_get_msg_sz(void);
static int sp_get_msg_sz(void);
/* Returns the simplewan magic number */
static int sw_get_magic();
/* Returns the simplep2p magic number */
static int sp_get_magic();
/* given two simplewan logical ids, do matrix lookups to get the point-to-point
/* given two simplep2p logical ids, do matrix lookups to get the point-to-point
* latency/bandwidth */
static double sw_get_table_ent(
static double sp_get_table_ent(
int from_id,
int to_id,
int num_lps,
double * table);
/* category lookup */
static category_idles* sw_get_category_idles(
static category_idles* sp_get_category_idles(
char * category, category_idles *idles);
/* collective network calls */
......@@ -120,8 +120,8 @@ static void simple_wan_collective();
/* collective network calls-- rc */
static void simple_wan_collective_rc();
/* Issues a simplewan packet event call */
static tw_stime simplewan_packet_event(
/* Issues a simplep2p packet event call */
static tw_stime simplep2p_packet_event(
char* category,
tw_lpid final_dest_lp,
uint64_t packet_size,
......@@ -136,80 +136,80 @@ static tw_stime simplewan_packet_event(
tw_lpid src_lp,
tw_lp *sender,
int is_last_pckt);
static void simplewan_packet_event_rc(tw_lp *sender);
static void simplep2p_packet_event_rc(tw_lp *sender);
static void simplewan_packet_event_rc(tw_lp *sender);
static void simplep2p_packet_event_rc(tw_lp *sender);
static void sw_report_stats();
static void sp_report_stats();
static tw_lpid sw_find_local_device(
static tw_lpid sp_find_local_device(
const char * annotation,
int ignore_annotations,
tw_lp *sender);
/* data structure for model-net statistics */
struct model_net_method simplewan_method =
struct model_net_method simplep2p_method =
{
.mn_configure = sw_configure,
.model_net_method_packet_event = simplewan_packet_event,
.model_net_method_packet_event_rc = simplewan_packet_event_rc,
.mn_configure = sp_configure,
.model_net_method_packet_event = simplep2p_packet_event,
.model_net_method_packet_event_rc = simplep2p_packet_event_rc,
.model_net_method_recv_msg_event = NULL,
.model_net_method_recv_msg_event_rc = NULL,
.mn_get_lp_type = sw_get_lp_type,
.mn_get_msg_sz = sw_get_msg_sz,
.mn_report_stats = sw_report_stats,
.mn_get_lp_type = sp_get_lp_type,
.mn_get_msg_sz = sp_get_msg_sz,
.mn_report_stats = sp_report_stats,
.model_net_method_find_local_device = NULL,
.mn_collective_call = simple_wan_collective,
.mn_collective_call_rc = simple_wan_collective_rc
};
static void sw_init(
sw_state * ns,
static void sp_init(
sp_state * ns,
tw_lp * lp);
static void sw_event(
sw_state * ns,
static void sp_event(
sp_state * ns,
tw_bf * b,
sw_message * m,
sp_message * m,
tw_lp * lp);
static void sw_rev_event(
sw_state * ns,
static void sp_rev_event(
sp_state * ns,
tw_bf * b,
sw_message * m,
sp_message * m,
tw_lp * lp);
static void sw_finalize(
sw_state * ns,
static void sp_finalize(
sp_state * ns,
tw_lp * lp);
tw_lptype sw_lp = {
(init_f) sw_init,
tw_lptype sp_lp = {
(init_f) sp_init,
(pre_run_f) NULL,
(event_f) sw_event,
(revent_f) sw_rev_event,
(final_f) sw_finalize,
(event_f) sp_event,
(revent_f) sp_rev_event,
(final_f) sp_finalize,
(map_f) codes_mapping,
sizeof(sw_state),
sizeof(sp_state),
};
static tw_stime rate_to_ns(uint64_t bytes, double MB_p_s);
static void handle_msg_ready_rev_event(
sw_state * ns,
sp_state * ns,
tw_bf * b,
sw_message * m,
sp_message * m,
tw_lp * lp);
static void handle_msg_ready_event(
sw_state * ns,
sp_state * ns,
tw_bf * b,
sw_message * m,
sp_message * m,
tw_lp * lp);
static void handle_msg_start_rev_event(
sw_state * ns,
sp_state * ns,
tw_bf * b,
sw_message * m,
sp_message * m,
tw_lp * lp);
static void handle_msg_start_event(
sw_state * ns,
sp_state * ns,
tw_bf * b,
sw_message * m,
sp_message * m,
tw_lp * lp);
/* collective network calls */
......@@ -225,18 +225,18 @@ static void simple_wan_collective_rc()
return;
}
/* returns pointer to LP information for simplewan module */
static const tw_lptype* sw_get_lp_type()
/* returns pointer to LP information for simplep2p module */
static const tw_lptype* sp_get_lp_type()
{
return(&sw_lp);
return(&sp_lp);
}
/* returns number of bytes that the simplewan module will consume in event
/* returns number of bytes that the simplep2p module will consume in event
* messages
*/
static int sw_get_msg_sz(void)
static int sp_get_msg_sz(void)
{
return(sizeof(sw_message));
return(sizeof(sp_message));
}
static double * parse_mat(char * buf, int *nvals_first, int *nvals_total, int is_tri_mat){
......@@ -301,21 +301,21 @@ static void fill_tri_mat(int N, double *mat, double *tri){
}
/* lets caller specify model parameters to use */
static void sw_set_params(
const char * startup_fname,
static void sp_set_params(
const char * latency_fname,
const char * bw_fname,
simplewan_param * params){
simplep2p_param * params){
long int fsize_s, fsize_b;
/* TODO: make this a run-time option */
int is_tri_mat = 0;
/* slurp the files */
FILE *sf = fopen(startup_fname, "r");
FILE *sf = fopen(latency_fname, "r");
FILE *bf = fopen(bw_fname, "r");
if (!sf)
tw_error(TW_LOC, "simplewan: unable to open %s", startup_fname);
tw_error(TW_LOC, "simplep2p: unable to open %s", latency_fname);
if (!bf)
tw_error(TW_LOC, "simplewan: unable to open %s", bw_fname);
tw_error(TW_LOC, "simplep2p: unable to open %s", bw_fname);
fseek(sf, 0, SEEK_END);
fsize_s = ftell(sf);
fseek(sf, 0, SEEK_SET);
......@@ -333,7 +333,7 @@ static void sw_set_params(
int nvals_first_s, nvals_first_b, nvals_total_s, nvals_total_b;
double *startup_tmp = parse_mat(sbuf, &nvals_first_s,
double *latency_tmp = parse_mat(sbuf, &nvals_first_s,
&nvals_total_s, is_tri_mat);
double *bw_tmp = parse_mat(bbuf, &nvals_first_b, &nvals_total_b, is_tri_mat);
......@@ -341,17 +341,17 @@ static void sw_set_params(
assert(nvals_first_s == nvals_first_b);
params->mat_len = nvals_first_s + ((is_tri_mat) ? 1 : 0);
if (is_tri_mat){
params->net_startup_ns_table =
params->net_latency_ns_table =
malloc(params->mat_len*params->mat_len*sizeof(double));
params->net_bw_mbps_table =
malloc(params->mat_len*params->mat_len*sizeof(double));
fill_tri_mat(params->mat_len, params->net_startup_ns_table, startup_tmp);
fill_tri_mat(params->mat_len, params->net_latency_ns_table, latency_tmp);
fill_tri_mat(params->mat_len, params->net_bw_mbps_table, bw_tmp);
free(startup_tmp);
free(latency_tmp);
free(bw_tmp);
}
else{
params->net_startup_ns_table = startup_tmp;
params->net_latency_ns_table = latency_tmp;
params->net_bw_mbps_table = bw_tmp;
}
......@@ -359,21 +359,21 @@ static void sw_set_params(
}
/* report network statistics */
static void sw_report_stats()
static void sp_report_stats()
{
/* TODO: Do we have some simplewan statistics to report like we have for torus and dragonfly? */
/* TODO: Do we have some simplep2p statistics to report like we have for torus and dragonfly? */
return;
}
static void sw_init(
sw_state * ns,
static void sp_init(
sp_state * ns,
tw_lp * lp)
{
uint32_t h1 = 0, h2 = 0;
memset(ns, 0, sizeof(*ns));
bj_hashlittle2(LP_METHOD_NM, strlen(LP_METHOD_NM), &h1, &h2);
sw_magic = h1+h2;
/* printf("\n sw_magic %d ", sw_magic); */
sp_magic = h1+h2;
/* printf("\n sp_magic %d ", sp_magic); */
ns->anno = codes_mapping_get_annotation_by_lpid(lp->gid);
if (ns->anno == NULL)
......@@ -409,20 +409,20 @@ static void sw_init(
return;
}
static void sw_event(
sw_state * ns,
static void sp_event(
sp_state * ns,
tw_bf * b,
sw_message * m,
sp_message * m,
tw_lp * lp)
{
assert(m->magic == sw_magic);
assert(m->magic == sp_magic);
switch (m->event_type)
{
case SW_MSG_START:
case SP_MSG_START:
handle_msg_start_event(ns, b, m, lp);
break;
case SW_MSG_READY:
case SP_MSG_READY:
handle_msg_ready_event(ns, b, m, lp);
break;
default:
......@@ -431,20 +431,20 @@ static void sw_event(
}
}
static void sw_rev_event(
sw_state * ns,
static void sp_rev_event(
sp_state * ns,
tw_bf * b,
sw_message * m,
sp_message * m,
tw_lp * lp)
{
assert(m->magic == sw_magic);
assert(m->magic == sp_magic);
switch (m->event_type)
{
case SW_MSG_START:
case SP_MSG_START:
handle_msg_start_rev_event(ns, b, m, lp);
break;
case SW_MSG_READY:
case SP_MSG_READY:
handle_msg_ready_rev_event(ns, b, m, lp);
break;
default:
......@@ -455,8 +455,8 @@ static void sw_rev_event(
return;
}
static void sw_finalize(
sw_state * ns,
static void sp_finalize(
sp_state * ns,
tw_lp * lp)
{
/* first need to add last known active-range times (they aren't added
......@@ -466,18 +466,18 @@ static void sw_finalize(
i < CATEGORY_MAX && strlen(ns->idle_times_cat[i].category) > 0;
i++){
category_idles *id = ns->idle_times_cat + i;
mn_stats *st = ns->sw_stats_array + i;
mn_stats *st = ns->sp_stats_array + i;
st->send_time += id->send_next_idle_all - id->send_prev_idle_all;
st->recv_time += id->recv_next_idle_all - id->recv_prev_idle_all;
}
model_net_print_stats(lp->gid, &ns->sw_stats_array[0]);
model_net_print_stats(lp->gid, &ns->sp_stats_array[0]);
return;
}
int sw_get_magic()
int sp_get_magic()
{
return sw_magic;
return sp_magic;
}
/* convert MiB/s and bytes to ns */
......@@ -497,21 +497,21 @@ static tw_stime rate_to_ns(uint64_t bytes, double MB_p_s)
/* reverse computation for msg ready event */
static void handle_msg_ready_rev_event(
sw_state * ns,
sp_state * ns,
tw_bf * b,
sw_message * m,
sp_message * m,
tw_lp * lp)
{
struct mn_stats* stat;
category_idles * idles;
stat = model_net_find_stats(m->category, ns->sw_stats_array);
stat = model_net_find_stats(m->category, ns->sp_stats_array);
stat->recv_count--;
stat->recv_bytes -= m->net_msg_size_bytes;
stat->recv_time = m->recv_time_saved;
ns->recv_next_idle[m->src_mn_rel_id] = m->recv_next_idle_saved;
idles = sw_get_category_idles(m->category, ns->idle_times_cat);
idles = sp_get_category_idles(m->category, ns->idle_times_cat);
idles->recv_next_idle_all = m->recv_next_idle_all_saved;
idles->recv_prev_idle_all = m->recv_prev_idle_all_saved;
......@@ -527,9 +527,9 @@ static void handle_msg_ready_rev_event(
* to recv, but we haven't checked to see if the recv queue is available yet
*/
static void handle_msg_ready_event(
sw_state * ns,
sp_state * ns,
tw_bf * b,
sw_message * m,
sp_message * m,
tw_lp * lp)
{
tw_stime recv_queue_time = 0;
......@@ -537,11 +537,11 @@ static void handle_msg_ready_event(
struct mn_stats* stat;
/* get source->me network stats */
double bw = sw_get_table_ent(m->src_mn_rel_id, ns->id,
double bw = sp_get_table_ent(m->src_mn_rel_id, ns->id,
ns->params->num_lps, ns->params->net_bw_mbps_table);
double startup = sw_get_table_ent(m->src_mn_rel_id, ns->id,
ns->params->num_lps, ns->params->net_startup_ns_table);