From 42fa434f36a91436ae816143a148d2bd5cd07439 Mon Sep 17 00:00:00 2001 From: mquinson Date: Wed, 7 Mar 2007 15:40:30 +0000 Subject: [PATCH] GRAS API BREAKAGE: allow users to never call gras_msgtype_by_name() explicitly, expect the callbacks to return 0 when everything went well git-svn-id: svn+ssh://scm.gforge.inria.fr/svn/simgrid/simgrid/trunk@3207 48e7efb5-ca39-0410-a469-dd3cf9ba447f --- include/gras/messages.h | 87 +++++++++++++++++++++++++++++------------ src/gras/Msg/msg.c | 28 ++++++------- src/gras/Msg/rpc.c | 26 ++++++------ 3 files changed, 88 insertions(+), 53 deletions(-) diff --git a/include/gras/messages.h b/include/gras/messages.h index a6e42c4e61..fd10f8ac54 100644 --- a/include/gras/messages.h +++ b/include/gras/messages.h @@ -3,7 +3,7 @@ /* messaging - high level communication (send/receive messages) */ /* module's public interface exported to end user. */ -/* Copyright (c) 2003, 2004 Martin Quinson. All rights reserved. */ +/* Copyright (c) 2003-2007 Martin Quinson. 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. */ @@ -149,15 +149,38 @@ XBT_PUBLIC(gras_socket_t) gras_msg_cb_ctx_from(gras_msg_cb_ctx_t ctx); */ /** @{ */ - - XBT_PUBLIC(void) gras_msg_send(gras_socket_t sock, - gras_msgtype_t msgtype, - void *payload); - XBT_PUBLIC(void) gras_msg_wait(double timeout, - gras_msgtype_t msgt_want, - gras_socket_t *expeditor, - void *payload); - XBT_PUBLIC(void) gras_msg_handleall(double period); +/** \brief Send the data pointed by \a payload as a message \a msgname on the \a sock + * @hideinitializer + * + * Using gras_msg_wait() is a bit slower than using gras_msg_wait_() since GRAS + * has to search for the given msgtype in the hash table. + */ +#define gras_msg_send(sock,name,payload) gras_msg_send_(sock,gras_msgtype_by_name(name),payload) + XBT_PUBLIC(void) gras_msg_send_(gras_socket_t sock, + gras_msgtype_t msgtype, + void *payload); + +/** \brief Waits for a message to come in over a given socket + * @hideinitializer + * @param timeout: How long should we wait for this message. + * @param msgt_want: type of awaited msg + * @param[out] expeditor: where to create a socket to answer the incomming message + * @param[out] payload: where to write the payload of the incomming message + * @return the error code (or no_error). + * + * Every message of another type received before the one waited will be queued + * and used by subsequent call to this function or gras_msg_handle(). + * + * Using gras_msg_wait() is a bit slower than using gras_msg_wait_() since GRAS + * has to search for the given msgtype in the hash table. + */ + +#define gras_msg_wait(timeout,msgt_want,expeditor,payload) gras_msg_wait_(timeout,gras_msgtype_by_name(msgt_want),expeditor,payload) + XBT_PUBLIC(void) gras_msg_wait_(double timeout, + gras_msgtype_t msgt_want, + gras_socket_t *expeditor, + void *payload); + XBT_PUBLIC(void) gras_msg_handleall(double period); XBT_PUBLIC(void) gras_msg_handle(double timeOut); /** @} */ @@ -189,17 +212,28 @@ XBT_PUBLIC(void) gras_msgtype_declare_rpc_v(const char *name, gras_datadesc_type_t payload_answer); /* client side */ -XBT_PUBLIC(void) gras_msg_rpccall(gras_socket_t server, - double timeOut, - gras_msgtype_t msgtype, - void *request, void *answer); + +/** @brief Conduct a RPC call + * @hideinitializer + */ +#define gras_msg_rpccall(server,timeout,msg,req,ans) gras_msg_rpccall_(server,timeout,gras_msgtype_by_name(msg),req,ans) +XBT_PUBLIC(void) gras_msg_rpccall_(gras_socket_t server, + double timeOut, + gras_msgtype_t msgtype, + void *request, void *answer); XBT_PUBLIC(gras_msg_cb_ctx_t) -gras_msg_rpc_async_call(gras_socket_t server, + +/** @brief Launch a RPC call, but do not block for the answer + * @hideinitializer + */ + +#define gras_msg_rpc_async_call(server,timeout,msg,req) gras_msg_rpc_async_call_(server,timeout,gras_msgtype_by_name(msg),req) +gras_msg_rpc_async_call_(gras_socket_t server, double timeOut, gras_msgtype_t msgtype, void *request); XBT_PUBLIC(void) gras_msg_rpc_async_wait(gras_msg_cb_ctx_t ctx, - void *answer); + void *answer); /* server side */ XBT_PUBLIC(void) gras_msg_rpcreturn(double timeOut, gras_msg_cb_ctx_t ctx,void *answer); @@ -248,18 +282,19 @@ typedef struct { typedef int (*gras_msg_filter_t)(gras_msg_t msg,void *ctx); -XBT_PUBLIC(void) gras_msg_wait_ext(double timeout, - gras_msgtype_t msgt_want, - gras_socket_t expe_want, - gras_msg_filter_t filter, - void *filter_ctx, - gras_msg_t msg_got); +#define gras_msg_wait_ext(timeout, msg, expe, filter, fctx,got) gras_msg_wait_ext_(timeout, gras_msgtype_by_name(msg), expe, filter, fctx,got) +XBT_PUBLIC(void) gras_msg_wait_ext_(double timeout, + gras_msgtype_t msgt_want, + gras_socket_t expe_want, + gras_msg_filter_t filter, + void *filter_ctx, + gras_msg_t msg_got); XBT_PUBLIC(void) gras_msg_wait_or(double timeout, - xbt_dynar_t msgt_want, - gras_msg_cb_ctx_t *ctx, - int *msgt_got, - void *payload); + xbt_dynar_t msgt_want, + gras_msg_cb_ctx_t *ctx, + int *msgt_got, + void *payload); /* @} */ diff --git a/src/gras/Msg/msg.c b/src/gras/Msg/msg.c index 5306a324cb..6fcf0ad434 100644 --- a/src/gras/Msg/msg.c +++ b/src/gras/Msg/msg.c @@ -300,7 +300,7 @@ gras_msgtype_t gras_msgtype_by_id(int id) { */ void -gras_msg_wait_ext(double timeout, +gras_msg_wait_ext_(double timeout, gras_msgtype_t msgt_want, gras_socket_t expe_want, @@ -408,15 +408,15 @@ gras_msg_wait_ext(double timeout, * and used by subsequent call to this function or gras_msg_handle(). */ void -gras_msg_wait(double timeout, - gras_msgtype_t msgt_want, - gras_socket_t *expeditor, - void *payload) { +gras_msg_wait_(double timeout, + gras_msgtype_t msgt_want, + gras_socket_t *expeditor, + void *payload) { s_gras_msg_t msg; - gras_msg_wait_ext(timeout, - msgt_want, NULL, NULL, NULL, - &msg); + gras_msg_wait_ext_(timeout, + msgt_want, NULL, NULL, NULL, + &msg); if (msgt_want->ctn_type) { xbt_assert1(payload, @@ -469,10 +469,10 @@ void gras_msg_wait_or(double timeout, s_gras_msg_t msg; VERB1("Wait %f seconds for several message types",timeout); - gras_msg_wait_ext(timeout, - NULL, NULL, - &gras_msg_wait_or_filter, (void*)msgt_want, - &msg); + gras_msg_wait_ext_(timeout, + NULL, NULL, + &gras_msg_wait_or_filter, (void*)msgt_want, + &msg); if (msg.type->ctn_type) { xbt_assert1(payload, @@ -497,7 +497,7 @@ void gras_msg_wait_or(double timeout, /** \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_msg_send_(gras_socket_t sock, gras_msgtype_t msgtype, void *payload) { @@ -672,7 +672,7 @@ gras_msg_handle(double timeOut) { if (!ran_ok) { DEBUG4("Use the callback #%d (@%p) for incomming msg %s (payload_size=%d)", cpt+1,cb,msg.type->name,msg.payl_size); - if ((*cb)(&ctx,msg.payl)) { + if (!(*cb)(&ctx,msg.payl)) { /* cb handled the message */ free(msg.payl); ran_ok = 1; diff --git a/src/gras/Msg/rpc.c b/src/gras/Msg/rpc.c index 8f87b3c35e..89374859ad 100644 --- a/src/gras/Msg/rpc.c +++ b/src/gras/Msg/rpc.c @@ -105,10 +105,10 @@ void gras_msg_ctx_mallocator_reset_f(void* ctx) { /** @brief Launch a RPC call, but do not block for the answer */ gras_msg_cb_ctx_t -gras_msg_rpc_async_call(gras_socket_t server, - double timeOut, - gras_msgtype_t msgtype, - void *request) { +gras_msg_rpc_async_call_(gras_socket_t server, + double timeOut, + gras_msgtype_t msgtype, + void *request) { gras_msg_cb_ctx_t ctx = xbt_mallocator_get(gras_msg_ctx_mallocator); if (msgtype->ctn_type) { @@ -136,7 +136,7 @@ gras_msg_rpc_async_call(gras_socket_t server, return ctx; } -/** @brief Wait teh answer of a RPC call previously launched asynchronously */ +/** @brief Wait the answer of a RPC call previously launched asynchronously */ void gras_msg_rpc_async_wait(gras_msg_cb_ctx_t ctx, void *answer) { xbt_ex_t e; @@ -155,9 +155,9 @@ void gras_msg_rpc_async_wait(gras_msg_cb_ctx_t ctx, TRY { /* The filter returns 1 when we eat an old RPC answer to something canceled */ do { - gras_msg_wait_ext(ctx->timeout, - ctx->msgtype, NULL, msgfilter_rpcID, &ctx->ID, - &received); + gras_msg_wait_ext_(ctx->timeout, + ctx->msgtype, NULL, msgfilter_rpcID, &ctx->ID, + &received); } while (received.ID != ctx->ID); } CATCH(e) { @@ -199,14 +199,14 @@ void gras_msg_rpc_async_wait(gras_msg_cb_ctx_t ctx, } /** @brief Conduct a RPC call */ -void gras_msg_rpccall(gras_socket_t server, - double timeout, - gras_msgtype_t msgtype, - void *request, void *answer) { +void gras_msg_rpccall_(gras_socket_t server, + double timeout, + gras_msgtype_t msgtype, + void *request, void *answer) { gras_msg_cb_ctx_t ctx; - ctx = gras_msg_rpc_async_call(server, timeout,msgtype,request); + ctx = gras_msg_rpc_async_call_(server, timeout,msgtype,request); gras_msg_rpc_async_wait(ctx, answer); } -- 2.20.1