| /* |
| * Copyright 2017 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can |
| * be found in the LICENSE file. |
| * |
| */ |
| |
| // |
| // NOTE THAT NONE OF THESE EXTENTS CHECK FOR ZERO-SIZED ALLOCATIONS. |
| // THAT'S OK FOR NOW. |
| // |
| |
| #include <stdlib.h> |
| |
| #include "runtime_cl_12.h" |
| #include "extent_cl_12.h" |
| #include "common/cl/assert_cl.h" |
| |
| // |
| // EPHEMERAL MAPPING |
| // |
| // ENTIRE EXTENT MAPPED TO R/W HOST MEMORY |
| // ENTIRE EXTENT UNMAPPED TO R/W DEVICE MEMORY |
| // |
| // Note: integrated vs. discrete GPUs will have different |
| // implementations because we don't want a GPU kernel repeatedly |
| // accessing pinned memory. |
| // |
| |
| #if 0 |
| |
| #pragma message("struct skc_extent_thrw_tdrw will be removed once the sorter is installed.") |
| |
| void |
| skc_extent_thrw_tdrw_alloc(struct skc_runtime * const runtime, |
| struct skc_extent_thrw_tdrw * const extent, |
| size_t const size) |
| { |
| extent->drw = skc_runtime_device_temp_alloc(runtime, |
| CL_MEM_READ_WRITE /* | CL_MEM_ALLOC_HOST_PTR */, |
| size,&extent->id,&extent->size); |
| } |
| |
| void |
| skc_extent_thrw_tdrw_free(struct skc_runtime * const runtime, |
| struct skc_extent_thrw_tdrw * const extent) |
| { |
| skc_runtime_device_temp_free(runtime,extent->drw,extent->id); |
| } |
| |
| void * |
| skc_extent_thrw_tdrw_map_size(struct skc_extent_thrw_tdrw * const extent, |
| size_t const size, |
| cl_command_queue const cq, |
| cl_event * const event) |
| { |
| cl_int cl_err; |
| |
| void * hrw = clEnqueueMapBuffer(cq,extent->drw, |
| CL_FALSE, |
| CL_MAP_READ | CL_MAP_WRITE,0,size, |
| 0,NULL,event,&cl_err); cl_ok(cl_err); |
| |
| return hrw; |
| } |
| |
| void * |
| skc_extent_thrw_tdrw_map(struct skc_extent_thrw_tdrw * const extent, |
| cl_command_queue const cq, |
| cl_event * const event) |
| { |
| return skc_extent_thrw_tdrw_map_size(extent,extent->size,cq,event); |
| } |
| |
| void |
| skc_extent_thrw_tdrw_unmap(struct skc_extent_thrw_tdrw * const extent, |
| void * const hrw, |
| cl_command_queue const cq, |
| cl_event * const event) |
| { |
| cl(EnqueueUnmapMemObject(cq,extent->drw,hrw,0,NULL,event)); |
| } |
| |
| #endif |
| |
| // |
| // DURABLE MAPPING |
| // |
| // ENTIRE EXTENT MAPPED TO R/W HOST MEMORY |
| // ENTIRE EXTENT UNMAPPED TO R/W DEVICE MEMORY |
| // |
| // Note: integrated vs. discrete GPUs will have different |
| // implementations because we don't want a GPU kernel repeatedly |
| // accessing pinned memory. |
| // |
| |
| void |
| skc_extent_phrw_pdrw_alloc(struct skc_runtime * const runtime, |
| struct skc_extent_phrw_pdrw * const extent, |
| size_t const size) |
| { |
| cl_int cl_err; |
| |
| extent->size = size; |
| extent->drw = clCreateBuffer(runtime->cl.context, |
| CL_MEM_READ_WRITE | CL_MEM_ALLOC_HOST_PTR, |
| size,NULL,&cl_err); cl_ok(cl_err); |
| } |
| |
| void |
| skc_extent_phrw_pdrw_free(struct skc_runtime * const runtime, |
| struct skc_extent_phrw_pdrw * const extent) |
| { |
| cl(ReleaseMemObject(extent->drw)); |
| } |
| |
| void * |
| skc_extent_phrw_pdrw_map_size(struct skc_extent_phrw_pdrw * const extent, |
| size_t const size, |
| cl_command_queue const cq, |
| cl_event * const event) |
| { |
| cl_int cl_err; |
| |
| void * hrw = clEnqueueMapBuffer(cq,extent->drw, |
| CL_FALSE, |
| CL_MAP_READ | CL_MAP_WRITE,0,size, |
| 0,NULL,event,&cl_err); cl_ok(cl_err); |
| |
| return hrw; |
| } |
| |
| void * |
| skc_extent_phrw_pdrw_map(struct skc_extent_phrw_pdrw * const extent, |
| cl_command_queue const cq, |
| cl_event * const event) |
| { |
| return skc_extent_phrw_pdrw_map_size(extent,extent->size,cq,event); |
| } |
| |
| void |
| skc_extent_phrw_pdrw_unmap(struct skc_extent_phrw_pdrw * const extent, |
| void * const hrw, |
| cl_command_queue const cq, |
| cl_event * const event) |
| { |
| cl(EnqueueUnmapMemObject(cq,extent->drw,hrw,0,NULL,event)); |
| } |
| |
| // |
| // DURABLE MAPPING |
| // |
| // ENTIRE EXTENT MAPPED TO R/O HOST MEMORY |
| // ENTIRE EXTENT UNMAPPED TO W/O DEVICE MEMORY |
| // |
| // Note: integrated vs. discrete GPUs will have different |
| // implementations because we don't want a GPU kernel repeatedly |
| // accessing pinned memory. |
| // |
| |
| void |
| skc_extent_phrN_pdwN_alloc(struct skc_runtime * const runtime, |
| struct skc_extent_phrN_pdwN * const extent, |
| size_t const size) |
| { |
| cl_int cl_err; |
| |
| extent->size = size; |
| extent->dwN = clCreateBuffer(runtime->cl.context, |
| CL_MEM_WRITE_ONLY | CL_MEM_ALLOC_HOST_PTR, |
| size,NULL,&cl_err); cl_ok(cl_err); |
| } |
| |
| void |
| skc_extent_phrN_pdwN_free(struct skc_runtime * const runtime, |
| struct skc_extent_phrN_pdwN * const extent) |
| { |
| cl(ReleaseMemObject(extent->dwN)); |
| } |
| |
| void * |
| skc_extent_phrN_pdwN_map_size(struct skc_extent_phrN_pdwN * const extent, |
| size_t const size, |
| cl_command_queue const cq, |
| cl_event * const event) |
| { |
| cl_int cl_err; |
| |
| void * hrN = clEnqueueMapBuffer(cq,extent->dwN, |
| CL_FALSE, |
| CL_MAP_READ,0,size, |
| 0,NULL,event,&cl_err); cl_ok(cl_err); |
| |
| return hrN; |
| } |
| |
| void * |
| skc_extent_phrN_pdwN_map(struct skc_extent_phrN_pdwN * const extent, |
| cl_command_queue const cq, |
| cl_event * const event) |
| { |
| return skc_extent_phrN_pdwN_map_size(extent,extent->size,cq,event); |
| } |
| |
| void |
| skc_extent_phrN_pdwN_unmap(struct skc_extent_phrN_pdwN * const extent, |
| void * const hrN, |
| cl_command_queue const cq, |
| cl_event * const event) |
| { |
| cl(EnqueueUnmapMemObject(cq,extent->dwN,hrN,0,NULL,event)); |
| } |
| |
| // |
| // DURABLE MAPPING |
| // |
| // ENTIRE EXTENT MAPPED TO W/O HOST MEMORY |
| // ENTIRE EXTENT UNMAPPED TO R/O DEVICE MEMORY |
| // |
| // Note: integrated vs. discrete GPUs will have different |
| // implementations because we don't want a GPU kernel repeatedly |
| // accessing pinned memory. |
| // |
| |
| void |
| skc_extent_phwN_pdrN_alloc(struct skc_runtime * const runtime, |
| struct skc_extent_phwN_pdrN * const extent, |
| size_t const size) |
| { |
| cl_int cl_err; |
| |
| extent->size = size; |
| extent->drN = clCreateBuffer(runtime->cl.context, |
| CL_MEM_READ_ONLY | CL_MEM_ALLOC_HOST_PTR, |
| size,NULL,&cl_err); cl_ok(cl_err); |
| } |
| |
| void |
| skc_extent_phwN_pdrN_free(struct skc_runtime * const runtime, |
| struct skc_extent_phwN_pdrN * const extent) |
| { |
| cl(ReleaseMemObject(extent->drN)); |
| } |
| |
| void * |
| skc_extent_phwN_pdrN_map_size(struct skc_extent_phwN_pdrN * const extent, |
| size_t const size, |
| cl_command_queue const cq, |
| cl_event * const event) |
| { |
| cl_int cl_err; |
| |
| void * hwN = clEnqueueMapBuffer(cq,extent->drN, |
| CL_FALSE, |
| CL_MAP_WRITE,0,size, |
| 0,NULL,event,&cl_err); cl_ok(cl_err); |
| |
| return hwN; |
| } |
| |
| void * |
| skc_extent_phwN_pdrN_map(struct skc_extent_phwN_pdrN * const extent, |
| cl_command_queue const cq, |
| cl_event * const event) |
| { |
| return skc_extent_phwN_pdrN_map_size(extent,extent->size,cq,event); |
| } |
| |
| void |
| skc_extent_phwN_pdrN_unmap(struct skc_extent_phwN_pdrN * const extent, |
| void * const hwN, |
| cl_command_queue const cq, |
| cl_event * const event) |
| { |
| cl(EnqueueUnmapMemObject(cq,extent->drN,hwN,0,NULL,event)); |
| } |
| |
| // |
| // |
| // |