This question already has an answer here:
Closed 11 years ago.
The community reviewed whether to reopen this question 8 months ago and left it closed:
Original close reason(s) were not resolved
Possible Duplicate:
AMD multi-core programming
Is Intel TBB processor dependent? Will it work on amd or on ARM (under meeGo for example?)
TBB is not completely processor-independent; there is a (rather small) layer that isolates the rest of TBB from processor architecture (primarily to provide atomic read-modify-write operations such as compare-and-swap) and certain OS pecularities. Implementations of this layer use some compiler-specific stuff as well, such as inlined assembler or built-in functions (intrinsics).
TBB will work out-of-the-box on x86 (32 and 64 bit) processors including those from AMD, except for rather old ones that do not have mfence instruction.
As for ARM, there is no direct support, but TBB 3.0 Update 7 added an implementation of TBB's platform isolation layer that uses GCC atomic built-ins. So it is definitely possible to make TBB running on ARM, probably with rather small additional effort. And actually there was a report about certain success with such a port at the TBB forum.
And, Intel(R) AppUp SDK for MeeGo also contains TBB, though it's only for Intel's Atom processor.
The answer is yes, for AMD anyhow.
For ARM things are more complex, judging by feedback on the Intel forums. I don't see anybody has gotten this working? For example see http://software.intel.com/en-us/forums/showthread.php?t=74346
The commercial version 3.0 has this in its release notes regarding recommended hardware: other platforms may be more sketchily supported, I would think.
Microsoft* Windows* Systems
Intel(R) Core(TM) 2 Duo processor or Intel(R) Xeon(R) processor
or higher
Linux* Systems
Intel(R) Core(TM) 2 Duo processor or Intel(R) Xeon(R) processor
or Intel(R) Itanium(R) processor or higher
Mac OS* X Systems
Intel(R) Core(TM) 2 Duo processor or higher
(Updated info Dec 2014)
ARM is supported on TBB as of 4.1 Update 3, with fixes in 4.2 Update 3. I have not used this myself so cannot attest to the robustness of this port.
No, it is not processor dependent. It is just a C++ library so as long as the compiler you are using is capable of compiling it you should be fine. From the FAQ of the website you linked to:
What compilers, operating systems and processors are supported?
The project is dedicated to supporting all compilers, all OSes and all processors as a cornerstone objective of the project. Up to date information on status is available on the web site.
Edit: Poking around a little more it looks like people are having problems getting it working on ARM processors, but nothing that should be insurmountable.
Related
I have a task on uni starts with setting the visual studio environment to :
OpenCL SDKs:
AMD – AMD APP (Accelerated Parallel Processing)
NVIDIA – CUDA (Compute Unified Device Architecture)
Intel – Intel SDK for OpenCL Applications
OpenCL uses an “Installable Client Driver” (ICD), model
To allow platforms from different vendors to co-exist
Applications can choose a platform at runtime
And I don't know how to do it ..
i need halp and thanks
I checked by running Regedit for the settings but I only found the default
In order to make OpenCL available for pre-compiled programs you simply need to install the Nvidia, AMD or Intel GPU drivers, depending on which GPU you have (not that older Intel integrated GPUs don't support OpenCL).
For CPU OpenCL support you can install the Intel runtime (Intel only) or POCL (open source, all modern CPUs supported, but you need to compile it from source). Unfortunately AMD does not provide APP SDK with CPU support anymore (although a simple web search will still get you the executables).
All of the above automatically register the respective ICD, so you don't have to do anything special about it.
For developing OpenCL applications you need a standalone OpenCL ICD loader (.lib/.a and .dll) and the OpenCL headers (.h), which you can get from those links, though you need to compile the former. These are also provided in ready to use, binary form in OpenCL SDKs such as the ones provided by Intel (which includes Intel's OpenCL CPU runtime) or AMD.
Documentation for Intel® C++ Compiler 19.0 Beta for Windows (and Linux) claims: Offload support for Intel® Graphics Technology has been removed.
Can someone verify that it applies to OpenMP offload directives for Intel integrated GPUs (Intel® Graphics Technology)?
Intel(R) C++ Compiler 19.0 Release Notes clarifies the removal of Offload support for Intel(R) Graphics Technology: https://software.intel.com/en-us/articles/intel-c-compiler-190-for-linux-release-notes-for-intel-parallel-studio-xe-2019#support_removed
By using the Intel® SDK for OpenCL Application, you could achieve the same goal but it will demand a rewrite to some of your code to be offloaded. See this link (https://software.intel.com/en-us/intel-opencl/download) for the free download and how to get started.
You can use Intel(R) TBB Flow Graph which supports opencl_node when it comes to heterogeneous programming for Intel(R) Processor Graphics. More information on this available at https://software.intel.com/en-us/blogs/2015/12/09/opencl-node-overview
You can use OpenMP 4.5/5.0 TARGET feature to offload computation to Intel Integrated Graphics (at this time Gen 9 through Gen 11). Although you will need to download and install the Intel oneAPI Base Toolkit AND the Intel oneAPI HPC Toolkit.
I have an intel i7 haswell cpu, and I would like to start exploring OpenCL development. In particular, I am interested to run OpenCL code on the integrated GPU.
Unfortunately, by now, I was not able to find any SDK on Intel's site..
May you provide some links, together with a summary of the current status of OpenCL tools for the Linux platform and Intel hardware?
I think this would be useful to many other people..
Thanks a lot!
Intel does not provide free support for OpenCL on their iGPUs under Linux - you have to buy the Intel Media Server Studio, minimum $499. On Windows, you can download a free driver to get OpenCL capability for the iGPU: https://software.intel.com/en-us/articles/opencl-drivers#philinux.
Note that you can use any OpenCL SDK you want - it doesn't have to be Intel. The SDK is only useful for building your program. For running an OpenCL program, you need an appropriate runtime (driver) from the manufacturer. The AMD SDK will give you access to the CPU as an OpenCL device, but not the iGPU.
There is Open Source OpenCL implementation for Intel GPUs on Linux called Beignet, maintained by bunch of guys from Intel.
Sadly, couldn't personally try and check if Your's GPU is properly supported, but on their wiki they states:
Supported Targets
4th Generation Intel Core Processors "Haswell", need kernel patch currently, see the "Known Issues" section.
Beignet: self-test failed" and almost all unit tests fail. Linux 3.15 and 3.16 (commits f0a346b to c9224fa) enable the register whitelist by default but miss some registers needed for Beignet.
This can be fixed by upgrading Linux, or by disabling the whitelist:
# echo 0 > /sys/module/i915/parameters/enable_cmd_parser
On Haswell hardware, Beignet 1.0.1 to 1.0.3 also required the above workaround on later Linux versions, but this should not be required in current (after 83f8739) git master.
So, it's worth a shoot. Btw, it worked well on my 3rd generation HD4000.
Also, toolchain and driver in question includes bunch of GPU-support test cases.
For anyone who comes across this question as I did, the existing answers have some out-of-date information; Intel now offers free drivers for Linux on the site posted above: https://software.intel.com/en-us/articles/opencl-drivers#philinux
The drivers themselves are only supported on 5th, 6th and 7th gen Core processors (and a bunch of other Celerons and Xeons, see link), with earlier processors such as 4th gen still needing the Media Server Studio.
However, they now offer a Linux Community version of Media Server Studio which is free to download.
They also have a Driver Support Matrix for Intel Media SDK and OpenCL which has some useful information about compatibility: https://software.intel.com/en-us/articles/driver-support-matrix-for-media-sdk-and-opencl
You may check intel open source Beignet OpenCL library: http://arrayfire.com/opencl-on-intel-hd-iris-graphics-on-linux/
For me (ubuntu 15.10 + Intel i5 4th generation GPU) it works quite well.
P.S.
Also I must say that I managed to download "media server" for linux a couple of months ago (but didn't used it yet). So you may check it also.
I don't know if its the right place to ask this question. But why did Apple choose to use llvm and its clang implementation to code for OpenCL/OpenGL?? What benefits did it bring to them and how? Excuse my ignorance on this topic, I know not much about this.
Apple created Clang as a drop in replacement to GCC for C/C++/ObjC and ObjC++. The creator of LLVM works at Apple inside their compiler divisions. In a joint effort with the University of Illinois who hosts the projects Apple has created complete replacements for GCC, GDB [see LLDB], libstdc++ [see libc++] and several new projects.
The GPLv3 was the final straw that ended Apple's interest in contributing to GCC which is the reason Apple ended it at GCC 4.2.x.
LLVM/Clang is rapidly supplanting GCC across the industry.
LLVM is now a misnomer of a title.
Present Target hardware supported in LLVM/Clang:
-- Targeting ARM
-- Targeting CppBackend
-- Targeting Hexagon
-- Targeting Mips
-- Targeting MBlaze
-- Targeting MSP430
-- Targeting NVPTX
-- Targeting PowerPC
-- Targeting Sparc
-- Targeting X86
-- Targeting XCore
-- Clang version: 3.3
Soon added out-of-the-box AMD R600 code base.
Clang is C99 compliant. OpenCL uses a subset of C99. Clang is the most complete C11 compliant Compiler suite available free of charge.
FreeBSD has moved to LLVM/Clang as the default set up for the upcoming 10.0 distribution.
AMD and Nvidia build their OpenCL stacks with LLVM/Clang.
Intel is moving their OpenCL and much more to LLVM/Clang.
Google is all in with LLVM/Clang. Ditto for Adobe, Sony, IBM, Cray, etc.
GCC is a mess of an architecture. The modularity of LLVM/Clang makes its rate of improvement and options for developers a much greater ceiling.
The Developer and User Guides for LLVM/Clang 3.2 are now very solid, with 3.3 trunk adding a much greater amount of docs to understand the benefits of LLVM/Clang.
The pace of development of high quality compiler code is second to none.
Straight from an LLVM/Apple Developer
More info, PDF Slides
LLVM is used in two different ways, at runtime:
Runtime code specialization within the fixed-function vertex-processing
pipeline. Basically, the OpenGL pipeline has many parameters (is fog
enabled? do vertices have texture info? etc) which rarely change:
executing the fully branchy code swamps the branch predictors and
performs poorly. To solve this, the code is precompiled to LLVM .bc
form, from which specializations of the code are made, optimized,
and JIT compiled as they are needed at runtime.
OpenGL vertex shaders are small programs written using a family of
programming langauges with highly domain-specific features (e.g. dot
product, texture lookup, etc). At runtime, the OpenGL stack translates
vertex programs into LLVM form, runs LLVM optimizer passes and then JIT
compiles the code.
(more details in the link above)
Because they contribute to the develop of Clang/LLVM and because source code compiled with LLVM/Clang produce faster binary than GCC ...
Clang's developers claim that it provides reduced memory footprint and
increased compilation speed compared to competing compilers, such as
GCC. To support their claim, they present that, as of October 2007,
Clang compiled the Carbon libraries well over twice as fast as GCC,
while using about one-sixth GCC's memory and disk space.
http://en.wikipedia.org/wiki/Clang
I have a laptop running Ubuntu, it has a 32 Bits processor (Intel Core 2 Duo T6400 2.00GHz) and a graphics card Intel Corporation Mobile 4 Series Chipset Integrated Graphics Controller. I would like to know if I can program with OpenCL in this system. If yes what do I need?
I have been searching Google, ofcourse. I found this page:
http://software.intel.com/en-us/articles/download-intel-opencl-sdk/
But I only found a RPM package in the Linux section. I can install it in my Ubuntu system, but the package is for a 64 bit system.
Unfortunately you will need the following distributions:
http://software.intel.com/en-us/articles/opencl-release-notes/
Novell* SUSE* Linux Enterprise Server 11 Service Pack 1 (64-bit version)
Red Hat* Enterprise Linux 6 (64-bit version).
If you cannot change distribution, an alternate way is to use NVIDIA's CUDA SDK in emulation mode. It will be slow, but will work.
Try AMD's APP SDK (link). It has 32 bit version and runs on Intel CPUs without any problems.
Using Intel GPUs for OpenCL is impossible right now.
Intel does not support GPU accelerated OpenCL as of now. The OpenCL SDK you linked in your question will run on your CPU. So yes, no matter what GPU you have in your system, you will be able to do OpenCL -- albeit on the CPU.
Furthermore Intel only provides an RPM. You can try to use Alien to install it on your Ubuntu system, if you had a 64bit CPU. The only thing you could do now would be to get an NVIDIA or AMD GPU and use their OpenCL SDKs respectively. Or get a new computer with Intel CPU / and 64 bit support.