Macintosh-Tools/Retro68
1
0
Fork 0
mirror of https://github.com/autc04/Retro68.git synced 2024-11-24 07:31:32 +00:00
Code Issues Projects Releases Wiki Activity
1048b06ce4
Retro68/gcc/liboffloadmic/include/coi/source/COIBuffer_source.h
Wolfgang Thaller 41040e16f5 Update gcc to 5.2.0
2015-08-28 17:33:40 +02:00

1312 lines
58 KiB
C
Raw Blame History

/*
* Copyright 2010-2013 Intel Corporation.
*
* This library is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as published
* by the Free Software Foundation, version 2.1.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
* 02110-1301 USA.
*
* Disclaimer: The codes contained in these modules may be specific
* to the Intel Software Development Platform codenamed Knights Ferry,
* and the Intel product codenamed Knights Corner, and are not backward
* compatible with other Intel products. Additionally, Intel will NOT
* support the codes or instruction set in future products.
*
* Intel offers no warranty of any kind regarding the code. This code is
* licensed on an "AS IS" basis and Intel is not obligated to provide
* any support, assistance, installation, training, or other services
* of any kind. Intel is also not obligated to provide any updates,
* enhancements or extensions. Intel specifically disclaims any warranty
* of merchantability, non-infringement, fitness for any particular
* purpose, and any other warranty.
*
* Further, Intel disclaims all liability of any kind, including but
* not limited to liability for infringement of any proprietary rights,
* relating to the use of the code, even if Intel is notified of the
* possibility of such liability. Except as expressly stated in an Intel
* license agreement provided with this code and agreed upon with Intel,
* no license, express or implied, by estoppel or otherwise, to any
* intellectual property rights is granted herein.
*/
#ifndef _COIBUFFER_SOURCE_H
#define _COIBUFFER_SOURCE_H
/** @ingroup COIBuffer
* @addtogroup COIBufferSource
@{
* @file source\COIBuffer_source.h
*/
#ifndef DOXYGEN_SHOULD_SKIP_THIS
#include "../common/COITypes_common.h"
#include "../common/COIResult_common.h"
#endif // DOXYGEN_SHOULD_SKIP_THIS
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////
/// The valid buffer types that may be created using COIBufferCreate.
/// Please see the COI_VALID_BUFFER_TYPES_AND_FLAGS matrix
/// below which describes the valid combinations of buffer types and flags.
///
typedef enum COI_BUFFER_TYPE
{
/// Normal buffers exist as a single physical buffer in either Source or
/// Sink physical memory. Mapping the buffer may stall the pipelines.
COI_BUFFER_NORMAL = 1,
/// A streaming buffer creates new versions each time it is passed to
/// Runfunction. These new versions are consumed by run functions.
/// To_SINK buffers are used to send data from SOURCE to SINK
/// These buffers are SOURCE write only buffers. If read, won't
/// get Data written by SINK
COI_BUFFER_STREAMING_TO_SINK,
/// To_SOURCE buffers are used to get data from SINK to SOURCE
/// These buffers are SOURCE Read only buffers. If written, data
/// won't get reflected on SINK side.
COI_BUFFER_STREAMING_TO_SOURCE,
/// A pinned buffer exists in a shared memory region and is always
/// available for read or write operations.
COI_BUFFER_PINNED,
/// OpenCL buffers are similar to Normal buffers except they don't
/// stall pipelines and don't follow any read write dependencies.
COI_BUFFER_OPENCL
} COI_BUFFER_TYPE;
/// @name COIBUFFER creation flags.
/// Please see the COI_VALID_BUFFER_TYPES_AND_FLAGS matrix
/// below which describes the valid combinations of buffer types and flags.
//@{
/// Create the buffer such that it has the same virtual address on all of the
/// sink processes with which it is associated.
#define COI_SAME_ADDRESS_SINKS 0x00000001
/// Create the buffer such that it has the same virtual address on all of the
/// sink processes with which it is associated and in the source process.
#define COI_SAME_ADDRESS_SINKS_AND_SOURCE 0x00000002
/// Hint to the runtime that the source will frequently read the buffer
#define COI_OPTIMIZE_SOURCE_READ 0x00000004
/// Hint to the runtime that the source will frequently write the buffer
#define COI_OPTIMIZE_SOURCE_WRITE 0x00000008
/// Hint to the runtime that the sink will frequently read the buffer
#define COI_OPTIMIZE_SINK_READ 0x00000010
/// Hint to the runtime that the sink will frequently write the buffer
#define COI_OPTIMIZE_SINK_WRITE 0x00000020
/// Used to delay the pinning of memory into physical pages, until required
/// for DMA. This can be used to delay the cost of time spent pinning memory
/// until absolutely necessary. Might speed up the execution of COIBufferCreate
/// calls, but slow down the first access of the buffer in
/// COIPipelineRunFunction(s) or other COIBuffer access API's.
/// Also of important note, that with this flag enabled COI will not be able to
/// check to see if this memory is read only. Ordinarily this is checked
/// and an error is thrown upon buffer creation. With this flag, the error
/// might occur later, and cause undetermined behavior. Be sure to always
/// use writeable memory for COIBuffers.
#define COI_OPTIMIZE_NO_DMA 0x00000040
/// Hint to the runtime to try to use huge page sizes for backing store on the
/// sink. Is currently not compatible with PINNED buffers or the SAME_ADDRESS
/// flags or the SINK_MEMORY flag.
#define COI_OPTIMIZE_HUGE_PAGE_SIZE 0x00000080
/// Used to tell Intel(R) Coprocessor Offload Infrastructure (Intel(R) COI)
/// to create a buffer using memory that has already been
/// allocated on the sink. This flag is only valid when passed in to the
/// COIBufferCreateFromMemory API.
#define COI_SINK_MEMORY 0x00000100
//@}
#ifndef DOXYGEN_SHOULD_SKIP_THIS
// Make the flag mask
#ifdef F
#undef F
#endif
#define F 0
#ifdef T
#undef T
#endif
#define T 1
#define MTM(_BUFFER, B1, B2, B3, B4, B5, B6, B7, B8, B9) \
(B1 | B2<<1 | B3<<2 | B4<<3 | B5<<4 | B6<<5 | B7<<6 | B8<<7 | B9<<8)
#endif
/// \enum COI_BUFFER_TYPE
/// This matrix shows the valid combinations of buffer types and buffer flags
/// that may be passed in to COIBufferCreate and COIBufferCreateFromMemory.
/// \code
static const uint64_t
COI_VALID_BUFFER_TYPES_AND_FLAGS[COI_BUFFER_OPENCL+1] = {
/* | | SAME | | | | | | | |
| SAME | ADDR | OPT | OPT | OPT | OPT | OPT | HUGE | COI |
| ADDR | SINK | SRC | SRC | SINK | SINK | NO | PAGE | SINK |
| SINKS | SRC | READ | WRITE | READ | WRITE | DMA | SIZE | MEM |
+-------+------+------+-------+------+-------+-----+------+-----*/
MTM(INVALID , F , F , F , F , F , F , F , F , F ),
MTM(NORMAL , T , T , T , T , T , T , T , T , T ),
MTM(TO_SINK , F , F , F , T , T , T , F , F , F ),
MTM(TO_SOURCE, F , F , T , F , F , T , F , F , F ),
MTM(PINNED , T , T , T , T , T , T , F , F , F ),
MTM(OPENCL , T , T , T , T , T , T , T , T , F ),
};
///\endcode
#undef MTM
//////////////////////////////////////////////////////////////////////////////
/// These flags control how the buffer will be accessed on the source after
/// it is mapped.
/// Please see the COI_VALID_BUFFER_TYPES_AND_MAP matrix below for the
/// valid buffer type and map operation combinations.
typedef enum COI_MAP_TYPE
{
/// Allows the application to read and write the contents of the buffer
/// after it is mapped.
COI_MAP_READ_WRITE = 1,
/// If this flag is set then the application must only read from the
/// buffer after it is mapped. If the application writes to the buffer
/// the contents will not be reflected back to the sink or stored for
/// the next time the buffer is mapped on the source.
/// This allows the runtime to make significant performance optimizations
/// in buffer handling.
COI_MAP_READ_ONLY,
/// Setting this flag means that the source will overwrite the entire
/// buffer once it is mapped. The app must not read from the buffer and
/// must not expect the contents of the buffer to be synchronized from
/// the sink side during the map operation.
/// This allows the runtime to make significant performance optimizations
/// in buffer handling.
COI_MAP_WRITE_ENTIRE_BUFFER
} COI_MAP_TYPE;
#ifndef DOXYGEN_SHOULD_SKIP_THIS
// Make the flag mask
#define MMM(_BUFFER, B1, B2, B3) \
{ F , B1, B2, B3}
#endif
/// \enum COI_MAP_TYPE
/// This matrix shows the valid combinations of buffer types and map
/// operations that may be passed in to COIBufferMap.
/// \code
static const uint64_t
COI_VALID_BUFFER_TYPES_AND_MAP
[COI_BUFFER_OPENCL+1][COI_MAP_WRITE_ENTIRE_BUFFER+1] = {
/* | MAP | MAP | MAP |
| READ | READ | WRITE |
| WRITE | ONLY | ENTIRE|
+-------+-------+-------+*/
MMM(INVALID , F , F , F ),
MMM(NORMAL , T , T , T ),
MMM(STREAMING_TO_SINK , F , F , T ),
MMM(STREAMING_TO_SOURCE , F , T , F ),
MMM(PINNED , T , T , T ),
MMM(OPENCL , T , T , T ),
};
///\endcode
#undef MMM
#ifndef DOXYGEN_SHOULD_SKIP_THIS
#undef F
#undef T
#endif
//////////////////////////////////////////////////////////////////////////////
/// The valid copy operation types for the COIBufferWrite, COIBufferRead,
/// and COIBufferCopy APIs.
///
typedef enum COI_COPY_TYPE
{
/// The runtime can pick the best suitable way to copy the data.
COI_COPY_UNSPECIFIED = 0,
/// The runtime should use DMA to copy the data.
COI_COPY_USE_DMA,
/// The runtime should use a CPU copy to copy the data.
/// CPU copy is a synchronous copy. So the resulting operations are always
/// blocking (even though a out_pCompletion event is specified).
COI_COPY_USE_CPU
} COI_COPY_TYPE;
//////////////////////////////////////////////////////////////////////////////
/// The buffer states are used to indicate whether a buffer is available for
/// access in a COIPROCESS. This is used with COIBufferSetState.
///
/// Buffer state holds only for NORMAL Buffers and OPENCL buffers. Pinned
/// buffers are always valid everywhere they get created. Streaming buffers
/// do not follow the state transition rules, as a new version of the
/// buffer is created every time it is Mapped or you issue a RunFunction.
///
/// Rules on State Transition of the buffer:
/// -. When a Buffer is created by default it is valid only on the source,
/// except for buffers created with COI_SINK_MEMORY flag which are valid
/// only on the sink where the memory lies when created.
/// -. Apart from SetState following APIs also alters the state of the buffer
/// internally:
///
/// - COIBufferMap alters state of buffer depending on the COI_MAP_TYPE.
/// COI_MAP_READ_ONLY: Makes Valid on the Source. Doesn't affect the state
/// of the buffer on the other devices.
/// COI_MAP_READ_WRITE: Makes it Valid only the Source and Invalid
/// everywhere else. OPENCL buffers are invalidated
/// only if it is not in use.
/// COI_MAP_WRITE_ENTIRE_BUFFER: Makes it valid only on the Source. OPENCL
/// buffers are invalidated only if not in use.
///
/// - COIPipelineRunfunction alters the state of the buffer depending on the
/// COI_ACCESS_FLAGS
/// COI_SINK_READ: Makes it valid on the sink where RunFunction is being
/// issued. Doesn't affect the state of the buffer on other
/// devices.
/// COI_SINK_WRITE: Makes it valid only on the sink where Runfunction is
/// being issued and invalid everywhere else. OPENCL
/// buffers are invalidated only if the buffer is not in
/// use.
/// COI_SINK_WRITE_ENTIRE: Makes it valid only on the sink where
/// Runfunction is being issued and invalid everywhere else
/// OPENCL buffers are invalidated only if the buffer is
/// not in use.
///
/// - COIBufferWrite makes the buffer exclusively valid where the write
/// happens. Write gives preference to Source over Sink. In other words
/// if a buffer is valid on the Source and multiple Sinks, Write will
/// happen on the Source and will Invalidate all other Sinks. If the
/// buffer is valid on multiple Sinks ( and not on the Source) then
/// Intel® Coprocessor Offload Infrastructure (Intel® COI)
/// selects process handle with the lowest numerical value to do the
/// exclusive write Again, OPENCL buffers are invalidated only if the
/// buffer is not in use on that SINK/SOURCE.
///
/// The preference rule mentioned above holds true even for SetState API,
/// when data needs to be moved from a valid location. The selection of
/// valid location happens as stated above.
///
/// - It is possible to alter only parts of the buffer and change it state
/// In other words it is possible for different parts of the buffer to have
/// different states on different devices. A byte is the minimum size at
/// which state can be maintained internally. Granularity level is completely
/// determined by how the buffer gets fragmented.
///
/// Note: Buffer is considered 'in use' if is
/// - Being used in RunFunction : In use on a Sink
/// - Mapped: In use on a Source
/// - AddRef'd: In use on Sink
///
//////////////////////////////////////////////////////////////////////////////
/// The buffer states used with COIBufferSetState call to indicate the new
/// state of the buffer on a given process
///
typedef enum {
COI_BUFFER_VALID = 0, // Buffer is valid and up-to-date on the process
COI_BUFFER_INVALID , // Buffer is not valid, need valid data
COI_BUFFER_VALID_MAY_DROP, // Same as valid but will drop the content when
// evicted to avoid overwriting the shadow
// memory
COI_BUFFER_RESERVED // Reserved for internal use
} COI_BUFFER_STATE;
///
/// Note: A VALID_MAY_DROP declares a buffer's copy as secondary on a given
/// process. This means that there needs to be at least one primary copy of the
/// the buffer somewhere in order to mark the buffer as VALID_MAY_DROP on a
/// process. In other words to make a buffer VALID_MAY_DROP on a given process
/// it needs to be in COI_BUFFER_VALID state somewhere else. The operation gets
/// ignored (or is a nop) if there is no primary copy of the buffer. The nature
/// of this state to "drop the content" when evicted is a side effect of
/// marking the buffer as secondary copy. So when a buffer marked
/// VALID_MAY_DROP is evicted Intel® Coprocessor Offload Infrastructure
/// (Intel® COI) doesn't back it up as it is assumed that
/// there is a primary copy somewhere.
//////////////////////////////////////////////////////////////////////////////
/// The buffer move flags are used to indicate when a buffer should be moved
/// when it's state is changed. This is used with COIBufferSetState.
typedef enum {
COI_BUFFER_MOVE = 0,// Dirty data is moved if state change requires it
COI_BUFFER_NO_MOVE // Change state without moving data
} COI_BUFFER_MOVE_FLAG;
// A process handle for COIBufferSetState call to indicate all the sink
// processes where the given buffer is valid
#define COI_SINK_OWNERS ((COIPROCESS)-2)
//////////////////////////////////////////////////////////////////////////////
///
/// Creates a buffer that can be used in RunFunctions that are queued in
/// pipelines. The address space for the buffer is reserved when it is
/// created although the memory may not be committed until the buffer is
/// used for the first time. Please note that the Intel® Coprocessor Offload
/// Infrastructure (Intel® COI) runtime may also
/// allocate space for the source process to use as shadow memory for
/// certain types of buffers. If Intel® Coprocessor Offload Infrastructure
/// (Intel® COI) does allocate this memory it will not
/// be released or reallocated until the COIBuffer is destroyed.
///
/// @param in_Size
/// [in] The number of bytes to allocate for the buffer. If in_Size
/// is not page aligned, it will be rounded up.
///
/// @param in_Type
/// [in] The type of the buffer to create.
///
/// @param in_Flags
/// [in] A bitmask of attributes for the newly created buffer.
/// Some of these flags are required for correctness while others
/// are provided as hints to the runtime system so it can make
/// certain performance optimizations.
///
/// @param in_pInitData
/// [in] If non-NULL the buffer will be initialized with the data
/// pointed to by pInitData. The memory at in_pInitData must hold
/// at least in_Size bytes.
///
/// @param in_NumProcesses
/// [in] The number of processes with which this buffer might be used.
///
/// @param in_pProcesses
/// [in] An array of COIPROCESS handles identifying the processes with
/// which this buffer might be used.
///
/// @param out_pBuffer
/// [out] Pointer to a buffer handle. The handle will be filled in
/// with a value that uniquely identifies the newly created buffer.
/// This handle should be disposed of via COIBufferDestroy()
/// once it is no longer needed.
///
/// @return COI_SUCCESS if the buffer was created
///
/// @return COI_ARGUMENT_MISMATCH if the in_Type and in_Flags parameters
/// are not compatible with one another. Please see the
/// COI_VALID_BUFFER_TYPES_AND_FLAGS map above for information about
/// which flags and types are compatible.
///
/// @return COI_OUT_OF_RANGE if in_Size is zero, if the bits set in
/// the in_Flags parameter are not recognized flags, or if
/// in_NumProcesses is zero.
///
/// @return COI_INVALID_POINTER if the in_pProcesses or out_pBuffer parameter
/// is NULL.
///
/// @return COI_NOT_SUPPORTED if one of the in_Flags is COI_SINK_MEMORY.
///
/// @return COI_NOT_SUPPORTED if the flags include either
/// COI_SAME_ADDRESS_SINKS or COI_SAME_ADDRESS_SINKS_AND_SOURCE and
/// COI_OPTIMIZE_HUGE_PAGE_SIZE.
///
/// @return COI_INVALID_HANDLE if one of the COIPROCESS handles in the
/// in_pProcesses array does not identify a valid process.
///
/// @return COI_OUT_OF_MEMORY if allocating the buffer fails.
///
/// @return COI_RESOURCE_EXHAUSTED if the sink is out of buffer memory.
///
COIACCESSAPI
COIRESULT
COIBufferCreate(
uint64_t in_Size,
COI_BUFFER_TYPE in_Type,
uint32_t in_Flags,
const void* in_pInitData,
uint32_t in_NumProcesses,
const COIPROCESS* in_pProcesses,
COIBUFFER* out_pBuffer);
//////////////////////////////////////////////////////////////////////////////
///
/// Creates a buffer from some existing memory that can be used in
/// RunFunctions that are queued in pipelines. If the flag COI_SINK_MEMORY
/// is specified then Intel® Coprocessor Offload I
/// nfrastructure (Intel® COI) will use that memory for the buffer on the sink.
/// If that flag isn't set then the memory provided is used as backing store
/// for the buffer on the source. In either case the memory must not be freed
/// before the buffer is destroyed.
/// While the user still owns the memory passed in they must use the
/// appropriate access flags when accessing the buffer in COIPipelinRunFunction
/// or COIBufferMap calls so that the runtime knows when the
/// memory has been modified. If the user just writes directly to the memory
/// location then those changes may not be visible when the corresponding
/// buffer is accessed.
/// Whatever values are already present in the memory location when this call
/// is made are preserved. The memory values are also preserved when
/// COIBufferDestroy is called.
///
/// @warning: Use of this function is highly discouraged if the calling program
/// program forks at all (including calls to system(3), popen(3), or similar
/// functions) during the life of this buffer. See the discussion around the
/// in_Memory parameter below regarding this.
///
/// @param in_Size
/// [in] The size of in_Memory in bytes. If in_Size
/// is not page aligned, it will be rounded up.
///
/// @param in_Type
/// [in] The type of the buffer to create. Note that streaming buffers
/// can not be created from user memory. Only COI_BUFFER_NORMAL and
/// COI_BUFFER_PINNED buffer types are supported.
///
/// @param in_Flags
/// [in] A bitmask of attributes for the newly created buffer.
/// Some of these flags are required for correctness while others
/// are provided as hints to the runtime system so it can make
/// certain performance optimizations. Note that the flag
/// COI_SAME_ADDRESS_SINKS_AND_SOURCE is still valid but may fail
/// if the same address as in_Memory can not be allocated on the sink.
///
/// @param in_Memory
/// [in] A pointer to an already allocated memory region
/// that should be turned into a COIBUFFER. Although the user still
/// owns this memory they should not free it before calling
/// COIBufferDestroy. They must also only access the memory using
/// COIBUFFER semantics, for example using COIBufferMap/COIBufferUnmap
/// when they wish to read or write the data. There are no alignment
/// or size requirements for this memory region.
///
/// WARNING:
/// Since the backing memory passed in can be the target of a DMA
/// the caller must ensure that there is no call to clone(2) (without
/// the CLONE_VM argument) during the life of this buffer. This
/// includes higher level functions that call clone such as fork(2),
/// system(3), popen(3), among others).
///
/// For forked processes, Linux uses copy-on-write semantics for
/// performances reasons. Conseqeuently, if the parent forks and then
/// writes to this memory, the physical page mapping changes causing
/// the DMA to fail (and thus data corruption).
///
/// In Linux you can mark a set of pages to not be copied across
/// across the clone by calling madvise(2) with an argument of
/// MADV_DONTFORK and then safely use that memory in this scenario.
/// Alternately, if the memory is from a region marked MAP_SHARED,
/// this will work.
///
/// @param in_NumProcesses
/// [in] The number of processes with which this buffer might be used.
/// If the flag COI_SINK_MEMORY is specified then this must be 1.
///
/// @param in_pProcesses
/// [in] An array of COIPROCESS handles identifying the processes with
/// which this buffer might be used.
///
/// @param out_pBuffer
/// [out] Pointer to a buffer handle. The handle will be filled in
/// with a value that uniquely identifies the newly created buffer.
/// This handle should be disposed of via COIBufferDestroy()
/// once it is no longer needed.
///
/// @return COI_SUCCESS if the buffer was created
///
/// @return COI_NOT_SUPPORTED if the in_Type value is not COI_BUFFER_NORMAL or
/// COI_BUFFER_PINNED.
///
/// @return COI_NOT_SUPPORTED if in_Memory is read-only memory
///
/// @return COI_NOT_SUPPORTED if one of the in_Flags is COI_SINK_MEMORY and
/// in_Type is not COI_BUFFER_NORMAL
///
/// @return COI_NOT_SUPPORTED if the flag COI_SAME_ADDRESS_SINKS is set
///
/// @return COI_NOT_SUPPORTED if the flag COI_SAME_ADDRESS_SINKS_AND_SOURCE is
/// set
///
/// @return COI_ARGUMENT_MISMATCH if the in_Type and in_Flags parameters
/// are not compatible with one another. Please see the
/// COI_VALID_BUFFER_TYPES_AND_FLAGS map above for information about
/// which flags and types are compatible.
///
/// @return COI_ARGUMENT_MISMATCH if the flag COI_SINK_MEMORY is specified and
/// in_NumProcesses > 1.
///
/// @return COI_ARGUMENT_MISMATCH if the flags COI_SINK_MEMORY and
/// COI_OPTIMIZE_HUGE_PAGE_SIZE are both set.
///
/// @return COI_OUT_OF_RANGE if in_Size is zero, if the bits set in
/// the in_Flags parameter are not recognized flags, or if
/// in_NumProcesses is zero.
///
/// @return COI_INVALID_POINTER if in_Memory, in_pProcesses or
/// out_pBuffer parameter is NULL.
///
/// @return COI_INVALID_HANDLE if one of the COIPROCESS handles in the
/// in_pProcesses array does not identify a valid process.
///
COIACCESSAPI
COIRESULT
COIBufferCreateFromMemory(
uint64_t in_Size,
COI_BUFFER_TYPE in_Type,
uint32_t in_Flags,
void* in_Memory,
uint32_t in_NumProcesses,
const COIPROCESS* in_pProcesses,
COIBUFFER* out_pBuffer);
//////////////////////////////////////////////////////////////////////////////
///
/// Destroys a buffer. Will block on completion of any operations on the
/// buffer, such as COIPipelineRunFunction or COIBufferCopy. Will block until
/// all COIBufferAddRef calls have had a matching COIBufferReleaseRef call
/// made. Will not block on an outstanding COIBufferUnmap but will instead
/// return COI_RETRY.
///
/// @param in_Buffer
/// [in] Handle of the buffer to destroy.
///
/// @return COI_SUCCESS if the buffer was destroyed.
///
/// @return COI_INVALID_HANDLE if the buffer handle was invalid.
///
/// @return COI_RETRY if the buffer is currently mapped. The buffer must
/// first be unmapped before it can be destroyed.
///
/// @return COI_RETRY if the sub-buffers created from this buffer are not yet
/// destroyed
///
COIACCESSAPI
COIRESULT
COIBufferDestroy(
COIBUFFER in_Buffer);
//////////////////////////////////////////////////////////////////////////////
///
/// This call initiates a request to access a region of a buffer. Multiple
/// overlapping (or non overlapping) regions can be mapped simultaneously for
/// any given buffer. If a completion event is specified this call will
/// queue a request for the data which will be satisfied when the buffer is
/// available. Once all conditions are met the completion event will be
/// signaled and the user can access the data at out_ppData. The user can call
/// COIEventWait with out_pCompletion to find out when the map operation has
/// completed. If the user accesses the data before the map operation is
/// complete the results are undefined. If out_pCompletion is NULL then this
/// call blocks until the map operation completes and when this call returns
/// out_ppData can be safely accessed. This call returns a map instance handle
/// in an out parameter which must be passed into COIBufferUnmap when the user
/// no longer needs access to that region of the buffer.
///
/// The address returned from COIBufferMap may point to memory that
/// Intel® Coprocessor Offload Infrastructure (Intel® COI)
/// manages on behalf of the user. The user must not free or reallocate this
/// memory, Intel® Coprocessor Offload Infrastructure (Intel® COI)
/// will perform any necessary cleanup when the buffer is
/// destroyed.
///
/// Note that different types of buffers behave differently when mapped.
/// For instance, mapping a COI_BUFFER_NORMAL for write must stall if the
/// buffer is currently being written to by a run function. Mapping a
/// COI_BUFFER_STREAMING_TO_SINK will create a new physical copy of the buffer
/// and make it available immediately. Mapping a COI_BUFFER_PINNED buffer will
/// not affect other functions that use that buffer since a COI_BUFFER_PINNED
/// buffer can be mapped at any time.
/// The asynchronous operation of COIBufferMap will likely be most useful when
/// paired with a COI_BUFFER_NORMAL.
///
/// @param in_Buffer
/// [in] Handle for the buffer to map.
///
/// @param in_Offset
/// [in] Offset into the buffer that a pointer should be returned
/// for. The value 0 can be passed in to signify that the mapped
/// region should start at the beginning of the buffer.
///
/// @param in_Length
/// [in] Length of the buffer area to map. This parameter, in
/// combination with in_Offset, allows the caller to specify
/// that only a subset of an entire buffer need be mapped. A
/// value of 0 can be passed in only if in_Offset is 0, to signify
/// that the mapped region is the entire buffer.
///
/// @param in_Type
/// [in] The access type that is needed by the application. This will
/// affect how the data can be accessed once the map operation
/// completes. See the COI_MAP_TYPE enum for more details.
///
/// @param in_NumDependencies
/// [in] The number of dependencies specified in the in_pDependencies
/// array. This may be 0 if the caller does not want the map
/// call initiation to wait for any events to be signaled before
/// starting the map operations.
///
/// @param in_pDependencies
/// [in] An optional array of handles to previously created COIEVENT
/// objects that this map operation will wait for before starting.
/// This allows the user to create dependencies between asynchronous
/// map calls and other operations such as run functions or other
/// asynchronous map calls. The user may pass in NULL if they do not
/// wish to wait for any dependencies to complete before initiating map
/// operations.
///
/// @param out_pCompletion
/// [out] An optional pointer to a COIEVENT object
/// that will be signaled when a map call with the passed in buffer
/// would complete immediately, that is, the buffer memory has been
/// allocated on the source and its contents updated. The user may pass
/// in NULL if the user wants COIBufferMap to perform a blocking map
/// operation.
///
/// @param out_pMapInstance
/// [out] A pointer to a COIMAPINSTANCE which represents this mapping
/// of the buffer and must be passed in to COIBufferUnmap when access
/// to this region of the buffer data is no longer needed.
///
/// @param out_ppData
/// [out] Pointer to the buffer data. The data will only be valid
/// when the completion object is signaled, or for a synchronous
/// map operation with the call to map returns.
///
///
/// @return COI_SUCCESS if the map request succeeds.
///
/// @return COI_OUT_OF_RANGE if in_Offset of (in_Offset + in_Length) exceeds
/// the size of the buffer.
///
/// @return COI_OUT_OF_RANGE if in_Length is 0, but in_Offset is not 0.
///
/// @return COI_OUT_OF_RANGE if in_Type is not a valid COI_MAP_TYPE.
///
/// @return COI_ARGUMENT_MISMATCH if in_NumDependencies is non-zero while
/// in_pDependencies was passed in as NULL.
///
/// @return COI_ARGUMENT_MISMATCH if in_pDependencies is non-NULL but
/// in_NumDependencies is zero.
///
/// @return COI_ARGUMENT_MISMATCH if the in_Type of map is not a valid type
/// for in_Buffer's type of buffer.
///
/// @return COI_RESOURCE_EXHAUSTED if could not create a version for TO_SINK
/// streaming buffer. It can fail if enough memory is not available to
/// register. This call will succeed eventually when the registered
/// memory becomes available.
///
/// @return COI_INVALID_HANDLE if in_Buffer is not a valid buffer handle.
///
/// @return COI_INVALID_POINTER if out_pMapInstance or out_ppData is NULL.
///
COIACCESSAPI
COIRESULT
COIBufferMap(
COIBUFFER in_Buffer,
uint64_t in_Offset,
uint64_t in_Length,
COI_MAP_TYPE in_Type,
uint32_t in_NumDependencies,
const COIEVENT* in_pDependencies,
COIEVENT* out_pCompletion,
COIMAPINSTANCE* out_pMapInstance,
void** out_ppData);
//////////////////////////////////////////////////////////////////////////////
///
/// Disables Source access to the region of the buffer that was provided
/// through the corresponding call to COIBufferMap. The number of calls to
/// COIBufferUnmap() should always match the number of calls made to
/// COIBufferMap(). The data pointer returned from the COIBufferMap() call
/// will be invalid after this call.
///
/// @param in_MapInstance
/// [in] buffer map instance handle to unmap.
///
/// @param in_NumDependencies
/// [in] The number of dependencies specified in the in_pDependencies
/// array. This may be 0 if the caller does not want the unmap call to
/// wait for any events to be signaled before performing the unmap
/// operation.
///
/// @param in_pDependencies
/// [in] An optional array of handles to previously created COIEVENT
/// objects that this unmap operation will wait for before starting.
/// This allows the user to create dependencies between asynchronous
/// unmap calls and other operations such as run functions or other
/// asynchronous unmap calls. The user may pass in NULL if they do not
/// wish to wait for any dependencies to complete before initiating
/// unmap operations.
///
/// @param out_pCompletion
/// [out] An optional pointer to a COIEVENT object that will be
/// signaled when the unmap is complete. The user may pass in NULL if
/// the user wants COIBufferUnmap to perform a blocking unmap
/// operation.
///
/// @return COI_SUCCESS upon successful unmapping of the buffer instance.
///
/// @return COI_INVALID_HANDLE if the passed in map instance handle was NULL.
///
/// @return COI_ARGUMENT_MISMATCH if the in_pDependencies is non NULL but
/// in_NumDependencies is 0.
///
/// @return COI_ARGUMENT_MISMATCH if in_pDependencies is NULL but
/// in_NumDependencies is not 0.
///
COIACCESSAPI
COIRESULT
COIBufferUnmap(
COIMAPINSTANCE in_MapInstance,
uint32_t in_NumDependencies,
const COIEVENT* in_pDependencies,
COIEVENT* out_pCompletion);
//////////////////////////////////////////////////////////////////////////////
///
/// Gets the Sink's virtual address of the buffer. This is the same
/// address that is passed to the run function on the Sink. The virtual
/// address assigned to the buffer for use on the sink is fixed;
/// the buffer will always be present at that virtual address on the sink
/// and will not get a different virtual address across different
/// RunFunctions.
/// This address is only valid on the Sink and should not be dereferenced on
/// the Source (except for the special case of buffers created with the
/// COI_SAME_ADDRESS flag).
///
/// @param in_Buffer
/// [in] Buffer handle
///
/// @param out_pAddress
/// [out] pointer to a uint64_t* that will be filled with the address.
///
/// @return COI_SUCCESS upon successful return of the buffer's address.
///
/// @return COI_INVALID_HANDLE if the passed in buffer handle was invalid.
///
/// @return COI_INVALID_POINTER if the out_pAddress parameter was invalid.
///
/// @return COI_NOT_SUPPORTED if the buffer passed in is of type
/// COI_BUFFER_STREAMING_TO_SOURCE or COI_BUFFER_STREAMING_TO_SINK.
///
COIACCESSAPI
COIRESULT
COIBufferGetSinkAddress(
COIBUFFER in_Buffer,
uint64_t* out_pAddress);
//////////////////////////////////////////////////////////////////////////////
///
/// Copy data from a normal virtual address into an existing COIBUFFER.
/// Note that it is not possible to use this API with any type of
/// Intel® Coprocessor Offload Infrastructure (Intel® COI) Streaming Buffers.
/// Please note that COIBufferWrite does not follow implicit buffer
/// dependencies. If a buffer is in use in a run function or has been added
/// to a process using COIBufferAddRef the call to COIBufferWrite will not
/// wait, it will still copy data immediately.
/// This is to facilitate a usage model where a buffer is being used outside
/// of a run function, for example in a spawned thread, but data still needs
/// to be transferred to or from the buffer.
///
/// @param in_DestBuffer
/// [in] Buffer to write into.
///
#ifdef COI_PROTOTYPE_TARGET_PROCESS
/// @param in_DestProcess
/// [in] A pointer to the processes which are used as hints
/// to to COI. Buffers are updated upon these processes first.
/// Can be left NULL and default behavior will be chosen, which
/// chooses the lowest SCIF node with an active regions first. Others
/// buffer regions are invalidated in both cases. Will only update a single
/// process at this time.
#endif
///
/// @param in_Offset
/// [in] Location in the buffer to start writing to.
///
/// @param in_pSourceData
/// [in] A pointer to local memory that should be copied into the
/// provided buffer.
///
/// @param in_Length
/// [in] The number of bytes to write from in_pSourceData into
/// in_DestBuffer. Must not be larger than the size of in_DestBuffer
/// and must not over run in_DestBuffer if an in_Offset is provided.
///
/// @param in_Type
/// [in] The type of copy operation to use, one of either
/// COI_COPY_UNSPECIFIED, COI_COPY_USE_DMA, COI_COPY_USE_CPU.
///
/// @param in_NumDependencies
/// [in] The number of dependencies specified in the in_pDependencies
/// array. This may be 0 if the caller does not want the write call to
/// wait for any additional events to be signaled before starting the
/// write operation.
///
/// @param in_pDependencies
/// [in] An optional array of handles to previously created COIEVENT
/// objects that this write operation will wait for before starting.
/// This allows the user to create dependencies between buffer write
/// calls and other operations such as run functions and map calls. The
/// user may pass in NULL if they do not wish to wait for any
/// additional dependencies to complete before doing the write.
///
/// @param out_pCompletion
/// [out] An optional event to be signaled when the write has
/// completed. This event can be used as a dependency to order
/// the write with regard to future operations.
/// If no completion event is passed in then the write is
/// synchronous and will block until the transfer is complete.
///
///
/// @return COI_SUCCESS if the buffer was copied successfully.
///
/// @return COI_INVALID_HANDLE if the buffer handle was invalid.
///
/// @return COI_OUT_OF_RANGE if in_Offset is beyond the end of the buffer.
///
/// @return COI_ARGUMENT_MISMATCH if the in_pDependencies is non NULL but
/// in_NumDependencies is 0.
///
/// @return COI_ARGUMENT_MISMATCH if in_pDependencies is NULL but
/// in_NumDependencies is not 0.
///
/// @return COI_NOT_SUPPORTED if the source buffer is of type
/// COI_BUFFER_STREAMING_TO_SINK or COI_BUFFER_STREAMING_TO_SOURCE.
///
/// @return COI_INVALID_POINTER if the in_pSourceData pointer is NULL.
///
/// @return COI_OUT_OF_RANGE if in_Offset + in_Length exceeds the size of
/// the buffer.
///
/// @return COI_OUT_OF_RANGE if in_Length is 0.
///
/// @return COI_RETRY if in_DestBuffer is mapped and is not a COI_BUFFER_PINNED
/// buffer or COI_BUFFER_OPENCL buffer.
///
#ifdef COI_PROTOTYPE_TARGET_PROCESS
COIACCESSAPI
COIRESULT
COIBufferWrite(
COIBUFFER in_DestBuffer,
const COIPROCESS in_DestProcess,
uint64_t in_Offset,
const void* in_pSourceData,
uint64_t in_Length,
COI_COPY_TYPE in_Type,
uint32_t in_NumDependencies,
const COIEVENT* in_pDependencies,
COIEVENT* out_pCompletion);
__asm__(".symver COIBufferWrite,COIBufferWrite@COI_2.0");
#else
COIACCESSAPI
COIRESULT
COIBufferWrite(
COIBUFFER in_DestBuffer,
uint64_t in_Offset,
const void* in_pSourceData,
uint64_t in_Length,
COI_COPY_TYPE in_Type,
uint32_t in_NumDependencies,
const COIEVENT* in_pDependencies,
COIEVENT* out_pCompletion);
__asm__(".symver COIBufferWrite,COIBufferWrite@COI_1.0");
#endif
//////////////////////////////////////////////////////////////////////////////
///
/// Copy data from a buffer into local memory.
/// Note that it is not possible to use this API with any type of
/// Intel® Coprocessor Offload Infrastructure (Intel® COI) Streaming Buffers.
/// Please note that COIBufferRead does not follow implicit buffer
/// dependencies. If a buffer is in use in a run function or has been added
/// to a process using COIBufferAddRef the call to COIBufferRead will not
/// wait, it will still copy data immediately.
/// This is to facilitate a usage model where a buffer is being used outside
/// of a run function, for example in a spawned thread, but data still needs
/// to be transferred to or from the buffer.
///
///
/// @param in_SourceBuffer
/// [in] Buffer to read from.
///
/// @param in_Offset
/// [in] Location in the buffer to start reading from.
///
/// @param in_pDestData
/// [in] A pointer to local memory that should be written into from
/// the provided buffer.
///
/// @param in_Length
/// [in] The number of bytes to write from in_SourceBuffer into
/// in_pDestData. Must not be larger than the size of in_SourceBuffer
/// and must not over run in_SourceBuffer if an in_Offset is provided.
///
/// @param in_Type
/// [in] The type of copy operation to use, one of either
/// COI_COPY_UNSPECIFIED, COI_COPY_USE_DMA, COI_COPY_USE_CPU.
///
/// @param in_NumDependencies
/// [in] The number of dependencies specified in the in_pDependencies
/// array. This may be 0 if the caller does not want the read call to
/// wait for any additional events to be signaled before starting the
/// read operation.
///
/// @param in_pDependencies
/// [in] An optional array of handles to previously created COIEVENT
/// objects that this read operation will wait for before starting.
/// This allows the user to create dependencies between buffer read
/// calls and other operations such as run functions and map calls. The
/// user may pass in NULL if they do not wish to wait for any
/// additional dependencies to complete before doing the read.
///
/// @param out_pCompletion
/// [out] An optional event to be signaled when the read has
/// completed. This event can be used as a dependency to order
/// the read with regard to future operations.
/// If no completion event is passed in then the read is
/// synchronous and will block until the transfer is complete.
///
/// @return COI_SUCCESS if the buffer was copied successfully.
///
/// @return COI_INVALID_HANDLE if the buffer handle was invalid.
///
/// @return COI_OUT_OF_RANGE if in_Offset is beyond the end of the buffer.
///
/// @return COI_ARGUMENT_MISMATCH if the in_pDependencies is non NULL but
/// in_NumDependencies is 0.
///
/// @return COI_ARGUMENT_MISMATCH if in_pDependencies is NULL but
/// in_NumDependencies is not 0.
///
/// @return COI_NOT_SUPPORTED if the source buffer is of type
/// COI_BUFFER_STREAMING_TO_SINK or COI_BUFFER_STREAMING_TO_SOURCE.
///
/// @return COI_OUT_OF_RANGE if in_Offset + in_Length exceeds the size of
/// the buffer.
///
/// @return COI_OUT_OF_RANGE if in_Length is 0.
///
/// @return COI_INVALID_POINTER if the in_pDestData pointer is NULL.
///
/// @return COI_RETRY if in_SourceBuffer is mapped and is not a
/// COI_BUFFER_PINNED buffer or COI_BUFFER_OPENCL buffer.
///
COIACCESSAPI
COIRESULT
COIBufferRead(
COIBUFFER in_SourceBuffer,
uint64_t in_Offset,
void* in_pDestData,
uint64_t in_Length,
COI_COPY_TYPE in_Type,
uint32_t in_NumDependencies,
const COIEVENT* in_pDependencies,
COIEVENT* out_pCompletion);
//////////////////////////////////////////////////////////////////////////////
///
/// Copy data between two buffers. It also allows copying within the same
/// buffer. For copy within the same buffer, if source and destination regions
/// overlap then this API returns error.
/// Note that it is not possible to use this API with any type of
/// Intel® Coprocessor Offload Infrastructure (Intel® COI) Streaming Buffers.
/// Please note that COIBufferCopy does not follow implicit buffer
/// dependencies. If a buffer is in use in a run function or has been added
/// to a process using COIBufferAddRef the call to COIBufferCopy will not
/// wait, it will still copy data immediately.
/// This is to facilitate a usage model where a buffer is being used outside
/// of a run function, for example in a spawned thread, but data still needs
/// to be transferred to or from the buffer.
///
/// @param in_DestBuffer
/// [in] Buffer to copy into.
#ifdef COI_PROTOTYPE_TARGET_PROCESS
/// @param in_DestProcess
/// [in] A pointer to the processes which are used as hints
/// to to COI. Buffers are updated upon these processes first.
/// Can be left NULL and default behavior will be chosen, which
/// chooses the lowest SCIF node with an active regions first. Others
/// buffer regions are invalidated in both cases. Will only update a single
/// process at this time.
#endif
///
/// @param in_SourceBuffer
/// [in] Buffer to copy from.
///
/// @param in_DestOffset
/// [in] Location in the destination buffer to start writing to.
///
/// @param in_SourceOffset
/// [in] Location in the source buffer to start reading from.
///
/// @param in_Length
/// [in] The number of bytes to copy from in_SourceBuffer into
/// in_DestinationBuffer.
/// If the length is specified as zero then length to be copied
// is entire destination buffer's length.
/// Must not be larger than the size of in_SourceBuffer or
/// in_DestBuffer and must not over run in_SourceBuffer or
/// in_DestBuffer if offsets are specified.
///
/// @param in_Type
/// [in] The type of copy operation to use, one of either
/// COI_COPY_UNSPECIFIED, COI_COPY_USE_DMA, COI_COPY_USE_CPU.
///
/// @param in_NumDependencies
/// [in] The number of dependencies specified in the in_pDependencies
/// array. This may be 0 if the caller does not want the copy call to
/// wait for any additional events to be signaled before starting the
/// copy operation.
///
/// @param in_pDependencies
/// [in] An optional array of handles to previously created COIEVENT
/// objects that this copy operation will wait for before starting.
/// This allows the user to create dependencies between buffer copy
/// calls and other operations such as run functions and map calls. The
/// user may pass in NULL if they do not wish to wait for any
/// additional dependencies to complete before doing the copy.
///
/// @param out_pCompletion
/// [out] An optional event to be signaled when the copy has
/// completed. This event can be used as a dependency to order
/// the copy with regard to future operations.
/// If no completion event is passed in then the copy is
/// synchronous and will block until the transfer is complete.
///
/// @return COI_SUCCESS if the buffer was copied successfully.
///
/// @return COI_INVALID_HANDLE if either buffer handle was invalid.
///
/// @return COI_MEMORY_OVERLAP if in_SourceBuffer and in_DestBuffer are the
/// same buffer(or have the same parent buffer) and the source and
/// destination regions overlap
///
/// @return COI_OUT_OF_RANGE if in_DestOffset is is beyond the end of
/// in_DestBuffer
///
/// @return COI_OUT_OF_RANGE if in_SourceOffset is beyond the end of
/// in_SourceBuffer.
///
/// @return COI_OUT_OF_RANGE if in_DestOffset + in_Length exceeds the size of
/// the in_DestBuffer
///
/// @return COI_OUT_OF_RANGE if in_SourceOffset + in_Length exceeds
/// the size of in_SourceBuffer.
///
/// @return COI_ARGUMENT_MISMATCH if the in_pDependencies is non NULL but
/// in_NumDependencies is 0.
///
/// @return COI_ARGUMENT_MISMATCH if in_pDependencies is NULL but
/// in_NumDependencies is not 0.
///
/// @return COI_NOT_SUPPORTED if the source or destination buffers are of type
/// COI_BUFFER_STREAMING_TO_SINK or COI_BUFFER_STREAMING_TO_SOURCE.
///
/// @return COI_NOT_SUPPORTED if either buffer is of type
/// COI_BUFFER_STREAMING_TO_SINK or COI_BUFFER_STREAMING_TO_SOURCE.
///
/// @return COI_RETRY if in_DestBuffer or in_SourceBuffer are mapped and not
/// COI_BUFFER_PINNED buffers or COI_BUFFER_OPENCL buffers.
///
#ifdef COI_PROTOTYPE_TARGET_PROCESS
COIACCESSAPI
COIRESULT
COIBufferCopy(
COIBUFFER in_DestBuffer,
const COIPROCESS in_DestProcess,
COIBUFFER in_SourceBuffer,
uint64_t in_DestOffset,
uint64_t in_SourceOffset,
uint64_t in_Length,
COI_COPY_TYPE in_Type,
uint32_t in_NumDependencies,
const COIEVENT* in_pDependencies,
COIEVENT* out_pCompletion);
__asm__(".symver COIBufferCopy,COIBufferCopy@COI_2.0");
#else
COIACCESSAPI
COIRESULT
COIBufferCopy(
COIBUFFER in_DestBuffer,
COIBUFFER in_SourceBuffer,
uint64_t in_DestOffset,
uint64_t in_SourceOffset,
uint64_t in_Length,
COI_COPY_TYPE in_Type,
uint32_t in_NumDependencies,
const COIEVENT* in_pDependencies,
COIEVENT* out_pCompletion);
__asm__(".symver COIBufferCopy,COIBufferCopy@COI_1.0");
#endif
//////////////////////////////////////////////////////////////////////////////
///
/// This API allows an experienced Intel® Coprocessor Offload Infrastructure
/// (Intel® COI) developer to set where a COIBUFFER is
/// located and when the COIBUFFER's data is moved. This functionality is
/// useful when the developer knows when and where a buffer is going to be
/// accessed. It allows the data movement to happen sooner than if the
/// Intel® Coprocessor Offload Infrastructure (Intel® COI)
/// runtime tried to manage the buffer placement itself. The advantage of
/// this API is that the developer knows much more about their own
/// application's data access patterns and can therefore optimize the data
/// access to be much more efficient than the Intel® Coprocessor Offload
/// Infrastructure (Intel® COI) runtime. Using this API may yield better
/// memory utilization, lower latency and overall improved workload
/// throughput.
/// This API does respect implicit dependencies for buffer read/write hazards.
/// For example, if the buffer is being written in one COIPROCESS and the user
/// requests the buffer be placed in another COIPROCESS then this API will wait
/// for the first access to complete before moving the buffer.
/// This API is not required for program correctness. It is intended solely
/// for advanced Intel® Coprocessor Offload Infrastructure (Intel® COI)
/// developers who wish to fine tune their application performance
/// Cases where "a change in state" is an error condition the change just gets
/// ignored without any error. This is because the SetState can be a
/// nonblocking call and in such cases we can't rely on the state of the buffer
/// at the time of the call. We can do the transition checks only at the time
/// when the actual state change happens (which is something in future).
/// Currently there is no way to report an error from something that happens in
/// future and that is why such state transitions are nop. One example is using
/// VALID_MAY_DROP with COI_SINK_OWNERS when buffer is not valid at source.
/// This operation will be a nop if at the time of actual state change the
/// buffer is not valid at source.
///
/// @param in_Buffer
/// [in] The buffer to modify.
///
/// @param in_Process
/// [in] The process where the state is being modified for this
/// buffer. To modify buffer's state on source process use
/// COI_PROCESS_SOURCE as process handle. To modify buffer's
/// state on all processes where buffer is valid use COI_SINK_OWNERS
/// as the process handle.
///
/// @param in_State
/// [in] The new state for the buffer. The buffer's state could be
/// set to invalid on one of the sink processes where it is being
/// used.
///
/// @param in_DataMove
/// [in] A flag to indicate if the buffer's data should be moved
/// when the state is changed. For instance, a buffer's state may
/// be set to valid on a process and the data move flag may be set to
/// COI_BUFFER_MOVE which would cause the buffer contents to be
/// copied to the process where it is now valid.
///
/// @param in_NumDependencies
/// [in] The number of dependencies specified in the in_pDependencies
/// array. This may be 0 if the caller does not want the SetState call
/// to wait for any additional events to be signaled before starting
/// this operation.
///
/// @param in_pDependencies
/// [in] An optional array of handles to previously created COIEVENT
/// objects that this SetState operation will wait for before starting
/// This allows the user to create dependencies between buffer
/// SetState calls and other operations such as run functions and map
/// calls. The user may pass in NULL if they do not wish to wait for
/// any additional dependencies to complete before doing the SetState
///
/// @param out_pCompletion
/// [out] An optional event to be signaled when the SetState has
/// completed. This event can be used as a dependency to order
/// the SetState with regard to future operations.
/// If no completion event is passed in then the is
/// synchronous and will block until the SetState and dma transfers
/// related to this operation are complete.
///
/// @return COI_SUCCESS if the buffer's state was changed successfully.
///
/// @return COI_INVALID_HANDLE if in_Buffer or in_Process is invalid.
///
/// @return COI_NOT_SUPPORTED if the in_Buffer is of any type other than
/// COI_BUFFER_NORMAL or COI_BUFFER_OPENCL.
///
/// @return COI_ARGUMENT_MISMATCH if the in_State is COI_BUFFER_VALID_MAY_DROP
/// and the in_Process is COI_PROCESS_SOURCE.
///
/// @return COI_ARGUMENT_MISMATCH if the in_Process is COI_SINK_OWNERS and the
/// COI_BUFFER_MOVE is passed as move flag.
///
/// @return COI_MISSING_DEPENDENCY if buffer was not created on the process
/// handle that was passed in.
///
COIACCESSAPI
COIRESULT
COIBufferSetState(
COIBUFFER in_Buffer,
COIPROCESS in_Process,
COI_BUFFER_STATE in_State,
COI_BUFFER_MOVE_FLAG in_DataMove,
uint32_t in_NumDependencies,
const COIEVENT* in_pDependencies,
COIEVENT* out_pCompletion);
//////////////////////////////////////////////////////////////////////////////
///
/// Creates a sub-buffer that is a reference to a portion of an existing
/// buffer. The returned buffer handle can be used in all API calls that the
/// original buffer handle could be used in except COIBufferCreateSubBuffer.
/// Sub buffers out of Huge Page Buffer are also supported but the original
/// buffer needs to be a OPENCL buffer created with COI_OPTIMIZE_HUGE_PAGE_SIZE
/// flag.
///
/// When the sub-buffer is used only the corresponding sub-section of the
/// original buffer is used or affected.
///
/// @param in_Buffer
/// [in] The original buffer that this new sub-buffer is a reference
/// to.
///
/// @param in_Length
/// [in] The length of the sub-buffer in number of bytes.
///
/// @param in_Offset
/// [in] Where in the original buffer to start this sub-buffer.
///
/// @param out_pSubBuffer
/// [out] Pointer to a buffer handle that is filled in with the newly
/// created sub-buffer.
///
/// @return COI_SUCCESS if the sub-buffer was created
///
/// @return COI_INVALID_HANDLE if in_Buffer is not a valid buffer handle.
///
/// @return COI_OUT_OF_RANGE if in_Length is zero, or if in_Offset + in_Length
/// is greater than the size of the original buffer.
///
/// @return COI_OUT_OF_MEMORY if allocating the buffer fails.
///
/// @return COI_INVALID_POINTER if the out_pSubBuffer pointer is NULL.
///
/// @return COI_NOT_SUPPORTED if the in_Buffer is of any type other than
/// COI_BUFFER_OPENCL
///
COIACCESSAPI
COIRESULT
COIBufferCreateSubBuffer(
COIBUFFER in_Buffer,
uint64_t in_Length,
uint64_t in_Offset,
COIBUFFER* out_pSubBuffer);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* _COIBUFFER_SOURCE_H */
/*! @} */
Reference in New Issue View Git Blame Copy Permalink