[PATCH 2/4] OpenMP 4.0 offloading to Intel MIC: liboffloadmic.

[thirdparty/gcc.git] / liboffloadmic / include / coi / source / COIBuffer_source.h

/*
 * 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 */

/*! @} */