Linux/Kubuntu - Qt + Cuda + QtCreator

"Cuda Toolkit 4.1 and Qt4 on Linux"

It is time for another tutorial. Today we want to setup Qt+Cuda on Linux/Kubuntu. It is recommend to install Qt from the repositories. In the 3rd section I also wrote down the instructions for compiling Qt from scratch. If you find some oddities, just leave a comment (this isn't the best HowTo, I am still learning).

Content:
1. GPU Drivers + CUDA Toolkit 4.1 + CUDA SDK
2. QtCreator and Qt4 Example Project with CUDA
3. Compile Qt4 from scratch (optional)
4. Tools - Debugging and Profiling

--

My System:
- Kubuntu 11.10 (Oneiric Ocelot) at 32bit.
- g++ v4.5, gcc v4.5 (4.6 and up is not supported by cuda toolkit 4.1, see here)
- Qt 4.7.4 (dev-tools, qtcreator)

Downloads:
- Cuda Toolkit 4.1 + SDK (got Ubuntu 11.04 & 32bit)
- qt4_mandelbrot (Qt4 example project with Cuda kernel)


--

1. Get the NVidia / CUDA stuff installed:

I've got here:
cudatoolkit_4.1.28_linux_32_ubuntu11.04.run
gpucomputingsdk_4.1.28_linux.run

1.1 Drivers
First of all we update our nvidia drivers. After I got some troubles with the downloaded drivers (blue colored videos^^) the following did it for me.

sudo add-apt-repository ppa:ubuntu-x-swat/x-updates
sudo apt-get update
sudo apt-get install nvidia-current

I've uninstalled all the nvidia drivers before, but maybe you don't have to. I did a backup of my /etc/X11/xorg.conf and stopped the x-server (ctrl+alt+F1 and sudo stop kdm, then purging my old nvidia stuff, then run the commands from above and finally sudo start kdm to get back, I hope you wont need to do that).

Now I have NVidia driver version 295.40.

(Refs: wiki.ubuntuusers.de, hecticgeek)

1.2 Toolkit
Just run:
sudo ./cudatoolkit_4.1.28_linux_32_ubuntu11.04.run

Edit your .bashrc:
export PATH=/usr/local/cuda/bin:$PATH
export LD_LIBRARY_PATH=/usr/local/cuda/lib:$LD_LIBRARY_PATH

1.3 NVIDIA GPU COMPUTING SDK
To install the gpu computing sdk, just run as user:
./gpucomputingsdk_4.1.28_linux.run

The examples are not build yet, you actually have to run make in ~/NVIDIA_GPU_Computing_SDK, but in most cases errors will occur.

Error Messages:

"unsupported GNU version! gcc 4.6 and up are not supported!",
Install gcc-4.5 and g++-4.5 as a second compiler and softlink to it in /usr/local/cuda/bin
sudo ln -s /usr/bin/gcc-4.5 /usr/local/cuda/bin/gcc

rendercheck_gl.cpp:(.text+0x119b): undefined reference to 'gluErrorString'
cannot find -lcuda
Lib paths are messed up in common.mk and common_cudalib.mk (see here). Path to nvidia_current is missing. I have uploaded a patched version.

Download Patch

Maybe you have to edit the path to your nvidia driver where libcuda and others are located. Edit in that downloaded patch the files common.mk and common_cudalib.mk at the beginning:
# ### patch for finding libcuda
NVIDIA_CURRENT = /usr/lib/nvidia-current/

There are still some errors in the freeImageInteropNPP in CUDALibraries, but I dont care for the moment. The examples can be compiled in NVIDIA_GPU_Computing_SDK/C/ directly. I run deviceQuery to check if installation was successfull.
~/NVIDIA_GPU_Computing_SDK/C/bin/linux/release$ ./deviceQuery

If this is working for you, then everything with cuda is fine. If you got "./deviceQuery: error while loading shared libraries: libcudart.so.4: cannot open shared object file: No such file or directory", then you forgot to add the cuda libs to LD_LIBRARY_PATH.

--

2. Qt4 Projects with CUDA on Linux

Start your QtCreator and create a new project (or download qt4_mandelbrot as example). My structure is:
qt4_mandelbrot - source code
qt4_mandelbrot/obj - object code including cuda object code
qt4_mandelbrot/bin - binaries

// I've disabled the shadow build option in the qt4 project settings, because I configured the directories in the .pro file on my own.

For the .pro file cuda settings I refer to this site. You also can have a look at the qt4_mandelbrot project.

In QtCreator you need to set the build environment. Go to Projects and add to the Build Environment a new variable "LD_LIBRARY_PATH" with "/usr/local/cuda/lib". Check if the execution environment has this setting as well.


Press Ctrl+B or Ctrl+R to build/run the project.

--

3. Qt4 - compile it from scratch (optional)

Downloads:
- Qt Environment (Download Page)
- - Qt Sourcecode (tar.gz) (v4.8.1)
- - Qt Creator (32bit Binary, v2.4.1)

untar source code:
tar -xf qt-everywhere-opensource-src-4.8.1.tar.gz

configure Qt for compilation ("-release", "-shared" are actually default)
./configure -release -shared -no-qt3support -no-webkit -optimized-qmake -no-multimedia -no-phonon -nomake examples -nomake demos

compile and install (takes a while, runs with two jobs at once cuz I have two CPUs):
sudo make install -j2

install qt creator
chmod +x qt-creator-linux-x86-opensource-2.4.1.bin
./qt-creator-linux-x86-opensource-2.4.1.bin

start qt creator and set path to qmake (Qt Creator - Tools - Options: Qt Versions):


Now you can try a qt application created by the project wizard of Qt Creator. Press Ctrl+R to compile and run.

To get access to Qt on shell/console, you have to extend the PATH variable. Edit .profile and .bashrc (home directory) and add:
export PATH=/usr/local/Trolltech/Qt-4.8.1/bin/:$PATH

Uninstall:
Qt: cd /pathto/qt_source and sudo make uninstall
QtCreator: cd /pathto/qtcreator/ and run ./uninstall

--

4. Tools - Debugging and Profiling
For debugging you can try DDD (sudo apt-get install ddd):
ddd --debugger cuda-gdb ./application

If you just have a single GPU you can't debug local kernels yet. Since NSight 2.2 enables Single-GPU debugging again (NSight is only for Windows/VisualStudio), I hope the upcoming Toolkit 4.2 will do this for Linux as well.

For informations on memory leaks and access errors just use cuda-memcheck (see manual ;) ).

Profiling:
To profile the gpu site you can use the nvidia profiler (nvvp). Just run nvvp and open your binary into a new session.

You can profile (the host site) with gprof or oprofile. gprof needs the compiler flag -pg that is also available in nvcc. Just have a look at the .pro file coming with this tutorials example project. To get a profile you have to run the binary, which creates a gmon.out for the gprof profiler. Now you can generate a readable output:
gprof ./qt4_mandelbrot > output.txt

oprofile (sudo apt-get install oprofile oprofile-gui).
"OProfile is a system-wide profiler for Linux systems, capable of profiling all running code at low overhead. [...] OProfile leverages the hardware performance counters of the CPU [...]" (oprofile website)

So oprofile offers CPU and hardware based profiling which gprof doesn't. For usage I just refer to this site. If you want to read more about the sampling methods and the advantages of oprofile, so read this site.

References:
http://stackoverflow.com/...cuda-incompatible-with-my-gcc-version
http://developer.nvidia.com/cuda-toolkit-41
http://wiki.ubuntuusers.de/Grafikkarten/Nvidia
http://www.hecticgeek.com/...drivers-in-ubuntu-11-10-oneiric-ocelot/
http://forums.developer.nvidia.com/...compiling-sdk-on-ubuntu-11-10/p1
http://qt.nokia.com/downloads
http://cudaspace.wordpress.com/...qt-creator-cuda-linux
http://www.gnu.org/s/ddd/
http://oprofile.sourceforge.net/about/
http://doc.opensuse.org/...tuning.oprofile.html
http://lbrandy.com/...oprofile-profiling-in-linux-for-fun-and-profit/

Visual Studio 2010 with Qt and CUDA and OpenGL

How to integrate CUDA in Visual Studio 2010 and how to write your Qt App with OpenGL using CUDA.

Source download
(tested on Win7 VS2010, Geforce 9800GT).
(for project/solution you still have to follow the howto :P)

Assuming you have at least:

• Windows 7 32bit/64bit (XP?)
• Visual Studio 2010 (not Express Edition)
• Qt 4.7.4 (howto integrate in vs2010)
• CUDA capable gpu (see nvidia)
• CUDA Toolkit 4.0 (32bit or 64bit)
  - Developer Drivers
  - CUDA Toolkit
  - GPU Computing SDK
  - Parallel Nsight 2.0 (makes integration in vs2010)

Howto:

Setup cuda syntax highlighting:

• copy usertype.dat to visual studio as following (Win7):
  C:\ProgramData\NVIDIA Corporation\NVIDIA GPU Computing SDK 4.0\C\doc\syntax_highlighting\visual_studio_8\usertype.dat
  TO
  C:\Program Files (x86)\Microsoft Visual Studio 10.0\Common7\IDE
  
• in your .cu files just add following headers for command recognition
  #include <cuda.h>
#include <cuda_runtime.h>
#include <device_launch_parameters.h>

Create Qt Project and connect .cu files with cuda.

1. create a qt4 gui project (Qt4 Projects - Qt Application) in vs2010 (i will call it qt4_test2)
   
2. follow the wizard and add OpenGL Library in the second step
   - (if you have 64bit consider the libgles32.lib linking bug, see notes in howto integrate in vs2010)
   
3. right click on project in solution explorer and click "Build Customizations" ("Buildanpassungen")
   - select CUDA 4.0 ...
   
4. go to Project Properties
   Add in Linker - Additional Dependencies
   - cudart.lib (cuda runtime library)
   Change Linker - System SubSystem to
   - Console (we want to see printf(), GUI will work though)
   In VC++ Directories
   - add $(CUDA_INC_PATH) to "Include Paths" (german "Includeverzeichnisse")
   Cutil Library
   If no cutil32.lib / cutil64.lib is there, just compile C:\ProgramData\NVIDIA Corporation\NVIDIA GPU Computing SDK 4.0\C\common\cutil_vs2010.sln
   Then add to your own project properties - VC++ Directories:
   - add $(NVSDKCOMPUTE_ROOT)\C\common\inc (Include Directories)
   - add $(NVSDKCOMPUTE_ROOT)\C\common\lib\Win32\ (Library Directories) (or x64\)
   or just copy *.dll from ..lib\Win32\ to ..lib\bin\
   
5. add a new qt class (not gui class) to be our opengl widget
   - Classname = AppGLWidget
   - BaseClass = QGLWidget
   - Constructor = QWidget *parent
   
6. open the qt4_test2.ui (this is our QMainWindow) (will start the qt designer)
   - make the central widget as AppGLWidget (see screenshots)
   
   
7. add to source a new cuda c/c++ file (.cu)
   - kernel.cu
   - right click on kernel.cu for properties and choose "CUDA C/C++" Compiler as type.
   (if there isnt anything you may have forgotten step 3)
   
8. insert the following code to the certain files:

AppGLWidget.h:
extern "C" void launch_kernel();

AppGLWidget.cpp in constructor method:
launch_kernel();

kernel.cu:

#include <stdio.h>
#include <cuda.h>
#include <cuda_runtime.h>
#include <device_launch_parameters.h>

__global__ void kernel()
{
 // ...
}

extern "C" void launch_kernel()
{
 printf("RUN CUDA KERNEL\n");
 kernel<<<1,1>>>();
}

Compile and go crazy.

Note: You will have to repeat project setting for Release configuration (assuming we've just been in Debug configuration).

Note: If you get asked at compiling that build must be finished ... you cant really get rid off it. it's an annoying bug of qt visual add-in. it's on the bug list (critical?). if you know more, just tell me.


For a more decent example in OpenGL using Pixelbuffer Objects for 2D procedural textures, see my next post: Qt4 Mandelbrot with CUDA.

Qt 4.7.4 and Visual Studio 2010 Integration

How to integrate Qt 4.7.4 in Visual Studio 2010 (32bit/64bit).

// i rewrote this howto for my mind but most of it comes from here (thanks)
// http://thomasstockx.blogspot.com/2011/03/qt-472-in-visual-studio-2010.html

My environment:

• Windows 7 (64bit)
  
• Qt 4.7.4 Source
  http://download.qt.nokia.com/qt/source/qt-everywhere-opensource-src-4.7.4.zip
  
• Visual Studio 2010 Ultimate Edition SP 1

Assuming you have at least:

• Visual Studio 2010 (not the express edition :P)
  (i will not cover alternative ways (mingw g++) here, but if you have tuts on it, let me know.)
  
• on windows xp it should work but tell me if not (with error description of course :))
  
• ServicePack 1 for Visual Studio 2010
  http://www.microsoft.com/download/en/details.aspx?id=23691
  if link doesnt work, google for visual studio 2010 service pack and download the web installer
  if i recall download size was beyond 500MB
  
• maybe this patch is still needed for vs2010 (only if u go for x64)
  http://archive.msdn.microsoft.com/KB2280741

How to:

1. extract qt source to dir (i'll use C:\Qt\4.7.4)
   
   
2. setup path in system environment variables
   - add new variable QTDIR with path to source (C:\Qt\4.7.4)
   - edit variable PATH and insert "%QTDIR%\bin;"
   - add variable QMAKESPEC="win32-msvc2010" (works also for 64bit)


3. start command prompt from visual studio tools:
   (it's a normal cmd with further environment vars for compiling)
   - there are several command prompt files:
   - 32bit: take the normal command prompt without any additions
   (I have "Visual Studio-Eingabeaufforderung (2010)" here :) )
   
   - 64bit: compiling take "...x64 Win64"
   ("Eingabeaufforderung von Visual Studio x64 Win64 (2010)" in german version)
   
   // if you do not really need 64bit i will recommend 32 bit
   // if you want both you perhaps have to create another dir such as Qt\4.7.4_64bit\
   
   
4. type in that command console
   $ cd %QTDIR%
$ configure -shared -debug-and-release -opensource -opengl desktop -platform win32-msvc2010 -no-qt3support -no-webkit -mp -no-phonon -no-phonon-backend
$ nmake
   // -mp = multiple processors for compiling with MSVC (-MP) // so you dont need "jom"
   // -platform win32-msvc2010 works also for 64bit if you took VS2010 x64 console
   // Qt Libs are compiled as 64bit then
   
   
5. compiling is done, now go for visual studio add-in (i have v1.1.9)
   http://qt.nokia.com/downloads/visual-studio-add-in
   - install it :)
   
   
6. run vs2010 and set qt dir in Qt -> Qt Options (C:\Qt\4.7.4)

NOTE: configure for static libs

if you want static libs running configure -static ... you will get a very big output (30gigs and more) because examples and demos will compiled as static (bigger exes). unfortunately you cannot disable compiling examples and demo by configure argument as you may know from linux (-nomake examples ...). you could disable compiling by modifying pro files respectively or you dont care cuz you have enough space. you also can clean the examples and demos afterwards by moving into these directories and run "nmake clean."

Note: 64bit Qt and OpenGL ("libgles32.lib" linker error)

If you have compiled on x64 you will get a linker error in Qt OpenGL based projects because of a "bug". Linker additional dependencies point to a "libgles32.lib". Well, we are not on an embedded system so remove this and insert opengl32.lib instead of it.
(Project Properties and Linker and then Input and Additional Dependencies if i translated it correct.)

Note: 64bit Qt Libs
You cannot create 32bit qt projects of course. Linking against x64 compiled Qt Libs will fail.

Note: Enabling 64bit compiling in VS2010
Project Properties and Configurations Manager (top right button). Create a new configuration and choose x64.

Note: Qt GUI with forms and Console for debug output (qDebug, printf, etc)
Project Properties and Linker and System and change SubSystem to Console (GUI will work though).

QTfeedback SVN Repository

I have setup a svn repository for version control of my so called QTfeedback code. That repo is public of course. License is GPL v2.1. Further Infos and Screenshots will be released on time. At the moment the interface is in german, but you will easily get through for sure :)

svn co https://qtfeedback.svn.sourceforge.net/svnroot/qtfeedback qtfeedback

If you want to compile, make sure you have OpenGL 2.1 driver and libnoise (http://libnoise.sourceforge.net/) installed.

10/10/22:
Updated to version SVN 6, color gradients from user images.



10/10/19:
By the way. After uploading the feedback video, i found more works on feedback code. One I want to mention is dave bollinger. His idea was the same but he used more rectangles. I follow him, so QTfeedback offers now multiple feedback planes. How nice...