Name String cl_intel_subgroups_short Contributors Ben Ashbaugh, Intel Felix J Degrood, Intel Biju George, Intel Raun M Krisch, Intel Konstantin A Pyjov, Intel Insoo Woo, Intel Contact Ben Ashbaugh, Intel (ben.ashbaugh 'at' intel.com) Version Version 1, October 20, 2016 Number OpenCL Extension #48 Status Final Draft Dependencies OpenCL 1.2 and support for cl_intel_subgroups is required. This extension is written against revision 29 of the OpenCL 2.0 API specification, against revision 33 of the OpenCL 2.0 OpenCL C specification, against revision 32 of the OpenCL 2.0 Extension specification, and against version 4 of the cl_intel_subgroups specification. Overview The goal of this extension is to allow programmers to improve the performance of applications operating on 16-bit data types by extending the subgroup functions described in the cl_intel_subgroups extension to support 16-bit integer data types (shorts and ushorts). Specifically, the extension: * Extends the subgroup broadcast function to allow 16-bit integer values to be broadcast from one work item to all other work items in the subgroup. * Extends the subgroup scan and reduction functions to operate on 16-bit integer data types. * Extends the Intel subgroup shuffle functions to allow arbitrarily exchanging 16-bit integer values among work items in the subgroup. * Extends the Intel subgroup block read and write functions to allow reading and writing 16-bit integer data from images and buffers. New OpenCL C Functions Add and to the list of supported data types for the subgroup broadcast, scan, and reduction functions: short intel_sub_group_broadcast( short x, uint sub_group_local_id ); ushort intel_sub_group_broadcast( ushort x, uint sub_group_local_id ) For the sub_group_reduce, sub_group_scan_exclusive, and sub_group_scan_inclusive functions, is , , or . short intel_sub_group_reduce_( short x ); short intel_sub_group_scan_exclusive_( short x ); short intel_sub_group_scan_inclusive_( short x ); ushort intel_sub_group_reduce_( ushort x ); ushort intel_sub_group_scan_exclusive_( ushort x ); ushort intel_sub_group_scan_inclusive_( ushort x ); Add , , , , , , , , , and to the list of data types supported by the sub_group_shuffle, sub_group_shuffle_down, sub_group_shuffle_up, and sub_group_suffle_xor functions: intel_sub_group_shuffle( data, uint c ); intel_sub_group_shuffle_down( current, next, uint delta ); intel_sub_group_shuffle_up( previous, current, uint delta ); intel_sub_group_shuffle_xor( data, uint value ); Add variants of the subgroup block read and write functions: ushort intel_sub_group_block_read_us( const __global ushort* p ); ushort2 intel_sub_group_block_read_us2( const __global ushort* p ); ushort4 intel_sub_group_block_read_us4( const __global ushort* p ); ushort8 intel_sub_group_block_read_us8( const __global ushort* p ); ushort intel_sub_group_block_read_us( image2d_t image, int2 byte_coord ); ushort2 intel_sub_group_block_read_us2( image2d_t image, int2 byte_coord ); ushort4 intel_sub_group_block_read_us4( image2d_t image, int2 byte_coord ); ushort8 intel_sub_group_block_read_us8( image2d_t image, int2 byte_coord ); void intel_sub_group_block_write_us( __global ushort* p, ushort data ); void intel_sub_group_block_write_us2( __global ushort* p, ushort2 data ); void intel_sub_group_block_write_us4( __global ushort* p, ushort4 data ); void intel_sub_group_block_write_us8( __global ushort* p, ushort8 data ); void intel_sub_group_block_write_us( image2d_t image, int2 byte_coord, ushort data ); void intel_sub_group_block_write_us2( image2d_t image, int2 byte_coord, ushort2 data ); void intel_sub_group_block_write_us4( image2d_t image, int2 byte_coord, ushort4 data ); void intel_sub_group_block_write_us8( image2d_t image, int2 byte_coord, ushort8 data ); For naming consistency, also adds suffixed aliases of the subgroup block read and write functions described in the cl_intel_subgroups extension: uint intel_sub_group_block_read_ui( const __global uint* p ); uint2 intel_sub_group_block_read_ui2( const __global uint* p ); uint4 intel_sub_group_block_read_ui4( const __global uint* p ); uint8 intel_sub_group_block_read_ui8( const __global uint* p ); uint intel_sub_group_block_read_ui( image2d_t image, int2 byte_coord ); uint2 intel_sub_group_block_read_ui2( image2d_t image, int2 byte_coord ); uint4 intel_sub_group_block_read_ui4( image2d_t image, int2 byte_coord ); uint8 intel_sub_group_block_read_ui8( image2d_t image, int2 byte_coord ); void intel_sub_group_block_write_ui( __global uint* p, uint data ); void intel_sub_group_block_write_ui2( __global uint* p, uint2 data ); void intel_sub_group_block_write_ui4( __global uint* p, uint4 data ); void intel_sub_group_block_write_ui8( __global uint* p, uint8 data ); void intel_sub_group_block_write_ui( image2d_t image, int2 byte_coord, uint data ); void intel_sub_group_block_write_ui2( image2d_t image, int2 byte_coord, uint2 data ); void intel_sub_group_block_write_ui4( image2d_t image, int2 byte_coord, uint4 data ); void intel_sub_group_block_write_ui8( image2d_t image, int2 byte_coord, uint8 data ); Additions to Section 6.13.15 - "Work Group Functions" of the OpenCL 2.0 C Specification: Add and to the list of supported data types for the subgroup broadcast, scan, and reduction functions: "---------------------------------------------------------------------------------------- Function Description ------------------------------------------ -------------------------------------------- sub_group_broadcast( Broadcasts the value of x for the work item x, identified by sub_group_local_id (value uint sub_group_local_id ) returned by get_sub_group_local_id) to all short intel_sub_group_broadcast( work items in the subgroup. short x, sub_group_local_id must be the same value uint sub_group_local_id ) for all work items in the subgroup. ushort intel_sub_group_broadcast( ushort x, uint sub_group_local_id ) sub_group_reduce_( Returns the result of the reduction operation x ) specified by for all values x specified short intel_sub_group_reduce_( by work items in a subgroup. short x ) ushort intel_sub_group_reduce_( ushort x ) sub_group_scan_exclusive_( Does an exclusive scan operation specified by x ) of all values specified by work items short intel_sub_group_scan_exclusive_( in a subgroup. The scan results are short x ) returned for each work item. ushort intel_sub_group_scan_exclusive_( ushort x ) The scan order is defined by increasing sub_group_local_id within the subgroup. sub_group_scan_inclusive_( Does an inclusive scan operation specified by x ) of all values specified by work items short intel_sub_group_scan_inclusive_( in a subgroup. The scan results are short x ) returned for each work item ushort intel_sub_group_scan_inclusive_( ushort x ) The scan order is defined by increasing sub_group_local_id within the subgroup. ----------------------------------------------------------------------------------------" Additions to Section 6.13.X - "Sub Group Shuffle Functions" of the OpenCL 2.0 C Specification, which was added by the cl_intel_subgroups Extension: Add , , , , , , , , , and to the list of data types supported by the sub_group_shuffle, sub_group_shuffle_down, sub_group_shuffle_up, and sub_group_suffle_xor functions: "The OpenCL C programming language implements the following built-in functions to allow data to be exchanged among work items in a subgroup. These built-in functions need not be encountered by all work items in a subgroup executing the kernel. For these functions, is , , , , , , , , , , , , , , , , , , , , , , , , , , or . If cl_khr_fp16 is supported, also includes . If cl_khr_fp64 or doubles are supported, also includes ." Modifications to Section 6.13.X "Sub Group Read and Write Functions" of the OpenCL 2.0 C Specification, which was added by the cl_intel_subgroups Extension: Add suffixed aliases of the previously un-suffixed 32-bit block read and write functions. There is no change to the description or behavior of these functions: "--------------------------------------------------------------------------------------- Function Description ---------------------------------------- ------------------------------------------ uint intel_sub_group_block_read( Reads 1, 2, 4, or 8 uints of data for each const __global uint* p ) work item in the subgroup from the specified uint2 intel_sub_group_block_read2( pointer as a block operation... const __global uint* p ) uint4 intel_sub_group_block_read4( const __global uint* p ) uint8 intel_sub_group_block_read8( const __global uint* p ) uint intel_sub_group_block_read_ui( const __global uint* p ) uint2 intel_sub_group_block_read_ui2( const __global uint* p ) uint4 intel_sub_group_block_read_ui4( const __global uint* p ) uint8 intel_sub_group_block_read_ui8( const __global uint* p ) uint intel_sub_group_block_read( Reads 1, 2, 4, or 8 uints of data for each image2d_t image, work item in the subgroup from the specified int2 byte_coord ) image at the specified coordinate as a block uint2 intel_sub_group_block_read2( operation... image2d_t image, int2 byte_coord ) uint4 intel_sub_group_block_read4( image2d_t image, int2 byte_coord ) uint8 intel_sub_group_block_read8( image2d_t image, int2 byte_coord ) uint intel_sub_group_block_read_ui( image2d_t image, int2 byte_coord ) uint2 intel_sub_group_block_read_ui2( image2d_t image, int2 byte_coord ) uint4 intel_sub_group_block_read_ui4( image2d_t image, int2 byte_coord ) uint8 intel_sub_group_block_read_ui8( image2d_t image, int2 byte_coord ) void intel_sub_group_block_write( Writes 1, 2, 4, or 8 uints of data for each __global uint* p, uint data ) work item in the subgroup to the specified void intel_sub_group_block_write2( pointer as a block operation... __global uint* p, uint2 data ) void intel_sub_group_block_write4( __global uint* p, uint4 data ) void intel_sub_group_block_write8( __global uint* p, uint8 data ) void intel_sub_group_block_write_ui( __global uint* p, uint data ) void intel_sub_group_block_write_ui2( __global uint* p, uint2 data ) void intel_sub_group_block_write_ui4( __global uint* p, uint4 data ) void intel_sub_group_block_write_ui8( __global uint* p, uint8 data ) void intel_sub_group_block_write( Writes 1, 2, 4, or 8 uints of data for each image2d_t image, work item in the subgroup to the specified int2 byte_coord, uint data ) image at the specified coordinate as a block void intel_sub_group_block_write2( operation... image2d_t image, int2 byte_coord, uint2 data ) void intel_sub_group_block_write4( image2d_t image, int2 byte_coord, uint4 data ) void intel_sub_group_block_write8( image2d_t image, int2 byte_coord, uint8 data ) void intel_sub_group_block_write_ui( image2d_t image, int2 byte_coord, uint data ) void intel_sub_group_block_write_ui2( image2d_t image, int2 byte_coord, uint2 data ) void intel_sub_group_block_write_ui4( image2d_t image, int2 byte_coord, uint4 data ) void intel_sub_group_block_write_ui8( image2d_t image, int2 byte_coord, uint8 data ) --------------------------------------------------------------------------------------" Also, add variants of the block read and write functions. In the descriptions of these functions, the "note below describing out-of-bounds behavior" is in the cl_intel_subgroups extension specification: "-------------------------------------------------------------------------------------- Function Description ---------------------------------------- ------------------------------------------- ushort intel_sub_group_block_read_us( Reads 1, 2, 4, or 8 ushorts of data for each const __global ushort* p ) work item in the subgroup from the specified ushort2 intel_sub_group_block_read_us2( pointer as a block operation. const __global ushort* p ) The data is read strided, so the first ushort4 intel_sub_group_block_read4( value read is: const __global ushort* p ) p[ sub_group_local_id ] ushort8 intel_sub_group_block_read_us8( and the second value read is: const __global ushort* p ) p[ sub_group_local_id + max_sub_group_size ] etc. p must be aligned to a 32-bit (4-byte) boundary. There is no defined out-of-range behavior for these functions. ushort intel_sub_group_block_read_us( Reads 1, 2, 4, or 8 ushorts of data for each image2d_t image, work item in the subgroup from the specified int2 byte_coord ) image at the specified coordinate as a block ushort2 intel_sub_group_block_read_us2( operation. Note that the coordinate is a image2d_t image, byte coordinate, not an image element int2 byte_coord ) coordinate. Also note that the image data ushort4 intel_sub_group_block_read_us4( is read without format conversion, so each image2d_t image, work item may read multiple image elements int2 byte_coord ) (for images with element size smaller than ushort8 intel_sub_group_block_read_us8( 16-bits). image2d_t image, int2 byte_coord ) The data is read row-by-row, so the first value read is from the row specified in the y-component of the provided byte_coord, the second value is read from the y-component of the provided byte_coord plus one, etc. Please see the note below describing out-of- bounds behavior for these functions. void intel_sub_group_block_write_us( Writes 1, 2, 4, or 8 ushorts of data for each __global ushort* p, work item in the subgroup to the specified ushort data ) pointer as a block operation. void intel_sub_group_block_write_us2( The data is written strided, so the first __global ushort* p, value is written to: ushort2 data ) p[ sub_group_local_id ] void intel_sub_group_block_write_us4( and the second value is written to: __global ushort* p, p[ sub_group_local_id + max_sub_group_size ] ushort4 data ) etc. void intel_sub_group_block_write_us8( p must be aligned to a 128-bit (16-byte) __global ushort* p, boundary. ushort8 data ) There is no defined out-of-range behavior for these functions. void intel_sub_group_block_write_us( Writes 1, 2, 4, or 8 ushorts of data for image2d_t image, each work item in the subgroup to the specified int2 byte_coord, ushort data ) image at the specified coordinate as a block void intel_sub_group_block_write_us2( operation. Note that the coordinate is a image2d_t image, byte coordinate, not an image element int2 byte_coord, ushort2 data ) coordinate. Unlike the image block read void intel_sub_group_block_write_us4( function, which may read from any arbitrary image2d_t image, byte offset, the x-component of the byte int2 byte_coord, ushort4 data ) coordinate for the image block write void intel_sub_group_block_write_us8( functions must be a multiple of four; in image2d_t image, other words, the write must begin at 32-bit int2 byte_coord, ushort8 data ) boundary. There is no restriction on the y-component of the coordinate. Also, note that the image data is written without format conversion, so each work item may write multiple image elements (for images with element size smaller than 16-bits). The data is written row-by-row, so the first value written is from the row specified by the y-component of the provided byte_coord, the second value is written from the y- component of the provided byte_coord plus one, etc. Please see the note below describing out-of- bounds behavior for these functions. --------------------------------------------------------------------------------------" Revision History Version 1 (2016/10/20): First public revision.