mirror of
https://github.com/autc04/Retro68.git
synced 2024-08-16 13:29:10 +00:00
1312 lines
58 KiB
C
1312 lines
58 KiB
C
/*
|
|
* 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 */
|
|
|
|
/*! @} */
|