| /* |
| * Copyright 2017 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can |
| * be found in the LICENSE file. |
| * |
| */ |
| |
| #pragma once |
| |
| // |
| // |
| // |
| |
| #include <CL/opencl.h> |
| |
| #include "suballocator.h" |
| #include "extent_ring.h" |
| |
| // |
| // Legend: |
| // |
| // p : durable |
| // t : ephemeral |
| // h : host |
| // d : device |
| // r : read |
| // w : write |
| // 1 : once -- e.g. w1 is 'write-once' |
| // N : many -- e.g. rN is 'read-many' |
| // g : ring |
| // s : ring snapshot |
| // |
| // Notes: |
| // |
| // rw : for now, read-write implies read-write many |
| // |
| |
| // |
| // DURABLE R/W HOST EXTENT -- STANDARD CACHED MEMORY |
| // |
| |
| struct skc_extent_phrw |
| { |
| void * hrw; |
| }; |
| |
| void |
| skc_extent_phrw_alloc(struct skc_runtime * const runtime, |
| struct skc_extent_phrw * const extent, |
| size_t const size); |
| |
| void |
| skc_extent_phrw_free(struct skc_runtime * const runtime, |
| struct skc_extent_phrw * const extent); |
| |
| // |
| // DURABLE R/W DEVICE EXTENT -- ALLOCATED FROM DEVICE HEAP |
| // |
| |
| struct skc_extent_pdrw |
| { |
| cl_mem drw; |
| }; |
| |
| void |
| skc_extent_pdrw_alloc(struct skc_runtime * const runtime, |
| struct skc_extent_pdrw * const extent, |
| size_t const size); |
| |
| void |
| skc_extent_pdrw_free(struct skc_runtime * const runtime, |
| struct skc_extent_pdrw * const extent); |
| |
| // |
| // EPHEMERAL DEVICE R/W EXTENT -- ALLOCATED QUICKLY FROM A MANAGED RING |
| // |
| |
| struct skc_extent_tdrw |
| { |
| size_t size; |
| cl_mem drw; |
| skc_subbuf_id_t id; |
| }; |
| |
| void |
| skc_extent_tdrw_alloc(struct skc_runtime * const runtime, |
| struct skc_extent_tdrw * const extent, |
| size_t const size); |
| |
| void |
| skc_extent_tdrw_free(struct skc_runtime * const runtime, |
| struct skc_extent_tdrw * const extent); |
| |
| void |
| skc_extent_tdrw_zero(struct skc_extent_tdrw * const extent, |
| cl_command_queue const cq, |
| cl_event * const event); |
| |
| // |
| // DURABLE SMALL EXTENTS BACKING ATOMICS |
| // |
| |
| struct skc_extent_phr_pdrw |
| { |
| size_t size; // must be multiple of words |
| void * hr; |
| cl_mem drw; |
| }; |
| |
| void |
| skc_extent_phr_pdrw_alloc(struct skc_runtime * const runtime, |
| struct skc_extent_phr_pdrw * const extent, |
| size_t const size); |
| |
| void |
| skc_extent_phr_pdrw_free(struct skc_runtime * const runtime, |
| struct skc_extent_phr_pdrw * const extent); |
| |
| void |
| skc_extent_phr_pdrw_read(struct skc_extent_phr_pdrw * const extent, |
| cl_command_queue const cq, |
| cl_event * const event); |
| |
| void |
| skc_extent_phr_pdrw_zero(struct skc_extent_phr_pdrw * const extent, |
| cl_command_queue const cq, |
| cl_event * const event); |
| |
| // |
| // EPHEMERAL SMALL EXTENTS BACKING ATOMICS |
| // |
| |
| struct skc_extent_thr_tdrw |
| { |
| size_t size; // must be multiple of words |
| |
| void * hr; |
| cl_mem drw; |
| |
| struct { |
| skc_subbuf_id_t hr; |
| skc_subbuf_id_t drw; |
| } id; |
| }; |
| |
| void |
| skc_extent_thr_tdrw_alloc(struct skc_runtime * const runtime, |
| struct skc_extent_thr_tdrw * const extent, |
| size_t const size); |
| |
| void |
| skc_extent_thr_tdrw_free(struct skc_runtime * const runtime, |
| struct skc_extent_thr_tdrw * const extent); |
| |
| void |
| skc_extent_thr_tdrw_read(struct skc_extent_thr_tdrw * const extent, |
| cl_command_queue const cq, |
| cl_event * const event); |
| |
| void |
| skc_extent_thr_tdrw_zero(struct skc_extent_thr_tdrw * const extent, |
| cl_command_queue const cq, |
| cl_event * const event); |
| |
| // |
| // DURABLE W/1 HOST RING WITH AN EPHEMERAL R/N DEVICE SNAPSHOT |
| // |
| |
| struct skc_extent_phw1g_tdrNs |
| { |
| void * hw1; |
| }; |
| |
| struct skc_extent_phw1g_tdrNs_snap |
| { |
| struct skc_extent_ring_snap * snap; |
| cl_mem drN; |
| skc_subbuf_id_t id; |
| }; |
| |
| void |
| skc_extent_phw1g_tdrNs_alloc(struct skc_runtime * const runtime, |
| struct skc_extent_phw1g_tdrNs * const extent, |
| size_t const size); |
| |
| void |
| skc_extent_phw1g_tdrNs_free(struct skc_runtime * const runtime, |
| struct skc_extent_phw1g_tdrNs * const extent); |
| |
| void |
| skc_extent_phw1g_tdrNs_snap_init(struct skc_runtime * const runtime, |
| struct skc_extent_ring * const ring, |
| struct skc_extent_phw1g_tdrNs_snap * const snap); |
| |
| void |
| skc_extent_phw1g_tdrNs_snap_alloc(struct skc_runtime * const runtime, |
| struct skc_extent_phw1g_tdrNs * const extent, |
| struct skc_extent_phw1g_tdrNs_snap * const snap, |
| cl_command_queue const cq, |
| cl_event * const event); |
| |
| void |
| skc_extent_phw1g_tdrNs_snap_free(struct skc_runtime * const runtime, |
| struct skc_extent_phw1g_tdrNs_snap * const snap); |
| |
| // |
| // DURABLE R/W HOST RING WITH AN EPHEMERAL R/N DEVICE SNAPSHOT |
| // |
| |
| struct skc_extent_phrwg_tdrNs |
| { |
| void * hrw; |
| }; |
| |
| struct skc_extent_phrwg_tdrNs_snap |
| { |
| struct skc_extent_ring_snap * snap; |
| cl_mem drN; |
| skc_subbuf_id_t id; |
| }; |
| |
| void |
| skc_extent_phrwg_tdrNs_alloc(struct skc_runtime * const runtime, |
| struct skc_extent_phrwg_tdrNs * const extent, |
| size_t const size); |
| |
| void |
| skc_extent_phrwg_tdrNs_free(struct skc_runtime * const runtime, |
| struct skc_extent_phrwg_tdrNs * const extent); |
| |
| void |
| skc_extent_phrwg_tdrNs_snap_init(struct skc_runtime * const runtime, |
| struct skc_extent_ring * const ring, |
| struct skc_extent_phrwg_tdrNs_snap * const snap); |
| |
| void |
| skc_extent_phrwg_tdrNs_snap_alloc(struct skc_runtime * const runtime, |
| struct skc_extent_phrwg_tdrNs * const extent, |
| struct skc_extent_phrwg_tdrNs_snap * const snap, |
| cl_command_queue const cq, |
| cl_event * const event); |
| |
| void |
| skc_extent_phrwg_tdrNs_snap_free(struct skc_runtime * const runtime, |
| struct skc_extent_phrwg_tdrNs_snap * const snap); |
| |
| // |
| // DURABLE HOST R/W RING WITH AN EPHEMERAL HOST R/1 SNAPSHOT |
| // |
| // Note that because the ring and snapshot are both in host memory and |
| // the snapshot blocks progress until freed we can simply point the |
| // fake ephemeral snapshot at the ring's durable extent. |
| // |
| |
| struct skc_extent_phrwg_thr1s |
| { |
| void * hrw; |
| }; |
| |
| struct skc_extent_phrwg_thr1s_snap |
| { |
| struct skc_extent_ring_snap * snap; |
| |
| struct { |
| skc_uint lo; |
| skc_uint hi; |
| } count; |
| |
| struct { |
| void * lo; |
| void * hi; |
| } hr1; |
| }; |
| |
| void |
| skc_extent_phrwg_thr1s_alloc(struct skc_runtime * const runtime, |
| struct skc_extent_phrwg_thr1s * const extent, |
| size_t const size); |
| |
| void |
| skc_extent_phrwg_thr1s_free(struct skc_runtime * const runtime, |
| struct skc_extent_phrwg_thr1s * const extent); |
| |
| void |
| skc_extent_phrwg_thr1s_snap_init(struct skc_runtime * const runtime, |
| struct skc_extent_ring * const ring, |
| struct skc_extent_phrwg_thr1s_snap * const snap); |
| |
| void |
| skc_extent_phrwg_thr1s_snap_alloc(struct skc_runtime * const runtime, |
| struct skc_extent_phrwg_thr1s * const extent, |
| struct skc_extent_phrwg_thr1s_snap * const snap); |
| |
| void |
| skc_extent_phrwg_thr1s_snap_free(struct skc_runtime * const runtime, |
| struct skc_extent_phrwg_thr1s_snap * const snap); |
| |
| // |
| // 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 |
| struct skc_extent_thrw_tdrw |
| { |
| size_t size; |
| cl_mem drw; |
| skc_subbuf_id_t id; |
| }; |
| |
| void |
| skc_extent_thrw_tdrw_alloc(struct skc_runtime * const runtime, |
| struct skc_extent_thrw_tdrw * const extent, |
| size_t const size); |
| |
| void |
| skc_extent_thrw_tdrw_free(struct skc_runtime * const runtime, |
| struct skc_extent_thrw_tdrw * const extent); |
| |
| 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); |
| |
| void * |
| skc_extent_thrw_tdrw_map(struct skc_extent_thrw_tdrw * const extent, |
| cl_command_queue const cq, |
| cl_event * const event); |
| |
| void |
| skc_extent_thrw_tdrw_unmap(struct skc_extent_thrw_tdrw * const extent, |
| void * const hrN, |
| cl_command_queue const cq, |
| cl_event * const 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. |
| // |
| |
| struct skc_extent_phrw_pdrw |
| { |
| size_t size; |
| cl_mem drw; |
| }; |
| |
| void |
| skc_extent_phrw_pdrw_alloc(struct skc_runtime * const runtime, |
| struct skc_extent_phrw_pdrw * const extent, |
| size_t const size); |
| |
| void |
| skc_extent_phrw_pdrw_free(struct skc_runtime * const runtime, |
| struct skc_extent_phrw_pdrw * const extent); |
| |
| 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); |
| |
| void * |
| skc_extent_phrw_pdrw_map(struct skc_extent_phrw_pdrw * const extent, |
| cl_command_queue const cq, |
| cl_event * const event); |
| |
| void |
| skc_extent_phrw_pdrw_unmap(struct skc_extent_phrw_pdrw * const extent, |
| void * const hrN, |
| cl_command_queue const cq, |
| cl_event * const 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. |
| // |
| |
| struct skc_extent_phrN_pdwN |
| { |
| size_t size; |
| cl_mem dwN; |
| }; |
| |
| void |
| skc_extent_phrN_pdwN_alloc(struct skc_runtime * const runtime, |
| struct skc_extent_phrN_pdwN * const extent, |
| size_t const size); |
| |
| void |
| skc_extent_phrN_pdwN_free(struct skc_runtime * const runtime, |
| struct skc_extent_phrN_pdwN * const extent); |
| |
| 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); |
| |
| void * |
| skc_extent_phrN_pdwN_map(struct skc_extent_phrN_pdwN * const extent, |
| cl_command_queue const cq, |
| cl_event * const 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); |
| |
| // |
| // 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. |
| // |
| |
| struct skc_extent_phwN_pdrN |
| { |
| size_t size; |
| cl_mem drN; |
| }; |
| |
| void |
| skc_extent_phwN_pdrN_alloc(struct skc_runtime * const runtime, |
| struct skc_extent_phwN_pdrN * const extent, |
| size_t const size); |
| |
| void |
| skc_extent_phwN_pdrN_free(struct skc_runtime * const runtime, |
| struct skc_extent_phwN_pdrN * const extent); |
| |
| 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); |
| |
| void * |
| skc_extent_phwN_pdrN_map(struct skc_extent_phwN_pdrN * const extent, |
| cl_command_queue const cq, |
| cl_event * const event); |
| |
| void |
| skc_extent_phwN_pdrN_unmap(struct skc_extent_phwN_pdrN * const extent, |
| void * const hwm, |
| cl_command_queue const cq, |
| cl_event * const event); |
| |
| // |
| // |
| // |