root/opal/mca/rcache/gpusm/rcache_gpusm_module.c

DEFINITIONS

1. mca_rcache_gpusm_registration_constructor
2. mca_rcache_gpusm_registration_destructor
3. mca_rcache_gpusm_module_init
4. mca_rcache_gpusm_find
5. mca_rcache_gpusm_register
6. mca_rcache_gpusm_deregister
7. mca_rcache_gpusm_finalize

   1 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
   2 /*
   3  * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
   4  *                         University Research and Technology
   5  *                         Corporation.  All rights reserved.
   6  * Copyright (c) 2004-2013 The University of Tennessee and The University
   7  *                         of Tennessee Research Foundation.  All rights
   8  *                         reserved.
   9  * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
  10  *                         University of Stuttgart.  All rights reserved.
  11  * Copyright (c) 2004-2005 The Regents of the University of California.
  12  *                         All rights reserved.
  13  * Copyright (c) 2006-2009 Cisco Systems, Inc.  All rights reserved.
  14  * Copyright (c) 2006      Voltaire. All rights reserved.
  15  * Copyright (c) 2007      Mellanox Technologies. All rights reserved.
  16  * Copyright (c) 2010      IBM Corporation.  All rights reserved.
  17  * Copyright (c) 2012-2015 NVIDIA Corporation.  All rights reserved.
  18  * Copyright (c) 2015      Los Alamos National Security, LLC.  All rights
  19  *                         reserved.
  20  *
  21  * $COPYRIGHT$
  22  *
  23  * Additional copyrights may follow
  24  *
  25  * $HEADER$
  26  */
  27 
  28 /**
  29  * @file:
  30  *
  31  * This file implements a simple memory pool that is used by the GPU
  32  * buffer on the sending side.  It just gets a memory handle and event
  33  * handle that can be sent to the remote side which can then use the
  34  * handles to get access to the memory and the event to determine when
  35  * it can start accessing the memory.  There is no caching of the
  36  * memory handles as getting new ones is fast.  The event handles are
  37  * cached by the cuda_common code.
  38  */
  39 
  40 #include "opal_config.h"
  41 #include "opal/mca/rcache/base/base.h"
  42 #include "opal/mca/rcache/gpusm/rcache_gpusm.h"
  43 #include "opal/mca/common/cuda/common_cuda.h"
  44 
  45 /**
  46  * Called when the registration free list is created.  An event is created
  47  * for each entry.
  48  */
  49 static void mca_rcache_gpusm_registration_constructor( mca_rcache_gpusm_registration_t *item )
  50 {
  51     mca_common_cuda_construct_event_and_handle(&item->event,
  52                                                (void *)&item->evtHandle);
  53 }
  54 
  55 /**
  56  * Called when the program is exiting.  This destroys the events.
  57  */
  58 static void mca_rcache_gpusm_registration_destructor( mca_rcache_gpusm_registration_t *item )
  59 {
  60     mca_common_cuda_destruct_event(item->event);
  61 }
  62 
  63 OBJ_CLASS_INSTANCE(mca_rcache_gpusm_registration_t, mca_rcache_base_registration_t,
  64                    mca_rcache_gpusm_registration_constructor,
  65                    mca_rcache_gpusm_registration_destructor);
  66 
  67 /*
  68  *  Initializes the rcache module.
  69  */
  70 void mca_rcache_gpusm_module_init(mca_rcache_gpusm_module_t* rcache)
  71 {
  72     rcache->super.rcache_component = &mca_rcache_gpusm_component.super;
  73     rcache->super.rcache_register = mca_rcache_gpusm_register;
  74     rcache->super.rcache_find = mca_rcache_gpusm_find;
  75     rcache->super.rcache_deregister = mca_rcache_gpusm_deregister;
  76     rcache->super.rcache_finalize = mca_rcache_gpusm_finalize;
  77 
  78     OBJ_CONSTRUCT(&rcache->reg_list, opal_free_list_t);
  79 
  80     /* Start with 0 entries in the free list since CUDA may not have
  81      * been initialized when this free list is created and there is
  82      * some CUDA specific activities that need to be done. */
  83     opal_free_list_init (&rcache->reg_list, sizeof(struct mca_rcache_common_cuda_reg_t),
  84             opal_cache_line_size,
  85             OBJ_CLASS(mca_rcache_gpusm_registration_t),
  86             0,opal_cache_line_size,
  87             0, -1, 64, NULL, 0, NULL, NULL, NULL);
  88 
  89 }
  90 
  91 /**
  92  * Just go ahead and get a new registration.  The find and register
  93  * functions are the same thing for this memory pool.
  94  */
  95 int mca_rcache_gpusm_find(mca_rcache_base_module_t *rcache, void *addr,
  96                          size_t size,
  97                          mca_rcache_base_registration_t **reg)
  98 {
  99     return mca_rcache_gpusm_register(rcache, addr, size, 0, 0, reg);
 100 }
 101 
 102 /*
 103  * This is the one function that does all the work.  It will call into
 104  * the register function to get the memory handle for the sending
 105  * buffer.  There is no need to deregister the memory handle so the
 106  * deregister function is a no-op.
 107  */
 108 int mca_rcache_gpusm_register(mca_rcache_base_module_t *rcache, void *addr,
 109                              size_t size, uint32_t flags, int32_t access_flags,
 110                              mca_rcache_base_registration_t **reg)
 111 {
 112     mca_rcache_gpusm_module_t *rcache_gpusm = (mca_rcache_gpusm_module_t*)rcache;
 113     mca_rcache_base_registration_t *gpusm_reg;
 114     opal_free_list_item_t *item;
 115     unsigned char *base, *bound;
 116     int rc;
 117 
 118     /* In spite of the fact we return an error code, the existing code
 119      * checks the registration for a NULL value rather than looking at
 120      * the return code.  So, initialize the registration to NULL in
 121      * case we run into a failure. */
 122     *reg = NULL;
 123 
 124     base = addr;
 125     bound = (unsigned char *)addr + size - 1;
 126 
 127     item = opal_free_list_get (&rcache_gpusm->reg_list);
 128     if(NULL == item) {
 129         return OPAL_ERR_OUT_OF_RESOURCE;
 130     }
 131     gpusm_reg = (mca_rcache_base_registration_t*)item;
 132 
 133     gpusm_reg->rcache = rcache;
 134     gpusm_reg->base = base;
 135     gpusm_reg->bound = bound;
 136     gpusm_reg->flags = flags;
 137     gpusm_reg->access_flags = access_flags;
 138 
 139     rc = cuda_getmemhandle (base, size, gpusm_reg, NULL);
 140 
 141     if(rc != OPAL_SUCCESS) {
 142         opal_free_list_return (&rcache_gpusm->reg_list, item);
 143         return rc;
 144     }
 145 
 146     *reg = gpusm_reg;
 147     (*reg)->ref_count++;
 148     return OPAL_SUCCESS;
 149 
 150 }
 151 
 152 /*
 153  * Return the registration to the free list.
 154  */
 155 int mca_rcache_gpusm_deregister(struct mca_rcache_base_module_t *rcache,
 156                                mca_rcache_base_registration_t *reg)
 157 {
 158     int rc;
 159     mca_rcache_gpusm_module_t *rcache_gpusm = (mca_rcache_gpusm_module_t *)rcache;
 160 
 161     rc = cuda_ungetmemhandle (NULL, reg);
 162     opal_free_list_return (&rcache_gpusm->reg_list, (opal_free_list_item_t *) reg);
 163     return OPAL_SUCCESS;
 164 }
 165 
 166 /**
 167  * Free up the resources.
 168  */
 169 void mca_rcache_gpusm_finalize(struct mca_rcache_base_module_t *rcache)
 170 {
 171     opal_free_list_item_t *item;
 172     mca_rcache_gpusm_module_t *rcache_gpusm = (mca_rcache_gpusm_module_t *)rcache;
 173 
 174     /* Need to run the destructor on each item in the free list explicitly.
 175      * The destruction of the free list only runs the destructor on the
 176      * main free list, not each item. */
 177     while (NULL != (item = (opal_free_list_item_t *)opal_lifo_pop(&(rcache_gpusm->reg_list.super)))) {
 178         OBJ_DESTRUCT(item);
 179     }
 180 
 181     OBJ_DESTRUCT(&rcache_gpusm->reg_list);
 182     return;
 183 }