
    <para>
      General information about sharing memory objects with Direct3D 11 follows.
    </para>

    <para>
      <!-- ext. spec p. 97, section 9.11.1 --> The goal of this extension is to provide
      interoperability between OpenCL and Direct3D 11. This is designed to function analogously
      to the OpenGL interoperability. If this extension is
      supported by an implementation, the string       
      <citerefentry><refentrytitle>cl_khr_d3d11_sharing</refentrytitle></citerefentry>
      will be present in the
      <constant>CL_PLATFORM_EXTENSIONS</constant> or <constant>CL_DEVICE_EXTENSIONS</constant> 
      string described in the table of allowed 
      values for <varname>param_name</varname> for 
      <citerefentry><refentrytitle>clGetDeviceInfo</refentrytitle></citerefentry>.

    </para>

    <para>
      As currently proposed the interfaces for this extension would be provided in
      <code>cl_d3d11.h</code>.
    </para>

    <para>
      <!-- ext. spec p. 101, section 9.11.7 --> This section discusses OpenCL functions that allow
      applications to use Direct3D 11 resources as OpenCL memory objects. This allows efficient
      sharing of data between OpenCL and Direct3D 11. The OpenCL API may be used to execute
      kernels that read and/or write memory objects that are also Direct3D 11 resources. An
      OpenCL image object may be created from a Direct3D 11 texture resource. An OpenCL buffer
      object may be created from a Direct3D 11 buffer resource. OpenCL memory objects may be
      created from Direct3D 11 objects if and only if the OpenCL context has been created from
      a Direct3D 11 device.
    </para>

    <para>
      <!-- ext. spec, p. 103, section 9.11.7.2 --> An OpenCL memory object created from a
      Direct3D 11 resource remains valid as long as the corresponding Direct3D 11 resource has
      not been deleted. If the Direct3D 11 resource is deleted through the Direct3D 11 API,
      subsequent use of the OpenCL memory object will result in undefined behavior, including
      but not limited to possible OpenCL errors, data corruption, and program termination.
    </para>

    <para>
      <!-- ext. spec, p. 103, section 9.11.7.2 --> The successful creation of a
      cl_context against a Direct3D 11 device specified via the context create parameter
      <constant>CL_CONTEXT_D3D11_DEVICE_KHR</constant> will increment the internal Direct3D
      reference count on the specified Direct3D 11 device. The internal Direct3D reference
      count on that Direct3D 11 device will be decremented when the OpenCL reference count on
      the returned OpenCL context drops to zero.
    </para>

    <para>
      The OpenCL context and corresponding command-queues are dependent on the
      existence of the Direct3D 11 device from which the OpenCL context was created. If the
      Direct3D 11 device is deleted through the Direct3D 11 API, subsequent use of the OpenCL
      context will result in undefined behavior, including but not limited to possible OpenCL
      errors, data corruption, and program termination.
    </para>

    <para>
      <!-- ext. spec p. 108, section 9.11.7.5 --> Properties of Direct3D 11 objects may be queried
      using <citerefentry><refentrytitle>clGetMemObjectInfo</refentrytitle></citerefentry>
      and <citerefentry><refentrytitle>clGetImageInfo</refentrytitle></citerefentry>
      with <varname>param_name</varname> <constant>CL_MEM_D3D11_RESOURCE_KHR</constant> and
      <constant>CL_IMAGE_D3D11_SUBRESOURCE_KHR</constant> as described for <citerefentry><refentrytitle>clGetImageInfo</refentrytitle></citerefentry> and in the information 
below about accessing mapped regions of a memory object. 
    </para>
<!-- "accessing mapped regions of a memory object" refers to include AccessMappedInc.xml from 5.4.3 -->   
<!-- 13-Oct-2011 -->
<!-- 15-Oct-11 -->

<!-- This include called from:
clCreateFromD3D11BufferKHR
clCreateFromD3D11Texture2DKHR
clCreateFromD3D11Texture3DKHR
clCreateEnqueAcquireD3D11ObjectsKHR
clCreateEnqueReleaseD3D11ObjectsKHR
clGetDeviceIdsFromD3D11KHR
-->