13 KiB
Release Notes v1.3
Level Zero Core API.
January 2022
Changes in this release:
Implict Scaling
Implicit scaling has been enabled by default on Level Zero on Xe HPC (PVC) B and later steppings. The EnableImplicitScaling debug key may be used to enable (EnableImplicitScaling=1) or disable (EnableImplicitScaling=0) implicit scaling on on Xe HPC and other multi-tile architectures.
Blocking Free
The blocking free memory policy has been implemented for zeMemFreeExt extension. Defer free policy will be added in upcoming releases.
PCI Properties Extension
Support for PCI properties extension has been added via zeDevicePciGetPropertiesExt interface. This currently provides access to device's BDF address only. Device bandwidth property will be exposed in future based on support from underlying components
Memory Compression Hints
Memory compression hints for shared and device memory allocations and images have been added.
Sampler Address Modes Fix
Level Zero driver had a bug in the implementation of the ZE_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER and ZE_SAMPLER_ADDRESS_MODE_CLAMP address modes, where this were being implemented invertedly. This is now fixed and users can use driver's version to determine which address mode to use. Details on how DPC++ is handling this can be found in:
[756c2e8fb4/sycl/plugins/level_zero/pi_level_zero.cpp (L5264)?]
Release Notes v1.2
Level Zero Core API.
August 2021
Changes in this release:
Extension to create image views for planar formats
This extension allows accessing each plane for planar formats and have different interpretations of created images.
Sample code:
Extension for querying image properties
This extension allows querying the different properties of an image, such as size, row pitch, and slice pitch.
Definition of ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES_1_2 properties
ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES_1_2 properties allows users to request driver to return timer resolution in cycles per seconds,
as defined v1.2 specification:
ze_api_version_t version;
zeDriverGetApiVersion(hDriver, &version);
...
ze_device_properties_t devProperties = {};
devProperties->stype = ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES_1_2;
zeDeviceGetProperties(device, &devProperties);
uint64_t timerResolutionInCyclesPerSecond = devProperties.timerResolution;
If ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES_1_2 is not set, then timer resolution is returned in nanoseconds, as defined in v1.1.
ze_api_version_t version;
zeDriverGetApiVersion(hDriver, &version);
...
ze_device_properties_t devProperties = {};
zeDeviceGetProperties(device, &devProperties);
uint64_t timerResolutionInNanoSeconds = devProperties.timerResolution;
Extension to set preferred allocation for USM shared allocations
ZE_DEVICE_MEM_ALLOC_FLAG_BIAS_INITIAL_PLACEMENT and ZE_HOST_MEM_ALLOC_FLAG_BIAS_INITIAL_PLACEMENT can now be set in
ze_device_mem_alloc_flags_t and ze_host_mem_alloc_flags_t, respectively, when creating a shared-alloaction, to indicate
the driver where a shared-allocation should be initially placed.
IPC Memory Cache Bias Flags
ZE_IPC_MEMORY_FLAG_BIAS_CACHED and ZE_IPC_MEMORY_FLAG_BIAS_UNCACHED can be passed when opening an IPC
memory handle with zeMemOpenIpcHandle to set the cache settings of the imported allocation.
Support for preferred group size
ze_kernel_preferred_group_size_properties_t can be used through zeKernelGetProperties to query for the preferred
multiple group size of a kernel for submission. Submitting a kernel with the preferred group size returned by the driver
may improve performance in certain platforms.
Module compilation options
Optimization levels can now be passed to zeModuleCreate using the -ze-opt-level option, which are then communicated
to the underlying graphics compiler as hint to indicate the level of optimization desired.
Extension to read the timestamps of each subdevice
This extension defines the zeEventQueryTimestampsExp interface to query for timestamps of the parent device or
all of the available subdevices.
Extension to set thread arbitration policy
The zeKernelSchedulingHintExp interface allows applications to set the thread arbitration policy desired for the
target kernel. Avaialable policies can be queried by application through zeDeviceGetModuleProperties with the
ze_scheduling_hint_exp_properties_t structure.
Policies include:
ZE_SCHEDULING_HINT_EXP_FLAG_OLDEST_FIRSTZE_SCHEDULING_HINT_EXP_FLAG_ROUND_ROBINZE_SCHEDULING_HINT_EXP_FLAG_STALL_BASED_ROUND_ROBIN
Extension for cache reservation
With zeDeviceReserveCacheExt, applications can reserve sections of the GPU cache for exclusive use. Cache level
support varies between platforms.
Likewise, zeDeviceSetCacheAdviceExt, can be used to set a region of the cached as reserved or non-reserved region. If default behavior selected, then non-reserved is used, where region is accessible to all clients or applications.
Release Notes v1.1
Level Zero Core API.
April 2021
Changes in this release:
Device allocations larger than 4GB size.
https://spec.oneapi.com/level-zero/latest/core/api.html?highlight=relaxed#relaxedalloclimits-enums
L0 driver now allows the allocation of buffers larger than 4GB. To use, the ze_relaxed_allocation_limits_exp_desc_t
structure needs to be passed to zeMemAllocHost or zeMemAllocShared as a linked descriptor.
Sample code:
ze_relaxed_allocation_limits_exp_desc_t relaxedDesc = {};
relaxedDesc.stype = ZE_STRUCTURE_TYPE_RELAXED_ALLOCATION_LIMITS_EXP_DESC;
relaxedDesc.flags = ZE_RELAXED_ALLOCATION_LIMITS_EXP_FLAG_MAX_SIZE;
ze_device_mem_alloc_desc_t deviceDesc = {};
deviceDesc.pNext = &relaxedDesc;
zeMemAllocDevice(context, &deviceDesc, size, 0, device, &ptr);
In addition to this, kernels need to be compiled with ze-opt-greater-than-4GB-buffer-required. This needs to be
passed in pBuildFlags field in ze_module_desc_t descriptor while calling zeModuleCreate.
zeDeviceGetGlobalTimestamps for CPU/GPU synchronized time.
Returns synchronized Host and device global timestamps.
Sample code:
ze_relaxed_allocation_limits_exp_desc_t relaxedDesc = {};
relaxedDesc.stype = ZE_STRUCTURE_TYPE_RELAXED_ALLOCATION_LIMITS_EXP_DESC;
relaxedDesc.flags = ZE_RELAXED_ALLOCATION_LIMITS_EXP_FLAG_MAX_SIZE;
ze_device_mem_alloc_desc_t deviceDesc = {};
deviceDesc.pNext = &relaxedDesc;
zeMemAllocDevice(context, &deviceDesc, size, 0, device, &ptr);
Global work offset
Applications now can set a global work offset to kernels.
Sample code:
...
uint32_t groupSizeX = sizeX;
uint32_t groupSizeY = 1u;
uint32_t groupSizeZ = 1u;
zeKernelSetGroupSize(kernel, groupSizeX, groupSizeY, groupSizeZ);
uint32_t offsetx = offset;
uint32_t offsety = 0;
uint32_t offsetz = 0;
zeKernelSetGlobalOffsetExp(kernel, offsetx, offsety, offsetz);
...
Atomic floating point properties
Applications now can query for floating atomic properties supported by the device in a kernel.
This is done by passing ze_float_atomic_ext_properties_t to zeDeviceGetModuleProperties as a linked property structure.
Sample code:
ze_device_module_properties_t kernelProperties = {};
ze_float_atomic_ext_properties_t extendedProperties = {};
extendedProperties.stype = ZE_STRUCTURE_TYPE_FLOAT_ATOMIC_EXT_PROPERTIES;
kernelProperties.pNext = &extendedProperties;
zeDeviceGetModuleProperties(hDevice, &kernelProperties);
if (extendedProperties.fp16Flags & ZE_DEVICE_FP_ATOMIC_EXT_FLAG_GLOBAL_ADD) {
// kernel supports floating atomic add and subtract
}
Context Creation for specific devices
Added zeContextCreateEX to create a context with a set of devices. Resources allocated against that context
are visible only to the devices for which the context was created.
Sample code:
std::vector<ze_device_handle_t> devices;
devices.push_back(device0);
devices.push_back(device1);
...
zeContextCreateEx(hDriver, &desc, devices.size(), devices.data(), &phContext);
Change on timer resolution
Time resolution returned by device properties has been changed to cycles/second (v1.0 has a resolution of nano-seconds).
To help libraries with the transtition to the new resolution, the UseCyclesPerSecondTimer variable has been defined.
When set to 1, the driver will return the resolution defined for v1.1 (cycles/second), otherwise, it will still
return the resolution for v1.0 (nanoseconds). The use of this environment variable is only temporal while applications
and libraries complete their transition to v1.1 and will be eventually eliminated, leaving the resolution for v1.1 as default.
When reading querying for the timere resolution, applications then need to keep in mind:
- If
ZE_API_VERSION_1_0returned byzeDriverGetApiVersion: Timer resolution is nanoseconds. - If
ZE_API_VERSION_1_1returned byzeDriverGetApiVersion: Timer resolution is nanoseconds, as in v1.0. - If
ZE_API_VERSION_1_1returned byzeDriverGetApiVersionandUseCyclesPerSecondTimer=1: Timer resolution is cycles per seconds, as in v1.1.
Note: In Release builds, NEOReadDebugKeys=1 may be needed to read environment variables. To confirm the L0 driver is
reading the environment variables, please use PrintDebugSettings=1, which will print them at the beginning of the
application. See below:
$ PrintDebugSettings=1 UseCyclesPerSecondTimer=1 ./zello_world_gpu
Non-default value of debug variable: PrintDebugSettings = 1
Non-default value of debug variable: UseCyclesPerSecondTimer = 1
...
Sample code:
if UseCyclesPerSecondTimer=1 set
ze_api_version_t version;
zeDriverGetApiVersion(hDriver, &version);
...
ze_device_properties_t devProperties = {};
zeDeviceGetProperties(device, &devProperties);
if (version == ZE_API_VERSION_1_1) {
uint64_t timerResolutionInCyclesPerSecond = devProperties.timerResolution;
} else {
uint64_t timerResolutionInNanoSeconds = devProperties.timerResolution;
}
...
if UseCyclesPerSecondTimer not set
ze_api_version_t version;
zeDriverGetApiVersion(hDriver, &version);
...
ze_device_properties_t devProperties = {};
zeDeviceGetProperties(device, &devProperties);
uint64_t timerResolutionInNanoSeconds = devProperties.timerResolution;
...