Hello everyone! 

I'm a new OpenCL developer. I'm trying to solve a problem using a genetic algorithm and a very importan part of this kind of heuristic algorithms is the randomness. To solve my problem I need to generate randomly an initial population and then some genetic operators will be selected in a random way too.  I want to solve my problem using heterogeneous computing, but the issue is that I cannot find a function to generate random numbers in the GPU. I was thinking that will be useful put this work into a CPU kernel.

Is there an allowed OpenCL function to generate random numbers in a kernel where the target is the CPU? 

Thanks!

M.C Juan Garcia.

Hi,

Intel SDK for OpenCL installer crashes just a few seconds after being launched. It displays a window with a progress bar and then it seems to exit, without giving any error and without installing the SDK.

Any idea how to fix this?

The SDK I am trying to install is intel_sdk_for_opencl_applications_2019.5.345. I am running on 64bit Windows 10.

support.txt file contains the following additional information:

Package ID: w_cembdw_comp_p_2019.5.082

This package contains:
        Intel(R) System Studio 2019 Update 5 Composer Edition for Windows*
        Intel(R) C++ Compiler 19.0 Update 5 for Windows* Target
        Intel(R) Math Kernel Library 2019 Update 5 for Windows* Target
        Intel(R) Integrated Performance Primitives 2019 Update 5 for Windows* Target
        Intel(R) Threading Building Blocks 2019 Update 8 for Windows* Target
        Intel(R) Data Analytics Acceleration Library 2019 Update 5 for Windows* Target
        Intel(R) Debugger for Heterogeneous Compute 2016**
        OpenCL(TM) Tools 2019 Update 5

Thanks.

Dear Intel,

Thank you for making various drivers and tools for OpenCL development. They are my reference driver for my OpenCL work. I have a question concerning the "Intel® Xeon® Processor OR Intel® Core™ Processor (CPU) Runtimes".

Your current CPU runtime is from 2018 (version 18.1) and is limited to Ubuntu 16.04. When can we expect a newer runtime for Ubuntu 18.04? Will this runtime include support for OpenCL 2.2?

Thank you for your time,

With best regards,

Robbert

Hi, we are planning to distribute via conda-forge open source software that benefits quite a lot from the Intel OpenCL CPU runtime. Unfortunately, none of the conda channels seems to have a recipe to install the Intel OpenCL CPU runtime via conda. Does the runtime license allow the hosting and distribution of the Intel OpenCL CPU runtime on conda forge? If yes, we would love to create a corresponding recipe for conda-forge.

Best wishes

Timo

Hello,

I just downloaded intel sdk for opencl applications 2019.5.345 (stand-alone version for Windows that I downloaded from https://software.intel.com/en-us/opencl-sdk/choose-download). I unzipped the archive and tried to run setup.exe. The first screen of the installer shows up, the progress bar is moving during 2 or 3 seconds and then... it closes and nothing more happens.

I went to Windows Event Viewer -> Windows Logs -> Application and saw an error (see below). Obviously the installer crashed. Is there any other way of getting this tool installed?

Thanks in advance for your time and help,

Sébastien Geron

---------------------------------

Application: install.exe
Framework Version: v4.0.30319
Description: The process was terminated due to an unhandled exception.
Exception Info: System.NotSupportedException
   at System.Reflection.RuntimeAssembly.nLoadFile(System.String, System.Security.Policy.Evidence)
   at System.Reflection.Assembly.LoadFile(System.String)
   at micl.plugin.net.loader.resolver.ResolveHandler(System.Object, System.ResolveEventArgs)
   at System.AppDomain.OnAssemblyResolveEvent(System.Reflection.RuntimeAssembly, System.String)

Exception Info: System.IO.FileLoadException
   at <Module>.?A0x9974d22c.??__E??_7v8_binder@wpf@net@plugin@micl@@6B@@@YMXXZ()
   at <Module>._initterm_m(Void* ()*, Void* ()*)
   at <Module>.<CrtImplementationDetails>.LanguageSupport.InitializeVtables(<CrtImplementationDetails>.LanguageSupport*)
   at <Module>.<CrtImplementationDetails>.LanguageSupport._Initialize(<CrtImplementationDetails>.LanguageSupport*)
   at <Module>.<CrtImplementationDetails>.LanguageSupport.Initialize(<CrtImplementationDetails>.LanguageSupport*)

Exception Info: <CrtImplementationDetails>.ModuleLoadException
   at <Module>.<CrtImplementationDetails>.LanguageSupport.Initialize(<CrtImplementationDetails>.LanguageSupport*)
   at <Module>..cctor()

Exception Info: System.TypeInitializationException

When trying to install the SDK, the installer fails.  See error_1.png.  If I debug the installer, I get the contents of error_2.png

Multiple users have reported installation hangs for the 2019 Update 5 version of the SDK. This issue is under investigation.

Speculation is that some .NET configurations may be blocking the installer.

The recommendation that some users confirmed as a work around was to run the installer by hand for .NET 3.5 like so:

install.exe --net35

install.exe is available in the root of the installation .zip file available from the Intel Registration Center download portal for the product. Reference:

Portal - Windows

Reports and references from other users:

• https://software.intel.com/en-us/forums/opencl/topic/830330
• https://software.intel.com/en-us/node/829568
• https://software.intel.com/en-us/forums/opencl/topic/831819

Please use this thread to send any screen shots or installation logs which may be available.

Installer logs are typically located in a folder structure that looks like this: %TEMP%\pset_tmp  or...

folders underneath %TEMP% with 'intel' in the folder name.

Thank you for your interest.

-MichaelC

When I used vs2019 to work with opencl, the update 5 dosn't support the vs2019.Is there mehod to solve this isssue??Thanks

Hi,

   I wrote kernels which are distributed between two files. And I tried compiling , it looked to be compiling fine.

But during linking it throws error as below.

I am also attaching my Makefile for reference.

Please let me know how i can solve this error.

 make
aoc -v -report -march=emulator -legacy-emulator -I ../../stb -I device/RTL -L device/RTL -l rtl_lib.aoclib  -g ./device/conv_pipe.cl ./device/frcnn.cl
Resolving library filenames to full paths
  lib_path = device/RTL
    lib_file = rtl_lib.aoclib
Resolved rtl_lib.aoclib to /home/vinay/Documents/stryker-fasterRCNN/stryker-arria10/project/device/RTL/rtl_lib.aoclib
  lib_path = .
All OpenCL C models were extracted from specified libraries and added to compilation
aoc: Environment checks are completed successfully.
aoc: Cached files in /var/tmp/aocl/ may be used to reduce compilation time
You are now compiling the full flow!!
aoc: Selected default target board a10gx
aoc: Running OpenCL parser....
/home/vinay/Documents/stryker-fasterRCNN/stryker-arria10/project/device/conv_pipe.cl:119:16: warning: unknown attribute 'task' ignored
__attribute__((task))
               ^
/home/vinay/Documents/stryker-fasterRCNN/stryker-arria10/project/device/conv_pipe.cl:402:16: warning: unknown attribute 'task' ignored
__attribute__((task))
               ^
/home/vinay/Documents/stryker-fasterRCNN/stryker-arria10/project/device/conv_pipe.cl:566:16: warning: unknown attribute 'task' ignored
__attribute__((task))
               ^
/home/vinay/Documents/stryker-fasterRCNN/stryker-arria10/project/device/conv_pipe.cl:661:16: warning: unknown attribute 'task' ignored
__attribute__((task))
               ^
/home/vinay/Documents/stryker-fasterRCNN/stryker-arria10/project/device/conv_pipe.cl:963:16: warning: unknown attribute 'task' ignored
__attribute__((task))
               ^
5 warnings generated.
aoc: OpenCL parser completed successfully.
aoc: Selected default target board a10gx
aoc: Running OpenCL parser....
/home/vinay/Documents/stryker-fasterRCNN/stryker-arria10/project/device/frcnn.cl:105:16: warning: unknown attribute 'task' ignored
__attribute__((task))
               ^
1 warning generated.
aoc: OpenCL parser completed successfully.
aoc: Selected default target board a10gx
aoc: Running OpenCL parser....
aoc: OpenCL parser completed successfully.
aoc: Linking Object files....
aoc: Compiling for Emulation ....
aocl-opt: /build/swbuild/SJ/nightly/19.2/57/l64/p4/acl/llvm/lib/IR/Value.cpp:404: void llvm::Value::doRAUW(llvm::Value*, llvm::Value::ReplaceMetadataUses): Assertion `New->getType() == getType() && "replaceAllUses of value with new value of different type!"' failed.
Stack dump:
0.    Program arguments: /home/wc/intelFPGA_pro/19.2/hld/linux64/bin/../../llvm/bin/aocl-opt -translate-library-calls -reverse-library-translation -insert-ip-library-calls -create-emulator-wrapper -generate-emulator-sys-desc -VPODirectiveCleanup -libfile /home/vinay/Documents/stryker-fasterRCNN/stryker-arria10/project/device/RTL/rtl_lib.aoclib -dbg-info-enabled c_model.1.bc -o c_model.bc
1.    Running pass 'CreateEmulatorWrappers: Creates kernel wrapper functions and lookup table that can be called from the emulator run time' on module 'c_model.1.bc'.
/home/wc/intelFPGA_pro/19.2/hld/llvm/bin/../lib/libLLVM-8svn.so(_ZN4llvm3sys15PrintStackTraceERNS_11raw_ostreamE+0x2a)[0x7f575a4e5a4a]
/home/wc/intelFPGA_pro/19.2/hld/llvm/bin/../lib/libLLVM-8svn.so(_ZN4llvm3sys17RunSignalHandlersEv+0x4c)[0x7f575a4e39ec]
/home/wc/intelFPGA_pro/19.2/hld/llvm/bin/../lib/libLLVM-8svn.so(+0xc22b3c)[0x7f575a4e3b3c]
/lib/x86_64-linux-gnu/libpthread.so.0(+0x12890)[0x7f57596b4890]
/lib/x86_64-linux-gnu/libc.so.6(gsignal+0xc7)[0x7f5757f51e97]
/lib/x86_64-linux-gnu/libc.so.6(abort+0x141)[0x7f5757f53801]
/lib/x86_64-linux-gnu/libc.so.6(+0x3039a)[0x7f5757f4339a]
/lib/x86_64-linux-gnu/libc.so.6(+0x30412)[0x7f5757f43412]
/home/wc/intelFPGA_pro/19.2/hld/llvm/bin/../lib/libLLVM-8svn.so(_ZN4llvm5Value6doRAUWEPS0_NS0_19ReplaceMetadataUsesE+0x230)[0x7f575a678ef0]
/home/wc/intelFPGA_pro/19.2/hld/llvm/bin/../lib/libLLVM-8svn.so(+0x1f639e9)[0x7f575b8249e9]
/home/wc/intelFPGA_pro/19.2/hld/llvm/bin/../lib/libLLVM-8svn.so(+0x1f6ccd0)[0x7f575b82dcd0]
/home/wc/intelFPGA_pro/19.2/hld/llvm/bin/../lib/libLLVM-8svn.so(_ZN4llvm6legacy15PassManagerImpl3runERNS_6ModuleE+0x3bc)[0x7f575a61da5c]
/home/wc/intelFPGA_pro/19.2/hld/linux64/bin/../../llvm/bin/aocl-opt(main+0x26c5)[0x555c80165b15]
/lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xe7)[0x7f5757f34b97]
/home/wc/intelFPGA_pro/19.2/hld/linux64/bin/../../llvm/bin/aocl-opt(+0x2a6bd)[0x555c801666bd]
Aborted (core dumped)
Error: Optimizer FAILED.
Refer to c_model/c_model.log for details.

Makefile:139: recipe for target 'conv.aocx' failed
make: *** [conv.aocx] Error 1

Hello, I'm having a problem with building one of my OpenCL kernels. I'm trying to build on the Intel HD graphics 4000 graphics card on a windows 64 machine, driver version 10.18.10.5069 (the latest I can find). I'm building the solution with visual studio 2019, and am using the cl2.hpp wrapper from the Khronos page. As I call cl::Program::build, I notice that the (host) memory usage of the program greatly increases, even to over 3 gigabytes. After several seconds of this, the build fails. The build log ends with the following:

fcl build 1 succeeded.
fcl build 2 succeeded.
Error: internal error.

This code was building just fine on a different windows machine using a different Intel card, but after moving to this machine it does this. The kernel code compiles without any problems, it just doesn't build. After deleting and changing certain aspects of the code, I can get it to build, but it still uses way too much memory. Could you guys tell me what I'm doing wrong or if there's some sort of bug?

I will attach code that has around 15 lines repeated about a hundred times, which is able to reproduce the issue (although my original kernel doesn't repeat 15 lines a hundred times), and the c++ code I'm using to load and build the kernel. Also worth noting is that I'm not linking against the Intel SDK files, but I downloaded and compiled my own from the Khronos repository.

Hi, 

I'm working on a project where I'm using OpenCL 2.1 NEO and I want to know if I can use C++ inside the kernel code. I see AMD has that feature and also OpenCL 2.1 it has C++ specs. But I'm not able to use the C++ code inside the kernel.

Hi, I'm getting a hang/deadlock when when initializing an Intel OpenCL context from a TBB thread on Linux. On Windows, it's fine. Please try the attached source code.

// ocl_test.cpp
//
// Compile with: g++ -std=c++14 -I/path/to/opencl/include -I/path/to/tbb/include -lOpenCL -ltbb -lpthread -L. ocl_test.cpp -o ocl_test
//
// cl.hpp used from: https://www.khronos.org/registry/OpenCL/api/2.1/cl.hpp
//
// Run with:
// $ cd /path/to/parent/dir/libintelocl.so
// $ env LD_LIBRARY_PATH=. LD_PRELOAD=libintelocl.so ./ocl_test
//
// This hangs on Linux under various Intel processors but not Windows
//
#include <iostream>
#include <future>
#include <atomic>
#include <vector>

#define __CL_ENABLE_EXCEPTIONS
#define CL_TARGET_OPENCL_VERSION 120
#include "cl.hpp"

#ifdef _WIN32
#ifdef _DEBUG
    #pragma comment(lib, "OpenCL_d")
    #pragma comment(lib, "tbb_debug")
#else
    #pragma comment(lib, "OpenCL")
    #pragma comment(lib, "tbb")
#endif
#endif

//#define TEST_STDTHREAD
#define TEST_TBB

#ifdef TEST_TBB
#include <tbb/tbb.h>

template <typename F>
class LambdaTask : public tbb::task
{
public:
    LambdaTask(const F& f) : myF(f) {
    }
private:
    tbb::task* execute() override {
        if (myF()) {
            return new(tbb::task::allocate_continuation()) LambdaTask(myF);
        }
        return nullptr;
    }
    F myF;
};

template <typename F>
static void EnqueueLambda(const F& f) {
    tbb::task::enqueue(
            *new(tbb::task::allocate_root()) LambdaTask<F>(f) );
}

template <typename F>
static void SpawnAndWaitLambda(const F& f) {
    tbb::task::spawn_root_and_wait(
            *new(tbb::task::allocate_root()) LambdaTask<F>(f) );
}
#endif

int main() {

    std::vector<cl::Platform> platforms;
    cl::Platform::get(&platforms);

    if (platforms.empty()) {
        std::cout << "No platforms found.\n";
        return 1;
    }

    for (const cl::Platform &platform : platforms) {
        std::cout << "Available platform: "<< platform.getInfo<CL_PLATFORM_NAME>() << "\n";
    }

    cl::Platform platform = platforms[0];
    std::cout << "Using platform: "<< platform.getInfo<CL_PLATFORM_NAME>()
              << "\n";

    std::vector<cl::Device> devices;
    platform.getDevices(CL_DEVICE_TYPE_ALL, &devices);
    if (devices.empty()) {
        std::cout << "No devices found.\n";
        return 1;
    }

    cl::Device device = devices[0];
    std::cout << "Using device: "<< device.getInfo<CL_DEVICE_NAME>() << "\n";

    auto create_context = [&]() {
        std::cout << "Attempting to create context"<< std::endl;
        cl::Context context({device});
        std::cout << "Created context"<< std::endl;
    };

#if defined(TEST_STDTHREAD)

    std::cout << "TEST_STDTHREAD"<< std::endl;
    auto task = std::async(std::launch::async, [&]() { create_context(); });
    task.wait();
    std::cout << "Done"<< std::endl;

#elif defined(TEST_TBB)

    std::cout << "TEST_TBB"<< std::endl;

    std::atomic_bool done(false);

    EnqueueLambda([&]() {
        create_context();
        done = true;
        return false;
    });

#if 1
    // Try waiting inside scheduler loop
    SpawnAndWaitLambda([&]() {
        if (done)
        {
            std::cout << "Done"<< std::endl;
            return false;
        }
        return true;
    });
#else
    // This also fails if we just spin loop
    while (!done)
        ;
    std::cout << "Done"<< std::endl;
#endif

#else
    std::cout << "TEST_SERIAL"<< std::endl;
    create_context();
    std::cout << "Done"<< std::endl;
#endif

    return 0;
}

Run the install, and nothing would happen after the splash screen disappeared. 

 When I use aoc to compile OpenCL kernel ，DSP utilization is limited to 25% .

At first , I used "#pragma unroll" to unroll the loop.  when the number of unroll become bigger ,  The DSP blocks utilization increased.

But,when the number of unroll is bigger enough ,the DSP blocks utilization  is limited to 25% .

Why does this happen？

board：Intel® Programmable Acceleration Card with Intel® Arria® 10 FPGA GX

SDK：Intel FPGA SDK for OpenCL 17.1

aoc compile report：

+--------------------------------------------------------------------+
; Estimated Resource Usage Summary                     ;
+----------------------------------------+---------------------------+
; Resource                                 + Usage                    ;
+----------------------------------------+---------------------------+
; Logic utilization                      ;   78%                     ;
; ALUTs                                     ;   48%                     ;
; Dedicated logic registers       ;   34%                     ;
; Memory blocks                      ;   57%                     ;
; DSP blocks                             ;   25%                     ;
+----------------------------------------+---------------------------;

aoc compile report(when number of unroll become bigger)：

+--------------------------------------------------------------------+
; Estimated Resource Usage Summary                     ;
+----------------------------------------+---------------------------+
; Resource                               + Usage                    ;
+----------------------------------------+---------------------------+
; Logic utilization                      ;  176%                    ;
; ALUTs                                     ;  130%                    ;
; Dedicated logic registers       ;   60%                     ;
; Memory blocks                      ;   74%                    ;
; DSP blocks                             ;   25%                     ;
+----------------------------------------+---------------------------;
 

I am learning OpenCL and configuring the environment right now.

My system is Ubuntu 18.04. The HW is Intel® Core™ i7-8700K with GeForce GTX 1080 Ti.

I download intel_sdk_for_opencl_applications_2020.0.270.tar.gz from Intel® SDK for OpenCL™ Applications, extract it, run 

sudo ./install.sh

and then follow the GUI instruction to complete the installation.

Then, I install NEO from intel/compute-runtime by

mkdir neo
cd neo
wget https://github.com/intel/compute-runtime/releases/download/19.51.15145/intel-gmmlib_19.3.4_amd64.deb
wget https://github.com/intel/compute-runtime/releases/download/19.51.15145/intel-igc-core_1.0.3041_amd64.deb
wget https://github.com/intel/compute-runtime/releases/download/19.51.15145/intel-igc-opencl_1.0.3041_amd64.deb
wget https://github.com/intel/compute-runtime/releases/download/19.51.15145/intel-opencl_19.51.15145_amd64.deb
wget https://github.com/intel/compute-runtime/releases/download/19.51.15145/intel-ocloc_19.51.15145_amd64.deb
sudo dpkg -i *.deb

I check the platform by clinfo which gives me the results:

Number of platforms                               2
  Platform Name                                   Intel(R) CPU Runtime for OpenCL(TM) Applications
  Platform Vendor                                 Intel(R) Corporation
  Platform Version                                OpenCL 2.1 LINUX
  Platform Profile                                FULL_PROFILE
  Platform Extensions                             cl_khr_icd cl_khr_global_int32_base_atomics cl_khr_global_int32_extended_atomics cl_khr_local_int32_base_atomics cl_khr_local_int32_extended_atomics cl_khr_byte_addressable_store cl_khr_depth_images cl_khr_3d_image_writes cl_intel_exec_by_local_thread cl_khr_spir cl_khr_fp64 cl_khr_image2d_from_buffer cl_intel_vec_len_hint 
  Platform Host timer resolution                  1ns
  Platform Extensions function suffix             INTEL

  Platform Name                                   NVIDIA CUDA
  Platform Vendor                                 NVIDIA Corporation
  Platform Version                                OpenCL 1.2 CUDA 10.2.95
  Platform Profile                                FULL_PROFILE
  Platform Extensions                             cl_khr_global_int32_base_atomics cl_khr_global_int32_extended_atomics cl_khr_local_int32_base_atomics cl_khr_local_int32_extended_atomics cl_khr_fp64 cl_khr_byte_addressable_store cl_khr_icd cl_khr_gl_sharing cl_nv_compiler_options cl_nv_device_attribute_query cl_nv_pragma_unroll cl_nv_copy_opts cl_nv_create_buffer cl_khr_int64_base_atomics cl_khr_int64_extended_atomics
  Platform Extensions function suffix             NV

  Platform Name                                   Intel(R) CPU Runtime for OpenCL(TM) Applications
Number of devices                                 1
  Device Name                                     Intel(R) Core(TM) i7-8700K CPU @ 3.70GHz
  Device Vendor                                   Intel(R) Corporation
  Device Vendor ID                                0x8086
  Device Version                                  OpenCL 2.1 (Build 0)
  Driver Version                                  18.1.0.0920
  Device OpenCL C Version                         OpenCL C 2.0 
  Device Type                                     CPU
  Device Profile                                  FULL_PROFILE
  Device Available                                Yes
  Compiler Available                              Yes
  Linker Available                                Yes
  Max compute units                               12
  Max clock frequency                             3700MHz
  Device Partition                                (core)
    Max number of sub-devices                     12
    Supported partition types                     by counts, equally, by names (Intel)
  Max work item dimensions                        3
  Max work item sizes                             8192x8192x8192
  Max work group size                             8192
  Preferred work group size multiple              128
  Max sub-groups per work group                   1
  Preferred / native vector sizes                 
    char                                                 1 / 32      
    short                                                1 / 16      
    int                                                  1 / 8       
    long                                                 1 / 4       
    half                                                 0 / 0        (n/a)
    float                                                1 / 8       
    double                                               1 / 4        (cl_khr_fp64)
  Half-precision Floating-point support           (n/a)
  Single-precision Floating-point support         (core)
    Denormals                                     Yes
    Infinity and NANs                             Yes
    Round to nearest                              Yes
    Round to zero                                 No
    Round to infinity                             No
    IEEE754-2008 fused multiply-add               No
    Support is emulated in software               No
    Correctly-rounded divide and sqrt operations  No
  Double-precision Floating-point support         (cl_khr_fp64)
    Denormals                                     Yes
    Infinity and NANs                             Yes
    Round to nearest                              Yes
    Round to zero                                 Yes
    Round to infinity                             Yes
    IEEE754-2008 fused multiply-add               Yes
    Support is emulated in software               No
  Address bits                                    64, Little-Endian
  Global memory size                              42109607936 (39.22GiB)
  Error Correction support                        No
  Max memory allocation                           10527401984 (9.804GiB)
  Unified memory for Host and Device              Yes
  Shared Virtual Memory (SVM) capabilities        (core)
    Coarse-grained buffer sharing                 Yes
    Fine-grained buffer sharing                   Yes
    Fine-grained system sharing                   Yes
    Atomics                                       Yes
  Minimum alignment for any data type             128 bytes
  Alignment of base address                       1024 bits (128 bytes)
  Preferred alignment for atomics                 
    SVM                                           64 bytes
    Global                                        64 bytes
    Local                                         0 bytes
  Max size for global variable                    65536 (64KiB)
  Preferred total size of global vars             65536 (64KiB)
  Global Memory cache type                        Read/Write
  Global Memory cache size                        262144 (256KiB)
  Global Memory cache line size                   64 bytes
  Image support                                   Yes
    Max number of samplers per kernel             480
    Max size for 1D images from buffer            657962624 pixels
    Max 1D or 2D image array size                 2048 images
    Base address alignment for 2D image buffers   64 bytes
    Pitch alignment for 2D image buffers          64 pixels
    Max 2D image size                             16384x16384 pixels
    Max 3D image size                             2048x2048x2048 pixels
    Max number of read image args                 480
    Max number of write image args                480
    Max number of read/write image args           480
  Max number of pipe args                         16
  Max active pipe reservations                    21845
  Max pipe packet size                            1024
  Local memory type                               Global
  Local memory size                               32768 (32KiB)
  Max number of constant args                     480
  Max constant buffer size                        131072 (128KiB)
  Max size of kernel argument                     3840 (3.75KiB)
  Queue properties (on host)                      
    Out-of-order execution                        Yes
    Profiling                                     Yes
    Local thread execution (Intel)                Yes
  Queue properties (on device)                    
    Out-of-order execution                        Yes
    Profiling                                     Yes
    Preferred size                                4294967295 (4GiB)
    Max size                                      4294967295 (4GiB)
  Max queues on device                            4294967295
  Max events on device                            4294967295
  Prefer user sync for interop                    No
  Profiling timer resolution                      1ns
  Execution capabilities                          
    Run OpenCL kernels                            Yes
    Run native kernels                            Yes
    Sub-group independent forward progress        No
    IL version                                    SPIR-V_1.0
    SPIR versions                                 1.2
  printf() buffer size                            1048576 (1024KiB)
  Built-in kernels                                
  Device Extensions                               cl_khr_icd cl_khr_global_int32_base_atomics cl_khr_global_int32_extended_atomics cl_khr_local_int32_base_atomics cl_khr_local_int32_extended_atomics cl_khr_byte_addressable_store cl_khr_depth_images cl_khr_3d_image_writes cl_intel_exec_by_local_thread cl_khr_spir cl_khr_fp64 cl_khr_image2d_from_buffer cl_intel_vec_len_hint 

  Platform Name                                   NVIDIA CUDA
Number of devices                                 1
  Device Name                                     GeForce GTX 1080 Ti
  Device Vendor                                   NVIDIA Corporation
  Device Vendor ID                                0x10de
  Device Version                                  OpenCL 1.2 CUDA
  Driver Version                                  440.33.01
  Device OpenCL C Version                         OpenCL C 1.2 
  Device Type                                     GPU
  Device Topology (NV)                            PCI-E, 01:00.0
  Device Profile                                  FULL_PROFILE
  Device Available                                Yes
  Compiler Available                              Yes
  Linker Available                                Yes
  Max compute units                               28
  Max clock frequency                             1645MHz
  Compute Capability (NV)                         6.1
  Device Partition                                (core)
    Max number of sub-devices                     1
    Supported partition types                     None
  Max work item dimensions                        3
  Max work item sizes                             1024x1024x64
  Max work group size                             1024
  Preferred work group size multiple              32
  Warp size (NV)                                  32
  Preferred / native vector sizes                 
    char                                                 1 / 1       
    short                                                1 / 1       
    int                                                  1 / 1       
    long                                                 1 / 1       
    half                                                 0 / 0        (n/a)
    float                                                1 / 1       
    double                                               1 / 1        (cl_khr_fp64)
  Half-precision Floating-point support           (n/a)
  Single-precision Floating-point support         (core)
    Denormals                                     Yes
    Infinity and NANs                             Yes
    Round to nearest                              Yes
    Round to zero                                 Yes
    Round to infinity                             Yes
    IEEE754-2008 fused multiply-add               Yes
    Support is emulated in software               No
    Correctly-rounded divide and sqrt operations  Yes
  Double-precision Floating-point support         (cl_khr_fp64)
    Denormals                                     Yes
    Infinity and NANs                             Yes
    Round to nearest                              Yes
    Round to zero                                 Yes
    Round to infinity                             Yes
    IEEE754-2008 fused multiply-add               Yes
    Support is emulated in software               No
  Address bits                                    64, Little-Endian
  Global memory size                              11718230016 (10.91GiB)
  Error Correction support                        No
  Max memory allocation                           2929557504 (2.728GiB)
  Unified memory for Host and Device              No
  Integrated memory (NV)                          No
  Minimum alignment for any data type             128 bytes
  Alignment of base address                       4096 bits (512 bytes)
  Global Memory cache type                        Read/Write
  Global Memory cache size                        1376256 (1.312MiB)
  Global Memory cache line size                   128 bytes
  Image support                                   Yes
    Max number of samplers per kernel             32
    Max size for 1D images from buffer            268435456 pixels
    Max 1D or 2D image array size                 2048 images
    Max 2D image size                             16384x32768 pixels
    Max 3D image size                             16384x16384x16384 pixels
    Max number of read image args                 256
    Max number of write image args                16
  Local memory type                               Local
  Local memory size                               49152 (48KiB)
  Registers per block (NV)                        65536
  Max number of constant args                     9
  Max constant buffer size                        65536 (64KiB)
  Max size of kernel argument                     4352 (4.25KiB)
  Queue properties                                
    Out-of-order execution                        Yes
    Profiling                                     Yes
  Prefer user sync for interop                    No
  Profiling timer resolution                      1000ns
  Execution capabilities                          
    Run OpenCL kernels                            Yes
    Run native kernels                            No
    Kernel execution timeout (NV)                 Yes
  Concurrent copy and kernel execution (NV)       Yes
    Number of async copy engines                  2
  printf() buffer size                            1048576 (1024KiB)
  Built-in kernels                                
  Device Extensions                               cl_khr_global_int32_base_atomics cl_khr_global_int32_extended_atomics cl_khr_local_int32_base_atomics cl_khr_local_int32_extended_atomics cl_khr_fp64 cl_khr_byte_addressable_store cl_khr_icd cl_khr_gl_sharing cl_nv_compiler_options cl_nv_device_attribute_query cl_nv_pragma_unroll cl_nv_copy_opts cl_nv_create_buffer cl_khr_int64_base_atomics cl_khr_int64_extended_atomics

NULL platform behavior
  clGetPlatformInfo(NULL, CL_PLATFORM_NAME, ...)  No platform
  clGetDeviceIDs(NULL, CL_DEVICE_TYPE_ALL, ...)   No platform
  clCreateContext(NULL, ...) [default]            No platform
  clCreateContext(NULL, ...) [other]              Success [INTEL]
  clCreateContextFromType(NULL, CL_DEVICE_TYPE_DEFAULT)  Success (1)
    Platform Name                                 Intel(R) CPU Runtime for OpenCL(TM) Applications
    Device Name                                   Intel(R) Core(TM) i7-8700K CPU @ 3.70GHz
  clCreateContextFromType(NULL, CL_DEVICE_TYPE_CPU)  Success (1)
    Platform Name                                 Intel(R) CPU Runtime for OpenCL(TM) Applications
    Device Name                                   Intel(R) Core(TM) i7-8700K CPU @ 3.70GHz
  clCreateContextFromType(NULL, CL_DEVICE_TYPE_GPU)  No devices found in platform
  clCreateContextFromType(NULL, CL_DEVICE_TYPE_ACCELERATOR)  No devices found in platform
  clCreateContextFromType(NULL, CL_DEVICE_TYPE_CUSTOM)  No devices found in platform
  clCreateContextFromType(NULL, CL_DEVICE_TYPE_ALL)  Success (1)
    Platform Name                                 Intel(R) CPU Runtime for OpenCL(TM) Applications
    Device Name                                   Intel(R) Core(TM) i7-8700K CPU @ 3.70GHz
	NOTE:	your OpenCL library only supports OpenCL 2.0,
		but some installed platforms support OpenCL 2.1.
		Programs using 2.1 features may crash
		or behave unexepectedly

By the way, I already install the CUDA through other channels. The result from clinfo doesn't detect Intel Graphics.

Also, I try sample code from Get Started with Intel® SDK for OpenCL™ Applications 2019 on Linux* OS with Training Sample.

The cpu version works well.

./CPUOpenCLProjectforLinux gives me

Selected device type is CL_DEVICE_TYPE_CPU
Number of available platforms: 2
Selected platform: Intel(R) CPU Runtime for OpenCL(TM) Applications
NDRange performance counter time 0.488000 ms.

while ./GPUOpenCLProjectforLinux gives me

Selected device type is CL_DEVICE_TYPE_GPU
Number of available platforms: 2
Selected platform: Intel(R) CPU Runtime for OpenCL(TM) Applications
clGetDeviceIDs() returned CL_DEVICE_NOT_FOUND for platform Intel(R) CPU Runtime for OpenCL(TM) Applications.
Error: Failed to find OpenCL platform.

Did I miss any procedure? Thanks

Hello,

I find in FAQ, but I do not understand how to do.

https://github.com/intel/compute-runtime/blob/master/documentation/FAQ.md

How can I enable OpenCL 2.1 on the Apollo Lake / Broxton platform?

You can enable a higher version of OpenCL using the ForceOCLVersion debug flag.

I'm trying my first OpenCL program. I installed "OpenCL™ Tools for Visual Studio" From <https://dynamicinstaller.intel.com/system-studio/> . Then, I created a project in VS2019, using "GPU openCL project for windows". I didn't change any line of code, just ran the "Build solution" command to build, and found the build failed with error code -1073741511 (see the first attached screenshot).

I copied and ran the build command in the command prompt window. It failed same but with more info. An error dialog appeared with title "ioc64.exe - Entry Point Not Found". (See the 2nd attached screenshot).

I googled and failed to find a solution. Also I tried reinstall the "OpenCL™ Tools for Visual Studio" multiple times. The issue persists.  It's frustrating and please help to provide some advices. Thanks!

Hi folks, quick system description:

Dell Precision M5530 2-in-1 with Intel 8706G, HD 630 + Radeon Pro WX Vega M.

This system used to be able to process BOINC SETI@Home GPU units without a problem several months ago, but it appears that now it's unable to process, possibly due to unabling to find or enumerate the AMD GPU?  

WIth every Intel GPU update I install, it breaks OpenCL so I have to re-install the AMD driver again just so BlackMagic DaVinci Resolve video editor would work, so I am guessing that now something got smudged up bad enough that BOINC won't work (can only do CPU work units).

Running on device number: 0
Priority of worker thread raised successfully
Priority of process adjusted successfully, below normal priority class used
OpenCL platform detected: Advanced Micro Devices, Inc.
BOINC assigns device 0
0 slot of 64 used for this instance
Info: BOINC provided OpenCL device ID used
ERROR: OpenCL kernel/call 'Creating Command Queue. (clCreateCommandQueue)' call failed (-6) in file ..\..\..\src\GPU_lock.cpp near line 1358.
Waiting 30 sec before restart...

After looking at this thread, I can't find anything with Khronos in my registry so I could change the REG_DWORD value to keep the Intel platform from enumerating.

https://software.intel.com/en-us/forums/opencl/topic/705036

Any other way I can fix or disable the Intel OpenCL?

Hello,

I'm using Intel's OpenCL tools for developing and debugging/profiling OpenCL kernels. I installed the newest 2020 update via System Studio, and enabled integration with Visual Studio 2019 (Community Edition). According to the documentation, CPU Kernel debugging needs to be enabled through VS's options for the OpenCL Code Builder via "Options -> Code Builder -> CPU Kernel Debugging", however, the "CPU Kernel Debugging" entry is missing, only "GPU Kernel Debugging" is available.

How to enable CPU Kernel debugging in Visual Studio 2019?

I have tried reinstalling the System Studio package to no avail.

My system runs on a Core i7-9800X CPU, which doesn't have an iGPU, therefore I need the CPU Kernel debugging to work.

Thank you for the help!

We use the Intel CPU OpenCL runtime libraries widely throughout our firm, but we are now in the position that we are stuck with out of date Intel runtime drivers due to the irksome nature of the Intel installer for the latest available version, 18.1. Specifically the installer requires that the machines Intel HD Graphics drivers are uninstalled before it will proceed and there appears to be no way of proceeding without this. This is a huge problem.

Up to now, our IT department has rolled out updates by simply adding the latest Intel installer to the list of available software in our internal database, which can then be deployed and run automatically. However, in this case it is impossible due to this extremely difficult prerequisite of removing the graphics drivers.

Can anyone at Intel please advise how they expect large clients to roll out the 18.1 CPU OpenCL runtime drivers internally? It's not reasonable to expect the local graphics drivers to be uninstalled, and then later re-installed, as part of an automated roll-out to 100s of machines. This is a huge headache.

Surely there must be some way of updating to the 18.1 OpenCL CPU runtime driver without removing the Intel graphics drivers?

This problem has us completely stuck, so any assistance with how we are meant to proceed would be greatly appreciated.