vipl_priv_handles.c

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 WIN32
#include <unistd.h>
#endif
#include <stdlib.h>

#include "vipl_priv.h"


/*******************/
/*                 */
/*   handle sets   */
/*                 */
/*******************/

VIP_RETURN
vip_init_handle_set (VIP_HANDLE_SET * set_ptr,
                     VIP_UINT32 handle_size,
                     VIP_UINT32 max_count, 
                     VIP_UINT32 magic_number)
{
  VIP_DEBUG_LABEL (("vip_init_handle_set"));

  if (set_ptr == NULL)
    {
      VIP_DEBUG (("Handle Set ptr is NULL"));
      return VIP_INVALID_PARAMETER;
    }

  if (handle_size == 0)
    {
      VIP_DEBUG (("Handle size is 0"));
      return VIP_INVALID_PARAMETER;
    }

  if (max_count == 0)
    {
      VIP_DEBUG (("Max count is 0"));
      return VIP_INVALID_PARAMETER;
    }

  if ((magic_number != VIP_CONN_MAGIC) && (magic_number != VIP_VI_MAGIC)
      && (magic_number != VIP_CQ_MAGIC) && (magic_number != VIP_MEM_MAGIC)
      && (magic_number != VIP_PTAG_MAGIC))
    {
      VIP_DEBUG (("Magic number is unknown"));
      return VIP_INVALID_PARAMETER;
    }

  set_ptr->lookaside = NULL;
  set_ptr->lookaside = gm_create_lookaside (handle_size, 8);
  if (set_ptr->lookaside == NULL)
    {
      VIP_DEBUG (("Unable to allocate lookaside list"));
      return VIP_ERROR_RESOURCE;
    }

  set_ptr->set_magic = magic_number;
  set_ptr->count = 0;
  set_ptr->max_count = max_count;
  set_ptr->cur_seq_num = 1;
  set_ptr->head = NULL;
  set_ptr->tail = NULL;

  VIP_DEBUG (("Success"));
  return VIP_SUCCESS;
}


VIP_HANDLE *
vip_allocate_handle (VIP_HANDLE_SET * set_ptr)
{
  VIP_HANDLE *handle_ptr;
  VIP_DEBUG_LABEL (("vip_allocate_handle"));

  VIP_ASSERT (set_ptr != NULL);
  VIP_ASSERT_MUTEX_LOCKED (&(set_ptr->vip_nic_ptr->lock));

  if (set_ptr->count >= set_ptr->max_count)
    {
      VIP_DEBUG (("Maximum of handles reached (%d)", set_ptr->max_count));
      return NULL;
    }

  handle_ptr = NULL;
  handle_ptr = (VIP_HANDLE *) gm_lookaside_zalloc (set_ptr->lookaside);
  if (handle_ptr == NULL)
    {
      VIP_DEBUG (("Unable to allocate handle from lookaside list"));
      return NULL;
    }
  else
    {
      handle_ptr->magic = set_ptr->set_magic;
      handle_ptr->seq_num = set_ptr->cur_seq_num;

      if (set_ptr->count == 0)
        {
          VIP_ASSERT (set_ptr->head == NULL);
          VIP_ASSERT (set_ptr->tail == NULL);
          set_ptr->head = handle_ptr;
          set_ptr->tail = handle_ptr;
        }
      else
        {
          VIP_ASSERT (set_ptr->head != NULL);
          VIP_ASSERT (set_ptr->tail != NULL);
          handle_ptr->prev = set_ptr->tail;
          set_ptr->tail->next = handle_ptr;
          set_ptr->tail = handle_ptr;
        }

      handle_ptr->vip_nic_ptr = set_ptr->vip_nic_ptr;
      handle_ptr->ref_count = 0;
      set_ptr->count++;
      set_ptr->cur_seq_num++;

      VIP_DEBUG (("Success"));
      return handle_ptr;
    }
}


void
vip_free_handle (VIP_HANDLE_SET * set_ptr, VIP_HANDLE * handle_ptr)
{
  VIP_DEBUG_LABEL (("vip_free_handle"));

  VIP_ASSERT (set_ptr != NULL);
  VIP_ASSERT (handle_ptr != NULL);
  VIP_ASSERT (set_ptr->count > 0);
  VIP_ASSERT (handle_ptr->ref_count == 0);
  VIP_ASSERT (set_ptr->vip_nic_ptr = handle_ptr->vip_nic_ptr);
  VIP_ASSERT_MUTEX_LOCKED (&(set_ptr->vip_nic_ptr->lock));

  handle_ptr->magic = 0;
  if (handle_ptr->prev != NULL)
    {
      handle_ptr->prev->next = handle_ptr->next;
    }
  else
    {
      set_ptr->head = handle_ptr->next;
    }
  if (handle_ptr->next != NULL)
    {
      handle_ptr->next->prev = handle_ptr->prev;
    }
  else
    {
      set_ptr->tail = handle_ptr->prev;
    }

  gm_lookaside_free (handle_ptr);
  set_ptr->count--;

  VIP_DEBUG (("Success"));
}


void
vip_destroy_conn_handle_set (VIP_HANDLE_SET * set_ptr)
{
  VIP_CONN *vip_conn_ptr;
  unsigned int i;
  VIP_DEBUG_LABEL (("vip_destroy_conn_handle_set"));

  VIP_ASSERT_MUTEX_LOCKED (&(set_ptr->vip_nic_ptr->lock));
  VIP_ASSERT (set_ptr->set_magic == VIP_CONN_MAGIC);

  while (set_ptr->head != NULL)
    {
      vip_conn_ptr = (VIP_CONN *) (set_ptr->head);
      while (vip_conn_ptr->handle.ref_count > 0)
        {
          VIP_EVENT_SIGNAL (&(vip_conn_ptr->event));
          VIP_MUTEX_UNLOCK (&(set_ptr->vip_nic_ptr->lock));
          
          for (i = 0; i < 100; i++)
            {
              vip_millisleep (1);
              VIP_MUTEX_LOCK (&(set_ptr->vip_nic_ptr->lock));
              if (vip_conn_ptr->handle.ref_count == 0)
                {
                  break;
                }
              else
                {
                  VIP_ABORT (("Persistent reference despite notification"));
                }
            }
        }

      vip_free_handle (set_ptr, set_ptr->head);
    }

  VIP_ASSERT (set_ptr->count == 0);
  VIP_ASSERT (set_ptr->tail == NULL);

  if (set_ptr->lookaside != NULL)
    {
      gm_destroy_lookaside (set_ptr->lookaside);
    }
  set_ptr->max_count = 0;
  set_ptr->set_magic = 0;

  VIP_DEBUG (("Success"));
}


void
vip_destroy_vi_handle_set (VIP_HANDLE_SET * set_ptr)
{
  VIP_VI *vip_vi_ptr;
  unsigned int i;
  VIP_DEBUG_LABEL (("vip_destroy_vi_handle_set"));

  VIP_ASSERT_MUTEX_LOCKED (&(set_ptr->vip_nic_ptr->lock));
  VIP_ASSERT (set_ptr->set_magic == VIP_VI_MAGIC);

  while (set_ptr->head != NULL)
    {
      vip_vi_ptr = (VIP_VI *) (set_ptr->head);
      while (vip_vi_ptr->handle.ref_count > 0)
        {
          VIP_EVENT_SIGNAL (&(vip_vi_ptr->send_queue.event));
          VIP_EVENT_SIGNAL (&(vip_vi_ptr->recv_queue.event));
          VIP_MUTEX_UNLOCK (&(set_ptr->vip_nic_ptr->lock));

          for (i = 0; i < 100; i++)
            {
              vip_millisleep (1);
              VIP_MUTEX_LOCK (&(set_ptr->vip_nic_ptr->lock));
              if (vip_vi_ptr->handle.ref_count == 0)
                {
                  break;
                }
              else
                {
                  VIP_ABORT (("Persistent reference despite notification"));
                }
            }
        }

      /* decrease send CQ reference counter if needed */
      if (vip_vi_ptr->send_queue.vip_cq_ptr != NULL)
        {
          vip_vi_ptr->send_queue.vip_cq_ptr->handle.ref_count--;
        }

      /* decrease recv CQ reference counter if needed */
      if (vip_vi_ptr->recv_queue.vip_cq_ptr != NULL)
        {
          vip_vi_ptr->recv_queue.vip_cq_ptr->handle.ref_count--;
        }

      /* decrease ptag reference counter */
      vip_vi_ptr->vip_ptag_ptr->handle.ref_count--;

      /* free the handle */
      vip_free_handle (set_ptr, set_ptr->head);
    }

  VIP_ASSERT (set_ptr->count == 0);
  VIP_ASSERT (set_ptr->tail == NULL);

  if (set_ptr->lookaside != NULL)
    {
      gm_destroy_lookaside (set_ptr->lookaside);
    }
  set_ptr->max_count = 0;
  set_ptr->set_magic = 0;

  VIP_DEBUG (("Success"));
}


void
vip_destroy_cq_handle_set (VIP_HANDLE_SET * set_ptr)
{
  VIP_CQ *vip_cq_ptr;
  unsigned int i;
  VIP_DEBUG_LABEL (("vip_destroy_cq_handle_set"));

  VIP_ASSERT_MUTEX_LOCKED (&(set_ptr->vip_nic_ptr->lock));
  VIP_ASSERT (set_ptr->set_magic == VIP_CQ_MAGIC);

  while (set_ptr->head != NULL)
    {
      vip_cq_ptr = (VIP_CQ *) (set_ptr->head);
      if (vip_cq_ptr->handle.ref_count > 0)
        {
          VIP_EVENT_SIGNAL (&(vip_cq_ptr->event));
          VIP_MUTEX_UNLOCK (&(set_ptr->vip_nic_ptr->lock));

          for (i = 0; i < 100; i++)
            {
              vip_millisleep (1);
              VIP_MUTEX_LOCK (&(set_ptr->vip_nic_ptr->lock));
              if (vip_cq_ptr->handle.ref_count == 0)
                {
                  break;
                }
              else
                {
                  VIP_ABORT (("Persistent reference despite notification"));
                }
            }
        }

      /* free the handle */
      vip_free_handle (set_ptr, set_ptr->head);
    }

  VIP_ASSERT (set_ptr->count == 0);
  VIP_ASSERT (set_ptr->tail == NULL);

  if (set_ptr->lookaside != NULL)
    {
      gm_destroy_lookaside (set_ptr->lookaside);
    }
  set_ptr->max_count = 0;
  set_ptr->set_magic = 0;

  VIP_DEBUG (("Success"));
}


void
vip_destroy_mem_handle_set (VIP_HANDLE_SET * set_ptr)
{
  VIP_DEBUG_LABEL (("vip_destroy_mem_handle_set"));

  VIP_ASSERT_MUTEX_LOCKED (&(set_ptr->vip_nic_ptr->lock));
  VIP_ASSERT (set_ptr->set_magic == VIP_MEM_MAGIC);

  while (set_ptr->head != NULL)
    {
      if (set_ptr->head->ref_count > 0)
        {
          VIP_ABORT (("MEM reference count is > 0, prevent destruction"));
        }

      /* decrease ptag reference counter */
      ((VIP_MEM *) set_ptr->head)->vip_ptag_ptr->handle.ref_count--;

      /* free the handle */
      vip_free_handle (set_ptr, set_ptr->head);
    }

  VIP_ASSERT (set_ptr->count == 0);
  VIP_ASSERT (set_ptr->tail == NULL);

  if (set_ptr->lookaside != NULL)
    {
      gm_destroy_lookaside (set_ptr->lookaside);
    }
  set_ptr->max_count = 0;
  set_ptr->set_magic = 0;

  VIP_DEBUG (("Success"));
}


void
vip_destroy_ptag_handle_set (VIP_HANDLE_SET * set_ptr)
{
  VIP_DEBUG_LABEL (("vip_destroy_ptag_handle_set"));

  VIP_ASSERT_MUTEX_LOCKED (&(set_ptr->vip_nic_ptr->lock));
  VIP_ASSERT (set_ptr->set_magic == VIP_PTAG_MAGIC);

  while (set_ptr->head != NULL)
    {
      if (set_ptr->head->ref_count > 0)
        {
          VIP_ABORT (("PTAG reference count is > 0, prevent destruction"));
        }

      /* free the handle */
      vip_free_handle (set_ptr, set_ptr->head);
    }

  VIP_ASSERT (set_ptr->count == 0);
  VIP_ASSERT (set_ptr->tail == NULL);

  if (set_ptr->lookaside != NULL)
    {
      gm_destroy_lookaside (set_ptr->lookaside);
    }
  set_ptr->max_count = 0;
  set_ptr->set_magic = 0;

  VIP_DEBUG (("Success"));
}

VIP_BOOLEAN 
vip_is_conn_notified (VIP_PVOID ptr)
{
  VIP_CONN *vip_conn_ptr;

  vip_conn_ptr = (VIP_CONN *) ptr;
  if (vip_conn_ptr->status != VIP_NOT_DONE)
    {
      return VIP_TRUE;
    }
  else
    {
      return VIP_FALSE;
    }
}

VIP_BOOLEAN 
vip_is_first_desc_notified (VIP_PVOID ptr)
{
  VIP_VI_QUEUE *vip_vi_queue_ptr;

  vip_vi_queue_ptr = (VIP_VI_QUEUE *) ptr;
  if ((vip_vi_queue_ptr->first->CS.Status & VIP_STATUS_DONE) != 0)
    {
      return VIP_TRUE;
    }
  else
    {
      return VIP_FALSE;
    }
}

VIP_BOOLEAN 
vip_is_first_cq_entry_notified (VIP_PVOID ptr)
{
  VIP_CQ *vip_cq_ptr;

  vip_cq_ptr = (VIP_CQ *) ptr;
  if (vip_cq_ptr->queue[vip_cq_ptr->next_poll].completed == VIP_TRUE)
    {
      return VIP_TRUE;
    }
  else
    {
      return VIP_FALSE;
    }
}


void *
vip_send_notify_thread (void *arg)
{
  VIP_VI *vip_vi_ptr;
  VIP_NIC *vip_nic_ptr;
  VIP_PVOID context;
  VIP_NOTIFY *vip_notify_ptr;
  VIP_DESCRIPTOR *vip_desc_ptr;
  void (*fct) (VIP_PVOID, VIP_NIC_HANDLE, VIP_VI_HANDLE, VIP_DESCRIPTOR *);
  VIP_DEBUG_LABEL (("vip_send_notify_thread"));

  vip_vi_ptr = (VIP_VI *) arg;
  vip_nic_ptr = vip_vi_ptr->handle.vip_nic_ptr;

  while (1)
    {
      VIP_SEMAPHORE_WAIT (&(vip_vi_ptr->send_queue.notify_tokens));
      
      /* test if the notify thread should be cancelled */
      if (vip_vi_ptr->send_queue.notify_cancelled == VIP_TRUE)
        {
          VIP_THREAD_EXIT (0);
        }

      VIP_DEBUG (("Process a pending send notify handle"));
      vip_desc_ptr = NULL;
      switch (VipSendWait (vip_vi_ptr, VIP_INFINITE, &vip_desc_ptr))
        {
        case VIP_SUCCESS:
        case VIP_DESCRIPTOR_ERROR:
          VIP_MUTEX_LOCK (&(vip_nic_ptr->vip_gm_ptr->lock));
          VIP_MUTEX_LOCK (&(vip_nic_ptr->lock));
          vip_notify_ptr = vip_vi_ptr->send_queue.first_notify_handler;
          VIP_ASSERT (vip_notify_ptr != NULL);

          /* remove the notify handle from the pending list */
          vip_vi_ptr->send_queue.first_notify_handler = vip_notify_ptr->next;
          if (vip_vi_ptr->send_queue.last_notify_handler == vip_notify_ptr)
            {
              VIP_ASSERT (vip_vi_ptr->send_queue.first_notify_handler ==
                          NULL);
              vip_vi_ptr->send_queue.last_notify_handler = NULL;
            }

          fct = vip_notify_ptr->handler;
          context = vip_notify_ptr->context;

          /* release the notify structure */
          gm_lookaside_free (vip_notify_ptr);

          VIP_MUTEX_UNLOCK (&(vip_nic_ptr->lock));
          VIP_MUTEX_UNLOCK (&(vip_nic_ptr->vip_gm_ptr->lock));

          /* execute the send notify handler */
          (*fct) (context, vip_nic_ptr, vip_vi_ptr, vip_desc_ptr);
          break;

        default:
          /* test if the notify thread should be cancelled */
          if (vip_vi_ptr->send_queue.notify_cancelled == VIP_TRUE)
            {
              VIP_THREAD_EXIT (0);
            }
          else
            {
              VIP_ABORT (("Internal error"));
            }
        }
    }
}


void *
vip_recv_notify_thread (void *arg)
{
  VIP_VI *vip_vi_ptr;
  VIP_NIC *vip_nic_ptr;
  VIP_PVOID context;
  VIP_NOTIFY *vip_notify_ptr;
  VIP_DESCRIPTOR *vip_desc_ptr;
  void (*fct) (VIP_PVOID, VIP_NIC_HANDLE, VIP_VI_HANDLE, VIP_DESCRIPTOR *);
  VIP_DEBUG_LABEL (("vip_recv_notify_thread"));

  vip_vi_ptr = (VIP_VI *) arg;
  vip_nic_ptr = vip_vi_ptr->handle.vip_nic_ptr;

  while (1)
    {
      VIP_SEMAPHORE_WAIT (&(vip_vi_ptr->recv_queue.notify_tokens));
   
      /* test if the notify thread should be cancelled */
      if (vip_vi_ptr->recv_queue.notify_cancelled == VIP_TRUE)
        {
          VIP_THREAD_EXIT (0);
        }
      
      VIP_DEBUG (("Process a pending recv notify handle"));
      vip_desc_ptr = NULL;
      switch (VipRecvWait (vip_vi_ptr, VIP_INFINITE, &vip_desc_ptr))
        {
        case VIP_SUCCESS:
        case VIP_DESCRIPTOR_ERROR:
          VIP_MUTEX_LOCK (&(vip_nic_ptr->vip_gm_ptr->lock));
          VIP_MUTEX_LOCK (&(vip_nic_ptr->lock));
          vip_notify_ptr = vip_vi_ptr->recv_queue.first_notify_handler;
          VIP_ASSERT (vip_notify_ptr != NULL);

          /* remove the notify handle from the pending list */
          vip_vi_ptr->recv_queue.first_notify_handler = vip_notify_ptr->next;
          if (vip_vi_ptr->recv_queue.last_notify_handler == vip_notify_ptr)
            {
              VIP_ASSERT (vip_vi_ptr->recv_queue.first_notify_handler ==
                          NULL);
              vip_vi_ptr->recv_queue.last_notify_handler = NULL;
            }

          fct = vip_notify_ptr->handler;
          context = vip_notify_ptr->context;

          /* release the notify structure */
          gm_lookaside_free (vip_notify_ptr);

          VIP_MUTEX_UNLOCK (&(vip_nic_ptr->lock));
          VIP_MUTEX_UNLOCK (&(vip_nic_ptr->vip_gm_ptr->lock));

          /* execute the recv notify handler */
          (*fct) (context, vip_nic_ptr, vip_vi_ptr, vip_desc_ptr);
          break;

        default:
          /* test if the notify thread should be cancelled */
          if (vip_vi_ptr->recv_queue.notify_cancelled == VIP_TRUE)
            {
              VIP_THREAD_EXIT (0);
            }
          else
            {
              VIP_ABORT (("Internal error"));
            }
        }
    }
}


void *
vip_cq_notify_thread (void *arg)
{
  VIP_CQ *vip_cq_ptr;
  VIP_NIC *vip_nic_ptr;
  VIP_PVOID context;
  VIP_VI_HANDLE vip_vi_handle;
  VIP_NOTIFY *vip_notify_ptr;
  VIP_BOOLEAN recv_queue;
  void (*fct) (VIP_PVOID, VIP_NIC_HANDLE, VIP_VI_HANDLE, VIP_BOOLEAN);
  VIP_DEBUG_LABEL (("vip_cq_notify_thread"));

  vip_cq_ptr = (VIP_CQ *) arg;
  vip_nic_ptr = vip_cq_ptr->handle.vip_nic_ptr;

  while (1)
    {
      VIP_SEMAPHORE_WAIT (&(vip_cq_ptr->notify_tokens));

      /* test if the notify thread should be cancelled */
      if (vip_cq_ptr->notify_cancelled == VIP_TRUE)
        {
          VIP_THREAD_EXIT (0);
        }

      VIP_DEBUG (("Process a pending CQ notify handle"));
      if (VipCQWait (vip_cq_ptr, VIP_INFINITE, &vip_vi_handle,
                     &recv_queue) != VIP_SUCCESS)
        {
          /* test if the notify thread should be cancelled */
          if (vip_cq_ptr->notify_cancelled == VIP_TRUE)
            {
              VIP_THREAD_EXIT (0);
            }
          else
            {
              VIP_ABORT (("Internal error"));
            }
        }

      VIP_MUTEX_LOCK (&(vip_nic_ptr->vip_gm_ptr->lock));
      VIP_MUTEX_LOCK (&(vip_nic_ptr->lock));
      vip_notify_ptr = vip_cq_ptr->first_notify_handler;
      VIP_ASSERT (vip_notify_ptr != NULL);

      /* remove the notify handle from the pending list */
      vip_cq_ptr->first_notify_handler = vip_notify_ptr->next;
      if (vip_cq_ptr->last_notify_handler == vip_notify_ptr)
        {
          VIP_ASSERT (vip_cq_ptr->first_notify_handler == NULL);
          vip_cq_ptr->last_notify_handler = NULL;
        }

      fct = vip_notify_ptr->handler;
      context = vip_notify_ptr->context;

      /* release the notify structure */
      gm_lookaside_free (vip_notify_ptr);

      VIP_MUTEX_UNLOCK (&(vip_nic_ptr->lock));
      VIP_MUTEX_UNLOCK (&(vip_nic_ptr->vip_gm_ptr->lock));

      /* execute the cq notify handler */
      (*fct) (context, vip_nic_ptr, vip_vi_handle, recv_queue);
    }
}