github.com/rohankumardubey/aresdb@v0.0.2-0.20190517170215-e54e3ca06b9c/memutils/memory/malloc.c (about)

     1  //  Copyright (c) 2017-2018 Uber Technologies, Inc.
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //     http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  #include <stdio.h>
    16  #include <stdlib.h>
    17  #include <string.h>
    18  
    19  #include "../memory.h"
    20  
    21  DeviceMemoryFlags GetFlags(){
    22    return 0x0;
    23  }
    24  
    25  CGoCallResHandle Init(){
    26    CGoCallResHandle resHandle = {NULL, NULL};
    27    return resHandle;
    28  }
    29  
    30  CGoCallResHandle HostAlloc(size_t bytes) {
    31    CGoCallResHandle resHandle = {NULL, NULL};
    32    resHandle.res = malloc(bytes);
    33    memset(resHandle.res, 0, bytes);
    34    return resHandle;
    35  }
    36  
    37  CGoCallResHandle HostFree(void *p) {
    38    CGoCallResHandle resHandle = {NULL, NULL};
    39    free(p);
    40    return resHandle;
    41  }
    42  
    43  // Dummy implementations.
    44  CGoCallResHandle CreateCudaStream(int device) {
    45    CGoCallResHandle resHandle = {NULL, NULL};
    46    return resHandle;
    47  }
    48  CGoCallResHandle WaitForCudaStream(void *s, int device) {
    49    CGoCallResHandle resHandle = {NULL, NULL};
    50    return resHandle;
    51  }
    52  
    53  CGoCallResHandle DestroyCudaStream(void *s, int device) {
    54    CGoCallResHandle resHandle = {NULL, NULL};
    55    return resHandle;
    56  }
    57  
    58  // Simulate on host side.
    59  CGoCallResHandle DeviceAllocate(size_t bytes, int device) {
    60    return HostAlloc(bytes);
    61  }
    62  
    63  CGoCallResHandle DeviceFree(void *p, int device) {
    64    return HostFree(p);
    65  }
    66  
    67  // Simulate on host side.
    68  CGoCallResHandle AsyncCopyHostToDevice(void *dst, void *src, size_t bytes,
    69                                         void *stream, int device) {
    70    memcpy(dst, src, bytes);
    71    CGoCallResHandle resHandle = {NULL, NULL};
    72    return resHandle;
    73  }
    74  
    75  CGoCallResHandle AsyncCopyDeviceToDevice(void *dst,
    76                                                  void *src,
    77                                                  size_t bytes,
    78                                                  void *stream,
    79                                                  int device) {
    80    memcpy(dst, src, bytes);
    81    CGoCallResHandle resHandle = {NULL, NULL};
    82    return resHandle;
    83  }
    84  
    85  CGoCallResHandle AsyncCopyDeviceToHost(void *dst,
    86                                                void *src,
    87                                                size_t bytes,
    88                                                void *stream,
    89                                                int device) {
    90    memcpy(dst, src, bytes);
    91    CGoCallResHandle resHandle = {NULL, NULL};
    92    return resHandle;
    93  }
    94  
    95  // Simulate on host side.
    96  CGoCallResHandle GetDeviceCount() {
    97    CGoCallResHandle resHandle = {(void *)1, NULL};
    98    return resHandle;
    99  }
   100  
   101  CGoCallResHandle GetDeviceGlobalMemoryInMB(int device) {
   102    // 24 GB
   103    CGoCallResHandle resHandle = {(void *)24392, NULL};
   104    return resHandle;
   105  }
   106  
   107  CGoCallResHandle CudaProfilerStart() {
   108    CGoCallResHandle resHandle = {NULL, NULL};
   109    return resHandle;
   110  }
   111  CGoCallResHandle CudaProfilerStop() {
   112    CGoCallResHandle resHandle = {NULL, NULL};
   113    return resHandle;
   114  }
   115  
   116  CGoCallResHandle GetDeviceMemoryInfo(size_t *freeSize, size_t *totalSize,
   117      int device){
   118    char* pStrErr = (char *) malloc(sizeof(NOT_SUPPORTED_ERR_MSG));
   119    snprintf(pStrErr, sizeof(NOT_SUPPORTED_ERR_MSG),
   120        NOT_SUPPORTED_ERR_MSG);
   121    CGoCallResHandle resHandle = {NULL, pStrErr};
   122    return resHandle;
   123  }
   124  
   125  CGoCallResHandle deviceMalloc(void **devPtr, size_t size){
   126    CGoCallResHandle resHandle = {NULL, NULL};
   127    *devPtr = malloc(size);
   128    return resHandle;
   129  }
   130  
   131  CGoCallResHandle deviceFree(void *devPtr){
   132    CGoCallResHandle resHandle = {NULL, NULL};
   133    free(devPtr);
   134    return resHandle;
   135  }
   136  
   137  CGoCallResHandle deviceMemset(void *devPtr, int value, size_t count) {
   138    CGoCallResHandle resHandle = {NULL, NULL};
   139    memset(devPtr, value, count);
   140    return resHandle;
   141  }
   142  
   143  CGoCallResHandle asyncCopyHostToDevice(void *dst, const void *src,
   144                                         size_t count, void *stream){
   145    CGoCallResHandle resHandle = {NULL, NULL};
   146    memcpy(dst, src, count);
   147    return resHandle;
   148  }