static DAT_RMR_TRIPLET *p_rmr_snd;
/* rdma pointers */
-char *rbuf = NULL;
-char *sbuf = NULL;
-int status;
+static char *rbuf = NULL;
+static char *sbuf = NULL;
/* timers */
-double start, stop, total_us, total_sec;
+static double start, stop;
struct dt_time {
double total;
double conn;
};
-struct dt_time ts;
+static struct dt_time ts;
/* defaults */
static int all_data_sizes = 0;
/* forward prototypes */
const char *DT_RetToStr(DAT_RETURN ret_value);
const char *DT_EventToStr(DAT_EVENT_NUMBER event_code);
-void print_usage(void);
-double get_time(void);
-void init_data(void);
-DAT_RETURN send_msg(void *data,
+static void print_usage(void);
+static double get_time(void);
+static void init_data(void);
+
+static DAT_RETURN send_msg(void *data,
DAT_COUNT size,
DAT_LMR_CONTEXT context,
DAT_DTO_COOKIE cookie, DAT_COMPLETION_FLAGS flags);
-DAT_RETURN connect_ep(char *hostname,
+static DAT_RETURN connect_ep(char *hostname,
DAT_CONN_QUAL conn_id,
struct sockaddr *ser_sa);
-void disconnect_ep(void);
-DAT_RETURN register_rdma_memory(void);
-DAT_RETURN unregister_rdma_memory(void);
-DAT_RETURN create_events(void);
-DAT_RETURN destroy_events(void);
-DAT_RETURN do_rdma_write_imm_with_msg(void);
-DAT_RETURN do_rdma_write_with_msg(void);
-DAT_RETURN do_rdma_write_ping_pong(int p2, int bytes);
-DAT_RETURN do_rdma_read_with_msg(void);
-DAT_RETURN do_ping_pong_msg(void);
+static void disconnect_ep(void);
+static DAT_RETURN register_rdma_memory(void);
+static DAT_RETURN unregister_rdma_memory(void);
+static DAT_RETURN create_events(void);
+static DAT_RETURN destroy_events(void);
+static DAT_RETURN do_rdma_write_imm_with_msg(void);
+static DAT_RETURN do_rdma_write_with_msg(void);
+static DAT_RETURN do_rdma_write_ping_pong(int p2, int bytes);
+static DAT_RETURN do_rdma_read_with_msg(void);
+static DAT_RETURN do_ping_pong_msg(void);
#define LOGPRINTF if (verbose) printf
#define CONN_PORT 15828
/* The Format of the message we pass through sockets */
#define CONN_MSG_FMT "%04hx:%08x:%08x:%08x:%s"
-void flush_evds(void)
+static void flush_evds(void)
{
DAT_EVENT event;
}
}
-int conn_client_connect(const char *servername, int port)
+static int conn_client_connect(const char *servername, int port)
{
struct addrinfo *res, *t;
return sockfd;
}
-int conn_server_connect(int port)
+static int conn_server_connect(int port)
{
struct addrinfo *res, *t;
struct addrinfo hints = {
return (0);
}
-double get_time(void)
+static double get_time(void)
{
struct timeval tp;
return ((double)tp.tv_sec + (double)tp.tv_usec * 1e-6);
}
-void init_data(void)
+static void init_data(void)
{
memset(rbuf, 'a', buf_len);
memset(sbuf, 'b', buf_len);
}
-DAT_RETURN
+static DAT_RETURN
send_msg(void *data,
DAT_COUNT size,
DAT_LMR_CONTEXT context,
}
if (event.event_data.dto_completion_event_data.status !=
- DAT_SUCCESS) {
+ DAT_DTO_SUCCESS) {
fprintf(stderr, "%d: ERROR: DTO event status %s\n",
getpid(), DT_RetToStr(ret));
return (DAT_ABORT);
return DAT_SUCCESS;
}
+static
DAT_RETURN connect_ep(char *hostname,
DAT_CONN_QUAL conn_id,
struct sockaddr *ser_sa)
return (DAT_SUCCESS);
}
-void disconnect_ep(void)
+static void disconnect_ep(void)
{
DAT_RETURN ret;
DAT_EVENT event;
return;
}
-DAT_RETURN do_rdma_write_with_msg(void)
+static DAT_RETURN do_rdma_write_with_msg(void)
{
DAT_EVENT event;
DAT_DTO_COMPLETION_EVENT_DATA *dto_event;
return (DAT_SUCCESS);
}
-DAT_RETURN do_rdma_write_imm_with_msg(void)
+static DAT_RETURN do_rdma_write_imm_with_msg(void)
{
DAT_EVENT event;
DAT_LMR_TRIPLET l_iov[MSG_IOV_COUNT];
}
#define PAT_NUM 5
-unsigned char pat[PAT_NUM] = { 0, 0xff, 0x55, 0xaa, 0 };
+static unsigned char pat[PAT_NUM] = { 0, 0xff, 0x55, 0xaa, 0 };
-void set_pat(unsigned int len, unsigned int pat_num)
+static void set_pat(unsigned int len, unsigned int pat_num)
{
if (len <= 1)
return;
/* always uni-direction */
-DAT_RETURN do_rdma_write_ping_pong(int p2, int bytes)
+static DAT_RETURN do_rdma_write_ping_pong(int p2, int bytes)
{
DAT_EVENT event;
DAT_LMR_TRIPLET l_iov[MSG_IOV_COUNT];
return (DAT_SUCCESS);
}
-DAT_RETURN do_rdma_read_with_msg(void)
+static DAT_RETURN do_rdma_read_with_msg(void)
{
DAT_EVENT event;
DAT_LMR_TRIPLET l_iov;
return (DAT_ABORT);
}
if (event.event_data.dto_completion_event_data.status !=
- DAT_SUCCESS) {
+ DAT_DTO_SUCCESS) {
fprintf(stderr, "%d: ERROR: DTO event status %s\n",
getpid(), DT_RetToStr(ret));
return (DAT_ABORT);
return (DAT_SUCCESS);
}
-DAT_RETURN do_ping_pong_msg()
+static DAT_RETURN do_ping_pong_msg()
{
DAT_EVENT event;
DAT_DTO_COOKIE cookie;
}
/* Register RDMA Receive buffer */
-DAT_RETURN register_rdma_memory(void)
+static DAT_RETURN register_rdma_memory(void)
{
DAT_RETURN ret;
DAT_REGION_DESCRIPTION region;
/*
* Unregister RDMA memory
*/
-DAT_RETURN unregister_rdma_memory(void)
+static DAT_RETURN unregister_rdma_memory(void)
{
DAT_RETURN ret;
/*
* Create CNO, CR, CONN, and DTO events
*/
-DAT_RETURN create_events(void)
+static DAT_RETURN create_events(void)
{
DAT_RETURN ret;
DAT_EVD_PARAM param;
* Destroy CR, CONN, CNO, and DTO events
*/
-DAT_RETURN destroy_events(void)
+static DAT_RETURN destroy_events(void)
{
DAT_RETURN ret;
* Map DAT_RETURN values to readable strings,
* but don't assume the values are zero-based or contiguous.
*/
-char errmsg[512] = { 0 };
+static char errmsg[512] = { 0 };
const char *DT_RetToStr(DAT_RETURN ret_value)
{
const char *major_msg, *minor_msg;
return ("Invalid_DAT_EVENT_NUMBER");
}
-void print_usage(void)
+static void print_usage(void)
{
printf("\n DAPL USAGE \n\n");
printf("s: server\n");
static DAT_EVD_HANDLE h_conn_evd = DAT_HANDLE_NULL;
static DAT_EP_ATTR ep_attr;
-char hostname[256] = { 0 };
-char provider[64] = DAPL_PROVIDER;
-char addr_str[INET_ADDRSTRLEN];
-
-int status;
+static char hostname[256] = { 0 };
+static char provider[64] = DAPL_PROVIDER;
/* timers */
-double start, stop, total_us, total_sec;
+static double start, stop;
struct dt_time {
double total;
double conn;
};
-struct dt_time ts;
+static struct dt_time ts;
/* defaults */
static int connected = 0;
/* forward prototypes */
const char *DT_RetToString(DAT_RETURN ret_value);
const char *DT_EventToSTr(DAT_EVENT_NUMBER event_code);
-void print_usage(void);
-double get_time(void);
-DAT_RETURN conn_client(void);
-DAT_RETURN conn_server(void);
-DAT_RETURN disconnect_eps(void);
-DAT_RETURN create_events(void);
-DAT_RETURN destroy_events(void);
+static void print_usage(void);
+static double get_time(void);
+static DAT_RETURN conn_client(void);
+static DAT_RETURN conn_server(void);
+static DAT_RETURN disconnect_eps(void);
+static DAT_RETURN create_events(void);
+static DAT_RETURN destroy_events(void);
#define LOGPRINTF if (verbose) printf
-void flush_evds(void)
+static void flush_evds(void)
{
DAT_EVENT event;
return (0);
}
-double get_time(void)
+static double get_time(void)
{
struct timeval tp;
return ((double)tp.tv_sec + (double)tp.tv_usec * 1e-6);
}
-DAT_RETURN conn_server()
+static DAT_RETURN conn_server()
{
DAT_RETURN ret;
DAT_EVENT event;
}
if ((event.event_number != DAT_CONNECTION_REQUEST_EVENT) &&
- (ud_test && event.event_number !=
+ (ud_test && event.event_number != (DAT_EVENT_NUMBER)
DAT_IB_UD_CONNECTION_REQUEST_EVENT)) {
fprintf(stderr, " Error unexpected CR event : %s\n",
DT_EventToSTr(event.event_number));
}
}
if ((event.event_number != DAT_CONNECTION_EVENT_ESTABLISHED) &&
- (ud_test && event.event_number !=
+ (ud_test && event.event_number != (DAT_EVENT_NUMBER)
DAT_IB_UD_CONNECTION_EVENT_ESTABLISHED)) {
fprintf(stderr, " Error unexpected CR EST "
}
-DAT_RETURN conn_client()
+static DAT_RETURN conn_client()
{
DAT_IA_ADDRESS_PTR raddr = (DAT_IA_ADDRESS_PTR)&remote;
DAT_RETURN ret;
#endif
if ((event.event_number !=
DAT_CONNECTION_EVENT_ESTABLISHED) &&
- (ud_test && event.event_number !=
+ (ud_test && event.event_number != (DAT_EVENT_NUMBER)
DAT_IB_UD_CONNECTION_EVENT_ESTABLISHED)) {
fprintf(stderr, " Error unexpected conn "
"event : 0x%x %s\n",
}
/* validate disconnected EP's and free them */
-DAT_RETURN disconnect_eps(void)
+static DAT_RETURN disconnect_eps(void)
{
DAT_RETURN ret;
DAT_EVENT event;
/*
* Create CR, CONN, and DTO events
*/
-DAT_RETURN create_events(void)
+static DAT_RETURN create_events(void)
{
DAT_RETURN ret;
* Destroy CR, CONN, CNO, and DTO events
*/
-DAT_RETURN destroy_events(void)
+static DAT_RETURN destroy_events(void)
{
DAT_RETURN ret;
* Map DAT_RETURN values to readable strings,
* but don't assume the values are zero-based or contiguous.
*/
-char errmsg[512] = { 0 };
+static char errmsg[512] = { 0 };
const char *DT_RetToString(DAT_RETURN ret_value)
{
const char *major_msg, *minor_msg;
return ("Invalid_DAT_EVENT_NUMBER");
}
-void print_usage(void)
+static void print_usage(void)
{
printf("\n DAPL USAGE \n\n");
printf("s: server\n");
static DAT_EVD_HANDLE h_conn_evd = DAT_HANDLE_NULL;
static DAT_EP_ATTR ep_attr;
-char hostname[256] = { 0 };
-char provider[64] = DAPL_PROVIDER;
-char addr_str[INET_ADDRSTRLEN];
-
-int status;
+static char hostname[256] = { 0 };
+static char provider[64] = DAPL_PROVIDER;
/* defaults */
static int server = 1;
static int tx_buf_len = 0, rx_buf_len;
static int connected = 0;
-char *rbuf = NULL;
-char *sbuf = NULL;
+static char *rbuf = NULL;
+static char *sbuf = NULL;
static DAT_SOCK_ADDR6 remote;
/* forward prototypes */
const char *DT_RetToString(DAT_RETURN ret_value);
const char *DT_EventToSTr(DAT_EVENT_NUMBER event_code);
-void print_usage(void);
-void flush_evds(void);
+static void print_usage(void);
+static void flush_evds(void);
static void print_ia_address(struct sockaddr *sa);
-DAT_RETURN conn_client(void);
-DAT_RETURN conn_server(void);
-DAT_RETURN disconnect_eps(void);
-DAT_RETURN create_events(void);
-DAT_RETURN destroy_events(void);
-DAT_RETURN register_rdma_memory(void);
-void unregister_rdma_memory(void);
-DAT_RETURN send_msg(char *buff, char msg_head, DAT_UINT32 ep_num, DAT_UINT32 msg_num);
-DAT_RETURN process_cr(void);
-DAT_RETURN process_conn(void);
+static DAT_RETURN conn_client(void);
+static DAT_RETURN conn_server(void);
+static DAT_RETURN disconnect_eps(void);
+static DAT_RETURN create_events(void);
+static DAT_RETURN destroy_events(void);
+static DAT_RETURN register_rdma_memory(void);
+static void unregister_rdma_memory(void);
+static DAT_RETURN send_msg(char *buff, char msg_head, DAT_UINT32 ep_num, DAT_UINT32 msg_num);
+static DAT_RETURN process_cr(void);
+static DAT_RETURN process_conn(void);
#define LOGPRINTF if (verbose) printf
int main(int argc, char **argv)
/* validate event number and status */
LOGPRINTF(" inbound message; message arrived!\n");
if (event.event_number != DAT_DTO_COMPLETION_EVENT &&
- ud_test && event.event_number != DAT_IB_DTO_EVENT) {
+ ud_test && event.event_number != (DAT_EVENT_NUMBER)
+ DAT_IB_DTO_EVENT) {
fprintf(stderr, " Error unexpected DTO event (%d): %s\n",
event.event_number,
DT_EventToSTr(event.event_number));
if ((event.event_data.dto_completion_event_data.
transfered_length != tx_buf_len)
|| event.event_data.dto_completion_event_data.
- status != DAT_SUCCESS) {
+ status != DAT_DTO_SUCCESS) {
fprintf(stderr, " ERROR: DTO REQ size %d, status %d\n",
event.event_data.dto_completion_event_data.
transfered_length,
return (0);
}
-DAT_RETURN process_cr()
+static DAT_RETURN process_cr()
{
DAT_RETURN ret;
DAT_EVENT event;
if (event.event_number != DAT_CONNECTION_REQUEST_EVENT &&
(ud_test && event.event_number !=
- DAT_IB_UD_CONNECTION_REQUEST_EVENT)) {
+ (DAT_EVENT_NUMBER)
+ DAT_IB_UD_CONNECTION_REQUEST_EVENT)) {
fprintf(stderr, " Error unexpected cr event : %s\n",
DT_EventToSTr(event.event_number));
return (DAT_ABORT);
return DAT_SUCCESS;
}
-DAT_RETURN process_conn()
+static DAT_RETURN process_conn()
{
DAT_RETURN ret;
DAT_EVENT event;
return DAT_SUCCESS;
}
-DAT_RETURN conn_server()
+static DAT_RETURN conn_server()
{
DAT_RETURN ret;
return DAT_SUCCESS;
}
-DAT_RETURN conn_client()
+static DAT_RETURN conn_client()
{
DAT_IA_ADDRESS_PTR raddr = (DAT_IA_ADDRESS_PTR)&remote;
DAT_RETURN ret;
}
/* validate disconnected EP's and free them */
-DAT_RETURN disconnect_eps(void)
+static DAT_RETURN disconnect_eps(void)
{
DAT_RETURN ret;
DAT_EVENT event, async_event;
/*
* Create CR, CONN, and DTO events
*/
-DAT_RETURN create_events(void)
+static DAT_RETURN create_events(void)
{
DAT_RETURN ret;
DAT_EVD_PARAM param;
/*
* Destroy CR, CONN, CNO, and DTO events
*/
-DAT_RETURN destroy_events(void)
+static DAT_RETURN destroy_events(void)
{
DAT_RETURN ret;
* Map DAT_RETURN values to readable strings,
* but don't assume the values are zero-based or contiguous.
*/
-char errmsg[512] = { 0 };
+static char errmsg[512] = { 0 };
const char *DT_RetToString(DAT_RETURN ret_value)
{
const char *major_msg, *minor_msg;
return ("Invalid_DAT_EVENT_NUMBER");
}
-void flush_evds(void)
+static void flush_evds(void)
{
DAT_EVENT event;
}
/* Register RDMA Receive buffer */
-DAT_RETURN register_rdma_memory(void)
+static DAT_RETURN register_rdma_memory(void)
{
DAT_RETURN ret;
DAT_REGION_DESCRIPTION region;
return DAT_SUCCESS;
}
-void unregister_rdma_memory()
+static void unregister_rdma_memory()
{
DAT_RETURN ret;
}
}
-DAT_RETURN send_msg(char *buff, char msg_head, DAT_UINT32 ep_num,
+static DAT_RETURN send_msg(char *buff, char msg_head, DAT_UINT32 ep_num,
DAT_UINT32 msg_num)
{
DAT_DTO_COOKIE cookie;
}
}
-void print_usage(void)
+static void print_usage(void)
{
printf("\n DAPL SRQ USAGE \n\n");
printf("s: server\n");
#include "dat2/udat.h"
#include "dat2/dat_ib_extensions.h"
-int disconnect_ep(void);
+static int disconnect_ep(void);
#define _OK(status, str) \
{\
#define MAX_EP_COUNT 1000
#define MAX_AH_COUNT (MAX_EP_COUNT * 2)
-DAT_VADDR *atomic_buf;
-DAT_LMR_HANDLE lmr_atomic;
-DAT_LMR_CONTEXT lmr_atomic_context;
-DAT_RMR_CONTEXT rmr_atomic_context;
-DAT_VLEN reg_atomic_size;
-DAT_VADDR reg_atomic_addr;
-DAT_LMR_HANDLE lmr[REG_MEM_COUNT * MAX_EP_COUNT];
-DAT_LMR_CONTEXT lmr_context[REG_MEM_COUNT * MAX_EP_COUNT];
-DAT_RMR_TRIPLET rmr[REG_MEM_COUNT * MAX_EP_COUNT];
-DAT_RMR_CONTEXT rmr_context[REG_MEM_COUNT * MAX_EP_COUNT];
-DAT_VLEN reg_size[REG_MEM_COUNT * MAX_EP_COUNT];
-DAT_VADDR reg_addr[REG_MEM_COUNT * MAX_EP_COUNT];
-DAT_RMR_TRIPLET *buf[REG_MEM_COUNT * MAX_EP_COUNT];
-DAT_EP_HANDLE ep[MAX_EP_COUNT];
-DAT_EVD_HANDLE async_evd = DAT_HANDLE_NULL;
-DAT_IA_HANDLE ia = DAT_HANDLE_NULL;
-DAT_PZ_HANDLE pz = DAT_HANDLE_NULL;
-DAT_EVD_HANDLE cr_evd = DAT_HANDLE_NULL;
-DAT_EVD_HANDLE con_evd = DAT_HANDLE_NULL;
-DAT_EVD_HANDLE dto_evd = DAT_HANDLE_NULL;
-DAT_PSP_HANDLE psp = DAT_HANDLE_NULL;
-int server = 1;
-int remote_host = 0;
-int ud_test = 0;
-int multi_eps = 0;
-int buf_size = BUF_SIZE;
-int msg_size = sizeof(DAT_RMR_TRIPLET);
-char provider[64] = DAPL_PROVIDER;
-char hostname[256] = { 0 };
+static DAT_VADDR *atomic_buf;
+static DAT_LMR_HANDLE lmr_atomic;
+static DAT_LMR_CONTEXT lmr_atomic_context;
+static DAT_RMR_CONTEXT rmr_atomic_context;
+static DAT_VLEN reg_atomic_size;
+static DAT_VADDR reg_atomic_addr;
+static DAT_LMR_HANDLE lmr[REG_MEM_COUNT * MAX_EP_COUNT];
+static DAT_LMR_CONTEXT lmr_context[REG_MEM_COUNT * MAX_EP_COUNT];
+static DAT_RMR_CONTEXT rmr_context[REG_MEM_COUNT * MAX_EP_COUNT];
+static DAT_VLEN reg_size[REG_MEM_COUNT * MAX_EP_COUNT];
+static DAT_VADDR reg_addr[REG_MEM_COUNT * MAX_EP_COUNT];
+static DAT_RMR_TRIPLET *buf[REG_MEM_COUNT * MAX_EP_COUNT];
+static DAT_EP_HANDLE ep[MAX_EP_COUNT];
+static DAT_EVD_HANDLE async_evd = DAT_HANDLE_NULL;
+static DAT_IA_HANDLE ia = DAT_HANDLE_NULL;
+static DAT_PZ_HANDLE pz = DAT_HANDLE_NULL;
+static DAT_EVD_HANDLE cr_evd = DAT_HANDLE_NULL;
+static DAT_EVD_HANDLE con_evd = DAT_HANDLE_NULL;
+static DAT_EVD_HANDLE dto_evd = DAT_HANDLE_NULL;
+static DAT_PSP_HANDLE psp = DAT_HANDLE_NULL;
+static int server = 1;
+static int remote_host = 0;
+static int ud_test = 0;
+static int multi_eps = 0;
+static int buf_size = BUF_SIZE;
+static int msg_size = sizeof(DAT_RMR_TRIPLET);
+static char provider[64] = DAPL_PROVIDER;
+static char hostname[256] = { 0 };
static DAT_IB_ADDR_HANDLE remote_ah[MAX_EP_COUNT][MAX_AH_COUNT];
-int eps = 1;
-int verbose = 0;
-int counters = 0;
-int counters_ok = 0;
-int query_only = 0;
+static int eps = 1;
+static int verbose = 0;
+static int counters = 0;
+static int counters_ok = 0;
+static int query_only = 0;
static int ucm = 0;
static DAT_SOCK_ADDR6 remote;
static DAT_IA_ATTR ia_attr;
#define CONN_MSG_SIZE 128
#define CONN_MSG_FMT "%04hx:%08x:%08x:%08x:%s"
-void print_usage(void)
+static void print_usage(void)
{
printf("\n dtestx usage \n\n");
printf("v: verbose\n");
}
}
-int conn_client_connect(const char *servername, int port)
+static int conn_client_connect(const char *servername, int port)
{
struct addrinfo *res, *t;
return sockfd;
}
-int conn_server_connect(int port)
+static int conn_server_connect(int port)
{
struct addrinfo *res, *t;
struct addrinfo hints = {
return 0;
}
-void
+static void
send_msg(void *data,
DAT_COUNT size,
DAT_LMR_CONTEXT context,
_OK(status, "dat_evd_wait after dat_ep_post_send");
if (event.event_number != DAT_DTO_COMPLETION_EVENT &&
- ud_test && event.event_number != DAT_IB_DTO_EVENT) {
+ ud_test && event.event_number !=
+ (DAT_EVENT_NUMBER) DAT_IB_DTO_EVENT) {
printf("unexpected event waiting post_send "
"completion - 0x%x\n",
event.event_number);
exit(1);
}
- _OK(dto_event->status, "event status for post_send");
+ _OK((DAT_RETURN)dto_event->status, "event status for post_send");
}
}
}
/* RC - Server only, UD - Server and Client, one per EP */
-void process_cr(int idx)
+static void process_cr(int idx)
{
DAT_EVENT event;
DAT_COUNT nmore;
status = dat_evd_wait(cr_evd, SERVER_TIMEOUT, 1, &event, &nmore);
_OK(status, "CR dat_evd_wait");
- if (event.event_number != DAT_CONNECTION_REQUEST_EVENT &&
- (ud_test && event.event_number !=
+ if (event.event_number !=
+ (DAT_EVENT_NUMBER) DAT_CONNECTION_REQUEST_EVENT &&
+ (ud_test && event.event_number != (DAT_EVENT_NUMBER)
DAT_IB_UD_CONNECTION_REQUEST_EVENT)) {
printf("unexpected event,!conn req: 0x%x\n",
event.event_number);
}
/* RC - Client and Server: 1, UD - Client: 1 per EP, Server: 2 per EP's */
-void process_conn(int idx)
+static void process_conn(int idx)
{
DAT_EVENT event;
DAT_COUNT nmore;
exp_event = DAT_CONNECTION_EVENT_ESTABLISHED;
/* Waiting on CR's or CONN_EST */
- if (event.event_number != exp_event) {
+ if (event.event_number != (DAT_EVENT_NUMBER) exp_event) {
printf("unexpected event, !conn established: 0x%x\n",
event.event_number);
exit(1);
}
-int connect_ep(char *hostname, struct sockaddr *ser_sa)
+static int connect_ep(char *hostname, struct sockaddr *ser_sa)
{
DAT_IA_ADDRESS_PTR remote_addr = (DAT_IA_ADDRESS_PTR)&remote;
DAT_EP_ATTR ep_attr;
ep_attr.max_rdma_read_in = 4;
ep_attr.max_rdma_read_out = 4;
}
+ cookie.as_64 = 0;
ep_attr.qos = 0;
ep_attr.recv_completion_flags = 0;
if (ud_test && !multi_eps)
_OK(status, "dat_evd_wait for receive message");
if ((event.event_number != DAT_DTO_COMPLETION_EVENT) &&
- (ud_test && event.event_number != DAT_IB_DTO_EVENT)) {
+ (ud_test && event.event_number !=
+ (DAT_EVENT_NUMBER) DAT_IB_DTO_EVENT)) {
printf("unexpected event waiting for RMR context "
"- 0x%x\n", event.event_number);
exit(1);
}
- _OK(dto_event->status, "event status for post_recv");
+ _OK((DAT_RETURN)dto_event->status, "event status for post_recv");
/*
* multi_eps - receive multi messages on single EP
return (0);
}
-int disconnect_ep(void)
+static int disconnect_ep(void)
{
DAT_RETURN status;
DAT_EVENT event;
return (0);
}
-int do_immediate()
+static int do_immediate()
{
DAT_EVENT event;
DAT_COUNT nmore;
*/
status = dat_evd_wait(dto_evd, DTO_TIMEOUT, 1, &event, &nmore);
_OK(status, "dat_evd_wait after dat_ib_post_rdma_write");
- if (event.event_number != DAT_IB_DTO_EVENT) {
+ if (event.event_number != (DAT_EVENT_NUMBER) DAT_IB_DTO_EVENT) {
printf("unexpected event #0x%x waiting for WR-IMMED #0x%x\n",
event.event_number, DAT_IB_DTO_EVENT);
exit(1);
if (nmore)
printf("%s() nmore %d\n", __FUNCTION__, nmore);
- _OK(dto_event->status, "DTO event status");
+ _OK((DAT_RETURN)dto_event->status, "DTO event status");
if (ext_event->type == DAT_IB_RDMA_WRITE_IMMED) {
if ((dto_event->transfered_length != buf_size) ||
(dto_event->user_cookie.as_64 != 0x9999)) {
*/
status = dat_evd_wait(dto_evd, DTO_TIMEOUT, 1, &event, &nmore);
_OK(status, "dat_evd_wait after dat_ib_post_rdma_write");
- if (event.event_number != DAT_IB_DTO_EVENT) {
+ if (event.event_number != (DAT_EVENT_NUMBER) DAT_IB_DTO_EVENT) {
printf("unexpected event # waiting for WR-IMMED - 0x%x\n",
event.event_number);
exit(1);
}
- _OK(dto_event->status, "event status");
+ _OK((DAT_RETURN)dto_event->status, "event status");
if (ext_event->type == DAT_IB_RDMA_WRITE_IMMED) {
if ((dto_event->transfered_length != buf_size) ||
(dto_event->user_cookie.as_64 != 0x9999)) {
return (0);
}
-int do_cmp_swap()
+static int do_cmp_swap()
{
DAT_DTO_COOKIE cookie;
DAT_RETURN status;
_OK(status, "dat_ib_post_cmp_and_swap");
status = dat_evd_wait(dto_evd, DTO_TIMEOUT, 1, &event, &nmore);
_OK(status, "dat_evd_wait for compare and swap");
- if (event.event_number != DAT_IB_DTO_EVENT) {
+ if (event.event_number != (DAT_EVENT_NUMBER) DAT_IB_DTO_EVENT) {
printf("unexpected event after post_cmp_and_swap: 0x%x\n",
event.event_number);
exit(1);
}
- _OK(dto_event->status, "event status for CMP and SWAP");
+ _OK((DAT_RETURN)dto_event->status, "event status for CMP and SWAP");
if (ext_event->type != DAT_IB_CMP_AND_SWAP) {
printf("unexpected event data of cmp_swap: type=%d cookie=%d "
"original " F64x "\n",
return (0);
}
-int do_fetch_add()
+static int do_fetch_add()
{
DAT_DTO_COOKIE cookie;
DAT_RETURN status;
_OK(status, "dat_ib_post_fetch_and_add");
status = dat_evd_wait(dto_evd, DTO_TIMEOUT, 1, &event, &nmore);
_OK(status, "dat_evd_wait for fetch and add");
- if (event.event_number != DAT_IB_DTO_EVENT) {
+ if (event.event_number != (DAT_EVENT_NUMBER) DAT_IB_DTO_EVENT) {
printf("unexpected event after post_fetch_and_add: 0x%x\n",
event.event_number);
exit(1);
}
- _OK(dto_event->status, "event status for FETCH and ADD");
+ _OK((DAT_RETURN)dto_event->status, "event status for FETCH and ADD");
if (ext_event->type != DAT_IB_FETCH_AND_ADD) {
printf("unexpected event data of fetch and add : type=%d "
"cookie=%d original%d\n",
status = dat_evd_wait(dto_evd, DTO_TIMEOUT, 1, &event, &nmore);
_OK(status, "dat_evd_wait for second fetch and add");
- if (event.event_number != DAT_IB_DTO_EVENT) {
+ if (event.event_number != (DAT_EVENT_NUMBER) DAT_IB_DTO_EVENT) {
printf("unexpected event after second post_fetch_and_add: "
"0x%x\n", event.event_number);
exit(1);
}
- _OK(dto_event->status, "event status for second FETCH and ADD");
+ _OK((DAT_RETURN)dto_event->status, "event status for second FETCH and ADD");
if (ext_event->type != DAT_IB_FETCH_AND_ADD) {
printf("unexpected event data of second fetch and add : "
"type=%d cookie=%d original%p\n",
projects / ~ardavis / dapl.git / commitdiff