Added the muxQueryMaxNumSubGroups entry point.

Removed mux_kernel_s::sub_group_size, which is now an implementation detail.

Added the __mux_mem_barrier, __mux_work_group_barrier, and __mux_sub_group_barrier builtins. They replace the older __mux_global_barrier, __mux_shared_local_barrier, and __mux_full_barrier builtins, which have been removed.

Added the mux_device_s::supports_generic_address_space field.

compiler::BaseModule::runBackendPasses and compiler::BaseModule::addLatePasses have been removed. Their functionality are covered by both the new compiler::BaseModule::getLateTargetPasses method and the pre-existing compiler::Module::createBinary.

Remove muxWait and move its functionality in muxTryWait when timeout is UINT64_MAX.

Require implementations of muxCloneCommandBuffer to deep copy ndrange kernel commands.

Add timeout parameter to muxTryWait.

Replace mux_error_command_buffer_not_ready with mux_fence_not_ready.

Replace mux_error_command_buffer_failure with mux_error_fence_failure.

Remove mux_error_command_buffer_wait_semaphore_failure.

Rename all builtin functions from __core to __mux.

compiler::BaseTarget now owns the builtins module optionally created in compiler::BaseTarget::init and initialized with the target as part of compiler::BaseTarget::initWithBuiltins.

Update muxDispatch to accept an optional mux_fence_t parameter.

Update muxTryWait to wait on a mux_fence_t rather than a mux_command_buffer_t.

Update muxWait to wait on a mux_fence_t rather than a mux_command_buffer_t.

Add muxCreateFence, muxDestroyFence and muxResetFence entry points.

Add mux_sync_point_s type, representing intra command-buffer synchronization points for ordering commands inside a command-buffer. MuxCommand* entry-points have been updated to return a sync-point, as well as taking a list of sync-points to wait on.

A new method getBuiltinCapabilities has been added to compiler::Info. Calling this function will return a bitfield of the builtin capabilities of the device, based on the mux device info.

Add the muxQueryWFVInfoForLocalSize entry point.

Add mux_fence_s type. There are currently no Mux entry points to create, wait on, query, reset or destory mux_fence_s objects, these will be added in a future spec version.

BaseModule has an additional virtual method createPassMachinery(). This will provide a PassMachinery which can be used throughout the pipeline to handle state needed for the new pass manager interface.

Added the mux_device_s::supports_work_group_collectives field.

Extend valid usage description of muxUpdateDescriptors to include text on changing the size of POD descriptors being undefined behaviour.

Add the following entry points: * compiler::Kernel::querySubGroupSizeForLocalSize * compiler::Kernel::queryLocalSizeForSubGroupCount * compiler::kernel::queryMaxSubGroupCount * muxQuerySubGroupSizeForLocalSize * muxQueryLocalSizeForSubGroupCount

Remove the following entry point: * compiler::Kernel::getSubGroupSize()

Add the following fields: * mux_device_info_s::max_sub_group_count * mux_kernel_s::max_sub_group_count

Remove the following field: * mux_device_info_s::max_num_sub_groups * mux_kernel_s::sub_group_size

Add the __core_dma_read_3D builtin.

Add the __core_dma_write_3D builtin.

Modify __core_dma_read_2D and __core_dma_write_2D to handle source and destination strides.

cargo::optional<mux_device_t> device and mux_allocator_info_t allocator_info has been removed from compiler::Info::createTarget.

compiler::BaseKernel::createSpecializedKernel has been moved to compiler::Kernel::createSpecializedKernel. compiler::Kernel::createMuxSpecializedKernel was an implementation detail of compiler::BaseKernel which has now been removed.

compiler::SpecializedKernel has been removed.

compiler::BaseTarget now loads the builtins module for the given builtin capabilities as part of compiler::BaseTarget::init. Compiler targets should implement compiler::BaseTarget::initWithBuiltins instead. Unlike init, initWithBuiltins does not need to delegate to compiler::BaseTarget first, as it’s a pure virtual function.

The notification callback passed to compiler::Target::init is now passed to compiler::Info::createTarget and is now of type compiler::NotifyCallbackFn. This should be passed along to compiler::BaseTarget’s constructor.

Change the user_function argument of muxCommandUserCallback to use the mux_command_user_callback_t type, rather than the function pointer type explicitly.

Remove note mandating that targets do their own validation of data and stride muxGetQueryPoolResults parameters.

Add the uint32_t mux_query_counter_s::hardware_counters field.

Add the uint32_t mux_device_info_s::max_hardware_counters field.

Rename member max_subgroup_size in mux_device_info_t to max_work_width.

Rename member function getDynamicSubgroupSize in compiler::Kernel to getDynamicWorkWidth.

Added the __core_get_max_sub_group_size() builtin.

Version bump to maintain parity with Core which has had the __core_get_num_sub_groups builtin added.

Version bump to maintain parity with Core which has had the __core_get_sub_group_id builtin added.

Add the size_t mux_kernel_s::sub_group_size field.

Add the cargo::expected<uint32_t, Result> compiler::Kernel::getSubGroupSize() method.

Add the uint32_t mux_device_info_s::max_num_sub_groups field.

Add the bool mux_device_info_s::sub_groups_support_ifp field.

Add member scalable_vector_support to compiler::Info to represent that the compiler supports generating scalable vector code.

Add member scalable_vectors to compiler::Options to indicate that the executable should be finalized with scalable vectors.

Version bump to maintain parity with Core which has had the __core_dma_write_2D and __core_dma_write_2D builtins added.

Initial release of the ComputeMux specification. The changelog for the Core specification has been duplicated here to preserve history.

Remove the corePushBarrier entry point, which was rendered obsolete when command groups were guaranteed to execute in order.

Add core_source_type_llvm_140 and core_source_capabilities_llvm_140 for supporting LLVM 14

Add the coreCloneCommandGroup entry point.

Add the bool core_device_info_s::can_clone_command_groups field.

Relax thread-safety requirements of implementing coreFinalizeCommandGroup(), so that the entry-point is only thread-safe with respect to the same command-group handle rather than across all invocations.

Add the coreUpdateDescriptors entry point.

Add the bool core_device_info_s::descriptors_updatable field.

Add the coreFinalizeCommandGroup entry point.

Add core_source_type_llvm_130 and core_source_capabilities_llvm_130 for supporting LLVM version 13.0.0.

Add core_source_type_llvm_120 and core_source_capabilities_llvm_120 for supporting LLVM version 12.0.0.

Add the size_t __core_get_global_linear_id() builtin.

Add the size_t __core_get_local_linear_id() builtin.

Add the size_t __core_get_enqueued_local_size(uint) builtin.

Remove host_pointer argument from coreAllocateMemory.

Remove core_allocation_type_use_host from core_allocation_type_e.

Rename core_allocation_capabilities_e enums core_allocation_capabilities_alloc_host to core_allocation_capabilities_coherent_host and core_allocation_capabilities_use_host to core_allocation_capabilities_cached_host.

Require stricter device capability core_allocation_capabilities_alloc_host to support entry point coreCreateMemoryFromHost, as this implies the device architecture has cache coherent memory with host.

Forbid mapping already mapped memory objects with coreMapMemory.

Specify flushing cache coherent memory as a nop.

Require core_memory_property_host_visible as a property of memory objects mapped with coreMapMemory.

Add a valid use clarification for coreCreateSpecializedKernel.

Add alignment argument to coreAllocateMemory to specify the minimum alignment for the allocated memory.

Add handle member to core_memory_s to allow the host runtime a way to represent the underlying memory address.

Add entry point coreCreateMemoryFromHost to allow APIs to create a core_memory_t device visible object from pre-allocated host memory.

Rename the core_vectorization_order_e enum to core_work_item_order_e, and the enum values to match the work_item naming.

Rename the vec_order field of core_executable_options_t to work_item_order, to match the rename of -cl-wfv-order to -cl-wi-order.

Upgrade Guidance: utils::createHandleBarriersPass() must now be passed a parameter of type enum core_work_item_order_e to specify the work item dimension priority.

Add core_vectorization_order_e enum type to represent vectorization priority order.

Add vec_order field to core_executable_options_t struct for supporting the -cl-wfv-order extension.

Add core_source_type_llvm_110 and core_source_capabilities_llvm_110 for supporting LLVM version 11.0.0.

Add documentation for maximum built-in kernel name length.

Add core_source_type_llvm_100 and core_source_capabilities_llvm_100 for supporting LLVM version 10.0.0.

Add __core_usefast() and __core_isembeddedprofile() functions as required builtins that core targets must replace.

Added core_floating_point_capabilities_full flag to core_floating_point_capabilities_e for IEEE-754 compliant representations.

Add flags to core_executable_flags_e to represent the various OpenCL math optimization build options, namely:

• core_executable_flags_mad_enable

• core_executable_flags_no_signed_zeroes

• core_executable_flags_unsafe_math_optimizations

• core_executable_flags_finite_math_only

Add compilation_options C string to core_device_info_s to hold custom build options provided by the device.

Add core_executable_options_t struct which encapsulates the core_executable_flags_e bitfield and a C string for the name and value of any device specific build options passed by the user.

Redefine core_executable_s struct to have a core_executable_options_t member rather than the core_executable_flags_e bitfield.

Redefine coreCreateBinaryFromSource() and coreCreateExecutable() to take a core_executable_options_t argument rather than a core_executable_flags_e bitfield.

Add core_executable_flags_prevec_loop and core_executable_flags_prevec_slp enum values to core_executable_flags_e for activation of “early vectorization” passes:

• Loop Vectorization

• SLP Vectorization

• Load/Store Vectorization

Core now accepts 3D descriptions of memory in the corePush*Region entry points, these layouts are passed down to the implementation.

• Reduce the overhead significantly.

• Redefine core_buffer_region_info_s to describe a buffer in 1D, 2D or 3D. This design is based on OpenCL’s clEnqueue*BufferRect entry points.

Add support for query counters, extending the mechanism for reporting performance statistics to the application by providing a configurable method for enabling a set of hardware counters alongside metadata which can be used by a profiling visualisation tool to describe the queried data.

• Extend core_query_type_e to include core_query_type_counter.

• Add coreGetSupportedQueryCounters() to enable applications to discover the full list of supported query counters.

• Add core_query_counter_t used to describe how to enable and interpret a query counter.

• Add core_query_counter_description_t used to provide human readable metadata about a query counter.

• Extend coreCreateQueryPool to accept an array of core_query_counter_config_ts to select which query counters to enable and pass through additional target specific counter configuration if necessary.

• Extend corePushBeginQuery/corePushEndQuery to accept a query_count in addition to a query_index, this allows multiple queries to be enabled at once.

• Add core_query_counter_result_t used to return the result of a single query counter to the application using coreGetQueryPoolResults().

Add support for queries, a mechanism for targets to report performance statistics to the application.

• The core_query_pool_t object is used to store the query results, coreCreateQueryPool() and coreDestroyQueryPool() define the objects lifecycle, coreGetQueryPoolResults() is used to provide the results to the application.

• The core_query_type_e enumeration defines a set of possible queries, currently only core_query_type_duration is supported and is intended to report the start and end timestamps of a command, results are reported using the core_query_duration_result_t object.

• The corePushBeginQuery() and corePushEndQuery() entry points define the range of commands for which a core_query_pool_t is to be used in a core_command_group_t, corePushResetQueryPool() is used to zero all query results in the spcified range within the core_query_pool_t.

Remove unnecessary member vectorize from core_kernel_t.

Fix core.xml comment to state that CL_DEVICE_NAME is matched with core_device_info_s::device_name.

Added core_source_capabilities_e::core_source_capabilities_llvm_any bit mask to match any of the LLVM source capability bits.

Add support for custom buffer descriptors, this allows passing through arbitrary data from the user to the Core target in addition to the address space provided by the compiler frontend. This includes:

• The custom_buffer_capabilities data member of core_device_info_s describing which custom buffer capabilities the Core target supports.

• The core_custom_capabilities_e enumeration of custom buffer capabilities.

• The core_descriptor_info_custom_buffer_s structure to describe the custom buffer to the Core target.

• The core_descriptor_info_type_custom_buffer enumeration value to specify that a descriptor is a custom buffer.

Clarify that whitespace characters other than `` `` are not supported in built-in kernel declarations.

Unify snapshot descriptions to favor snapshot “stages” over snapshot “points”. Rename:

• coreListSnapshotPoints to coreListSnapshotStages

• coreSetSnapshotPoint to coreSetSnapshotStage

Specify that passing an invalid snapshot stage name to coreSetSnapshotStage must return core_error_malformed_parameter.

Remove core_snapshot_type_none to make it harder to set an invalid format.

Rename core_snapshot_type_e to core_snapshot_format_e to unify how the format information is called and used.

Introduce core_snapshot_format_default to unify how the format information is used.

Re-order the parameters of coreSetSnapshotStage, i.e., move the snapshot_format parameter before the snapshot_callback parameter.

Added built-in kernel usage section to the Core spec.md document.

Clarify syntax for built-in kernel declarations.

Clarify that build_flags have no effect on coreCreateExecutable when the source type is core_source_type_builtin_kernel.

Clarify that Core implementations of command groups must not access signal semaphores of completed command groups they depend on.

Add core_callback_info_t to support implementations providing detailed messages to users about API usage.

Change <client>CreateFinalizer to take a core_callback_info_t parameter to support provision of detailed messages about compilation.

Change <client>CreateCommandGroup to take a core_callback_info_t parameter to support provision of detailed messages about command execution.

Clarify the error return codes of coreCreateExecutable and coreCreateBinaryFromSource for unknown or invalid source_type arguments.

Clarify the valid usage of permitted actions in the user_function callback of coreDispatch.

Clarify when a command group passed to coreDispatch is considered complete.

Add allocator validity check to id.h and rename it to utils.h.

Weaken requirement that host-side allocations must use the user provided allocator to that they should use it. This enables use of third-party libraries, like LLVM or the C standard library, which do not support user provided allocators and should not affect existing target implementations.

Supersede generate_core_header with add_core_target, this also simplifies the mechanism by which targets register themselves and how they specify their capabilities in addition to creating a CMake target to generate the core target header.

Add add_core_cross_compilers which simplifies the mechanism for registering a targets cross-compilers with the cross target.

Add requirement that commands in a command group must be executed in the order they were pushed onto the command group, making command groups in-order.

Add addition valid usage requirements for the usage core_semaphore_t defining when it can be reset and destroyed relating to the lifetime of a coreDispatch().

Changed builtin_kernel_names to builtin_kernel_declarations to better represent what information is contained.

Numerous clarifications and inconsistencies corrected in the specification and Doxygen comments of core.h.

Add core_device_type_compiler to core_device_type_e to represent a target which only implements the compilation entry points for use in compiling offline and cross-compiled kernels.

Change core_device_type_e enumerations to make them usable in a bitfield and add core_device_type_all for selecting all device types.

Change coreGetDeviceInfos to take a bitfield of core_device_type_e in order to selectively initialize only desired devices.

Changed type of device member variable in core_finalizer_s from core_device_t to core_device_info_t.

Add core_source_type_llvm_80 and core_source_capabilities_llvm_80 for supporting LLVM version 8.0.0.

Add back in the removed id member from the core_device_s struct to fix compilation failures in coreSelect.h when multiple targets are registered.

Add support for builtin kernels to core.

Added core_source_type_unknown, core_source_type_builtin_kernel and core_source_capabilities_builtin_kernel to core_source_type_e and core_source_capabilities_e.

Added core_source_type_builtin_kernel as one of the supported types to coreCreateExecutable for creation of a core_executable with builtin kernels.

Reordered values in core_source_type_e and core_source_capabilities_e.

Changed coreCreateFinalizer and coreDestroyFinalizer entrypoints to take core_device_info_ts instead of core_device_ts.

Added a new type core_binary_t.

Removed coreGetBinary and replaced it with a new coreCreateBinaryFromExecutable entrypoint.

Added coreCreateBinaryFromSource entrypoint for offline/cross-compilation support.

Added a matching coreDestroyBinary to destroy binaries created by the above two functions.

Separate device enumeration from initialization by adding a new structure: core_device_info_t, and a new function: coreGetDeviceInfos.

coreCreateDevices hook API has changed - a new hook for coreGetDeviceInfos was added, which has an almost identical interface to the existing coreCreateDevices hook.

Add core_executable_flags_dma_never and core_executable_flags_vectorize_never enum values to core_executable_flags_e, so that the core implementations are informed of whether the user chose explicitly to enable/disable these optimizations, or if the default behavior is to be used when neither the never nor always flags are present.

Add member endianness to core_device_t to represent whether the device is big- or little-endian.

Change to CMake to build only the required builtins based on target capabilities. Capabilities must be reported in a <target_name>_CAPABILITIES variable.

Change the CMake mechanism to generate <client> API headers, it is now possible to override the clang-format executable used during header generation.

Change references to command_buffer in Doxygen documentation and parameter variable names to command_group.

Add member dma_optimizable to core_device_t to represent that DMA optimizations can be performed for this device.

Add core_executable_flags_dma_always to core_executable_flags_e to represent that DMA optimizations must be performed.

Add a new command <client>ResetSemaphore() to reset a semaphore such that it has no previous signalled state.

Add member image2d_array_writes to core_device_t.

Add member integer_capabilities to core_device_t.

Add enum core_integer_capabilities_e.

Add member vectorizable to core_device_t to represent that vectorization can be performed for this device.

Add member vectorize to core_kernel_t.

Add core_executable_flags_vectorize_always to core_executable_flags_e to represent that vectorization must be performed.

Add core_executable_flags_denorms_may_be_zero to core_executable_flags_e to represent that denormal floats may be flushed to zero.

Added member local_memory_size to core_kernel_t.

Add a new command <client>PushBarrier() to enforce the execution order of commands within a command group.

Add a core_finalizer_t argument to <client>DestroyExecutable(), <client>DestroyKernel() and <client>DestroyScheduledKernel(). Note that <client>DestroySpecializedKernel() does not take a core_finalizer_t.

Add core_source_type_llvm_70 and core_source_capabilities_llvm_70 for supporting LLVM version 7.0.0.

Remove dead symbol references in Doxygen documentation.

Add allocation_size to core_device_s to represent the maximum size of a single memory allocation.

Add __core_get_work_dim(), __core_get_group_id(), __core_get_global_id(), __core_get_local_id(), __core_get_num_groups(), __core_get_global_size(), __core_get_local_size(), __core_get_global_offset(), __core_full_barrier(), __core_shared_local_barrier(), and __core_global_barrier(), required builtins that core targets must replace.

Add core_source_type_llvm_60 and core_source_capabilities_llvm_60 for supporting the latest version of LLVM.

Add <client>PushReadBufferRegions() to allow for multiple regions within a source buffer to be copied to a destination host pointer.

Add <client>WriteCopyBufferRegions() to allow for multiple regions within a host pointer to be copied to a destination buffer.

Add <client>PushCopyBufferRegions() to allow for multiple regions within a source buffer to be copied to a destination buffer.

Add core_buffer_regions_info_s as a helper struct to specify to the new entry points above what source offset, destination offset, and size to use for each region.

Add max_subgroup_size to core_device_s to represent the maximum subgroup size for kernels on a device, and dynamic_subgroup_size to core_scheduled_kernel_s to represent the actual subgroup size for that scheduled kernel.

Add core_source_type_llvm_50 to core_source_flags_e to allow input binaries to be from LLVM 5.0.

Add core_source_capabilities_llvm_50 to core_source_capabilities_e to allow input binaries to be from LLVM 5.0.

Add core_device_t argument to create entry points which were not already passed a device making the API consistent across all create and destroy functions.

Add __core_dma_read_1d(), __core_dma_read_2d(), and __core_dma_wait() functions as builtins that core targets must replace if they use the automatic DMA.

Add core_allocator_info argument to all entry points which perform host allocations to support Vulkan style user allocator override.

Change order of entry points so that <client>Create<Object> is directly before <client>Destroy<Object>.

Add compute_units to core_device_s to let implementations pass information on how many compute units their device has.

Add device_priority to core_device_s. This is used to keep track of device priorities when returning default devices.

Add __core_isftz() function as a required builtin that core targets must replace.

Add support for multiple memory heaps.

Add supported_heaps bitfield to core_memory_requirements_s allowing the client target to state which heaps are supported for a specific buffer or image.

Change core_buffer_t to have a memory_requirements data member, replacing size and adding support for specifying alignment and supported_heaps.

Add heap argument to <client>AllocateMemory to specify the heap to allocate memory from.

Added native_vector_width and preferred_vector_width to core_device_t to let devices expose what vector width (in bytes) their hardware is, and what size of vectors they would prefer implementations give them.

Added preferred_local_size_x, preferred_local_size_y, and preferred_local_size_z to core_kernel_t to let implementations pass information on what would be a suitable local work group size to use for a given kernel.

Removed <client>PushTerminate() as it put a higher burden on client targets than was necessary.

Add <client>GetBinary() to retrieve the binary representation of a core_executable_t.

Add core_source_type_binary to core_source_flags_e to allow the input to be a binary for the given core target.

Add core_source_capabilities_binary to core_source_capabilities_e to allow a core target to advertise it can support creating executables from binaries.

Rename <client>CreateQueue() to <client>GetQueue() and change the function signature to take two extra parameters for the queue type and index. core_queue_t‘s now belong to the device, and are queried from the device, rather than an arbitrary number of them being created (which simplifies the engineering effort required by our customers).

Add new enum core_queue_type_e to denote all possible types of queue we can support - at present this only contains core_queue_type_compute, but is available for extension later.

Add new field to core_device_t to query the number of queues of each core_queue_type_e a device supports.

Remove <client>DestroyQueue(), as queues are now implicitly destroyed when the device they were retrieved from is destroyed.

Fix bug in core::util::allocator::create where references were not correctly passed through to the constructor of the object being created.

Add core_source_type_llvm_40 to core_source_flags_e to allow input binaries to be from LLVM 4.0.

Add core_source_capabilities_llvm_40 to core_source_capabilities_e to allow input binaries to be from LLVM 4.0.

Add core_executable_flags_no_opt to core_executable_flags_e.

Change semantics of core_executable_flags_debug to mean built with debug info.

Add core_executable_flags_soft_math to core_executable_flags_e to force finalization to occur using software math builtins.

Add max_work_group_size_x, max_work_group_size_y and max_work_group_size_z to core_device_t.

Add CORE_NULL_ID preprocessor definition to be used by clients when initializing core_<object>_s::id.

Add ID types core_id_t, core_object_id_t, core_target_id_t.

Generate core_target_id_e enum in core/coreConfig.h from list of registered targets.

Add core_id_t id member to all objects created by clients.

Add missing core_device_t parameter to <client>ListSnapshotPoints.

Add core/util/id.h utility header for working with object ID’s.

Added builtins_type, builtins, and builtins_length parameters to <client>CreateFinalizer() to pass the compute APIs standard library to the core client target for linking. Client targets must now link in the builtin function definitions themselves to use our provided implementations. By moving the responsibility for linking to the client target, clients now have a mechanism to intercept any of the builtin functions with target specific optimizations, before linking in any remaining builtins that the client does not have optimized support for.

Remove no longer required page_size from core_device_t.

Renamed core_descriptor_info_shared_scratch_s to core_descriptor_info_shared_local_buffer_s to be more consistent with our naming.

Renamed core_descriptor_info_type_shared_scratch to core_descriptor_info_type_shared_local_buffer to be more consistent with our naming.

Add overload to core::allocator::alloc() which takes a non-template alignment parameter.

Add image3d_writes flag to core_device_s to signify support for writing to 3D images.

Add <client>FlushMappedMemoryToDevice() to synchronize device memory with data currently residing in host memory.

Add <client>FlushMappedMemoryFromDevice() to synchronize host memory with data currently residing in device memory.

Remove flags parameter to coreMapMemory(), use <client>FlushMappedMemoryToDevice() and <client>FlushMappedMemoryFromDevice() to perform flushing instead.

Remove core_mapping_type_e, coreMapMemory() and coreUnmapMemory() are no longer required to synchronize memory.

Remove max_instructions_issued_per_cycle from core_device_s as it is no longer a required (or useful) piece of functionality to require our customers to guestimate.

Change core_source_type_e and core_source_capabilities_e to be the LLVM version of the bitcode module being passed in (which more correctly fits our usage).

LLVM bitcode modules being passed in with core_source_type_llvm_38 and core_source_type_llvm_39 must have the “unknown-unknown-unknown” target triple now.

Add function <client>ListSnapshotPoints to retrieve the list of compilation stages snapshots can be taken at in partner code.

Add function <client>SetSnapshotPoint to set a snapshot point in partner code.

Add enum core_snapshot_type_e to describe snapshot formats.

Add typedef core_snapshot_callback_t to describe the function prototype for the callback invoked when a snapshot point is hit.

Add struct core_semaphore_s representing a device semaphore object.

Add function <client>CreateSemaphore to create device semaphore objects.

Add function <client>DestroySemaphore to destroy device semaphore objects.

Add function <client>TryWait to try and wait on command groups.

Change <client>Dispatch to include two arrays of semaphores, one to wait on before beginning execution of the command group, and one to signal when the command group has completed executing.

Change <client>Dispatch to include a command group complete callback and user data.

Add core_error_command_group_failure to core_error_e enum to signal that a command group that was waited on failed.

Add core_error_command_group_wait_semaphore_failure to core_error_e enum to signal that a command group that was waiting on another command group via a semaphore failed because the other command group failed.

Add core_error_command_group_not_ready to core_error_e enum to signal that a command group that was waited on was not yet complete.

Add extra parameter to <client>PushFillImage to specify the size of the user memory being passed in as the color parameter.

Add function <client>PushTerminate to signal that a command group should terminate, and any semaphore in the chain of waits on it, should not execute.

Add function <client>ResetCommandGroup to reset a command group such that it has no previous commands enqueued within it.

Add struct core_image_s representing a device image object.

And struct core_sampler_s representing a device sampler object.

Update struct core_device_s to contain the devices image capabilities.

Change enum core_memory_type_e into core_memory_property_e to describe the desired memory properties for an allocation, core_memory_type_e was too restrictive and did not allow implementation of CL_MEM_OBJECT_IMAGE1D_BUFFER.

Add struct core_memory_requirements_s to describe the device memory allocation requirements of a core_buffer_t or a core_image_t.

Add struct core_offset_3d_t to describe the offset into an image.

Add struct core_extent_3d_t to describe the region of an image.

Add enum core_image_type_e to describe the type of an image.

Add enum core_image_format_e to describe the format on an image.

Add enum values core_descriptor_info_type_image and core_descriptor_info_type_sampler to core_descriptor_info_type_e.

Add enum core_address_mode_e to describe sampler addressing modes.

Add enum core_filter_mode_e to describe sampler filter modes.

Change <client>AllocateMemory to accept a bitfield of core_memory_property_e

Add function <client>CreateImage to create device image objects.

Add function <client>DestroyImage to destroy device image objects.

Add function <client>BindImageMemory to bind device memory to an image object.

Add function <client>GetSupportedImageFormats to query the device for supported image formats.

Add function <client>PushReadImage to read an image in a command group.

Add function <client>PushWriteImage to write an image in a command group.

Add function <client>PushFillImage to fill an image in a command group.

Add function <client>PushCopyImage to copy and image to another in a command group.

Add function <client>PushCopyImageToBuffer to copy an image to a buffer in a command group.

Add function <client>PushCopyBufferToImage to copy a buffer to an image in a command group.

Fixed core_memory_type_e - it should have been a bitfield.

Fixed core.h C compilation issue (enum types are called enum <type>).

Added enum core_executable_flags_e for build flags.

Added build_flags field to executable representing compilation/linking options set for the module.

Added build_flags parameter to function <client>CreateExecutable.

Add handle core_memory_t to take sole ownership of device memory allocations in preparation for image support.

Add struct core_memory_s.

Add functions <client>AllocateMemory and <client>FreeMemory to handle device memory allocations.

Add function <client>BindBufferMemory to associate a device memory allocation with a buffer object. This also adds first class support to the API for clCreateSubBuffer.

Add enum core_memory_type_e used to specify if an allocation should support buffers, images, or both buffers and images. Add typedef to the definition to allow passing as a function parameter.

Combine core_buffer_mapping_type_e and core_buffer_unmapping_type_e and rename the enum to core_mapping_type_e. Add typedef to definition to allow passing as a function parameter.

Simplify function <client>CreateBuffer to remove allocation specific parameters.

Add core_device_t parameter to function <client>DestroyBuffer.

Remove functions <client>MapBuffer and <client>UnmapBuffer, this functionality now applies to core_memory_t allocations.

Add functions <client>MapMemory and <client>UnmapMemory replacing the buffer specific variety.

Remove member device from struct core_buffer_s, device is now passed to API functions instead.

Fix documentation for API function <client>CreateSpecializedKernel.

Removed CORE_DEVICE_KHRONOS_CODEPLAY_ID and CORE_DEVICE_KHRONOS_CODEPLAY_NAME as they are specific to the Codeplay backends.

Added enum core_floating_point_capabilities_e for floating point support.

Added half_capabilities to device for what half floating point mode is supported.

Added float_capabilities to device for what floating point mode is supported.

Added double_capabilities to device for what double floating point mode is supported.

Added enum core_shared_local_memory_type_e for local memory types.

Added shared_local_memory_type to device for the type of shared local memory the device supports.

Added shared_local_memory_size to device for the size of the shared local memory the device has.

Added enum core_cache_capabilities_e for read/write caching.

Added cache_capabilities field to device for what caching is supported.

Added cache_size field to device for the size of the cache supported.

Added cacheline_size field to device for the length of a line within the cache.

Replace <client>_hook with <client>CreateDevices, adding support for multiple devices per target.

Add version to XML schema and generated headers.

Add compile time check for matching versions of all registered targets.