xbt_workload_declare_datadesc();
gras_msgtype_declare("go", NULL);
gras_msgtype_declare("commands",
- gras_datadesc_dynar(gras_datadesc_by_name
+ xbt_datadesc_dynar(xbt_datadesc_by_name
("xbt_workload_elm_t"),
xbt_workload_elm_free_voidp));
gras_msgtype_declare("chunk",
- gras_datadesc_by_name("xbt_workload_data_chunk_t"));
+ xbt_datadesc_by_name("xbt_workload_data_chunk_t"));
}
int master(int argc, char *argv[])
declare_msg();
- xbt_assert0(argc == 3, "usage: replay_master tracefile port");
+ xbt_assert(argc == 3, "usage: replay_master tracefile port");
gras_socket_server(atoi(argv[2])); /* open my master socket, even if I don't use it */
xbt_dynar_t peers = amok_pm_group_new("replay"); /* group of slaves */
xbt_peer_t peer;
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();
+ xbt_dict_t pals_int = xbt_dict_new_homogeneous(NULL);
xbt_dynar_foreach(cmds, cursor, cmd) {
int *p = xbt_dict_get_or_null(pals_int, cmd->who);
if (!p) {
/* friends, we're ready. Come and play */
XBT_INFO("Wait for peers for a while. I need %d peers",
- xbt_dict_size(pals_int));
- while (xbt_dynar_length(peers) < xbt_dict_size(pals_int)) {
+ xbt_dict_length(pals_int));
+ while (xbt_dynar_length(peers) < xbt_dict_length(pals_int)) {
TRY {
gras_msg_handle(20);
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
xbt_dynar_foreach(peers, cursor, peer) {
xbt_dict_remove(pals_int, peer->name);
}
xbt_dict_free(&pals_int);
/* Check who came */
- xbt_dict_t pals = xbt_dict_new();
- gras_socket_t pal;
+ xbt_dict_t pals = xbt_dict_new_homogeneous(NULL);
+ xbt_socket_t pal;
xbt_dynar_foreach(peers, cursor, peer) {
//XBT_INFO("%s is here",peer->name);
- gras_socket_t sock = gras_socket_client(peer->name, peer->port);
+ xbt_socket_t sock = gras_socket_client(peer->name, peer->port);
xbt_dict_set(pals, peer->name, sock, NULL);
}
/* check that we have a dude for every element of the trace */
typedef struct {
xbt_dynar_t commands;
xbt_dict_t peers;
- gras_socket_t mysock;
+ xbt_socket_t mysock;
} s_worker_data_t, *worker_data_t;
-static gras_socket_t get_peer_sock(char *peer)
+static xbt_socket_t get_peer_sock(char *peer)
{
worker_data_t g = gras_userdata_get();
- gras_socket_t peer_sock = xbt_dict_get_or_null(g->peers, peer);
+ xbt_socket_t peer_sock = xbt_dict_get_or_null(g->peers, peer);
if (!peer_sock) {
XBT_INFO("Create a socket to %s", peer);
peer_sock = gras_socket_client(peer, 4000);
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;
if (cmd->action == XBT_WORKLOAD_SEND) {
- gras_socket_t sock = get_peer_sock(cmd->str_arg);
+ xbt_socket_t sock = get_peer_sock(cmd->str_arg);
chunk = xbt_workload_data_chunk_new((int) (cmd->d_arg));
XBT_INFO("Send %.f bytes to %s %s:%d", cmd->d_arg, cmd->str_arg,
- gras_socket_peer_name(sock), gras_socket_peer_port(sock));
+ xbt_socket_peer_name(sock), xbt_socket_peer_port(sock));
gras_msg_send_(sock, gras_msgtype_by_name("chunk"), &chunk);
XBT_INFO("Done sending %.f bytes to %s", cmd->d_arg, cmd->str_arg);
TRY {
gras_msg_wait(1000000, "chunk", NULL, &chunk);
}
- CATCH(e) {
+ CATCH_ANONYMOUS {
SIMIX_display_process_status();
- RETHROW2("Exception while waiting for %f bytes from %s: %s",
+ RETHROWF("Exception while waiting for %f bytes from %s: %s",
cmd->d_arg, cmd->str_arg);
}
xbt_workload_data_chunk_free(chunk);
globals = gras_userdata_new(s_worker_data_t);
/* Create the connexions */
globals->mysock = gras_socket_server(4000); /* FIXME: shouldn't be hardcoded */
- gras_socket_t master = NULL;
+ xbt_socket_t master = NULL;
int connected = 0;
gras_cb_register("commands", worker_commands_cb);
- globals->peers = xbt_dict_new();
+ globals->peers = xbt_dict_new_homogeneous(NULL);
if (gras_if_RL())
XBT_INFO("Sensor %s starting. Connecting to master on %s",
switch (cmd->action) {
case XBT_WORKLOAD_COMPUTE:
/* If any communication were queued, do them in parallel */
- if (xbt_dynar_length(cmd_to_go)) {
+ if (!xbt_dynar_is_empty(cmd_to_go)) {
TRY {
xbt_dynar_dopar(cmd_to_go, do_command);
xbt_dynar_reset(cmd_to_go);
}
CATCH(e) {
SIMIX_display_process_status();
+ xbt_ex_free(e);
}
XBT_INFO("Communications all done");
xbt_dynar_reset(cmd_to_go);
/* do in parallel any communication still queued */
XBT_INFO("Do %ld pending communications after end of TODO list",
xbt_dynar_length(cmd_to_go));
- if (xbt_dynar_length(cmd_to_go)) {
+ if (!xbt_dynar_is_empty(cmd_to_go)) {
xbt_dynar_dopar(cmd_to_go, do_command);
xbt_dynar_reset(cmd_to_go);
}