I would like to start developping OpenACC program and I have few questions to ask :
Is it possible to execute OpenACC code on AMD gpu ?
If so, I'm looking for a compiler available for windows environment. I spent like hour to find nothing, I'm going desperate to find anything that could allow me to compile Openacc directive.
Yes, there's a few compilers that support AMD devices. You can see the targets offered by PGI at: http://www.pgroup.com/resources/accel.htm#targets. This includes several AMD Radeon devices.
I believe Pathscale also targets AMD devices (http://www.pathscale.com/) but I'm not sure if they have a Windows compiler available. Please contact them directly for more information.
Hope this helps,
Mat
Related
I have started working on STM32F4 Discovery board and have compiled and run a few basic programs using the latest Yagarto toolchain containing the GCC 4.6.2. Lately though on several forums I have read that many toolchains including the latest Yagarto have problems when it comes to using the on-board hardware FPU. I have also read that the latest CodeSourcery toolchain does support hardware floating point, but not in the lite edition!!
While digging deep into the topic I found this toolchain which is specifically for ARM Cortex M/R controllers, and claims to have no problems when it comes to hardware FPU.
https://launchpad.net/gcc-arm-embedded
I wanted to know from users' experience, if the hardware FPU problems really exist in Yagarto? I am interested in using Yagarto because I also work on ARM7 and yagarto supports that as well. So instead of having different toolchains for different architectures, it is convineant to have one for both ARM7 and Cortex M/R.
If the FPU problems do really exist, then could anyone suggest me a good tried and tested toolchain for both ARM7 and Cortex M/R?
P.S. : I use CodeSourcery's latest GNU Linux toolchain for the BeagleBoard (Cortex A-8), havn't yet faced any issues with it.
I just wrote an article about using ARM's free GCC toolchain (GNU Tools for ARM Embedded Processors) and STLINK on Linux/Ubuntu to write/program/debug code for an STM32F4 Discovery Board (the F4 is a Cortex M4) - that may help you, the compiler does have hardware floating point support and I'm using it in my examples...
http://www.wolinlabs.com/blog/linux.stm32.discovery.gcc.html
I consider using OpenCL in a consumer product which is currently under development.
Doing a small research I found that generally there is good support under Mac OSX. Linux support is also relatively good, but my target audience does not use Linux. It remains to check how well it is supported in Windows.
Regarding Windows I found OpenCL distribution which raises some concerns.
Do any of you have any experience with using OpenCL in consumer-oriented products under Windows? I am more interested in the GPU side of OpenCL, specifically driver support.
Just like CUDA or Stream, OpenCL needs to be supported by the driver. Most CUDA-capable GPUs support OpenCL with a somewhat up-to-date driver (CUDA 1.0 upwards).
In fact, if you compile with, say, CUDA SDK 4.1 your end users will need newer drivers than if you had used OpenCL.
Also, OpenCL is not bound to any GPU architecture. While this might be problematic for specifically designed algorithms, it shouldn't have a very high impact on normal end user programs.
At least with CUDA, you can only compile code optimized for the current known major version. Compiling OpenCL kernels on the end user machine might allow optimizations for newer binary specifications in the future.
The crashes the author in that questions reported for Nvidia OpenCL generally seem to happen a lot if resources are not freed properly. I've been seeing similar crashes until I fixed a leak that didn't release created kernels.
I'm not saying it's the only reason why it might crash, but apart from programmer errors it appears fairly stable to me.
AMD and NVidia both support OpenCL on most (all?) of their GPUs
Unfortunately Intel only supports it on the CPU which is a bit pointless and if you have to insist that the user has a separate GPU for your app you can also insist that they have an NVidia one and use CUDA. This has limited the uptake of OpenCL.
How can I know which CPU can be programmed by OpenCL?
For example, the Pentium E5200.
Is there a way to know w/o running and querying it?
OpenCL compatibility can generally be determined by looking on the vendor's sites. AMD's APP SDK requires CPUs to support at least SSE2. They also have a list of currently supported ATI/AMD video cards.
The most official source is probably the Khronos conformance list:
http://www.khronos.org/conformance/adopters/conformant-products#opencl
For compatibility with the AMD APP SDK: http://developer.amd.com/gpu/AMDAPPSDK/pages/DriverCompatibility.aspx
For the NVIDIA, anything that supports CUDA should support their implementation of OpenCL:
http://www.nvidia.com/object/cuda_gpus.html
For compatibility with the Intel OpenCL SDK, look at:
https://software.intel.com/en-us/articles/opencl-code-builder-release-notes
Here is the list of conforming OpenCL products from the Khronos site:
http://www.khronos.org/conformance/adopters/conformant-products/
You got Intel OpenCL too http://software.intel.com/en-us/articles/intel-opencl-sdk/ for windows right now.
Just one more comment about Intel, Now they do not only support OpenCL under windows, but also linux. But it is part of a commercial SDK see https://software.intel.com/en-us/intel-media-server-studio.
Another alternative for OpenCL development under Linux is Beignet, an OpenCL source project maintain by Intel China.
http://www.freedesktop.org/wiki/Software/Beignet/
I have tested on linux and it works as per tutorial, however, the compiler they use is completely different from the one under the windows.
Well for the CPU, AMD's SDK is supposed to work on x86 (even on Intel's x86), so that will cover most of your options.
And for the GPU, I think almost all cards made in the last couple of years should run OpenCL kernels. I don't have of a particular list.
EDIT: Looks like AMD removed the original SDK pages with no replacement. There are unofficial mirrors for Windows and Linux, but I haven't tried them.
I'm developing a GPS application under Linux, with ARM7 microprocessor.
Which compiler do you recommend? Do you know if there is any toolkit with libraries ready to develop GPS applications?
A friend of mine recommended gcc... what do you guys think about it?
Thank you
I don't think that the compiler matters that much. What is more important is your precise understanding of the library you are using, or of the actual device you are invoking.
However, I will recommend GCC, and I do recommend using a very recent version of GCC. For instance, GCC 4.6.2 is appearing these days, and there have been lot of work recently put in GCC to improve its perfomance for ARM processors. So, if possible, us a 4.6 GCC, not a 4.3 one (some hardware vendors don't give recent GCC with their ARM development kit; you should consider in that case building your GCC (and perhaps binutils) from their source code.
I know nothing about GPS itself.
I am a complete newbie to the ARM world. I need to be able to write C code, compile it, and then download into an ARM emulator, and execute. I need to use the GCC 4.1.2 compiler for the C code compilation.
Can anybody point me in the correct directions for the following issues?
What tool chain to use?
What emulator to use?
Are there tutorials or guides on setting up the tool chain?
building a gcc cross compiler yourself is pretty easy. the gcc library and the C library and other things not so much, an embedded library and such a little harder. Depends on how embedded you want to get. I have little use for gcclib or a c library so roll your own works great for me.
After many years of doing this, perhaps it is an age thing, I now just go get the code sourcery tools. the lite version works great. yagarto, devkitarm, winarm or something like that (the site with a zillion examples) all work fine. emdebian also has a good pre-built toolchain. a number of these places if not all have info on how they built their toolchains from gnu sources.
You asked about gcc, but bear in mind that llvm is a strong competitor, and as far as cross compiling goes, since it always cross compiles, it is a far easier cross compiler to download and build and get working than gcc. the recent version is now producing code (for arm) that competes with gcc for performance. gcc is in no way a leader in performance, other compilers I have used run circles around it, but it has been improving with each release (well the 3.x versions sometimes produce better code than the 4.x versions, but you need 4.x for the newer cores and thumb2). even if you go with gcc, try the stable release of llvm from time to time.
qemu is a good emulator, depending on what you are doing the gba emulator virtual gameboy advance is good. There are a couple of nds emulators too. GDB and other places have what appear to be ARMs own armulator. I found it hard to extract and use, so I wrote my own, but being lazy only implemented the thumb instruction set, I called mine the thumbulator. easy to use. Far easier than qemu and armulator to add peripherals to and watch and debug your code. ymmv.
Hmmm I posted a similar answer for someone recently. Google: arm verilog and at umich you will find a file isc.tgz in which is an arm10 behavioural (as in you cannot make a chip from it therefore you can find verilog on the net) model. Which for someone wanting to learn an instruction set, watching your code execute at the gate level is about as good as it gets. Be careful, like a drug, you can get addicted then have a hard time when you go back to silicon where you have relatively zero visibility into your code while it is executing. Somewhere in stackoverflow I posted the steps involved to get that arm10 model and another file or two to turn it into an arm emulator using icarus verilog. gtkwave is a good and free tool for examining the wave (vcd) files.
Above all else you will need the ARM ARM. (The ARM Architectural Reference Manual). Just google it and find it on ARM's web site. There is pseudo code for each instruction teaching you what they do. Use the thumbulator or armulator or others if you need to understand more (mame has an arm core in it too). I make no guarantees that the thumbulator is 100% debugged or accurate, I took some common programs and compared their output to silicon both arm and non-arm to debug the core.
Toolchain you can use Yagarto http://www.yagarto.de/
Emulator you can use Proteus ISIS http://www.labcenter.com/index.cfm
(There is a demo version)
and tutorials, well, google them =)
Good luck!