Line data    Source code

       1              : /*----------------------------------------------------------------------------*/
       2              : /*  CP2K: A general program to perform molecular dynamics simulations         */
       3              : /*  Copyright 2000-2025 CP2K developers group <https://cp2k.org>              */
       4              : /*                                                                            */
       5              : /*  SPDX-License-Identifier: BSD-3-Clause                                     */
       6              : /*----------------------------------------------------------------------------*/
       7              : #include "offload_buffer.h"
       8              : #include "offload_library.h"
       9              : #include "offload_mempool.h"
      10              : #include "offload_runtime.h"
      11              : 
      12              : #include <assert.h>
      13              : #include <stdio.h>
      14              : #include <stdlib.h>
      15              : 
      16              : #if 1
      17              : #define OFFLOAD_BUFFER_MEMPOOL
      18              : #endif
      19              : 
      20              : /*******************************************************************************
      21              :  * \brief Allocates a buffer of given length, ie., number of elements.
      22              :  * \author Ole Schuett
      23              :  ******************************************************************************/
      24       274876 : void offload_create_buffer(const int length, offload_buffer **buffer) {
      25       274876 :   const size_t requested_size = sizeof(double) * length;
      26              : 
      27       274876 :   if (*buffer != NULL) {
      28              : #if !defined(OFFLOAD_BUFFER_MEMPOOL)
      29              :     if ((*buffer)->size >= requested_size) {
      30              :       return; // reuse existing buffer
      31              :     } else
      32              : #endif
      33              :     {
      34        11356 :       offload_free_buffer(*buffer);
      35              :     }
      36              :   }
      37              : 
      38       274876 :   (*buffer) = malloc(sizeof(offload_buffer));
      39       274876 :   assert(NULL != *buffer);
      40       274876 :   (*buffer)->size = requested_size;
      41       274876 :   (*buffer)->host_buffer = NULL;
      42       274876 :   (*buffer)->device_buffer = NULL;
      43              : #if defined(OFFLOAD_BUFFER_MEMPOOL)
      44       274876 :   (*buffer)->host_buffer = offload_mempool_host_malloc(requested_size);
      45       274876 :   (*buffer)->device_buffer = offload_mempool_device_malloc(requested_size);
      46              : #elif defined(__OFFLOAD)
      47              :   offload_activate_chosen_device();
      48              :   offloadMallocHost((void **)&(*buffer)->host_buffer, requested_size);
      49              :   offloadMalloc((void **)&(*buffer)->device_buffer, requested_size);
      50              : #else
      51              :   (*buffer)->host_buffer = malloc(requested_size);
      52              :   (*buffer)->device_buffer = NULL;
      53              : #endif
      54       274876 :   if (NULL == (*buffer)->host_buffer) { /* unified memory */
      55          473 :     (*buffer)->host_buffer = (*buffer)->device_buffer;
      56              :   }
      57       274876 : }
      58              : 
      59              : /*******************************************************************************
      60              :  * \brief Deallocate given buffer.
      61              :  * \author Ole Schuett
      62              :  ******************************************************************************/
      63       274876 : void offload_free_buffer(offload_buffer *buffer) {
      64       274876 :   if (NULL == buffer) {
      65              :     return;
      66              :   }
      67              : #if defined(OFFLOAD_BUFFER_MEMPOOL)
      68       274876 :   offload_mempool_host_free(buffer->host_buffer);
      69       274876 :   offload_mempool_device_free(buffer->device_buffer);
      70              : #elif defined(__OFFLOAD)
      71              :   offloadFreeHost(buffer->host_buffer);
      72              :   offloadFree(buffer->device_buffer);
      73              : #else
      74              :   free(buffer->host_buffer);
      75              :   assert(NULL == buffer->device_buffer);
      76              : #endif
      77       274876 :   free(buffer);
      78              : }
      79              : 
      80              : /*******************************************************************************
      81              :  * \brief Returns a pointer to the host buffer.
      82              :  * \author Ole Schuett
      83              :  ******************************************************************************/
      84       273954 : double *offload_get_buffer_host_pointer(offload_buffer *buffer) {
      85       273954 :   assert(NULL != buffer);
      86       273954 :   return buffer->host_buffer;
      87              : }
      88              : 
      89              : // EOF