Developer Guide and Reference

  • 2022.2
  • 09/08/2022
  • Public Content

Diagnostics Reference

This topic gives you all of the diagnostic reference numbers, messages, detailed help, and suggestion to fix your errors.
ID
Message
An error handling
if-stmt
was detected but could not be rewritten. See the details in the resulting file comments.
The statement could not be removed. See the details in the resulting file comments.
A special case error handling
if-stmt
was detected. You may need to rewrite this code.
The migrated API does not return an error code, so
(*, 0)
is inserted. You may need to rewrite this code.
Compatible SYCL code could not be generated.
The SYCL device version is different from CUDA Compute Compatibility. You may need to rewrite this code.
SYCL does not provide a standard API to differentiate between integrated and discrete GPU devices.
Migration of
<API name>
is not supported by the Intel® DPC++ Compatibility Tool.
The clock function is not defined in SYCL. This is a hardware-specific feature. Consult with your hardware vendor to find a replacement.
SYCL uses exceptions to report errors and does not use error codes. The original code was commented out and a warning string was inserted. You may need to rewrite this code.
SYCL uses exceptions to report errors and does not use error codes. The call was replaced with 0. You may need to rewrite this code.
The tool detected overloaded operators for built-in vector types, which may conflict with the SYCL 1.2.1 standard operators (see 4.10.2.1 Vec interface). The tool inserted a namespace to avoid the conflict. Use SYCL 1.2.1 standard operators instead.
Detected a kernel execution time measurement pattern and generated an initial code for time measurements in SYCL. You can change the way time is measured depending on your requirements.
The rounding mode could not be specified and the generated code may have different precision than the original code. Verify the correctness. The SYCL math built-in functions rounding mode is aligned with the OpenCL™ C 1.2 standard.
The flag and priority options are not supported for SYCL queues. The output parameter(s) are set to 0.
The output requires adjustment.
The
<API name>
was not migrated, because parameter(s)
<parameter name a>
and/or
<parameter name b>
could not be evaluated, or because
<parameter name a>
is not equal to
<parameter name b>
. Rewrite this code manually.
The
<SYCL API name>
call is used instead of the
<CUDA API name>
call. These two calls do not provide the same functionality. Check the potential precision and/or performance issues for the generated code.
The
<API name>
was migrated, but the generated code performance may be sub-optimal due to the following reasons:
  • The
    <parameter name>
    could not be evaluated and may be smaller than
    <other parameter name>
    .
  • The
    <parameter name>
    is equal to
    <other parameter name>
    , but is greater than 1.
The
local_mem_size
in SYCL is not a complete equivalent of
sharedMemPerBlock
. You may need to adjust the code.
The migration of
<api name>
, if it is called from
__global__
or
__device__
function, is not supported. You may need to redesign the code to use the host-side
<api name>
instead, which submits this call to the SYCL queue automatically.
Migration of
cublasHandle_t
in
__global__
or
__device__
function is not supported. You may need to redesign the code
There is no exact match between the
maxGridSize
and the
max_nd_range
size. Verify the correctness of the code.
The SYCL sub-group does not support mask options for
<api name>
.
The original code returned the error code that was further consumed by the program logic. This original code was replaced with 0. You may need to rewrite the program logic consuming the error code.
The SYCL queue is created ignoring the flag and priority options.
The call to
<API name>
was removed because
<reason>
.
The reason can be:
  • SYCL currently does not support setting resource limits on devices
  • SYCL currently does not support associating USM with a specific queue
  • SYCL currently does not support query operations on queues
  • SYCL currently does not support capture operations on queues
  • SYCL currently does not support configuring shared memory on devices
  • SYCL currently does not support setting cache config on devices
  • SYCL currently does not support registering of existing host memory for use by device. Use USM to allocate memory for use by host and device
  • SYCL currently does not support setting flags for devices
  • SYCL currently does not support memory access across peer devices
  • there is no corresponding API in SYCL
  • this call is redundant in SYCL
The call to
<API name>
was replaced with 0 because
<reason>
.
The reason can be:
  • SYCL currently does not support setting resource limits on devices
  • SYCL currently does not support associating USM with a specific queue
  • SYCL currently does not support query operations on queues
  • SYCL currently does not support capture operations on queues
  • SYCL currently does not support configuring shared memory on devices
  • SYCL currently does not support setting cache config on devices
  • SYCL currently does not support registering of existing host memory for use by device. Use USM to allocate memory for use by host and device
  • SYCL currently does not support setting flags for devices
  • SYCL currently does not support memory access across peer devices
  • there is no corresponding API in SYCL
  • this call is redundant in SYCL
The
<API name>
was not migrated because the parameter
<parameter name>
is unsupported.
SYCL currently does not support getting device resource limits. The output parameter(s) are set to 0.
SYCL currently does not support inter-process communication (IPC) operations. You may need to rewrite the code.
SYCL currently does not support memory access across peer devices. The output parameter(s) are set 0.
A different random number generator is used. You may need to adjust the code.
The migrated code uses a basic Sobol generator. Initialize the
mkl::rng::sobol
generator with user-defined direction numbers to use it as Scrambled Sobol generator.
The migrated API does not return an error code. 0 is returned in the lambda. You may need to rewrite this code.
All SYCL devices can be used by the host to submit tasks. You may need to adjust this code.
The type
<type name>
was not migrated because the migration depends on the
<API call>
.
Rewrite this code using
<library name>
with SYCL.
When the kernel function name is used as a macro argument, the migration result may be incorrect. You need to verify the definition of the macro.
The generated code assumes that
<parameter name>
points to the global memory address space. If it points to a local memory address space, replace
<function name>
with
<function name>
.
Use
sycl::stream
instead of
printf
if your code is used on the device.
SYCL uses exceptions to report errors, it does not use error codes. 0 is used instead of an error code in a
<statement>
. You may need to rewrite this code.
The size of the arguments passed to the SYCL kernel exceeds the minimum size limit (1024) for a non-custom SYCL device. You can get the hardware argument size limit by querying
info::device::max_parameter_size
. You may need to rewrite this code if the size of the arguments exceeds the hardware limit.
The version-related API is different in SYCL. An initial code was generated, but you need to adjust it.
<BaseClass1>
was removed because
<BaseClass2>
has been deprecated in C++11. You may need to remove references to typedefs from
<BaseClass1>
in the class definition.
Migration is only supported for this API for the general sparse matrix type. You may need to adjust the code.
The
<original API name>
was not migrated because
<reason>
. You need to adjust the code. This may be due to one of the following:
  • Not all values of parameters could be evaluated in migration.
  • The combination of matrix data type and scalar type is unsupported.
The meaning of
<parameter name>
in the
<API name>
is different from the
<API name>
. You may need to check the migrated code.
The original value
<macro name>
is not meaningful in the migrated code and was removed or replaced with 0. You may need to check the migrated code.
The work-group size passed to the SYCL kernel may exceed the limit. To get the device limit, query
info::device::max_work_group_size
. Adjust the work-group size if needed.
The template argument of the
<type>
could not be deduced. You need to update this code.
SYCL does not support the device property that would be functionally compatible with
<property name>
. It was migrated to
<migrated token>
. You may need to rewrite the code.
SYCL does not support the member access for a volatile qualified vector type. The volatile qualifier was removed. You may need to rewrite the code.
Migration of device assembly code is not supported.
The type of variable
<variable name>
is declared in device function with the name
<type>
. Adjust the code to make the
<type>
declaration visible at the accessor declaration point.
Vector types with size 1 are migrated to the corresponding fundamental types, which cannot be inherited. You need to rewrite the code.
The Intel® DPC++ Compatibility Tool did not detect the variable
<variable name>
used in device code. If this variable is also used in device code, you need to rewrite the code.
Variable
<variable name>
was used in host code and device code. The Intel® DPC++ Compatibility Tool updated
<variable name>
type to be used in SYCL device code and generated new
<host variable name>
to be used in host code. You need to update the host code manually to use the new
<host variable name>
.
<API Name>
is not migrated because it is not called in the code.
SYCL only supports 4-channel image format. Adjust the code.
SYCL range can only be a 1D, 2D, or 3D vector. Adjust the code.
Call to
<macro name>
macro was removed because it only contains code, which is unnecessary in SYCL.
SYCL Image doesn’t support normalized read mode.
Advice parameter is device-defined. You may need to adjust it.
Migrated
<function name>
call is used in a macro definition and is not valid for all macro uses. Adjust the code.
Consider replacing
sycl::nd_item::barrier()
with
sycl::nd_item::barrier(sycl::access::fence_space::local_space)
for better performance if there is no access to global memory.
Input/Output distance are migrated to FWD/BWD_DISTANCE. You may need to update the code manually.
The
<parameter name>
parameter could not be migrated. You may need to update the code manually.
The value of
<argument type>
could not be deduced. You need to update
<placeholder>
manually.
The argument
<argument name>
of the kernel function contains virtual pointer(s), which cannot be dereferenced. Try to migrate the code with
\"usm-level=restricted\"
.
<pointer variable name>
is allocated by
dpct::dpct_malloc
. Use
dpct::get_host_ptr<type>(pointer variable name)
to access the pointer from the host code.
The placement of the FFT computational function could not be deduced, so it is assumed out-of-place. You may need to adjust the code.
SYCL currently does not support getting the available memory on the current device. You may need to adjust the code.
The field values of parameter
{0}
could not be deduced, so the call was not migrated. You need to update this code manually.
The SYCL Image class does not support some of the flags used in the original code. Unsupported flags were ignored. Data read from SYCL Image could not be normalized as specified in the original code.
Migration of cuFFT calls may be incorrect and require review.
The device attribute was not recognized by the Intel® DPC++ Compatibility Tool. You may need to adjust the code.
<macro name>
redefines a standard SYCL type, which may cause conflicts.
Consider replacing
memory_order::acq_rel
with
memory_order::seq_cst
for correctness if strong memory order restrictions are needed.
Replace “dpct_placeholder” with the file path of the dynamic library.
Variadic functions cannot be called in a SYCL kernel or by functions called by the kernel. You may need to adjust the code.
The generated code assumes that
<pointer variable>
points to the global memory address space. If it points to a local or private memory address space, replace
address_space::global
with
address_space::local
or
address_space::private
.
The type
<type name>
was not migrated because the Intel® DPC++ Compatibility Tool doesn’t support migration of this type.
The size of local memory in the migrated code may be different from the original code. Check that the allocated memory size in the migrated code is correct.
The function call has multiple migration results in different template instantiations that could not be unified. You may need to adjust the code.
The function
%0
requires sub-group size to be
%1
, while other sub-group functions in the same SYCL kernel require a different sub-group size. You may need to adjust the code.
__activemask()
is migrated to
0xffffffff
. You may need to adjust the code.
SYCL currently does not support cross group synchronization. You can specify
--use-experimental-features=nd_range_barrier
to use the dpct helper function
nd_range_barrier
to migrate
<grid type variable name>.sync()
.
The macro definition has multiple migration results in the dimension of free queries function that could not be unified. You may need to modify the code.
The value of the sub-group size attribute argument
<argument name>
cannot be evaluated by the Intel(R) DPC++ Compatibility Tool. Replace "dpct_placeholder" with an integral constant expression.
SYCL does not support the device property that would be functionally compatible with
<property name>
. It was not migrated. You need to rewrite the code.
The function
dpct::segmented_reduce
only supports DPC++ native binary operation. Replace “dpct_placeholder” with a DPC++ native binary operation.
Consider replacing work-group size 128 with different value for specific hardware for better performance.
The
<Device ID>
device may be not the one intended for use. Adjust the selected device if needed.
Content contains misleading bidirectional Unicode characters.
The identifier
<Identifier A>
is confusable with another identifier
<Identifier B>
.
The right-most dimension of the work-group used in the SYCL kernel that calls this function may be less than
<value of kernel sub-group size attribute>
. The function
<help function name>
may return an unexpected result on the CPU device. Modify the size of the work-group to ensure that the value of the right-most dimension is a multiple of
<value of kernel sub-group size attribute>
.
The function
<backward function name>
may require the workspace used to save intermediate results from function
<forward function name>
. By default, a workspace from
engine_ext
is selected according to the source data pointer, but this may be incorrect and cause a workspace data race. You may need to rewrite this code.
The
<expression text>
expression is used instead of the
<function name>
call. These two expressions do not provide the exact same functionality. Check the generated code for potential precision and/or performance issues.

Product and Performance Information

1

Performance varies by use, configuration and other factors. Learn more at www.Intel.com/PerformanceIndex.