/********************************************************************************************/
static void env_Pairwisehost_bw(int argc, char *argv[])
{
- xbt_ex_t e;
-
/* where are the sensors */
xbt_dynar_t hosts = xbt_dynar_new(sizeof(xbt_host_t), &free_host);
int nb_hosts;
amok_bw_saturate_start(h1->name, h1->port, host_test, h1->port, //"Ginette"
msg_size, 120); // sturation of the link with msg_size to compute a concurent bandwidth MA //MB
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
RETHROWF("Cannot ask hosts to saturate the link: %s");
}
// gras_os_sleep(1.0);
/********************************************************************************************/
static void full_fledged_saturation(int argc, char *argv[])
{
- xbt_ex_t e;
double time1 = 5.0, bw1 = 5.0; // 0.5 for test
/* timers */
double begin_simulated;
amok_bw_saturate_start(h1->name, h1->port, h2->name, h2->port, 0, /* Be nice, compute msg_size yourself */
0 /* no timeout */ );
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
RETHROWF("Cannot ask peers to saturate the link: %s");
}
gras_os_sleep(5);
TRY {
gras_msg_send(toserver, "ping", &ping);
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
gras_socket_close(toserver);
RETHROWF("Failed to send PING to server: %s");
}
TRY {
gras_msg_wait(6000, "pong", &from, &pong);
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
gras_socket_close(toserver);
RETHROWF("Why can't I get my PONG message like everyone else: %s");
}
static int server_cb_ping_handler(gras_msg_cb_ctx_t ctx, void *payload)
{
-
- xbt_ex_t e;
/* 1. Get the payload into the msg variable, and retrieve my caller */
int msg = *(int *) payload;
gras_socket_t expeditor = gras_msg_cb_ctx_from(ctx);
gras_msg_send(expeditor, "pong", &msg);
/* 6. Deal with errors: add some details to the exception */
- } CATCH(e) {
+ }
+ CATCH_ANONYMOUS {
gras_socket_close(globals->sock);
RETHROWF("Unable answer with PONG: %s");
}
int server(int argc, char *argv[])
{
- xbt_ex_t e;
gras_socket_t sock = NULL;
int port = 4000;
TRY {
sock = gras_socket_server(port);
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
RETHROWF("Unable to establish a server socket: %s");
}
int client(int argc, char *argv[])
{
- xbt_ex_t e;
gras_socket_t toserver = NULL; /* peer */
gras_socket_t from;
TRY {
toserver = gras_socket_client(host, port);
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
RETHROWF("Unable to connect to the server: %s");
}
XBT_INFO("Connected to %s:%d.", host, port);
int server(int argc, char *argv[])
{
- xbt_ex_t e;
gras_socket_t sock = NULL;
int port = 4002;
TRY {
sock = gras_socket_server(port);
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
RETHROWF("Unable to establish a server socket: %s");
}
/* Callback function */
static int node_cb_stoken_handler(gras_msg_cb_ctx_t ctx, void *payload)
{
-
- xbt_ex_t e;
-
/* 1. Get the payload into the msg variable, and retrieve my caller */
int msg = *(int *) payload;
gras_socket_t expeditor = gras_msg_cb_ctx_from(ctx);
/* 6. Deal with errors */
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
gras_socket_close(globals->sock);
RETHROWF("Unable to forward token: %s");
}
int myport;
int peerport;
- xbt_ex_t e;
-
/* 1. Init the GRAS infrastructure and declare my globals */
gras_init(&argc, argv);
globals = gras_userdata_new(node_data_t);
TRY {
gras_msg_send(globals->tosuccessor, "stoken", &token);
- } CATCH(e) {
+ }
+ CATCH_ANONYMOUS {
RETHROWF("Unable to send the freshly created token: %s");
}
}
static void forward_get_suc(get_suc_t msg, char host[1024], int port)
{
gras_socket_t temp_sock = NULL;
- xbt_ex_t e; // the error variable used in TRY.. CATCH tokens.
//XBT_INFO("Transmiting message to %s:%d",host,port);
TRY {
temp_sock = gras_socket_client(host, port);
- } CATCH(e) {
+ }
+ CATCH_ANONYMOUS {
RETHROWF("Unable to connect!: %s");
}
TRY {
gras_msg_send(temp_sock, "can_get_suc", &msg);
- } CATCH(e) {
+ }
+ CATCH_ANONYMOUS {
RETHROWF("Unable to send!: %s");
}
XBT_INFO("Forwarding a get_successor message to %s for (%d;%d)", host,
TRY {
temp_sock = gras_socket_client(incoming->host, incoming->port);
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
RETHROWF
("Unable to connect to the node wich has requested for an area!: %s");
}
gras_msg_send(temp_sock, "can_rep_suc", &outgoing);
XBT_INFO("Environment informations sent!");
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
RETHROWF("%s:Timeout sending environment informations to %s: %s",
globals->host, gras_socket_peer_name(expeditor));
}
TRY {
temp_sock = gras_socket_client(argv[4], atoi(argv[5]));
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
RETHROWF("Unable to connect known host to request for an area!: %s");
}
TRY { // asking.
gras_msg_send(temp_sock, "can_get_suc", &get_suc_msg);
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
gras_socket_close(temp_sock);
RETHROWF("Unable to contact known host to get an area!: %s");
}
XBT_INFO("Waiting for reply!");
gras_msg_wait(6000, "can_rep_suc", &temp_sock2, &rep_suc_msg);
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
RETHROWF("%s: Error waiting for an area:%s", globals->host);
}
{
gras_socket_t temp_sock = NULL;
nuke_t nuke_msg;
- xbt_ex_t e; // the error variable used in TRY.. CATCH tokens.
//return 0; // in order to inhibit the War of the Nodes
gras_init(&argc, argv);
gras_os_sleep((15 - gras_os_getpid()) * 20 + 200); // wait a bit.
TRY { // contacting the bad guy that will launch the War.
temp_sock = gras_socket_client(gras_os_myname(), atoi(argv[1]));
- } CATCH(e) {
+ }
+ CATCH_ANONYMOUS {
RETHROWF("Unable to connect known host so as to declare WAR!: %s");
}
TRY {
gras_msg_send(temp_sock, "can_nuke", &nuke_msg);
- } CATCH(e) {
+ }
+ CATCH_ANONYMOUS {
gras_socket_close(temp_sock);
RETHROWF
("Unable to contact known host so as to declare WAR!!!!!!!!!!!!!!!!!!!!!: %s");
{
node_data_t *globals = (node_data_t *) gras_userdata_get();
gras_socket_t temp_sock = NULL;
- xbt_ex_t e; // the error variable used in TRY.. CATCH tokens.
if (xId >= globals->x1 && xId <= globals->x2 && yId >= globals->y1
&& yId <= globals->y2) {
TRY { // sending the nuke.
temp_sock = gras_socket_client(host, port);
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
RETHROWF("Unable to connect the nuke!: %s");
}
//XBT_INFO("%s ON %s %d %d <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<",globals->host,host,xId,yId);
TRY {
gras_msg_send(temp_sock, "can_nuke", msg);
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
RETHROWF("Unable to send the nuke!: %s");
}
gras_socket_close(temp_sock);
TRY {
temp_sock = gras_socket_client(host, port);
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
RETHROWF("Unable to connect the nuke!: %s");
}
TRY {
gras_msg_send(temp_sock, "can_nuke", incoming);
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
RETHROWF("Unable to send the nuke!: %s");
}
XBT_INFO("Nuke re-aimed by %s to %s for (%d;%d)", globals->host, host,
void *payload_data)
{
gras_socket_t expeditor = gras_msg_cb_ctx_from(ctx);
- xbt_ex_t e;
get_suc_t incoming = *(get_suc_t *) payload_data;
rep_suc_t outgoing;
node_data_t *globals = (node_data_t *) gras_userdata_get();
temp_sock = gras_socket_client(globals->finger[contact].host,
globals->finger[contact].port);
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
RETHROWF("Unable to connect!: %s");
}
TRY {
gras_msg_send(temp_sock, "chord_get_suc", &asking);
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
RETHROWF("Unable to ask!: %s");
}
gras_msg_wait(10., "chord_rep_suc", &temp_sock, &outgoing);
gras_msg_send(expeditor, "chord_rep_suc", &outgoing);
XBT_INFO("Successor information sent!");
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
RETHROWF("%s:Timeout sending successor information to %s: %s",
globals->host, gras_socket_peer_name(expeditor));
}
static void fix_fingers()
{
get_suc_t get_suc_msg;
- xbt_ex_t e;
gras_socket_t temp_sock = NULL;
gras_socket_t temp_sock2 = NULL;
rep_suc_t rep_suc_msg;
TRY {
temp_sock = gras_socket_client(globals->host, globals->port);
- } CATCH(e) {
+ }
+ CATCH_ANONYMOUS {
RETHROWF("Unable to contact known host: %s");
}
get_suc_msg.id = globals->id;
TRY {
gras_msg_send(temp_sock, "chord_get_suc", &get_suc_msg);
- } CATCH(e) {
+ }
+ CATCH_ANONYMOUS {
gras_socket_close(temp_sock);
RETHROWF("Unable to contact known host to get successor!: %s");
}
TRY {
XBT_INFO("Waiting for reply!");
gras_msg_wait(6000, "chord_rep_suc", &temp_sock2, &rep_suc_msg);
- } CATCH(e) {
+ }
+ CATCH_ANONYMOUS {
RETHROWF("%s: Error waiting for successor:%s", globals->host);
}
globals->finger[0].id = rep_suc_msg.id;
TRY {
temp_sock = gras_socket_client(other_host, other_port);
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
RETHROWF("Unable to contact known host: %s");
}
TRY {
gras_msg_send(temp_sock, "chord_get_suc", &get_suc_msg);
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
gras_socket_close(temp_sock);
RETHROWF("Unable to contact known host to get successor!: %s");
}
XBT_INFO("Waiting for reply!");
gras_msg_wait(10., "chord_rep_suc", &temp_sock2, &rep_suc_msg);
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
RETHROWF("%s: Error waiting for successor:%s", globals->host);
}
globals->finger[0].id = rep_suc_msg.id;
temp_sock = gras_socket_client(globals->finger[0].host,
globals->finger[0].port);
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
RETHROWF("Unable to contact successor: %s");
}
TRY {
gras_msg_send(temp_sock, "chord_notify", ¬ify_msg);
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
RETHROWF("Unable to notify successor! %s");
}
}
TRY {
gras_msg_send(toserver, "ping", &ping);
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
gras_socket_close(toserver);
RETHROWF("Failed to send PING to server: %s");
}
TRY {
gras_msg_wait(6000, "pong", &from, &pong);
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
gras_socket_close(toserver);
RETHROWF("Why can't I get my PONG message like everyone else: %s");
}
static int server_cb_ping_handler(gras_msg_cb_ctx_t ctx, void *payload)
{
-
- xbt_ex_t e;
/* 1. Get the payload into the msg variable, and retrieve my caller */
int msg = *(int *) payload;
gras_socket_t expeditor = gras_msg_cb_ctx_from(ctx);
gras_msg_send(expeditor, "pong", &msg);
/* 6. Deal with errors: add some details to the exception */
- } CATCH(e) {
+ }
+ CATCH_ANONYMOUS {
gras_socket_close(globals->sock);
RETHROWF("Unable answer with PONG: %s");
}
s_pmm_assignment_t assignment = *(s_pmm_assignment_t *) payload;
gras_socket_t master = gras_msg_cb_ctx_from(ctx);
- xbt_ex_t e;
-
int step, l;
xbt_matrix_t bA = xbt_matrix_new(submatrix_size, submatrix_size,
sizeof(double), NULL);
xbt_matrix_free(bB);
gras_msg_wait(600, "dataB", &from, &bB);
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
RETHROWF("Can't get a data message from line : %s");
}
XBT_VERB("LINE: step(%d) <> Myline(%d). Receive data from %s", step,
xbt_matrix_free(bA);
gras_msg_wait(1200, "dataA", &from, &bA);
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
RETHROWF("Can't get a data message from row : %s");
}
XBT_VERB("ROW: step(%d)<>myrow(%d). Receive data from %s", step, myrow,
TRY {
gras_msg_send(master, "result", &result);
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
RETHROWF("Failed to send answer to server: %s");
}
XBT_VERB(">>>>>>>> Result sent to %s:%d <<<<<<<<",
xbt_workload_sort_who_date(cmds);
unsigned int cursor;
xbt_workload_elm_t cmd;
-
- xbt_ex_t e;
xbt_dict_cursor_t dict_cursor;
xbt_dict_t pals_int = xbt_dict_new();
TRY {
gras_msg_handle(20);
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
xbt_dynar_foreach(peers, cursor, peer) {
xbt_dict_remove(pals_int, peer->name);
}
static void do_command(int rank, void *c)
{
- xbt_ex_t e;
xbt_workload_elm_t cmd = *(xbt_workload_elm_t *) c;
xbt_workload_data_chunk_t chunk;
TRY {
gras_msg_wait(1000000, "chunk", NULL, &chunk);
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
SIMIX_display_process_status();
RETHROWF("Exception while waiting for %f bytes from %s: %s",
cmd->d_arg, cmd->str_arg);
toserver = gras_socket_client(host, port);
toforwarder = gras_socket_client(argv[3], atoi(argv[4]));
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
RETHROWF("Unable to connect to the server: %s");
}
XBT_INFO("Connected to %s:%d.", host, port);
exception_catching();
gras_msg_rpccall(toserver, 6000.0, "plain ping", &ping, &pong);
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
gras_socket_close(toserver);
RETHROWF("Failed to execute a PING rpc on the server: %s");
}
TRY {
gras_msg_rpccall(peer, 15, "BW handshake", &request, &request_ack);
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
RETHROWF("Error encountered while sending the BW request: %s");
}
measIn = gras_socket_meas_accept(measMasterIn);
request_ack->peer.port,
request->buf_size, 1);
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
RETHROWF
("Error encountered while opening the measurement socket to %s:%d for BW test: %s",
gras_socket_peer_name(peer), request_ack->peer.port);
request->msg_amount);
XBT_DEBUG("Data sent. Wait ACK");
gras_socket_meas_recv(measIn, 120, 1, 1);
- } CATCH(e) {
+ }
+ CATCH_ANONYMOUS {
gras_socket_close(measOut);
gras_socket_close(measMasterIn);
gras_socket_close(measIn);
TRY {
gras_msg_rpcreturn(60, ctx, &answer);
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
gras_socket_close(measMasterIn);
/* FIXME: tell error to remote */
RETHROWF("Error encountered while sending the answer: %s");
request->peer.port,
request->buf_size, 1);
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
RETHROWF
("Error encountered while opening a measurement socket back to %s:%d : %s",
gras_socket_peer_name(expeditor), request->peer.port);
answer->buf_size, answer->msg_size, answer->msg_amount,
answer->peer.port);
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
gras_socket_close(measMasterIn);
gras_socket_close(measIn);
gras_socket_close(measOut);
gras_socket_meas_recv(measIn, 120, request->msg_size,
request->msg_amount);
gras_socket_meas_send(measOut, 120, 1, 1);
- } CATCH(e) {
+ }
+ CATCH_ANONYMOUS {
gras_socket_close(measMasterIn);
gras_socket_close(measIn);
gras_socket_close(measOut);
meas = gras_socket_meas_accept(measMaster);
XBT_DEBUG("saturation handshake answered");
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
gras_socket_close(measMaster);
RETHROWF("Error during saturation handshake: %s");
}
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);
bw_res_t answer;
XBT_VERB("Ask %s:%d to stop the saturation", from_name, from_port);
TRY {
gras_msg_rpccall(sock, 60, "amok_bw_sat stop", NULL, &answer);
- } CATCH(e) {
- RETHROWF("Cannot ask %s:%d to stop saturation: %s", from_name,
- from_port);
+ }
+ CATCH_ANONYMOUS {
+ RETHROWF("Cannot ask %s:%d to stop saturation: %s", from_name, from_port);
}
gras_socket_close(sock);
if (time)
*/
int gras_datadesc_memcpy(gras_datadesc_type_t type, void *src, void *dst)
{
- xbt_ex_t e;
static gras_cbps_t state = NULL;
static xbt_dict_t refs = NULL; /* all references already sent */
int size = 0;
} TRY_CLEANUP {
xbt_dict_reset(refs);
gras_cbps_reset(state);
- } CATCH(e) {
+ }
+ CATCH_ANONYMOUS {
RETHROW;
}
return size;
void gras_datadesc_send(gras_socket_t sock,
gras_datadesc_type_t type, void *src)
{
-
- xbt_ex_t e;
static gras_cbps_t state = NULL;
static xbt_dict_t refs = NULL; /* all references already sent */
} TRY_CLEANUP {
xbt_dict_reset(refs);
gras_cbps_reset(state);
- } CATCH(e) {
+ }
+ CATCH_ANONYMOUS {
RETHROW;
}
}
gras_datadesc_recv(gras_socket_t sock,
gras_datadesc_type_t type, int r_arch, void *dst)
{
-
- xbt_ex_t e;
static gras_cbps_t state = NULL; /* callback persistent state */
static xbt_dict_t refs = NULL; /* all references already sent */
} TRY_CLEANUP {
xbt_dict_reset(refs);
gras_cbps_reset(state);
- } CATCH(e) {
+ }
+ CATCH_ANONYMOUS {
RETHROW;
}
}
gras_trp_recv(sock, &c_kind, 1);
msg->kind = (e_gras_msg_kind_t) c_kind;
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
RETHROWF
("Exception caught while trying to get the message header: %s");
}
gras_socket_server_ext(unsigned short port,
unsigned long int buf_size, int measurement)
{
-
- xbt_ex_t e;
gras_trp_plugin_t trp;
gras_socket_t sock;
XBT_DEBUG("in=%c out=%c accept=%c",
sock->incoming ? 'y' : 'n',
sock->outgoing ? 'y' : 'n', sock->accepting ? 'y' : 'n');
- } CATCH(e) {
-
+ }
+ CATCH_ANONYMOUS {
free(sock);
RETHROW;
}
unsigned short port,
unsigned long int buf_size, int measurement)
{
-
- xbt_ex_t e;
gras_trp_plugin_t trp;
gras_socket_t sock;
XBT_DEBUG("in=%c out=%c accept=%c",
sock->incoming ? 'y' : 'n',
sock->outgoing ? 'y' : 'n', sock->accepting ? 'y' : 'n');
- } CATCH(e) {
+ }
+ CATCH_ANONYMOUS {
free(sock);
RETHROW;
}
gras_procdata_t * pd)
{
void *res = NULL;
- xbt_ex_t e;
if (xbt_set_length(pd->libdata) <
xbt_dynar_length(_gras_procdata_fabrics)) {
/* Damn, some new modules were added since procdata_init(). Amok? */
TRY {
res = xbt_set_get_by_name(pd->libdata, name);
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
RETHROWF("Cannot retrieve the libdata associated to %s: %s", name);
}
return res;
name);
}
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
free(optionlist_cpy);
RETHROW;
}
{
xbt_dynar_t lens = xbt_dynar_new(sizeof(unsigned long int), NULL);
unsigned long i;
- xbt_ex_t e;
for (i = 0; i < xbt_dynar_length(keys); i++) {
char *thiskey = xbt_dynar_get_as(keys, i, char *);
xbt_multidict_set_ext(mdict, keys, lens, data, free_ctn);
} TRY_CLEANUP {
xbt_dynar_free(&lens);
- } CATCH(e) {
+ }
+ CATCH_ANONYMOUS {
RETHROW;
}
}
void xbt_multidict_remove(xbt_dict_t mdict, xbt_dynar_t keys)
{
-
- xbt_ex_t e;
xbt_dynar_t lens = xbt_dynar_new(sizeof(unsigned long int), NULL);
unsigned long i;
xbt_multidict_remove_ext(mdict, keys, lens);
} TRY_CLEANUP {
xbt_dynar_free(&lens);
- } CATCH(e) {
+ }
+ CATCH_ANONYMOUS {
RETHROW;
}
}
n++;
THROWF(unknown_error, 0, "something");
}
- CATCH(ex) {
+ CATCH_ANONYMOUS {
if (n != 6)
xbt_test_fail("M3: n=%d (!= 6)", n);
n++;
if (cp1 != NULL)
free(cp1);
}
- CATCH(ex) {
+ CATCH_ANONYMOUS {
printf("cp3=%s", cp3);
RETHROW;
}
static void good_example(void)
{
global_context_t *global_context = malloc(sizeof(global_context_t));
- xbt_ex_t ex;
/* GOOD_EXAMPLE */
{ /*01 */
free(cp2);
/*05 cp1 was given away */
}
- CATCH(ex) {
+ CATCH_ANONYMOUS {
/*05 global context untouched */
RETHROW;
}
void xbt_queue_push_timed(xbt_queue_t queue, const void *src, double delay)
{
double begin = xbt_time();
- xbt_ex_t e;
xbt_mutex_acquire(queue->mutex);
xbt_cond_timedwait(queue->not_full, queue->mutex,
delay < 0 ? -1 : delay - (xbt_time() - begin));
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
xbt_mutex_release(queue->mutex);
RETHROW;
}
void xbt_queue_pop_timed(xbt_queue_t queue, void *const dst, double delay)
{
double begin = xbt_time();
- xbt_ex_t e;
xbt_mutex_acquire(queue->mutex);
xbt_cond_timedwait(queue->not_empty, queue->mutex,
delay < 0 ? -1 : delay - (xbt_time() - begin));
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
xbt_mutex_release(queue->mutex);
RETHROW;
}
double delay)
{
double begin = xbt_time();
- xbt_ex_t e;
xbt_mutex_acquire(queue->mutex);
xbt_cond_timedwait(queue->not_full, queue->mutex,
delay < 0 ? -1 : delay - (xbt_time() - begin));
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
xbt_mutex_release(queue->mutex);
RETHROW;
}
double delay)
{
double begin = xbt_time();
- xbt_ex_t e;
xbt_mutex_acquire(queue->mutex);
xbt_cond_timedwait(queue->not_empty, queue->mutex,
delay < 0 ? -1 : delay - (xbt_time() - begin));
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
xbt_mutex_release(queue->mutex);
RETHROW;
}
XBT_INFO("Launch server (port=%d)", myport);
TRY {
me = gras_socket_server(myport);
- } CATCH(e) {
+ }
+ CATCH_ANONYMOUS {
RETHROWF("Unable to establish a server socket: %s");
}
gras_os_sleep(1); /* Wait for pal to startup */
TRY {
pal = gras_socket_client_from_string(palstr);
- } CATCH(e) {
+ }
+ CATCH_ANONYMOUS {
RETHROWF("Unable to establish a socket to %s: %s", palstr);
}
XBT_INFO("Initialization done.");
gras_socket_t me = NULL, pal = NULL;
int myport;
char *palstr;
- xbt_ex_t e;
gras_init(&argc, argv);
xbt_assert(argc == 3, "Usage: client <myport> <server>");
XBT_INFO("Launch client (port=%d)", myport);
TRY {
me = gras_socket_server(myport);
- } CATCH(e) {
+ }
+ CATCH_ANONYMOUS {
RETHROWF("Unable to establish a server socket: %s");
}
gras_os_sleep(1); /* Wait for pal to startup */
TRY {
pal = gras_socket_client_from_string(palstr);
- } CATCH(e) {
+ }
+ CATCH_ANONYMOUS {
RETHROWF("Unable to establish a socket to %s: %s", palstr);
}
XBT_INFO("Initialization done.");
/* Launch handle(-1). Lock until message from server expected */
TRY {
gras_msg_handle(-1);
- } CATCH(e) {
+ }
+ CATCH_ANONYMOUS {
RETHROWF("No exception expected during handle(-1), but got %s");
}
XBT_INFO("gras_msg_handle(-1) works as expected (locked)");