vipl_macros.h

Go to the documentation of this file.

/********************************************************
 * Myricom VI-GM  networking software and documentation *
 * Copyright (c) 2001 by Myricom, Inc.                  *
 * All rights reserved.                                 *
 * See the file `COPYING' for copyright notice.         *
 ********************************************************/

#ifndef __VIPL_MACROS
#define __VIPL_MACROS

/***********/
/* threads */
/***********/

#ifndef WIN32

#define VIP_THREAD_T pthread_t

#define VIP_THREAD_CREATE(thread,fctn,arg) \
pthread_create (thread, NULL, fctn, arg)

#define VIP_THREAD_JOIN(thread) pthread_join (thread, NULL)

#define VIP_THREAD_EXIT(retval) pthread_exit (retval)

#define VIP_THREAD_SELF() pthread_self()

#else

#define VIP_THREAD_T vipl_win_thread_t
#define VIP_THREAD_CREATE(thread,fctn,arg) \
vipl_win_thread_create (thread, fctn, arg)
#define VIP_THREAD_JOIN(thread) vipl_win_thread_join (thread, NULL)
#define VIP_THREAD_EXIT(retval) vipl_win_thread_exit (retval)
#define VIP_THREAD_SELF() vipl_win_thread_self()

#endif

/***********/
/* mutexes */
/***********/

#ifndef WIN32

#define VIP_MUTEX_T pthread_mutex_t

#ifdef VI_GM_DEBUG_MUTEX /* VI_GM_DEBUG_MUTEX */
#include <asm/errno.h>
#define VIP_MUTEX_ATTR pthread_mutexattr_t vip_mutex_attr
extern pthread_mutexattr_t vip_mutex_attr;
int pthread_mutexattr_setkind_np (pthread_mutexattr_t *, int);
#define VIP_MUTEX_INIT(lock)                                                \
pthread_mutexattr_init (&vip_mutex_attr);                                   \
pthread_mutexattr_setkind_np (&vip_mutex_attr,PTHREAD_MUTEX_ERRORCHECK_NP); \
pthread_mutex_init (lock,&vip_mutex_attr)

#define VIP_ASSERT_MUTEX_LOCKED(lock) \
assert (pthread_mutex_lock (lock) == EDEADLK)
#else /* VI_GM_DEBUG_MUTEX */

#define VIP_MUTEX_ATTR

#define VIP_MUTEX_INIT(lock) pthread_mutex_init (lock,NULL)

#define VIP_ASSERT_MUTEX_LOCKED(lock)
#endif /* VI_GM_DEBUG_MUTEX */

#define VIP_MUTEX_TRYLOCK(lock) \
((pthread_mutex_trylock (lock) == EBUSY) ? VIP_FALSE : VIP_TRUE)

#ifdef VI_GM_DEBUG_ASSERT /* VI_GM_DEBUG_ASSERT */

#define VIP_MUTEX_DESTROY(lock) assert (pthread_mutex_destroy (lock) == 0)

#define VIP_MUTEX_LOCK(lock) assert (pthread_mutex_lock (lock) == 0)

#define VIP_MUTEX_UNLOCK(lock) assert (pthread_mutex_unlock (lock) == 0)
#else /* VI_GM_DEBUG_ASSERT */

#define VIP_MUTEX_DESTROY(lock) pthread_mutex_destroy (lock)

#define VIP_MUTEX_LOCK(lock) pthread_mutex_lock (lock)

#define VIP_MUTEX_UNLOCK(lock) pthread_mutex_unlock (lock)
#endif /* VI_GM_DEBUG_ASSERT */

#else

#define VIP_MUTEX_T CRITICAL_SECTION
#define VIP_MUTEX_INIT(lock) InitializeCriticalSection (lock)
#define VIP_ASSERT_MUTEX_LOCKED(lock)
#define VIP_MUTEX_DESTROY(lock) DeleteCriticalSection (lock)
#define VIP_MUTEX_LOCK(lock) EnterCriticalSection (lock)
#define VIP_MUTEX_UNLOCK(lock) LeaveCriticalSection (lock)
#define VIP_MUTEX_TRYLOCK(lock) TryEnterCriticalSection (lock)

#endif

/*******************/
/* event signaling */
/*******************/

#ifndef WIN32

#define VIP_EVENT_T pthread_cond_t

#define VIP_EVENT_INIT(event) pthread_cond_init (event, NULL)

#define VIP_EVENT_SIGNAL(event) pthread_cond_signal (event)

#define VIP_EVENT_WAIT(event,lock) pthread_cond_wait (event,lock)

#define VIP_EVENT_WAIT_TIMEOUT(event,lock,timeout) \
pthread_cond_timedwait (event,lock,timeout)
#ifdef VI_GM_DEBUG_ASSERT /* VI_GM_DEBUG_ASSERT */

#define VIP_EVENT_DESTROY(event) assert (pthread_cond_destroy (event) == 0)
#else /* VI_GM_DEBUG_ASSERT */

#define VIP_EVENT_DESTROY(event) pthread_cond_destroy (event)
#endif /* VI_GM_DEBUG_ASSERT */

#else

#define VIP_EVENT_T HANDLE
#define VIP_EVENT_INIT(event) *event=CreateEvent(NULL,FALSE,FALSE,NULL)
#define VIP_EVENT_SIGNAL(event) SetEvent(*event)
#define VIP_EVENT_WAIT(event,lock)        \
do {                                      \
  VIP_MUTEX_UNLOCK (lock);                \
  WaitForSingleObject (*event, INFINITE); \
  VIP_MUTEX_LOCK (lock);                  \
} while (0)
#define VIP_EVENT_WAIT_TIMEOUT(event,lock,abstime)               \
do {                                                             \
  double timestart, timestop, timegap;                           \
  struct timeval tv;                                             \
  DWORD milli;                                                   \
  vip_gettimeofday (&tv, NULL);                                  \
  timestart = tv.tv_sec + tv.tv_usec/1000000.;                   \
  timestop = (abstime)->tv_sec + (abstime)->tv_nsec/1000000000.; \
  timegap = (timestop - timestart) * 1000.;                      \
  milli = (timegap < 0.0) ? 0 : (DWORD) timegap;                 \
  VIP_MUTEX_UNLOCK (lock);                                       \
  WaitForSingleObject (*event, milli);                           \
  VIP_MUTEX_LOCK (lock);                                         \
} while (0)
#define VIP_EVENT_DESTROY(event) CloseHandle(*event)

#endif


/**************/
/* semaphores */
/**************/

#ifndef WIN32

#define VIP_SEMAPHORE_T sem_t

#define VIP_SEMAPHORE_WAIT(sema) sem_wait (sema)
#ifdef VI_GM_DEBUG_ASSERT /* VI_GM_DEBUG_ASSERT */

#define VIP_SEMAPHORE_INIT(sema,value) assert (sem_init(sema,0,value) == 0)

#define VIP_SEMAPHORE_DESTROY(sema) assert (sem_destroy (sema) == 0)

#define VIP_SEMAPHORE_POST(sema) assert (sem_post (sema) == 0)
#else /* VI_GM_DEBUG_ASSERT */

#define VIP_SEMAPHORE_INIT(sema,value) sem_init(sema,0,value)

#define VIP_SEMAPHORE_DESTROY(sema) sem_destroy (sema)

#define VIP_SEMAPHORE_POST(sema) sem_post (sema)
#endif /* VI_GM_DEBUG_ASSERT */

#else

#define VIP_SEMAPHORE_T HANDLE
#define VIP_SEMAPHORE_WAIT(sema) WaitForSingleObject (*sema, INFINITE)
#define VIP_SEMAPHORE_INIT(sema,value) \
*sema = CreateSemaphore (NULL, value, 0x7FFFFFFFL, NULL)
#define VIP_SEMAPHORE_DESTROY(sema) CloseHandle (*sema)
#define VIP_SEMAPHORE_POST(sema) ReleaseSemaphore (*sema, 1, NULL)

#endif


/*************/
/* AVL trees */
/*************/

#define VIP_AVL_TREE_T avl_tree *

#define VIP_AVL_TREE_INIT(tree) \
tree = avl_create (vip_avl_compare_function, NULL)

#define VIP_AVL_TREE_DESTROY(tree) avl_destroy (tree, vip_avl_free_function)

#define VIP_AVL_TREE_FIND(tree,data) avl_find (tree, data)
#ifdef VI_GM_DEBUG_ASSERT /* VI_GM_DEBUG_ASSERT */

#define VIP_AVL_TREE_INSERT(tree,data) assert (avl_insert (tree, data) == 0)

#define VIP_AVL_TREE_DELETE(tree,data) assert (avl_delete (tree, data) != 0)
#else /* VI_GM_DEBUG_ASSERT */

#define VIP_AVL_TREE_INSERT(tree,data) avl_insert (tree, data)

#define VIP_AVL_TREE_DELETE(tree,data) avl_delete (tree, data)
#endif /* VI_GM_DEBUG_ASSERT */


#define VIP_NOTICE(args) vip_notice args

#ifdef VI_GM_DEBUG_ASSERT /* VI_GM_DEBUG_ASSERT */

#define VIP_ASSERT(exp) assert (exp)
#else /* VI_GM_DEBUG_ASSERT */

#define VIP_ASSERT(exp)
#endif /* VI_GM_DEBUG_ASSERT */

#define VIP_INVALID_NIC_HANDLE(vip_nic_ptr)                                \
((vip_nic_ptr == NULL)                                                     \
 || (((VIP_UINTPTR) vip_nic_ptr) <= VI_GM_MAX_NIC_HANDLES)                 \
 || (vip_nic_ptr->magic != VIP_NIC_MAGIC))

#define VIP_INVALID_PTAG_HANDLE(vip_ptag_ptr)                              \
((vip_ptag_ptr == NULL) || (vip_ptag_ptr->handle.magic != VIP_PTAG_MAGIC)  \
 || (vip_ptag_ptr->handle.vip_nic_ptr->magic != VIP_NIC_MAGIC))

#define VIP_INVALID_CQ_HANDLE(vip_cq_ptr)                                  \
((vip_cq_ptr == NULL) || (vip_cq_ptr->handle.magic != VIP_CQ_MAGIC)        \
 || (vip_cq_ptr->handle.vip_nic_ptr->magic != VIP_NIC_MAGIC))

#define VIP_INVALID_VI_HANDLE(vip_vi_ptr)                                  \
((vip_vi_ptr == NULL)                                                      \
 || (((VIP_UINTPTR) vip_vi_ptr) <= VI_GM_MAX_VI)                           \
 || (vip_vi_ptr->handle.magic != VIP_VI_MAGIC)                             \
 || (vip_vi_ptr->handle.vip_nic_ptr->magic != VIP_NIC_MAGIC))

#define VIP_INVALID_MEM_HANDLE(vip_mem_ptr)                                \
((vip_mem_ptr == NULL)                                                     \
 || (((VIP_UINTPTR) vip_mem_ptr) <= VI_GM_MAX_REGISTER_REGIONS)            \
 || (vip_mem_ptr->handle.magic != VIP_MEM_MAGIC)                           \
 || (vip_mem_ptr->handle.vip_nic_ptr->magic != VIP_NIC_MAGIC))

#define VIP_INVALID_CONN_HANDLE(vip_conn_ptr)                              \
((vip_conn_ptr == NULL) || (vip_conn_ptr->handle.magic != VIP_CONN_MAGIC)  \
 || (vip_conn_ptr->handle.vip_nic_ptr->magic != VIP_NIC_MAGIC))

#define VIP_FILL_GENERIC_HEAD(ptr,len,vi,type_code)                        \
ptr->vip_pkt_eager_ur.type = VIP_HTON_UCHAR (type_code);                   \
ptr->vip_pkt_eager_ur.length_24 = VIP_HTON_UCHAR ((len & 0xFF0000) >> 16); \
ptr->vip_pkt_eager_ur.length_16 = VIP_HTON_UCHAR ((len & 0xFF00) >> 8);    \
ptr->vip_pkt_eager_ur.length_8 = VIP_HTON_UCHAR (len & 0xFF);              \
ptr->vip_pkt_eager_ur.net_remote_nic_index = vi->net_remote_nic_index;     \
ptr->vip_pkt_eager_ur.net_remote_vi_index = vi->net_remote_vi_index

#define VIP_ENTER_IOCTL(gm_ptr)

#define VIP_EXIT_IOCTL(gm_ptr)

#define VIP_PROGRESSION(gm_ptr)                                            \
do                                                                         \
  {                                                                        \
    if (VIP_MUTEX_TRYLOCK (&(gm_ptr->recv_lock)) == VIP_TRUE)              \
      {                                                                    \
        vip_receive_event (gm_ptr, VIP_FALSE);                             \
        VIP_MUTEX_UNLOCK (&(gm_ptr->recv_lock));                           \
      }                                                                    \
  }                                                                        \
while (0)

#define STRINGIZE(arg) #arg

#define XSTRINGIZE(arg) STRINGIZE(arg)

#define LINE_STR XSTRINGIZE(__LINE__)

#ifdef VI_GM_DEBUG_PRINT /* VI_GM_DEBUG_PRINT */

#define VIP_DEBUG(args)                                                   \
do                                                                        \
  {                                                                       \
    char hostname[64];                                                    \
    char fmt[4096];                                                       \
    char *output;                                                         \
                                                                          \
    VIP_ASSERT (vip_gethostname (hostname, 64) == 0);                     \
    output = vip_vsprintf args;                                           \
    if (output != NULL)                                                   \
      {                                                                   \
        sprintf (fmt, "VI-GM [%s/%lu] <%s>: %s (%s:%s)\n", hostname,      \
                 (unsigned long) VIP_THREAD_SELF (), function_name,       \
                 output, __FILE__, LINE_STR);                             \
        fprintf (stderr, fmt);                                            \
        free (output);                                                    \
      }                                                                   \
  }                                                                       \
while (0)

#define VIP_DEBUG_GM(args)                                                \
do                                                                        \
  {                                                                       \
    char fmt[4096];                                                       \
    char *output;                                                         \
                                                                          \
    output = vip_vsprintf args;                                           \
    if (output != NULL)                                                   \
      {                                                                   \
        sprintf (fmt, "VI-GM <%s>: %s (%s:%s)\n", function_name,          \
                 output, __FILE__, LINE_STR);                             \
        gm_perror (fmt, gm_status);                                       \
      }                                                                   \
    free (output);                                                        \
  }                                                                       \
while (0)

#define VIP_DEBUG_LABEL(name)                                   \
const char function_name[64] = name;                            \
VIP_DEBUG ((""))

#define VIP_DEBUG_PROTECTED(args)                               \
VIP_MUTEX_LOCK (&vip_gm_host_name_lock);                        \
VIP_ENTER_IOCTL (vip_gm_ptr);                                   \
VIP_DEBUG (args)                                                \
VIP_EXIT_IOCTL (vip_gm_ptr);                                    \
VIP_MUTEX_UNLOCK (&vip_gm_host_name_lock)

#define VIP_DEBUG_GM_PROTECTED(args)                            \
VIP_MUTEX_LOCK (&vip_gm_host_name_lock);                        \
VIP_DEBUG_GM (args);                                            \
VIP_MUTEX_UNLOCK (&vip_gm_host_name_lock)

#define VIP_ABORT(args) VIP_DEBUG (args); abort ()

#else /* VI_GM_DEBUG_PRINT */

#define VIP_DEBUG_LABEL(name)

#define VIP_DEBUG(args)

#define VIP_DEBUG_GM(args)

#define VIP_DEBUG_PROTECTED(args)

#define VIP_DEBUG_GM_PROTECTED(args)

#define VIP_ABORT(args) VIP_DEBUG (("Print Debug not enabled")); abort ()
#endif /* VI_GM_DEBUG_PRINT */



#ifdef VI_GM_DEBUG_CHECKSUM     /* VI_GM_DEBUG_CHECKSUM */

#define VI_GM_DEBUG_CHECKSUM_SMALL VIP_PKT_CKSUM cksum_small;

#define VI_GM_DEBUG_CHECKSUM_LARGE VIP_PKT_CKSUM cksum_large;

#define VI_GM_DEBUG_CHECKSUM_COMPUTE(cksum_ptr,buf,len) \
vi_gm_debug_checksum_compute(cksum_ptr, buf, len)

#define VI_GM_DEBUG_CHECKSUM_CHECK(msg,buf,from,cksum_ptr) \
vi_gm_debug_checksum_check(msg, buf, from, cksum_ptr)

#define VI_GM_DEBUG_CHECKSUM_COPY(cksum_target,cksum_source) \
vi_gm_debug_checksum_copy(cksum_target, cksum_source)
#else /* VI_GM_DEBUG_CHECKSUM */

#define VI_GM_DEBUG_CHECKSUM_SMALL

#define VI_GM_DEBUG_CHECKSUM_LARGE

#define VI_GM_DEBUG_CHECKSUM_COMPUTE(cksum_ptr,buf,len)

#define VI_GM_DEBUG_CHECKSUM_CHECK(msg,buf,from,cksum_ptr)

#define VI_GM_DEBUG_CHECKSUM_COPY(cksum_target,cksum_source)
#endif /* VI_GM_DEBUG_CHECKSUM */



/*****************/
/* Magic numbers */
/*****************/

#define VIP_NIC_MAGIC  0xCAFE

#define VIP_VI_MAGIC   0xABCD

#define VIP_CQ_MAGIC   0xBABA

#define VIP_PTAG_MAGIC 0xDEDE

#define VIP_MEM_MAGIC  0xFADE

#define VIP_CONN_MAGIC 0xFFAA



/****************/
/* Send buffers */
/****************/

#define VIP_SEND_REQ_NONE          1

#define VIP_SEND_REQ_DMA           2

#define VIP_SEND_REQ_MALLOC        4

#define VIP_SEND_REQ_RELIABLE      8

#define VIP_SEND_REQ_UNRELIABLE   16

#define VIP_SEND_REQ_RDMA_WRITE   32

#define VIP_SEND_REQ_OPMASK \
(VIP_SEND_REQ_RELIABLE + VIP_SEND_REQ_UNRELIABLE + VIP_SEND_REQ_RDMA_WRITE)

#define VIP_SEND_REQ_TYPEMASK \
(VIP_SEND_REQ_NONE + VIP_SEND_REQ_DMA + VIP_SEND_REQ_MALLOC)



/****************/
/* Report types */
/****************/

#define VIP_REPORT_COMPLETION_RR    1

#define VIP_REPORT_REM_DESC_ERROR   2

#define VIP_REPORT_INVALID_SENDER   4

#define VIP_REPORT_RECV_QUEUE_EMPTY 8

#define VIP_REPORT_RDMA_PROT_ERROR  16

#define VIP_REPORT_CONN_LOST        32

#define VIP_CONN_TYPE_CLIENT 1

#define VIP_CONN_TYPE_SERVER 2

#define VIP_CONN_TYPE_PEER   4



/***********************/
/* network order stuff */
/***********************/

#define VIP_NET_UCHAR gm_u8_n_t

#define VIP_NET_UINT16 gm_u16_n_t

#define VIP_NET_UINT32 gm_u32_n_t

#define VIP_NET_UINT64 gm_u64_n_t

#define VIP_HTON_UCHAR(x)  gm_hton_u8 (x)

#define VIP_HTON_UINT16(x) gm_hton_u16 (x)

#define VIP_HTON_UINT32(x) gm_hton_u32 (x)

#define VIP_HTON_UINT64(x) gm_hton_u64 (x)

#define VIP_NTOH_UCHAR(x)  gm_ntoh_u8 (x)

#define VIP_NTOH_UINT16(x) gm_ntoh_u16 (x)

#define VIP_NTOH_UINT32(x) gm_ntoh_u32 (x)

#define VIP_NTOH_UINT64(x) gm_ntoh_u64 (x)


#endif