X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/6a09e6076188e3de9637c24d4ae74839fb03b33f..00366131b0706b5a4e901663d7d5cabbe7a27ebf:/src/gras/Msg/sg_msg.c diff --git a/src/gras/Msg/sg_msg.c b/src/gras/Msg/sg_msg.c index 711fc83c49..a45a728799 100644 --- a/src/gras/Msg/sg_msg.c +++ b/src/gras/Msg/sg_msg.c @@ -19,46 +19,161 @@ XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(gras_msg); typedef void *gras_trp_bufdata_; +#include "simix/datatypes.h" +#include "simix/private.h" -gras_msg_t gras_msg_recv_any(void) { +/* Yeah, the following is awfull, breaking the encapsulation of at least 3 modules + * at the same time, but I'm tracking this bug since too long now, I want it dead. now. + * Sorry, Mt. + */ +typedef struct { + xbt_thread_t listener; +} *fake_gras_msg_listener_t; +typedef struct { + smx_process_t s_process; +} *fake_xbt_thread_t; + +int gras_socket_im_the_server(gras_socket_t sock) { + gras_trp_sg_sock_data_t sock_data = sock->data; + gras_procdata_t* pd; + gras_msg_listener_t l; + xbt_thread_t listener_thread; + smx_process_t server_listener_process=NULL; + smx_process_t client_listener_process = NULL; + + + if (sock_data->server == SIMIX_process_self()) + return 1; + if (sock_data->client == SIMIX_process_self()) + return 0; + + /* neither the client nor the server. Check their respective listeners */ + pd = ((gras_procdata_t*)SIMIX_process_get_data(sock_data->server)); + l = pd->listener; + if (l) { + listener_thread = ((fake_gras_msg_listener_t)l)->listener; + server_listener_process = ((fake_xbt_thread_t)listener_thread)->s_process; + if (server_listener_process == SIMIX_process_self()) + return 1; + } + + if (sock_data->client) { + pd = ((gras_procdata_t*)SIMIX_process_get_data(sock_data->client)); + l = pd->listener; + if (l) { + listener_thread = ((fake_gras_msg_listener_t)l)->listener; + client_listener_process = ((fake_xbt_thread_t)listener_thread)->s_process; + if (client_listener_process == SIMIX_process_self()) + return 0; + } + } + /* THAT'S BAD! I should be either client or server of the sockets I get messages on!! */ + /* This is where the bug is visible. Try to die as loudly as possible */ + xbt_backtrace_display_current(); + ((char*)sock)[sizeof(*sock)+1] = '0'; /* Try to make valgrind angry to see where that damn socket comes from */ + if(system(bprintf("cat /proc/%d/maps 1>&2",getpid()))){} + INFO6("I'm not the client in socket %p (comm:%p, rdvser=%p, rdvcli=%p) to %s, that's %s", + sock,sock_data->comm_recv,sock_data->rdv_server,sock_data->rdv_client, + SIMIX_host_get_name(SIMIX_process_get_host(sock_data->server)), + sock_data->client?SIMIX_host_get_name(SIMIX_process_get_host(sock_data->client)):"(no client)"); + INFO7("server:%s (%p) server_listener=%p client:%s (%p) client_listener=%p, I'm %p", + SIMIX_host_get_name(SIMIX_process_get_host(sock_data->server)), sock_data->server,server_listener_process, + sock_data->client?SIMIX_host_get_name(SIMIX_process_get_host(sock_data->client)):"(no client)", sock_data->client,client_listener_process, + SIMIX_process_self()); + xbt_die("Bailing out after finding that damn bug"); + +} + +gras_msg_t gras_msg_recv_any(void) +{ gras_trp_procdata_t trp_proc = (gras_trp_procdata_t) gras_libdata_by_name("gras_trp"); gras_msg_t msg; /* Build a dynar of all communications I could get something from */ - xbt_dynar_t comms = xbt_dynar_new(sizeof(smx_comm_t),NULL); - unsigned int cursor; + xbt_dynar_t comms = xbt_dynar_new(sizeof(smx_comm_t), NULL); + unsigned int cursor = 0; int got = 0; - smx_comm_t comm; - gras_socket_t sock; - gras_trp_sg_sock_data_t *sock_data; - xbt_dynar_foreach(trp_proc->sockets,cursor,sock) { - sock_data = (gras_trp_sg_sock_data_t *) sock->data; - if (sock_data->comm_recv) { - INFO2("Copy %p of size %lu",sock_data->comm_recv,(unsigned long int)sizeof(smx_comm_t)); - xbt_dynar_push(comms,&(sock_data->comm_recv)); - } + smx_comm_t comm = NULL; + gras_socket_t sock = NULL; + gras_trp_sg_sock_data_t sock_data; + xbt_dynar_foreach(trp_proc->sockets, cursor, sock) { + sock_data = (gras_trp_sg_sock_data_t) sock->data; + + + DEBUG5 + ("Consider socket %p (data:%p; Here rdv: %p; Remote rdv: %p; Comm %p) to get a message", + sock, sock_data, + gras_socket_im_the_server(sock)? + sock_data->rdv_server : sock_data->rdv_client, + gras_socket_im_the_server(sock)? + sock_data->rdv_client : sock_data->rdv_server, + sock_data->comm_recv); + + + /* If the following assert fails in some valid conditions, we need to + * change the code downward looking for the socket again. + * + * For now it relies on the facts (A) that sockets and comms are aligned + * (B) every sockets has a posted irecv in comms + * + * This is not trivial because we need that alignment to hold after the waitany(), so + * after other processes get scheduled. + * + * I cannot think of conditions where they get desynchronized (A violated) as long as + * 1) only the listener calls that function + * 2) Nobody but the listener removes sockets from that set (in main listener loop) + * 3) New sockets are added at the end, and signified ASAP to the listener (by awaking him) + * The throw bellow ensures that B is never violated without failing out loudly. + * + * We cannot search by comparing the comm object pointer that object got + * freed by the waiting process (down in smx_network, in + * comm_wait_for_completion or comm_cleanup). So, actually, we could + * use that pointer since that's a dangling pointer, but no one changes it. + * I still feel unconfortable with using dangling pointers, even if that would + * let the code work even if A and/or B are violated, provided that + * (C) the new irecv is never posted before we return from waitany to that function. + * + * Another approach, robust to B violation would be to retraverse the socks dynar with + * an iterator, incremented only when the socket has a comm. And we've the right socket + * when that iterator is equal to "got", the result of waitany. Not needed if B holds. + */ + xbt_assert1(sock_data->comm_recv, + "Comm_recv of socket %p is empty; please report that nasty bug", + sock); + /* End of paranoia */ + + VERB4("Consider receiving messages from on comm_recv %p (%s) rdv:%p (other rdv:%p)", + sock_data->comm_recv, sock_data->comm_recv->type == comm_send? "send":"recv", + gras_socket_im_the_server(sock)? + sock_data->rdv_server : sock_data->rdv_client, + gras_socket_im_the_server(sock)? + sock_data->rdv_client : sock_data->rdv_server); + xbt_dynar_push(comms, &(sock_data->comm_recv)); } - VERB1("Wait on %ld 'sockets'",xbt_dynar_length(comms)); + VERB1("Wait on %ld 'sockets'", xbt_dynar_length(comms)); /* Wait for the end of any of these communications */ got = SIMIX_network_waitany(comms); /* retrieve the message sent in that communication */ - xbt_dynar_get_cpy(comms,got,&(comm)); - msg=SIMIX_communication_get_data(comm); - VERB1("Got something. Communication %p's over",comm); + xbt_dynar_get_cpy(comms, got, &(comm)); + msg = SIMIX_communication_get_data(comm); + sock = xbt_dynar_get_as(trp_proc->sockets, got, gras_socket_t); + sock_data = (gras_trp_sg_sock_data_t) sock->data; + VERB3("Got something. Communication %p's over rdv_server=%p, rdv_client=%p", + comm,sock_data->rdv_server,sock_data->rdv_client); + SIMIX_communication_destroy(comm); /* Reinstall a waiting communication on that rdv */ - /* Get the sock again */ - xbt_dynar_foreach(trp_proc->sockets,cursor,sock) { - sock_data = (gras_trp_sg_sock_data_t *) sock->data; +/* xbt_dynar_foreach(trp_proc->sockets,cursor,sock) { + sock_data = (gras_trp_sg_sock_data_t) sock->data; if (sock_data->comm_recv && sock_data->comm_recv == comm) break; } - sock_data = (gras_trp_sg_sock_data_t *) sock->data; - sock_data->comm_recv = SIMIX_network_irecv( - sock_data->im_server?sock_data->rdv_server:sock_data->rdv_client, - NULL,0); - SIMIX_communication_destroy(comm); + */ + sock_data->comm_recv = + SIMIX_network_irecv(gras_socket_im_the_server(sock) ? + sock_data->rdv_server : sock_data->rdv_client, + NULL, 0); return msg; } @@ -73,19 +188,31 @@ void gras_msg_send_ext(gras_socket_t sock, This is used to report the load onto the simulator. It also counts the size of pointed stuff */ gras_msg_t msg; /* message to send */ smx_comm_t comm; - gras_trp_sg_sock_data_t *sock_data = NULL; + gras_trp_sg_sock_data_t sock_data = (gras_trp_sg_sock_data_t) sock->data; + + smx_rdv_t target_rdv = + (sock_data->server == SIMIX_process_self())? + sock_data->rdv_client : + sock_data->rdv_server; + /*initialize gras message */ msg = xbt_new(s_gras_msg_t, 1); + sock->refcount++; msg->expe = sock; msg->kind = kind; msg->type = msgtype; msg->ID = ID; + + VERB4("Send msg %s (%s) to rdv %p sock %p", + msgtype->name, e_gras_msg_kind_names[kind], target_rdv, sock); + if (kind == e_gras_msg_kind_rpcerror) { /* error on remote host, careful, payload is an exception */ msg->payl_size = gras_datadesc_size(gras_datadesc_by_name("ex_t")); msg->payl = xbt_malloc(msg->payl_size); - whole_payload_size = gras_datadesc_memcpy(gras_datadesc_by_name("ex_t"), - payload, msg->payl); + whole_payload_size = + gras_datadesc_memcpy(gras_datadesc_by_name("ex_t"), payload, + msg->payl); } else if (kind == e_gras_msg_kind_rpcanswer) { msg->payl_size = gras_datadesc_size(msgtype->answer_type); if (msg->payl_size) @@ -103,116 +230,10 @@ void gras_msg_send_ext(gras_socket_t sock, whole_payload_size = gras_datadesc_memcpy(msgtype->ctn_type, payload, msg->payl); } - sock_data = (gras_trp_sg_sock_data_t *) sock->data; - - SIMIX_network_send(sock_data->im_server ? sock_data->rdv_client : sock_data->rdv_client, - whole_payload_size,-1,-1,&msg,sizeof(void*),&comm,msg); -#ifdef KILLME - smx_action_t act; /* simix action */ - gras_hostdata_t *hd; - gras_trp_procdata_t trp_remote_proc; - gras_msg_procdata_t msg_remote_proc; + SIMIX_network_send(target_rdv, whole_payload_size, -1, -1, &msg, + sizeof(void *), &comm, msg); - sock_data = (gras_trp_sg_sock_data_t *) sock->data; + VERB0("Message sent (and received)"); - hd = (gras_hostdata_t *) SIMIX_host_get_data(SIMIX_host_self()); - - xbt_assert1(!gras_socket_is_meas(sock), - "Asked to send a message on the measurement socket %p", sock); - - - /* put the selectable socket on the queue */ - trp_remote_proc = (gras_trp_procdata_t) - gras_libdata_by_name_from_remote("gras_trp", sock_data->to_process); - - xbt_queue_push(trp_remote_proc->msg_selectable_sockets, &sock); - - /* put message on msg_queue */ - msg_remote_proc = (gras_msg_procdata_t) - gras_libdata_by_name_from_remote("gras_msg", sock_data->to_process); - xbt_fifo_push(msg_remote_proc->msg_to_receive_queue, msg); - - /* wait for the receiver */ - SIMIX_cond_wait(sock_data->cond, sock_data->mutex); - - /* creates simix action and waits its ends, waits in the sender host - condition */ - act = SIMIX_action_communicate(SIMIX_host_self(), - sock_data->to_host, msgtype->name, - (double) whole_payload_size, -1); - SIMIX_register_action_to_condition(act, sock_data->cond); - - VERB5("Sending to %s(%s) a message type '%s' kind '%s' ID %lu", - SIMIX_host_get_name(sock_data->to_host), - SIMIX_process_get_name(sock_data->to_process), - msg->type->name, e_gras_msg_kind_names[msg->kind], msg->ID); - - SIMIX_cond_wait(sock_data->cond, sock_data->mutex); - SIMIX_unregister_action_to_condition(act, sock_data->cond); - /* error treatmeant (FIXME) */ - - /* cleanup structures */ - SIMIX_action_destroy(act); - SIMIX_mutex_unlock(sock_data->mutex); -#endif - VERB0("Message sent"); - -} - -#ifdef KILLMETOO -/* - * receive the next message on the given socket. - */ -void gras_msg_recv(gras_socket_t sock, gras_msg_t msg) -{ - - gras_trp_sg_sock_data_t *sock_data = - (gras_trp_sg_sock_data_t *) sock->data; - gras_msg_t msg_got; - size_t size_got = sizeof(void*); - - xbt_assert1(!gras_socket_is_meas(sock), - "Asked to receive a message on the measurement socket %p", - sock); - - SIMIX_network_recv(sock_data->rdv,-1,&msg_got,&size_got,NULL); -#ifdef KILLME - gras_trp_sg_sock_data_t *remote_sock_data; - gras_hostdata_t *remote_hd; - gras_msg_procdata_t msg_procdata = - (gras_msg_procdata_t) gras_libdata_by_name("gras_msg"); - - xbt_assert0(msg, "msg is an out parameter of gras_msg_recv..."); - - sock_data = (gras_trp_sg_sock_data_t *) sock->data; - remote_sock_data = - ((gras_trp_sg_sock_data_t *) sock->data)->to_socket->data; - DEBUG3("Remote host %s, Remote Port: %d Local port %d", - SIMIX_host_get_name(sock_data->to_host), sock->peer_port, - sock->port); - remote_hd = (gras_hostdata_t *) SIMIX_host_get_data(sock_data->to_host); - - if (xbt_fifo_size(msg_procdata->msg_to_receive_queue) == 0) { - THROW_IMPOSSIBLE; - } - DEBUG1("Size msg_to_receive buffer: %d", - xbt_fifo_size(msg_procdata->msg_to_receive_queue)); - msg_got = xbt_fifo_shift(msg_procdata->msg_to_receive_queue); - - SIMIX_mutex_lock(remote_sock_data->mutex); - /* ok, I'm here, you can continuate the communication */ - SIMIX_cond_signal(remote_sock_data->cond); - - /* wait for communication end */ - SIMIX_cond_wait(remote_sock_data->cond, remote_sock_data->mutex); - - msg_got->expe = msg->expe; - memcpy(msg, msg_got, sizeof(s_gras_msg_t)); - xbt_free(msg_got); - SIMIX_mutex_unlock(remote_sock_data->mutex); -#endif - VERB3("Received a message type '%s' kind '%s' ID %lu", // from %s", - msg->type->name, e_gras_msg_kind_names[msg->kind], msg->ID); } -#endif