-/* $Id$ */
-
/* amok_saturate - Link saturating facilities (for ALNeM's BW testing) */
-/* Copyright (c) 2003, 2004 Martin Quinson. All rights reserved. */
+/* Copyright (c) 2004, 2005, 2006, 2007, 2009, 2010. The SimGrid Team.
+ * All rights reserved. */
/* This program is free software; you can redistribute it and/or modify it
* under the terms of the license (GNU LGPL) which comes with this package. */
void amok_bw_sat_init(void)
{
- gras_datadesc_type_t bw_res_desc = gras_datadesc_by_name("bw_res_t");
- gras_datadesc_type_t sat_request_desc;
+ xbt_datadesc_type_t bw_res_desc = xbt_datadesc_by_name("bw_res_t");
+ xbt_datadesc_type_t sat_request_desc;
/* Build the saturation datatype descriptions */
- sat_request_desc = gras_datadesc_struct("s_sat_request_desc_t");
- gras_datadesc_struct_append(sat_request_desc, "peer",
- gras_datadesc_by_name("s_xbt_peer_t"));
- gras_datadesc_struct_append(sat_request_desc, "msg_size",
- gras_datadesc_by_name("unsigned int"));
- gras_datadesc_struct_append(sat_request_desc, "duration",
- gras_datadesc_by_name("unsigned int"));
- gras_datadesc_struct_close(sat_request_desc);
- sat_request_desc = gras_datadesc_ref("sat_request_t", sat_request_desc);
+ sat_request_desc = xbt_datadesc_struct("s_sat_request_desc_t");
+ xbt_datadesc_struct_append(sat_request_desc, "peer",
+ xbt_datadesc_by_name("s_xbt_peer_t"));
+ xbt_datadesc_struct_append(sat_request_desc, "msg_size",
+ xbt_datadesc_by_name("unsigned int"));
+ xbt_datadesc_struct_append(sat_request_desc, "duration",
+ xbt_datadesc_by_name("unsigned int"));
+ xbt_datadesc_struct_close(sat_request_desc);
+ sat_request_desc = xbt_datadesc_ref("sat_request_t", sat_request_desc);
/* Register the saturation messages */
gras_msgtype_declare_rpc("amok_bw_sat start", sat_request_desc, NULL);
const char *to_name, unsigned int to_port,
unsigned int msg_size, double duration)
{
- gras_socket_t sock;
+ xbt_socket_t sock;
sat_request_t request = xbt_new(s_sat_request_t, 1);
- VERB4("Start from_name %s:%d -> to_name %s:%d",
+ XBT_VERB("Start from_name %s:%u -> to_name %s:%u",
from_name, from_port, to_name, to_port);
sock = gras_socket_client(from_name, from_port);
static int amok_bw_cb_sat_start(gras_msg_cb_ctx_t ctx, void *payload)
{
sat_request_t request = *(sat_request_t *) payload;
- gras_socket_t expeditor = gras_msg_cb_ctx_from(ctx);
+ xbt_socket_t expeditor = gras_msg_cb_ctx_from(ctx);
- VERB4("Asked by %s:%d to start a saturation to %s:%d",
- gras_socket_peer_name(expeditor), gras_socket_peer_port(expeditor),
+ XBT_VERB("Asked by %s:%d to start a saturation to %s:%d",
+ xbt_socket_peer_name(expeditor), xbt_socket_peer_port(expeditor),
request->peer.name, request->peer.port);
gras_msg_rpcreturn(60, ctx, NULL);
* each of the messages occupy the connexion one second
*/
void amok_bw_saturate_begin(const char *to_name, unsigned int to_port,
- unsigned int msg_size, double duration,
+ volatile unsigned int msg_size, double duration,
/*out */ double *elapsed_res, double *bw_res)
{
xbt_ex_t e;
- gras_socket_t peer_cmd = gras_socket_client(to_name, to_port);
+ xbt_socket_t peer_cmd = gras_socket_client(to_name, to_port);
gras_msg_cb_ctx_t ctx;
- gras_socket_t meas;
+ xbt_socket_t meas;
s_gras_msg_t msg_got;
- unsigned int packet_sent = 0;
+ volatile unsigned int packet_sent = 0;
double start, elapsed = -1; /* timer */
double bw;
/* Negociate the saturation with the peer */
sat_request_t request = xbt_new(s_sat_request_t, 1);
- DEBUG2("Begin to saturate to %s:%d", to_name, to_port);
+ XBT_DEBUG("Begin to saturate to %s:%u", to_name, to_port);
memset(&msg_got, 0, sizeof(msg_got));
request->msg_size = msg_size;
1, /* at least one sec */
&sec, &bw);
msg_size = request->msg_size = (int) bw;
- DEBUG1("Saturate with packets of %d bytes", request->msg_size);
+ XBT_DEBUG("Saturate with packets of %u bytes", request->msg_size);
}
/* Launch the saturation */
- ctx = gras_msg_rpc_async_call(peer_cmd, 60, "amok_bw_sat begin", &request);
+ ctx =
+ gras_msg_rpc_async_call(peer_cmd, 60, "amok_bw_sat begin", &request);
free(request);
gras_msg_rpc_async_wait(ctx, &request);
meas = gras_socket_client_ext(to_name, request->peer.port,
free(request);
gras_socket_close(peer_cmd);
- INFO4("Saturation(%s:%d->%s:%d) started", gras_os_myname(),
+ XBT_INFO("Saturation(%s:%d->%s:%u) started", gras_os_myname(),
gras_os_myport(), to_name, to_port);
/* Start experiment */
do {
/* do send it */
- gras_socket_meas_send(meas, 120, msg_size, 1);
+ xbt_socket_meas_send(meas, 120, msg_size, 1);
packet_sent++;
/* Check whether someone asked us to stop saturation */
/* Check whether the experiment has to be terminated by now */
elapsed = gras_os_time() - start;
- DEBUG3("elapsed %f duration %f (msg_size=%d)", elapsed, duration,
+ XBT_DEBUG("elapsed %f duration %f (msg_size=%u)", elapsed, duration,
msg_size);
} while (saturate_further && (duration == 0 || elapsed < duration));
bw_res_t answer = xbt_new(s_bw_res_t, 1);
s_gras_msg_cb_ctx_t ctx;
- INFO6("Saturation from %s:%d to %s:%d stopped by %s:%d",
+ XBT_INFO("Saturation from %s:%d to %s:%u stopped by %s:%d",
gras_os_myname(), gras_os_myport(), to_name, to_port,
- gras_socket_peer_name(msg_got.expe),
- gras_socket_peer_port(msg_got.expe));
+ xbt_socket_peer_name(msg_got.expe),
+ xbt_socket_peer_port(msg_got.expe));
answer->timestamp = gras_os_time();
answer->sec = elapsed;
answer->bw = bw;
gras_msg_rpcreturn(60, &ctx, &answer);
free(answer);
} else {
- INFO6
- ("Saturation from %s:%d to %s:%d elapsed after %f sec (achieving %f kb/s)",
- gras_os_myname(), gras_os_myport(), to_name, to_port, elapsed,
- bw / 1024.0);
+ XBT_INFO
+ ("Saturation from %s:%d to %s:%u elapsed after %f sec (achieving %f kb/s)",
+ gras_os_myname(), gras_os_myport(), to_name, to_port, elapsed,
+ bw / 1024.0);
}
gras_socket_close(meas);
sat_request_t answer = xbt_new0(s_sat_request_t, 1);
volatile int saturate_further = 1;
xbt_ex_t e;
- gras_socket_t measMaster = NULL, meas = NULL;
- gras_socket_t from = gras_msg_cb_ctx_from(ctx);
+ volatile xbt_socket_t measMaster = NULL, meas = NULL;
+ volatile xbt_socket_t from = gras_msg_cb_ctx_from(ctx);
- int port = 6000;
+ volatile int port = 6000;
while (port <= 10000 && measMaster == NULL) {
TRY {
measMaster = gras_socket_server_ext(port, 0 /*bufsize: auto */ ,
if (port < 10000)
xbt_ex_free(e);
else
- RETHROW0
- ("Error encountered while opening a measurement server socket: %s");
+ RETHROWF
+ ("Error encountered while opening a measurement server socket: %s");
}
if (measMaster == NULL)
port++; /* prepare for a new loop */
gras_os_sleep(5); /* Wait for the accept */
TRY {
- meas = gras_socket_meas_accept(measMaster);
- DEBUG0("saturation handshake answered");
+ meas = xbt_socket_meas_accept(measMaster);
+ XBT_DEBUG("saturation handshake answered");
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
gras_socket_close(measMaster);
- RETHROW0("Error during saturation handshake: %s");
+ RETHROWF("Error during saturation handshake: %s");
}
while (saturate_further) {
TRY {
- gras_socket_meas_recv(meas, 5, request->msg_size, 1);
+ xbt_socket_meas_recv(meas, 5, request->msg_size, 1);
}
CATCH(e) {
saturate_further = 0;
xbt_ex_free(e);
}
}
- INFO4("Saturation comming from %s:%d stopped on %s:%d",
- gras_socket_peer_name(from), gras_socket_peer_port(from),
+ XBT_INFO("Saturation comming from %s:%d stopped on %s:%d",
+ xbt_socket_peer_name(from), xbt_socket_peer_port(from),
gras_os_myname(), gras_os_myport());
gras_socket_close(meas);
void amok_bw_saturate_stop(const char *from_name, unsigned int from_port,
/*out */ double *time, double *bw)
{
- xbt_ex_t e;
-
- gras_socket_t sock = gras_socket_client(from_name, from_port);
+ xbt_socket_t sock = gras_socket_client(from_name, from_port);
bw_res_t answer;
- VERB2("Ask %s:%d to stop the saturation", from_name, from_port);
+ XBT_VERB("Ask %s:%u to stop the saturation", from_name, from_port);
TRY {
gras_msg_rpccall(sock, 60, "amok_bw_sat stop", NULL, &answer);
- } CATCH(e) {
- RETHROW2("Cannot ask %s:%d to stop saturation: %s", from_name, from_port);
+ }
+ CATCH_ANONYMOUS {
+ RETHROWF("Cannot ask %s:%u to stop saturation: %s", from_name, from_port);
}
gras_socket_close(sock);
if (time)
