X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/7193fe1f5fb4e2b290923cfdc73ef0d4cd80c351..6a09e6076188e3de9637c24d4ae74839fb03b33f:/src/gras/Msg/sg_msg.c diff --git a/src/gras/Msg/sg_msg.c b/src/gras/Msg/sg_msg.c index 6add5c1680..711fc83c49 100644 --- a/src/gras/Msg/sg_msg.c +++ b/src/gras/Msg/sg_msg.c @@ -1,8 +1,7 @@ -/* $Id$ */ - /* messaging - Function related to messaging code specific to SG */ -/* Copyright (c) 2003-2005 Martin Quinson. All rights reserved. */ +/* Copyright (c) 2005, 2006, 2007, 2008, 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. */ @@ -15,68 +14,205 @@ #include "gras/DataDesc/datadesc_interface.h" #include "gras/Transport/transport_interface.h" /* gras_trp_chunk_send/recv */ -#include "gras/Transport/transport_private.h" /* sock->data */ +#include "gras/Transport/transport_private.h" /* sock->data */ -XBT_LOG_EXTERNAL_CATEGORY(gras_msg); -XBT_LOG_DEFAULT_CATEGORY(gras_msg); +XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(gras_msg); -/** \brief Send the data pointed by \a payload as a message of type - * \a msgtype to the peer \a sock */ -void -gras_msg_send(gras_socket_t sock, - gras_msgtype_t msgtype, - void *payload) { +typedef void *gras_trp_bufdata_; - m_task_t task=NULL; - gras_trp_sg_sock_data_t *sock_data = (gras_trp_sg_sock_data_t *)sock->data; +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; - int whole_payload_size=0; /* msg->payload_size is used to memcpy the payload. - This is used to report the load onto the simulator. It also counts the size of pointed stuff */ - - xbt_assert1(!gras_socket_is_meas(sock), - "Asked to send a message on the measurement socket %p", sock); - - msg=xbt_new0(s_gras_msg_t,1); - msg->type=msgtype; - - - msg->payload_size=gras_datadesc_size(msgtype->ctn_type); - msg->payload=xbt_malloc(gras_datadesc_size(msgtype->ctn_type)); - if (msgtype->ctn_type) - whole_payload_size = gras_datadesc_copy(msgtype->ctn_type,payload,msg->payload); + /* 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; + 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)); + } + } + 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); + + /* 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; + 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); + + return msg; +} - task=MSG_task_create(msgtype->name,0, - ((double)msg->payload_size)/(1024.0*1024.0),msg); - if (MSG_task_put(task, sock_data->to_host,sock_data->to_chan) != MSG_OK) - THROW0(system_error,0,"Problem during the MSG_task_put"); +void gras_msg_send_ext(gras_socket_t sock, + e_gras_msg_kind_t kind, + unsigned long int ID, + gras_msgtype_t msgtype, void *payload) +{ + int whole_payload_size = 0; /* msg->payload_size is used to memcpy the payload. + 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; + /*initialize gras message */ + msg = xbt_new(s_gras_msg_t, 1); + msg->expe = sock; + msg->kind = kind; + msg->type = msgtype; + msg->ID = ID; + 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); + } else if (kind == e_gras_msg_kind_rpcanswer) { + msg->payl_size = gras_datadesc_size(msgtype->answer_type); + if (msg->payl_size) + msg->payl = xbt_malloc(msg->payl_size); + else + msg->payl = NULL; + + if (msgtype->answer_type) + whole_payload_size = gras_datadesc_memcpy(msgtype->answer_type, + payload, msg->payl); + } else { + msg->payl_size = gras_datadesc_size(msgtype->ctn_type); + msg->payl = msg->payl_size ? xbt_malloc(msg->payl_size) : NULL; + if (msgtype->ctn_type) + 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; + + sock_data = (gras_trp_sg_sock_data_t *) sock->data; + + 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. + * receive the next message on the given socket. */ -void -gras_msg_recv(gras_socket_t sock, - gras_msgtype_t *msgtype, - void **payload, - int *payload_size) { - - m_task_t task=NULL; - gras_msg_t msg; - gras_trp_procdata_t pd=(gras_trp_procdata_t)gras_libdata_by_name("gras_trp"); - - xbt_assert1(!gras_socket_is_meas(sock), - "Asked to receive a message on the measurement socket %p", sock); - - if (MSG_task_get(&task, pd->chan) != MSG_OK) - THROW0(system_error,0,"Error in MSG_task_get()"); - - msg = MSG_task_get_data(task); - *msgtype = gras_msgtype_by_id(msg->type->code); - *payload = msg->payload; - *payload_size = msg->payload_size; - - free(msg); - if (MSG_task_destroy(task) != MSG_OK) - THROW0(system_error,0,"Error in MSG_task_destroy()"); +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