Tagged with opencl - NVIDIA Developer Forums

Non-blocking writing/reading not working

edodas — Tue, 01 May 2012 11:40:20 -0400

Hi,
Is there any reason that non-blocking data transfer wouldn't work? I am using a Quadro FX580 and when I set the blocking parameter to CL_FALSE in clEnqueueWriteImage or clEnqueueReadImage, I still have the impression that the data writing/reading is blocking.

OpenCL examples unavailable

Xor — Mon, 14 May 2012 05:23:15 -0400

Hi there

I'm trying to optimize a separable convolution filter further but i'm unable to download the sample code from the following part of the nvidia site http://developer.download.nvidia.com/compute/cuda/3_0/sdk/website/OpenCL/website/samples.html

When i click download it says file not found.

Does anyone perhaps know where these samples can be found?

thanks in advance

GTX680 OpenCL in Ubuntu 11.10, clBuildProgram returns -30

yashiz — Fri, 11 May 2012 09:05:02 -0400

I've tested driver 295.49 and 302.07 both.

clBuildProgram returns -30 when build some kernel files, not all of them, while the others have the same config, as:

m_ciErrNum = clBuildProgram(m_program, 0, NULL, "-cl-fast-relaxed-math", NULL, NULL);

one of the problem kernels is in the attachment.

when I remove TabulateCDF1Dv, no -30 and pass
when I keep TabulateCDF1Dv, and remove read_imagef and write_imagef inside, no -30 and pass
when I keep TabulateCDF1Dv, and remove write_imagef inside only, return -30.

I think, maybe it is the problem of reading or writing 2D texture with height 1 . but kernel TabulateCDF2D runs well.

these code can run on GTX460 and GTX580 with latest driver, so maybe a GTX680 driver bug ?

it is quite weird...

thanks for you help

here is the code (if you can not get the attachment)

__kernel __attribute__((reqd_work_group_size(WORKGROUP_SIZE, 1, 1)))
void TabulateCDF1Dv(__read_only image2d_t CDF1D, sampler_t normSampler, __write_only image2d_t CDF1DTable, sampler_t pixSampler, int lenth)
{
uint tid = get_global_id(0);
float cdfValue = (tid+0.0f)/(lenth+0.0f);

float index = 0.5f;
float step = 0.5f;

for(int i=0; i<8; i++)
{

float4 tex1DRefValue = read_imagef(CDF1D, normSampler, (float2)(index,0.0f));
float refValue = tex1DRefValue.x;

step *= 0.5f;

float diff = (cdfValue - refValue);

if(diff < pMAXERROR && diff > nMAXERROR)
{
break;
}
if(diff < nMAXERROR)
{
index = index - step;
}
if(diff > pMAXERROR)
{
index = index + step;
}
}

write_imagef(CDF1DTable, (int2)(tid,0), (float4)(index));
}

__kernel __attribute__((reqd_work_group_size(WORKGROUP_SIZE, 1, 1)))
void TabulateCDF2D(__read_only image2d_t CDF2D, sampler_t normSampler,__read_only image2d_t CDF1DTable, __write_only image2d_t CDF2DTable, sampler_t pixSampler, int lenth)
{
uint tid = get_global_id(0);
uint indexU = get_group_id(0);
uint indexV = get_local_id(0);

float4 tex1DRefValue = read_imagef(CDF1DTable, pixSampler, (int2)(indexU,0));

float cdfValueV = (indexV+1.0f)/(lenth+1.0f);

float indexU0 = tex1DRefValue.x;
float indexV0 = 0.5f;
float step = 0.5;

for(int i = 0; i<8; i++)
{
float4 tex2DRefValue = read_imagef(CDF2D, normSampler, (float2)(indexV0, indexU0));

float refValue = tex2DRefValue.x;

step *= 0.5f;

float diff = (cdfValueV - refValue);

if(diff < pMAXERROR && diff > nMAXERROR)
{
break;
}
if(diff < nMAXERROR)
{
indexV0 = indexV0 - step;
}
if(diff > pMAXERROR)
{
indexV0 = indexV0 + step;
}
}

write_imagef(CDF2DTable, (int2)(indexV,indexU), (float4)(indexV0));
}

OpenCL callbacks scheduling

rjmarques — Thu, 10 May 2012 09:59:48 -0400

Greatings,

I am having a huge overhead when using callbacks on linux. After I enqueue the necessary read operation, I set a callback for apropriate threatment. The read takes less then a milisecond to complete, however the callback is only issued after, about, 19 miliseconds. Is this a driver issue?

The graphics card is a Tesla C2050.
The driver version is 295.41.
And the GCC version is 4.4.3.

Thanks,
Ricardo Marques

Is Nvidia working on OpenCL 1.2 beta drivers?

oscarbg — Tue, 03 Jan 2012 13:54:43 -0500

AMD has already OCL 1.2 beta drivers.. when reg. developers can expect to have some build?

Driver issue at Linux 11.10

sajis — Mon, 05 Mar 2012 04:39:28 -0500

Hello forum,

I have installed ubuuntu linux 11.10 on asus g74 and installed the most recent nvidia driver instead of the one that comes as default. It has the GeForce GTX 560M on board

Now the system hangs whenever i try to run any of the CUDA examples. The very samples runs fine in windows with the same machine. I want to test OpenCL apps in linux, but the tool kit do not come with any opencl exmples for linux.

Any suggestion deal with this issue?

Regards
Sajjad

Out of order command execution non-working on Linux?

thorfdbg — Wed, 25 Apr 2012 11:23:13 -0400

Could it be that out-of-order execution in command queues is currently simply not working with the current OpenCL SDK? I'm creating here a command queue with the flag CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, but when checking in the profiler, I see that the memory operations (buffer copy) and the GPU computation are still not overlapping, but executed sequentially.

Low memcpy performance in OpenCL, what to do about it?

thorfdbg — Fri, 16 Mar 2012 19:41:24 -0400

Folks,

using the nvvp profiler shows that my current OpenCL application has a low memcpy performance on Linux. Actually, it is only ~400MB/sec host to device and about 800MB/sec device to host. The nvvp compiler makes suggestions on CUDA, which I'm not using (this is OpenCL). The manual states that I should allocate pinned memory.

I tried the following approaches:

a) Allocate the buffers with CL_MEM_ALLOC_HOST_PTR and mapping buffers to host memory. Result: Negative.

b) Pinning memory myself with the mlock() Linux system call. Result: Negative.

Memcpy performance remains at a crawl in both setups, at exactly the same speed. This brings me to the rather paradoxical situation that even though my kernel is fast (~10ms for an operation) the memcpy to the GPU and back takes an enmourmous amount of time (~70ms) and makes the GPU usage rather unattractive - I can get about the same speed with using SSE2 vector instructions of the CPU.

Any help or hints?

Crash with the new LLVM compiler

Tofic — Mon, 02 Apr 2012 06:41:37 -0400

Hi,

OpenCL 1.1, drivers 296.10, GTX 580, 64-bits compiler, Windows 7 64-bits.

100% crash inside the compiler, when trying to compile this construction (well-compilable with the old compiler):
const struct BBox bbox = { (float4)(-.5f,-.5f,-.5f,0), (float4)(.5f,.5f,.5f,0) };

....

Error: OpenCL error 'Invalid binary': compilation error
ptxas application ptx input, line 13; error : Module-scoped variables in .local state space are not allowed with ABI

or

UNREACHABLE executed.

Fix: remove the "const" modifier. Started with new LLVM compiler.

Best wishes,
Anton

openCL equivalent for "cudaMallocPitch"..?

HariniS — Tue, 24 Apr 2012 03:01:59 -0400

Hi every one,
I am very new to openCL and strated converting on eof the cuda code to opencl but got stuck in this part of code.My PC is having AMD processor with ATI graphics card which doesnt support openCL, but other codes are running fine here by falling back to CPU. someone please give me some suggestion so that i can get rid of this problem. the cuda code is

size_t pitch = 0;
cudaError error = cudaMallocPitch( (void**)&gpu_data, (size_t*)&pitch, instances->cols * sizeof(float), instances->rows);

for( int i = 0; i < instances->rows; i++ ){
///error = cudaMemcpy((void*)(gpu_data + (pitch/sizeof(float))*i), (void*)(instances->data + (instances->cols*i)), instances->cols * sizeof(float) ,cudaMemcpyHostToDevice);

My converted openCL code is

gpu_data = clCreateBuffer(context, CL_MEM_READ_WRITE, ((instances->cols)*(instances->rows))*sizeof(float), NULL, &ret);

for( int i = 0; i < instances->rows; i++ ){
ret = clEnqueueWriteBuffer(command_queue, gpu_data , CL_TRUE, 0, ((instances->cols)*(instances->rows))*sizeof(float),(void*)(instances->data + (instances->cols*i)) , 0, NULL, NULL);
if(ret != CL_SUCCESS)
break;
}

some times it works fine but some times it stucks. But every time it stucks in reading part i.e.

ret = clEnqueueReadBuffer(command_queue, gpu_data, CL_TRUE, 0,sizeof( float ) * instances->cols* 1 , instances->data, 0, NULL, NULL);

where "gpu_data" is a device memory of type cl_mem and "instances" is a "matrix".
For both case its giving
Unhandled exception at 0x10001098 in CL_kmeans.exe: 0xC000001D: Illegal Instruction.
when break is pressed
No symbols are loaded for any call stack frame. The source code cannot be displayed.

and in Call stack,

> OCL8CA9.tmp.dll!10001098()
[Frames below may be incorrect and/or missing, no symbols loaded for OCL8CA9.tmp.dll]
amdocl.dll!5c39de16()

is displayed. Someone please help me in getting out of this.
Thanks in advance

OpenCL and DirectCompute

Nadeem Mohammad — Mon, 29 Aug 2011 17:52:21 -0400

NVIDIA continues to have one of the most advance support for OpenCL and DirectCompute.
When discussing these please use the correct tags below .

When will there be OpenCL 1.2 drivers?

ekpyron — Sun, 22 Apr 2012 21:08:13 -0400

Are there any information about a likely date for the release of OpenCL 1.2 drivers (and/or when a conformance candidate will be available to registered developers)?
The specification has been published several months ago and competitors already published beta drivers, so I'd appreciate at least some information about when to expect support from Nvidia.
OpenCL 1.2 will include major improvements and add some key features to the API, so that I eagerly await supporting drivers.

Simultaneous data transfert

edodas — Thu, 19 Apr 2012 11:31:20 -0400

Hi,

I am new to OpenCL and I have a question about data transfer from the host to a device (a GPU in my case):
is it possible to write (or read) simultaneously to (from) two different memory objects?
(using the same command queue)

Know of any multi-GPU image segmentation algorithms?

chippies — Wed, 18 Apr 2012 09:53:03 -0400

Hi all, has anyone published research on image segmentation algorithms that run efficiently on multiple GPUs and handle gigabytes of image data (3D volumes). If so, can you please post links, titles or at least the names of institutions that are doing this research.

I'm asking this because it might be a good research direction and I want to know what others have done, but Google, IEEE Explore, Science Direct, Springer Link and Ebscohost haven't turned up any hits.

Is there a tag for image processing?

OpenCL issue with Driver

christophheindl — Sat, 10 Mar 2012 01:59:43 -0500

Lately, our uses have complained that ReconstructMe won't work with the latest 295.73 driver. When compiling the following stripped down OpenCL code with -cl-nv-arch sm_12 (or a device which does not support sm_13)

float4 p0 = points[i];
float4 p1 = points[i+1];
float4 p2 = points[i+2];

float4 n_tmp = -normalize(cross(p1 - p0, p2 - p0));

we get a lot of error messages using the latest driver:

Instruction 'mov' requires SM 1.3 or higher, or map_f64_to_f32 directiv
Instruction 'mov' requires SM 1.3 or higher, or map_f64_to_f32 directiv
Instruction 'mov' requires SM 1.3 or higher, or map_f64_to_f32 directiv
Instruction 'cvt' requires SM 1.3 or higher, or map_f64_to_f32 directiv
Instruction 'abs' requires SM 1.3 or higher, or map_f64_to_f32 directiv
Instruction 'setp' requires SM 1.3 or higher, or map_f64_to_f32 directi
Double is not supported. Demoting to float

I suspect it is due to the translation of the normalize command, since the cross product seems to work fine. Since we are not using any double precision calculus I think it is a driver related bug.

With 285.62 everything works fine. Here are the reports

https://groups.google.com/d/topic/reconstructme/TgDG9f4AjJI/discussion

Sharing numerous small buffer objects between OpenGL and OpenCL-- driver issue or user issue?

escorelle — Tue, 27 Mar 2012 20:43:12 -0400

I was writing some test code for an application which included allocating a lot of small buffers and sharing them with OpenCL. I noticed that after about 3000 shares, I would get errors for the next few hundred, and then everything would be fine afterwards. I'm going to put a work around in place, but was wondering what was going on. The following code (context initialization omitted) shows the issue:

std::vector< unsigned > vbos;

for( int i = 0; i < 5000; ++i )
{
unsigned vbo = 0;
glGenBuffers( 1, &vbo );
vbos.push_back( vbo );

glBindBuffer( GL_ARRAY_BUFFER, vbo );
glBufferData( GL_ARRAY_BUFFER, 355 * sizeof( float ) * 4, 0, GL_STATIC_DRAW );
glBindBuffer( GL_ARRAY_BUFFER, 0 );

cl_mem sharedObject = 0;

cl_int clError = 0;
sharedObject = clCreateFromGLBuffer( context_, CL_MEM_READ_WRITE, vbo, &clError );

if( clError != CL_SUCCESS )
{
std::cout << "Error creating GL Interop Buffer." << std::endl;
}

if( sharedObject )
{
clReleaseMemObject( sharedObject );
}

clFinish( queue_ );
}

glDeleteBuffers( vbos.size(), &vbos[0] );

Card: nVidia GeForce GTX 260M
Driver: 286.16

Instrumented driver for profiling on Linux

thorfdbg — Wed, 29 Feb 2012 05:58:11 -0500

Dear NVidia team,

looking currently into OpenCL development, I'm missing a method for profiling my kernel code which runs slower than expected. The nvvp debugger on Linux is of less help than expected as it cannot collect all necessary data for a full analysis [I get an error saying "CUPTI_ERROR_PARAMETER_SIZE_NOT_SUFFICIENT"]. I believe this might be because I'm not using an instrumented X driver for my 560GT graphics card. However, the latest available driver I could find, NVPerfKit-Linux-x86_64-195.36.31, does not support the Fermi-based chips. Where would I find newer instrumented drivers and/or a fully functional nvvp profiler?

clEnqueueReadBuffer always blocks with newer drivers

stefanvehoff — Thu, 01 Mar 2012 02:27:30 -0500

Dear NVIDIA, dear OpenCL-developers,

we are using OpenCL on Windows systems equipped with NVIDIA cards for quite some time now and so far did not have any problems. However, during the last days I tried to replace our calls to "clFinish", which occur at the end of our GPU computations, by something that does not use one full CPU core until the GPU is finished (sleeps in combination with event status polling).

While doing so I realized that the calls to "clEnqueueReadBuffer", which are used to copy the results of the computation back to the host, always block the CPU. This is expected, of course, when the "blocking_read" parameter is set to true, but this is not the case in our code. This is why we introduced the calls to "clFinish" in the first place.

So yesterday I did a simple check: I added a time measurement to our code which reports the time the CPU needs to execute all of the GPU commands. These range from copying data to the GPU, include all the calculations on the GPU, the "clEnqueueReadBuffer"-commands at the end but NOT the "clFinish"-command. Running this code on my machine (i7 975, GTX 560, 295.73 driver) I get values of around 14 ms and slightly larger values on the machine of a colleague (i7 975, GTX 295, 285-something driver). Running the same code on yet another machine with an older driver (i7 975, GTX 295, 266-something) I get results of around 1 ms and this is also how I remember it, i.e. the CPU rushing across the GPU commands without caring whether they are finished or not.

Am I doing something wrong or is this really a driver issue/bug? Did anyony experience something similar or is somebody willing to test the behavior of "clEnqueueReadBuffer" on his system?

Thanks for your help!

[volumeRender] Why are unequally sized volumes rendered as cubes (i.e., scaled)?

ivma — Thu, 16 Feb 2012 09:12:51 -0500

Hi!
I am trying out the volume renderer from the NVIDIA GPU Computing SDK 4.1/4.0 and I was wondering why it renders the Bucky.raw volume (256x256x256) accordingly but it scales unequally sized volumes such as for example the lobster (120x120x34)[1].

Here are some resulting images (from bottom 120x120 and from the side where the volume resolution in Z direction is only 34 voxels):

Does anybody have a clue why that is and possibly how to fix it?

PS: I have tried it on a couple of other data sets as well but with the same effect.

Greetings,
ivma

[1] lobster.zip

Bug in cl_nv_d3d11_sharing: Cannot map DirectX buffer for interop

mchajdas — Mon, 12 Mar 2012 03:25:21 -0400

There seems to be a bug in cl_nv_d3d11_sharing which prevents more than 526 buffers being mapped for interop, even if there is plenty of memory free. In the attached application, we create, map and release 1 MiB sized buffers and on both a 560 Ti with 1 GiB of memory and a 480 with 1.5 GiB it fails at around buffer 526 (depending on the buffer size.) We have reproduced the issue also on a 3 GiB Tesla C2050. What's going on here? As we release each and every buffer, we should be able to map them until the end of days, shouldn't we?

Include, link and use both OpenCL and CUDA in the same application at the same time, is it possible?

ggrocca — Wed, 07 Mar 2012 12:53:05 -0500

Maybe it's a stupid question, but I'm optimizing an app that currently uses a lot of OpenCL code. After a lot of work, the most needed thing now is optimization of some sparse matrix operations (currently done in CPU with eigen). It seems that the most complete library in this field is cusparse, which is obviously a cuda library.

Has anybody tried something like this? Will there happen obvious problems which I cannot foresee?

I wanted to know if anyone has insights to share in this regard before starting to code.

Thank you very much in advance!

Different OpenCL results with different drivers

Dan Mackley — Thu, 08 Mar 2012 18:41:25 -0500

Hello,
Until today, I have been using the libOpenCL.so that came with the 280 driver to build a C program that does a just-in-time compile of OpenCL code and then runs it and uses the results. The application runs on multiple, different platforms with possibly different nVidia hardware and driver versions.
Today I loaded the 295 driver, and the program gives different results -- different enough that they're unacceptable, numerically.
For various reasons, I do not want to keep multiple versions of our application around, built with and keyed to the different nVidia drivers (we have multiple customers with different hardware configs)... I'd prefer to stick with just 32- and 64-bit versions.
Is this the way things work -- does the libOpenCL that's used when building a C program need to match the runtime system's libOpenCL?
(By the way, both libOpenCL's are numbered as version 1.0.0)

Automating profile collection for nvvp

bmerry — Thu, 08 Mar 2012 08:42:05 -0500

I've found nvvp in CUDA 4.1 to be quite handy, but since running my program to do the analysis takes a long time I'd like to automate it as part of the nightly build. I've looked at the COMPUTE_PROFILE_* environment variables, but they're a very low-level interface to select a specific set of counters, and to use them it seems you need to know which counters are compatible with each other. What I'd ideally like is a way to take a project I've saved in nvvp and, from the command-line, request that it reruns everything and stores all the results back in a project file I can open in nvvp have have all the analyses available.

I don't mind getting my hands dirty with some scripting to do it, but I don't really know where to start since I don't know which counters nvvp wants on each run or how to integrate the per-run profiles into one easy-to-open file.

I want to know the meaning of envreg0~31 in PTX code.

komb — Sun, 26 Feb 2012 01:31:59 -0500

I am a programmer for GPGPU. I am studying OpenCL.
I have GeForce GT520M.

I have a question about PTX code.
I made a PTX code for matrix multiplication.
The special register is used like %envreg0 ~ %envreg6.
I guess that envreg0 and envreg1 are group id for x, y at two dimension.
But I can't find the meanings of the other registers.
I can't find any documents on that. The meaning is not descirbed in PTX spec.
Please let me know the meaning of special register envreg. Are there any documents?

Geforce GTS250 OpenCL compiler bug?

hakuliu — Tue, 06 Mar 2012 12:03:22 -0500

Hi, I'm working on some project using OpenCL, and encountered this bug while using the GTS250.
I'm using OpenCL with Java using the JavaCL library, http://code.google.com/p/javacl/
I'm quite sure that the bug however is not a part of JavaCL...

I made a reproducible unit test for this case. The kernel is as follows and the unit test, (which is in java) looks like this There are a bunch of utility classes in there that's not explained, but I'm sure it should be pretty easy to understand...

I ran this test, and the unit test fails during the compilation process with this stack trace.

Peculiarly, I have Windows and linux installed on this computer, and it seems to be working in linux but not in windows (with the same hardware, probably different drivers...) Could it be that the windows opencl driver for this card has some sort of bug?

for - break issue

thefonzy0 — Sat, 18 Feb 2012 06:39:20 -0500

Hi all. Please, can anyone help me with my puzzle?
I write a CG Vertex/Fragment program for 3D real time medical data visualization. Until I changed my PC and operating system (from Windows 7 32 bit to Windows 7 64 bit), the program worked correctly, but now I have strange display errors. I have isolated and identified the portion of code that does not work, trial and error (since there is no a debugger for CG ... this thing is really absurd!!). This is my code:

 		    
	float3  Position;
	float3  Position1;
        int vidx1 ;
	int vidx2;
	float3 vecV1;
	float3 vecV2;
	float3 vecStart;
	float3 vecDir;
	float  denom;
	float  lambda ;
	int e;
	bool Test0, Test1, Test2,Test3,Test4,Test5;
	float   dPlane = dPlaneStart + Vin.y * dPlaneIncr;
	for (e = 0; e < 4; ++e) {
		vidx1 = nSequence[int(frontIdx * 8 + v1[Vin.x*4+e])];
		vidx2 = nSequence[int(frontIdx * 8 + v2[Vin.x*4+e])];
		vecV1=vecVertices [vidx1];
		vecV2=vecVertices [vidx2];
		vecDir=vecV2-vecV1;
		vecStart=vecV1+vecTranslate;
		denom= dot(vecDir,vecWiew);
		lambda = (denom!=0.0)?(dPlane - dot(vecStart,vecWiew))/denom : -1.0;
		if ((lambda >=0.0) && (lambda<=1.0)){
			Position= vecStart + lambda * vecDir;
			break;
	 	 }
	   }
	  Test0=(Vin.x==0)&& Position.x==-1;  // OK
	  Test1=(Vin.x==1);  // OK
	  Test2=(Vin.x==2);  // OK
	  Test3=(Vin.x==3);  // OK
	  Test4=(Vin.x==4);  // OK
	  Test5=(Vin.x==5);  // OK
	  ...

The portion of code that does not work is that of the if block: if I split that :

           
	if ((lambda >=0.0) && (lambda<=1.0))
		 Position= vecStart + lambda * vecDir;
	if ((lambda >=0.0) && (lambda<=1.0))
		break;

All appear to work.

Am I doing something wrong?

regards,
TheFonzy

Floating Point Number Errors

komb — Sun, 26 Feb 2012 01:27:01 -0500

I have a question.
I intalled SDK and am studing OpenCL.
The SDK is included examples made by OpenCL for example DCT8X8.
It check floating point values as comparing the result computed by GPU with the result computed by CPU.
But the floating point values are not same. There is a little difference.
Why has it difference?

I checked the difference.
Every part in IEEE754 is the same but mantissa is a little deffirent.
Please let me know why it has difference.

clSetKernelArg in loop CL_OUT_OF_RESSOURCES

ratcrever3 — Wed, 22 Feb 2012 05:47:26 -0500

Hello,

I have to pass kernel arguments in a loop.

for (...)
{
clSetKernelArg(....)
...
//running the kernel

clWaitForEvents(...)
}

after a while, clWaitForEvents return CL_OUT_OF_RESSOURCES on windows.
It works just fine on mac and linux.

I supposed a driver problem, even with the lastest one!

Does someone else had that kind of problem?

Sincerely

OpenCL: Using Constant Memory Causes CL_INVALID_KERNEL_ARGS from clEnqueueReadBuffer

homemade-jam — Mon, 20 Feb 2012 03:37:01 -0500

I am reposting a question I asked here: http://www.khronos.org/message_boards/viewtopic.php?f=28&t=4758&sid=7ffe1878e45cb6600e61e1d09fe24eba

What is happening is, I recently switched my code to be using events to indicate the dependencies rather than flushing the command queue each time. This works fine 90% of the time except in this particular case.

I have a kernel that works fine under Intel and AMD SDKs for my CPU and used to work fine on NVIDIA too. It uses constant memory. All my others kernels (the 90%) use textures and global and these work fine. Both kernels are identical except for the __constant in the args. The constant memory kernel causes an error to be returned from the clEnqueueReadBuffer command.

The documentation doesn't mention the result of CL_INVALID_KERNEL_ARGS from clEnqueueReadBuffer. Has anyone experienced this problem before? I can't see how it has occured.

Killing the watchdog timer under macOSX lion

ratcrever3 — Sun, 19 Feb 2012 05:34:42 -0500

Hello,

I have the watchdog timer problem during the execution of a kernel and i did not found any solution on the forum.
My kernel browse an half edge structure and fetch neighborhoods.
Even by creating small groups, the kernel is killed...
The kernel has been succesfully execute on Linux and Windows when the watchdog timer has been killed.
My only solution is to desactivate it...

My question is the following :
How can i desactivate the watchdog timer?

Best regards

OpenCL app crashed kernel mode display driver, System can't boot!

pixelpusher — Sat, 18 Feb 2012 13:36:24 -0500

I have come across a very horrible problem.
I was running an OpenCL + OpenGL raytracing program in VS 2010.
When a simply tried to run the program, it crashed the user mode driver (screen just goes blank and comes right back) but when I tried to debug the program it crashed the kernel mode driver and the system had to do a hard restart. But when the computer tried to reboot, instead of loading the BIOS, its just beeps 3 times. :(
This page for my motherboard says that it is a memory error, but I checked both RAM sticks and they are fine? The motherboard also shows EB or E8 (can't tell) on the LCD display, but that has to do with boot device selection?
Now I cannot boot my system!
How could crashing the display driver cause this kind of issue? Has anyone ever experience this sort of thing before?
I would appreciate any thoughts you might have, I am getting quite desperate.
Thanks

Code runs on weak GT540M but not on fast GF 560Ti ??

StefanDS — Sun, 27 Nov 2011 07:46:51 -0500

Hi all,

I'm writing some OpenCL kernels to do stream compaction, which works fine on a Quadro FX 4600 (old powerful professional card) and an GT 540M (1-year old low-range laptop chipset). But when I try to run on a GTX 560 Ti (1-year old high/mid range desktop card), a clCreateFromGLTexture2D call returns CL_OUT_OF_RESOURCES.

How is this possible? The Quadro I could understand, I believe the drivers of professional cards manage resources differently, but the GTX 560 is in every way a better card then the GT540M, and they are both consumer cards. The 560 also has more recent drivers, I would expect it to run better, not worse.

Does anyone has an idea on what could cause this? I'll attach the output of oclDeviceQuery for both cards (except the imageformat stuff with is identical):

---------------------------------
Device GeForce GT 540M
---------------------------------
CL_DEVICE_NAME: GeForce GT 540M
CL_DEVICE_VENDOR: NVIDIA Corporation
CL_DRIVER_VERSION: 270.51
CL_DEVICE_VERSION: OpenCL 1.0 CUDA
CL_DEVICE_TYPE: CL_DEVICE_TYPE_GPU
CL_DEVICE_MAX_COMPUTE_UNITS: 2
CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS: 3
CL_DEVICE_MAX_WORK_ITEM_SIZES: 1024 / 1024 / 64
CL_DEVICE_MAX_WORK_GROUP_SIZE: 1024
CL_DEVICE_MAX_CLOCK_FREQUENCY: 1344 MHz
CL_DEVICE_ADDRESS_BITS: 32
CL_DEVICE_MAX_MEM_ALLOC_SIZE: 248 MByte
CL_DEVICE_GLOBAL_MEM_SIZE: 993 MByte
CL_DEVICE_ERROR_CORRECTION_SUPPORT: no
CL_DEVICE_LOCAL_MEM_TYPE: local
CL_DEVICE_LOCAL_MEM_SIZE: 48 KByte
CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE: 64 KByte
CL_DEVICE_QUEUE_PROPERTIES: CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE
CL_DEVICE_QUEUE_PROPERTIES: CL_QUEUE_PROFILING_ENABLE
CL_DEVICE_IMAGE_SUPPORT: 1
CL_DEVICE_MAX_READ_IMAGE_ARGS: 128
CL_DEVICE_MAX_WRITE_IMAGE_ARGS: 8
CL_DEVICE_SINGLE_FP_CONFIG: denorms INF-quietNaNs round-to-nearest round-to-zero round-to-inf fma

CL_DEVICE_IMAGE 2D_MAX_WIDTH 4096
2D_MAX_HEIGHT 32768
3D_MAX_WIDTH 2048
3D_MAX_HEIGHT 2048
3D_MAX_DEPTH 2048

CL_DEVICE_EXTENSIONS: cl_khr_byte_addressable_store
cl_khr_icd
cl_khr_gl_sharing
cl_nv_d3d9_sharing
cl_nv_d3d10_sharing
cl_khr_d3d10_sharing
cl_nv_d3d11_sharing
cl_nv_compiler_options
cl_nv_device_attribute_query
cl_nv_pragma_unroll
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_DEVICE_COMPUTE_CAPABILITY_NV: 2.1
NUMBER OF MULTIPROCESSORS: 2
NUMBER OF CUDA CORES: 96
CL_DEVICE_REGISTERS_PER_BLOCK_NV: 32768
CL_DEVICE_WARP_SIZE_NV: 32
CL_DEVICE_GPU_OVERLAP_NV: CL_TRUE
CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV: CL_TRUE
CL_DEVICE_INTEGRATED_MEMORY_NV: CL_FALSE
CL_DEVICE_PREFERRED_VECTOR_WIDTH_ CHAR 1, SHORT 1, INT 1, LONG 1, FLOAT 1, DOUBLE 1

---------------------------------
Device GeForce GTX 560 Ti
---------------------------------
CL_DEVICE_NAME: GeForce GTX 560 Ti
CL_DEVICE_VENDOR: NVIDIA Corporation
CL_DRIVER_VERSION: 285.62
CL_DEVICE_VERSION: OpenCL 1.1 CUDA
CL_DEVICE_OPENCL_C_VERSION: OpenCL C 1.1
CL_DEVICE_TYPE: CL_DEVICE_TYPE_GPU
CL_DEVICE_MAX_COMPUTE_UNITS: 8
CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS: 3
CL_DEVICE_MAX_WORK_ITEM_SIZES: 1024 / 1024 / 64
CL_DEVICE_MAX_WORK_GROUP_SIZE: 1024
CL_DEVICE_MAX_CLOCK_FREQUENCY: 1660 MHz
CL_DEVICE_ADDRESS_BITS: 32
CL_DEVICE_MAX_MEM_ALLOC_SIZE: 256 MByte
CL_DEVICE_GLOBAL_MEM_SIZE: 1024 MByte
CL_DEVICE_ERROR_CORRECTION_SUPPORT: no
CL_DEVICE_LOCAL_MEM_TYPE: local
CL_DEVICE_LOCAL_MEM_SIZE: 48 KByte
CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE: 64 KByte
CL_DEVICE_QUEUE_PROPERTIES: CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE
CL_DEVICE_QUEUE_PROPERTIES: CL_QUEUE_PROFILING_ENABLE
CL_DEVICE_IMAGE_SUPPORT: 1
CL_DEVICE_MAX_READ_IMAGE_ARGS: 128
CL_DEVICE_MAX_WRITE_IMAGE_ARGS: 8
CL_DEVICE_SINGLE_FP_CONFIG: denorms INF-quietNaNs round-to-nearest round-to-zero round-to-inf fma

CL_DEVICE_IMAGE 2D_MAX_WIDTH 32768
2D_MAX_HEIGHT 32768
3D_MAX_WIDTH 2048
3D_MAX_HEIGHT 2048
3D_MAX_DEPTH 2048

CL_DEVICE_EXTENSIONS: cl_khr_byte_addressable_store
cl_khr_icd
cl_khr_gl_sharing
cl_nv_d3d9_sharing
cl_nv_d3d10_sharing
cl_khr_d3d10_sharing
cl_nv_d3d11_sharing
cl_nv_compiler_options
cl_nv_device_attribute_query
cl_nv_pragma_unroll
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_DEVICE_COMPUTE_CAPABILITY_NV: 2.1
NUMBER OF MULTIPROCESSORS: 8
NUMBER OF CUDA CORES: 384
CL_DEVICE_REGISTERS_PER_BLOCK_NV: 32768
CL_DEVICE_WARP_SIZE_NV: 32
CL_DEVICE_GPU_OVERLAP_NV: CL_TRUE
CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV: CL_TRUE
CL_DEVICE_INTEGRATED_MEMORY_NV: CL_FALSE
CL_DEVICE_PREFERRED_VECTOR_WIDTH_ CHAR 1, SHORT 1, INT 1, LONG 1, FLOAT 1, DOUBLE 1

nsight OpenCL profiling issue

ivanmalin — Sun, 05 Feb 2012 10:49:26 -0500

Hi! I'm a beginner in OpenCL and would like to ask a question.
I'm trying to get profiling information about my OpenCL app and get no success.
Using MS VS 2010, parallel nsight 2.1 under Windows 7 x 64 with GTX 550 Ti card.
I start new analysis activity, set its type to "Profile", experiment configuration to "Memory" and launch. But after it finishes its work, I get no information except for "Session Summary" and in the report events collection status is No Events Captured.
How can I get all counters, statistics etc?

P.S. Also, when I use nVidia Visual Profiler from 4.1 Toolkit, I get an error, saying "Unable to collect metric and event values" CUPTI_ERROR_PARAMETER_SIZE_NOT_SUFFICIENT

Visual Profiler not working under Mac OS X

juanrgar — Tue, 07 Feb 2012 11:13:24 -0500

I have an OpenCL program that runs without problems on a MacBook Pro with Snow Leopard installed, using Apple's OpenCL implementation. I want to profile that program with Visual Profiler. I have installed the NVIDIA developer drivers and then the CUDA Toolkit, with matching versions. I have tried versions 4.1 and 4.0. When I run my program under Visual Profiler 4.1 I get a "No Timeline" message, and no analysis can be performed. When running under Visual Profiler 4.0 I get the following error message:

Application : "/Users/juanrgar/Work/SSII/ldpc-gpu/jrgarcia/src/OpenCL/serial-schedule/ver0/ldpc".
Profiler data file '/Users/juanrgar/Work/SSII/ldpc-gpu/jrgarcia/src/OpenCL/serial-schedule/ver0/temp_compute_profiler_0_0.csv' for application run 0 not found.

I think the problem is I am using Apple's OpenCL implementation, so the platform is identified as "Apple" instead of "NVIDIA OpenCL" or something like that, and Visual Profiler thinks it is a plain C program. I have installed the CUDA Toolkit in Windows too, and I get no errors with version 4.1 of Visual Profiler. Although in Windows I compile and link against NVIDIA's OpenCL implementation.

I am not sure if that is the problem I am running in, but if it is I would want to know how to solve it. I have asked google and I got nothing.

Thank you very much.

NV Controller stop responding during OpenCL kernel execution.

Ffelagund — Tue, 15 Nov 2011 06:09:06 -0500

Hello,

We are starting with OpenCL and we are performing some sample applications to learn how it works under the tables. We found in one execution that the device driver stopped responding and rebooted (not the machine, only the device driver).
I've attache the VS2008 solution that makes the application crash, as well as a screen capture in the moment of the problem (sorry, it is in Spanish)

We are using a NV 525M GT, with driver version 285.62 in a laptop with Windows 7 64b.

Any clue to foind out why this happens will be really appreciated :)

Regards,
Jacobo.

opencl application is portable cuda for intel and amd?

silviocassiano — Fri, 02 Dec 2011 13:18:08 -0500

Good afternoon, is the first time I write, I am newbie in this world, someone from the forum would respond if it is possible to run an application OpenCL developed using the Intel SDKon architecture Nvidia, RADEON and Intel or application developed using the nvidia sdk architectures run on Intel, AMD and RADEON.

my e-mail is silvio.cassiano@hotmail.com

Thank you.

floating point precison loss on gpu in opencl

AbhijitDalvi — Thu, 12 Jan 2012 00:14:03 -0500

Hi,
I am getting precision loss while working on floating point at 6th or 7th decimal point. I am doing simple addition operation of 64 values on CPU and GPU.
please see below for input values

I Observed that if I am doing bellows operation
CPU Method for addition:
for(i=0;i<64;i++)
{
sum += input[i];
}
I am getting sum value as " 31.637564 "

GPU Method for addition using OPENCL 1.0:
And if I using vector addition (float8) I am getting result as " 31.637560 "

#pragma OPENCL EXTENSION cl_khr_fp64: enable
__kernel void test_dist(__global float8 *gpu_output,__global float8 *gpu_input, __global float *temp_buf)
{

//vector addition
gpu_output[0] = gpu_input[0]+gpu_input[1]+gpu_input[2]+gpu_input[3]+
gpu_input[4]+gpu_input[5]+ gpu_input[6]+gpu_input[7];

//scalar addition
barrier(CLK_GLOBAL_MEM_FENCE);
temp_buf[0] = gpu_output[0].s0+gpu_output[0].s1+gpu_output[0].s2+gpu_output[0].s3+gpu_output[0].s4+gpu_output[0].s5+gpu_output[0].s6+gpu_output[0].s7;

}

Anyone please tell me why this is happening
input values are below (randomly generated):
0.481918
0.963439
0.134709
0.630177
0.461104
0.868496
0.095309
0.669088
0.147649
0.588305
0.575121
0.513291
0.750877
0.275674
0.206702
0.056642
0.361522
0.901700
0.869289
0.463973
0.653462
0.438917
0.359844
0.171880
0.485275
0.734458
0.449446
0.500961
0.996734
0.041017
0.167516
0.097964
0.292367
0.675222
0.658773
0.927183
0.307413
0.770959
0.456038
0.028596
0.948546
0.598041
0.512803
0.763482
0.104038
0.413373
0.839412
0.764000
0.617084
0.314493
0.086306
0.307260
0.814997
0.063601
0.918607
0.331980
0.689566
0.351146
0.525010
0.816004
0.321238
0.467574
0.105716
0.734275

OpenCL: Program crash when copying data onto device

BaiLong — Thu, 12 Jan 2012 08:45:16 -0500

Hey there,

I'm completely new to OpenCL and I can't find a thread to my issue.

My situation is: I have a single method in which I create a kernel, run and delete it. (Maybe not the smartest way, but that's only for the first tests whether OpenCL is the right way to go) The method itself is called several times (currently approx. 30), but so far I don't access any data after I free the memory.
My problem is: My program crashes with no error but that appears to be at random. Sometimes it crashes on the first execution of move, sometimes it runs through nicely and sometimes it crashes in between. I don't get any error code (except code 0) or crash message, the program window just closes and that's it. I only can tell it's always when copying data onto my graphics card.

I really tried everything I could imagine! :(
Hopefully that's just a beginners issue.

Here is the host method:

      void move(
         const float *srcPos, float *destPos,
         size_t numVertices)
      {         
         cl_context context = 0;
         cl_command_queue commandQueue = 0;
         cl_program program = 0;
         cl_device_id device = 0;
         cl_kernel kernel = 0;
         cl_int errNum;

         // Create an OpenCL context on first available platform
         context = CreateContext();

         // Create a command-queue on the first device available
         // on the created context
         commandQueue = CreateCommandQueue(context, &device);

         char* kernelPath = "move.cl";         

         program = CreateProgram(context, device, kernelPath);

         // Create OpenCL kernel
         kernel = clCreateKernel(program, "move_kernel", NULL);         

         // Create memory objects that will be used as arguments to kernel.
         float* result = (float*)malloc(numVertices * sizeof(float));

         cl_mem d_result = clCreateBuffer(context, CL_MEM_WRITE_ONLY,
                                 sizeof(float) * numVertices, NULL, &errNum);   

         cl_mem d_srcPos = clCreateBuffer( context, CL_MEM_READ_ONLY,
                                 sizeof(float) * numVertices * 3, (void*)srcPos, &errNum);      

         //#########################
         // This is the call that causes the crash
         //#########################
         errNum = clEnqueueWriteBuffer(commandQueue, d_srcPos, CL_TRUE, 0, sizeof(float) * numVertices * 3,
                           (void*)srcPos, 0, NULL, NULL);
         //#########################
         if (errNum != CL_SUCCESS)
         {
            std::cerr << "Error setting kernel argument." << std::endl;
            std::cout << "Error code: " << errNum << std::endl;   
            std::getchar();
            return;
         }

         cl_mem d_destPos = clCreateBuffer( context, CL_MEM_WRITE_ONLY,
                                 sizeof(float) * numVertices * 3, NULL, &errNum);

         errNum = clSetKernelArg(kernel, 0, sizeof(cl_mem), &d_srcPos);
         errNum |= clSetKernelArg(kernel, 1, sizeof(cl_mem), &d_destPos);
         errNum |= clSetKernelArg(kernel, 2, sizeof(int), &numVertices);
         errNum |= clSetKernelArg(kernel, 3, sizeof(cl_mem), &d_result);

         if (errNum != CL_SUCCESS)
         {
            std::cerr << "Error setting kernel arguments." << std::endl;
            std::cout << "Error code: " << errNum << std::endl;
            Cleanup(context, commandQueue, program, kernel, memObjects);
            std::getchar();
            return;
         }

         size_t localWorkSize[1] = { 1 };
         size_t globalWorkSize[1] = { numVertices };

         // Queue the kernel up for execution across the array
         errNum = clEnqueueNDRangeKernel(commandQueue, kernel, 1, NULL,
                                 globalWorkSize, localWorkSize,
                                 0, NULL, NULL);

         // Read the output buffer back to the Host      
         errNum = clEnqueueReadBuffer(commandQueue, d_result, CL_TRUE,
                               0, numVertices * sizeof(float), result,
                               0, NULL, NULL);

         std::cout << "Executed program succesfully." << std::endl;

         free(result);

         clReleaseMemObject(d_result);
         clReleaseMemObject(d_srcPos);
         clReleaseMemObject(d_destPos);

         clReleaseCommandQueue(commandQueue);

         clReleaseKernel(kernel);

         clReleaseProgram(program);

         clReleaseContext(context);
}

The kernel so far looks like this:

__kernel void move_kernel(__global const float *d_srcPos,
                                 __global float *d_destPos,
                                 int numVertices,
                                 __global float *d_result
                                 )
{   
        int gid = get_global_id(0);   

        d_result[gid] = gid;
}

I also tried to use

cl_mem d_srcPos = clCreateBuffer( context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(float) * numVertices * 3, (void*)srcPos, &errNum);

instead, but that causes the same behavior.

A lot of the code is still from some example file, which worked perfectly (even with data transfer), but since I added this mem-copy function I get the described crashes.

Since I'm still working on it, the variable result is just a test variable, that I sometimes use to output values (e.g. get_global_id(), or such).
For the sake of readability I also deleted all the error handling like if(kernel == NULL). Therefore you have to believe me I really tested everything and the only thing that causes the crash is the marked function call.

Does anyone have an idea what could cause my Problem?

Thanks in advance!

Cheers,
--Markus

My Device:
Quadro 5000
Driver 285.58

PS: I also posted in the khronos forum, which gave me the idea it could also be some driver related issue.

Accessing GPU Memory from Operating System Kernel

FrankFeinbube — Thu, 26 Jan 2012 09:45:30 -0500

Hi everyone,

we are working on a research prototype where we intend to use the GPU memory for a "GPU RAM Disk".
At the moment we have a user-mode module that uses OpenCL to copy data to and from the GPU memory.

We would prefer a way of accessing the GPU memory directly from the Windows Kernel (thereby reducing the overhead introduced f.e. by the context switch). What is the best way to achieve this?

Best regards,
Frank

GPU Accelerated 2D to Stereo 3D Video Conversion

DryRiver — Tue, 24 Jan 2012 16:43:20 -0500

Hello All,

I have written a pretty good 2D-to-3D video conversion algorithm in C# NET. (Took a little over 2 years of experimenting to get it right)

I now want to GPU accelerate this 2D-to-3D conversion algorithm. I am hoping for a 10x - 20x times speedup using the GPU to do the pixel crunching, instead of the CPU.

My requirements are:

- The GPU code needs to execute inside a C# .NET Windows Forms Applicaton

- I want to use the easiest/beginner friendliest GPU coding method possible

Where should I start with this? CUDA.NET? OpenCL.NET? Brahma (for C#)?

Are there any beginners tutorials for using CUDA/OpenCL inside C# NET?

Are there, specifically, any Image Processing tutorials/examples for CUDA/OpenCL?

Thank you for any feedback. I am a complete CUDA/OpenCL Noob and am hoping for expert advice on making my first GPU accelerated project happen.

Best Regards,

DryRiver

linker errors while executing opencl sample codes

Prasanna — Fri, 13 Jan 2012 06:10:44 -0500

Hi
I am new in executing opencl codes...I have downloaded the GPU Computing SDK and drivers and executing opencl samples from that...I have included all the .lib files which are there in opencl in SDK...While executing i got the following errors in visual studio 2010

1>------ Build started: Project: testopencl, Configuration: Debug Win32 ------
1> Skipping... (no relevant changes detected)
1> testopencl.cpp
1>testopencl.obj : error LNK2019: unresolved external symbol _shrComparefet referenced in function _main
1>testopencl.obj : error LNK2019: unresolved external symbol _clEnqueueReadBuffer@36 referenced in function _main
1>testopencl.obj : error LNK2019: unresolved external symbol _clEnqueueNDRangeKernel@36 referenced in function _main
1>testopencl.obj : error LNK2019: unresolved external symbol _clEnqueueWriteBuffer@36 referenced in function _main
1>testopencl.obj : error LNK2019: unresolved external symbol _clSetKernelArg@16 referenced in function _main
1>testopencl.obj : error LNK2019: unresolved external symbol _clCreateKernel@12 referenced in function _main
1>testopencl.obj : error LNK2019: unresolved external symbol _clBuildProgram@24 referenced in function _main
1>testopencl.obj : error LNK2019: unresolved external symbol _clCreateProgramWithSource@20 referenced in function _main
1>testopencl.obj : error LNK2019: unresolved external symbol _oclLoadProgSource referenced in function _main
1>testopencl.obj : error LNK2019: unresolved external symbol _shrFindFilePath referenced in function _main
1>testopencl.obj : error LNK2019: unresolved external symbol _clCreateBuffer@24 referenced in function _main
1>testopencl.obj : error LNK2019: unresolved external symbol _clCreateCommandQueue@20 referenced in function _main
1>testopencl.obj : error LNK2019: unresolved external symbol _clCreateContext@24 referenced in function _main
1>testopencl.obj : error LNK2019: unresolved external symbol _clGetDeviceIDs@24 referenced in function _main
1>testopencl.obj : error LNK2019: unresolved external symbol _clGetPlatformIDs@12 referenced in function _main
1>testopencl.obj : error LNK2019: unresolved external symbol _shrFillArray referenced in function _main
1>testopencl.obj : error LNK2019: unresolved external symbol _shrRoundUp referenced in function _main
1>testopencl.obj : error LNK2019: unresolved external symbol _shrLog referenced in function _main
1>testopencl.obj : error LNK2019: unresolved external symbol _shrSetLogFileName referenced in function _main
1>testopencl.obj : error LNK2019: unresolved external symbol _shrCheckCmdLineFlag referenced in function _main
1>testopencl.obj : error LNK2019: unresolved external symbol _clReleaseMemObject@4 referenced in function "void __cdecl Cleanup(int,char * *,int)" (?Cleanup@@YAXHPAPADH@Z)
1>testopencl.obj : error LNK2019: unresolved external symbol _clReleaseContext@4 referenced in function "void __cdecl Cleanup(int,char * *,int)" (?Cleanup@@YAXHPAPADH@Z)
1>testopencl.obj : error LNK2019: unresolved external symbol _clReleaseCommandQueue@4 referenced in function "void __cdecl Cleanup(int,char * *,int)" (?Cleanup@@YAXHPAPADH@Z)
1>testopencl.obj : error LNK2019: unresolved external symbol _clReleaseProgram@4 referenced in function "void __cdecl Cleanup(int,char * *,int)" (?Cleanup@@YAXHPAPADH@Z)
1>testopencl.obj : error LNK2019: unresolved external symbol _clReleaseKernel@4 referenced in function "void __cdecl Cleanup(int,char * *,int)" (?Cleanup@@YAXHPAPADH@Z)
1>C:\Users\Acer\Documents\Visual Studio 2010\Projects\testopencl\Debug\testopencl. exe : fatal error LNK1120: 25 unresolved externals
========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ==========

I am using Windows7 os 64-bit with nvidia graphic card...It will be great helpful if anyone reply the solution for this problem.
Thank You...

Memory Leak

ti6csb — Tue, 17 Jan 2012 06:29:49 -0500

Hi there,

I am using the Nvidia SDK 4.0 on a 64-bit 10.10 Ubuntu with the kernel version 2.6.35-30-generic.

When using the OpenCL function clEnqueueNDRangeKernel() there happens to be a memory leak when the 5th and 6th parameter i.e. the global- and localworksize are not arrays and passed by providing the address of the variable via &. In this case valgrind reports a memory leak. This leak disappears when both variables are arrays.

best regards,
Cem

Mip-map texture support - Vote for this feature and discuss!

Crog — Thu, 12 Jan 2012 10:23:06 -0500

Hi, please vote on this discussion if you want mip-map support added in CUDA. If enough of the community show desire Nvidia may investigate this as the hardware is known to support this feature so we just need CUDA to give us the access to it.

We desire this as we are using CUDA and OptiX to perform ray-tracing and texture aliasing is a major issue in larger scale/real scenes. We are limited to software emulating mip-mapping ourselves. The interface for mip-maps is already in the OptiX interface its just there isn't enough emphasis on it from the community for the CUDA development team to implement this yet.

Also if anybody has ideas/ways of optimizing a software mip-map implementation they can discuss them here for others to find. For example how do you efficiently pack them in memory and then access these locations with as few instructions as possible.

Cheers,
Craig

OpenCL: what is best way to implement an atomic add with upper bound (clamp) to prevent roll over?

connertorcroboticscom — Mon, 16 Jan 2012 17:43:16 -0500

I need to increment a uint by a calculated amount "inc" between 0 and UINT_MAX. These calculations occur in parallel, and several threads may access the same value.

I can do this with atom_add(pmap, inc), but there is a distinct possibility that the value may wrap.

Is there an efficient way to prevent the roll over by clamping the value?

Currently I increment the value, then retrieve the value and test that it is > inc.
If I detect roll over, then I just set the value to UINT_MAX.

This would be simple if atom_add() return the new value, but atom_add returns the "old" value.

As it is, this two step process is not guaranteed to be correct.

Is there a good and computationally efficient way to do what I need?

Thanks

GPU Computing SDK: problem with the OpenCL n-body simulation example.

Bekos — Sun, 04 Dec 2011 08:41:50 -0500

Hello everyone!

I have a question regarding the n-body OpenCL simulation in the nVidia GPU computing SDK. First of all I want to apologize if I am asking something very silly. My physics and n-body knowledge is not very good yet. I was checking the CPU version of the n-body algorithm in file "oclBodySystemCPU.cpp". My question is related to the void BodySystemCPU::_integrateNBodySystem(float) function. This function, at line 165 calculates the velocity of the particle at the end of the interval. And then uses this velocity to calculate the position of the particle at the end of the interval. Isn't this wrong? I thought the correct solution is to calculate the position using the velocity of the particle at the end of the previous interval. And the velocity calculated at line 165 should be used for the next interval. I am missing something here? Thanks a lot for your time.

Cheers,
Bekos

Does cuda-gdb work with OpenCL?

connertorcroboticscom — Mon, 09 Jan 2012 18:11:52 -0500

I'm developing an OpenCL application on NVIDIA processor, and would like to debug and profile the code. I've tried gDEBugger for Windows, but it seems to hang a lot.

The code is cross-platform compatible, so I'm curious if the cuda-gdb tool set will help with debugging and profiling OpenCL code on a Linux (Ubuntu 10.04) platform. Does it provide useful information for OpenCL programs?

parallel-nsight looked promising, but I'm not using Visual Studio professional.

New Developer's Driver 285.67 OpenCL Problem: command queues are not started

kontakt2 — Mon, 05 Dec 2011 09:21:26 -0500

Hi Everyone,

I am developing an application which uses the OpenCL implementation of NVIDIA. Until yesterday I had the old developer's driver (270.81) installed everything ran smoothly.
Now with the new driver (285.67) suddenly, when I Enqueue a kernel in a command queue, the command is never being sent to the device, it stays at status CL_QUEUED.

To give a few details:
In my main thread I initialize the OpenCL runtime (platform, a command queue, etc) and in that thread I create buffers, transfer data to the buffers, etc. So far everything works fine.
But when I call clEnqueueNDRangeKernel(...) and pass a cl_event in there to check the status of the kernel execution, the event always stays in the state CL_QUEUED and is never finished.

When I reinstall the old driver, everything works fine again!

Do you have similar problems perhaps?

Visual Profiler 4.0 Problem : Rows dropped

kontakt2 — Mon, 05 Dec 2011 09:24:53 -0500

Hi,

I have a problem with the Visual Profiler. This problem now persists for a long time and I wanted to check whether someone in here has a solution:

I have OpenCL application which I want to profile. When I start the Visual Profiler 4.0 and profile my application I always get an error about dropped rows. Now there are some posts on the internet but none worked for me, and most of the posts don't even have a solution.
Do you guys have the same issues with the Profiler?

Thanks for your help

OpenCL C++ Bindings

robloblaw — Fri, 02 Dec 2011 14:59:16 -0500

I'm new to using OpenCL with my nVidia GTX 260 card, so please bear with me...

I installed the Cuda Toolkit and newest graphics driver on my Ubuntu 11.10 box and have OpenCL up and running using the C version of OpenCL (using the header file cl.h). I was looking on the Khronos Group's website and noticed they have C++ bindings for OpenCL. I was reading somewhere to simply place the cl.hpp file in the CL directory with the other OpenCL header files, but g++ gave me the following error:

/usr/local/cuda/include/CL/cl.hpp:160:19: fatal error: GL/gl.h: No such file or directory
compilation terminated.
make: *** [smith-waterman] Error 1

Are there some dependencies (i.e. OpenGL dependencies) that I need to download to enable C++ support?

weird texture opencl behaviour by using write_imagef

florisdesmedt — Thu, 17 Nov 2011 11:55:04 -0500

Hi,

To learn to work with texture memory,I have created a demo-application.


Kernel Code:
__kernel void testimage(__write_only image2d_t outputImage, const int width, const int height, sampler_t Sam,__read_only image2d_t InputImage){

        int x = get_global_id(0);
        int y = get_global_id(1);

        if(x < width && y < height ){
                int2 coord = (int2)(x,y);
                float2 coord3 = (float2)(x,y);
                int2 coord2 = (int2)(x*2,y);
                float4 I = read_imagef(InputImage,Sam,coord);

                write_imagef(outputImage,coord2,I);
        }
}

Host Code:
#include 
#include 
#include 
#include "highgui.h"

using namespace std;

int main(int argc, char** argv){
	 cout << "Starting program ..." << endl << flush;

//initialisation
	 cl_int error = 0;
	 cl_context context;
	 cl_command_queue queue;
	 cl_device_id device;

FILE *fp;
long filelen, readlen;
char* kernelSource;

int W=10, H=10; //width and height of image in pixels

// Platform
cl_platform_id platform[2];

cl_device_id devices[4];
cl_uint nplat;

//Platform
error = clGetPlatformIDs(2,platform,&nplat);
if (error != CL_SUCCESS) {
   cout << "Error getting platform id: "  << endl<< flush;
   exit(error);
}

// Device
cl_uint ndevices;
error = clGetDeviceIDs(platform[1], CL_DEVICE_TYPE_GPU, 4, devices, &ndevices);
if (error != CL_SUCCESS) {
   cout << "Error getting device ids: " << endl<< flush;
   exit(error);
}

//context
int numberOfDevices = 1; //amount of devices to use
context = clCreateContext(NULL, numberOfDevices, &devices[3], NULL, NULL, &error);
if (error != CL_SUCCESS) {
   cout << "Error creating context: " << endl<< flush;
   exit(error);
}

//command queue
queue = clCreateCommandQueue(context, devices[3], 0, &error);
if (error != CL_SUCCESS) {
   cout << "Error creating command queue: "  << endl<< flush;
   exit(error);
}


cl_image_format form2;
form2.image_channel_order = CL_RGBA;
form2.image_channel_data_type = CL_FLOAT;

const size_t ori[3] = {0,0,0};
const size_t reg[3] = {W,H,1}; 

cl_mem Afbeelding2 = clCreateImage2D(context,CL_MEM_READ_WRITE,&form2,W,H,0,NULL,&error); 
cl_mem Afbeelding = clCreateImage2D(context,CL_MEM_READ_WRITE,&form2,W,H,0,NULL,&error); 

float Geh[W*H*4]; //input data of image
//fill array of input data
for(int Q=0;Q	Geh[Q] = Q;

clEnqueueWriteImage(queue,Afbeelding, CL_TRUE, ori, reg, 0,0,Geh,0,NULL,NULL);

fprintf(stderr,"End creating store on GPU ...\n");
fprintf(stderr,"Give kernel to execute ...\n");

//reading kernel code
fp = fopen("kernel.cl","r");
fseek(fp,0L,SEEK_END);
filelen = ftell(fp);
rewind(fp);

kernelSource = (char*)malloc(sizeof(char)*filelen+1);
readlen = fread(kernelSource,1,filelen,fp);
if(readlen != filelen){
        cout << "PROBLEM READING KERNEL" << endl;
}
kernelSource[filelen] = '\0';

cl_program prog = clCreateProgramWithSource(context,1, (const char**)&kernelSource, NULL, &error);
assert(error == CL_SUCCESS);
fprintf(stderr,"Start building GPU program ...\n");

device = devices[3];

//create program
error = clBuildProgram(prog, 1, &device, NULL,NULL,NULL);
if(error == CL_INVALID_PROGRAM)
	cout << "Invalid program" << endl<< flush;
else if(error == CL_INVALID_VALUE)
	cout << "device list is NULL en num_devices is greater than zero or num_devices is zero ofwel is user data not NULL maar wel als NULL ingevuld" << endl<< flush;
else if(error == CL_INVALID_DEVICE)
	cout << "No valid device" << endl<< flush;
else if(error == CL_INVALID_BUILD_OPTIONS)
	cout << "No valid build options" << endl<< flush;
else if (error == CL_INVALID_OPERATION)
	cout << "CL_INVALID_OPERATION"<< endl<< flush;
else if(error == CL_COMPILER_NOT_AVAILABLE)
	cout << "CL_COMPILER_NOT_AVAILABLE" <else if(error == CL_BUILD_PROGRAM_FAILURE)
	cout << "CL_BUILD_PROGRAM_FAILURE" << endl<< flush;

if(error != CL_SUCCESS){
	char* buildLog;
	size_t log_size;
	clGetProgramBuildInfo(prog,device, CL_PROGRAM_BUILD_LOG, 0, NULL, &log_size);
	buildLog = new char[log_size+1];
	clGetProgramBuildInfo(prog, device, CL_PROGRAM_BUILD_LOG, log_size, buildLog, NULL);
	buildLog[log_size] = '\0'; 
	printf("BuildLog:\n-----------\n%s",buildLog);
	delete[] buildLog;
}
assert(error == CL_SUCCESS);

fprintf(stderr,"GPU program created ...\n");
fprintf(stderr,"Creating kernel ...\n");

//Kernel to use
cl_kernel kern = clCreateKernel(prog, "testimage", &error);
assert(error == CL_SUCCESS);

fprintf(stderr,"Kernel created ...\n");
fprintf(stderr,"Create sampler object ...\n");
cl_sampler Samp = clCreateSampler(context, CL_FALSE, CL_ADDRESS_CLAMP_TO_EDGE, CL_FILTER_NEAREST, &error);
assert(error == CL_SUCCESS);
fprintf(stderr,"Sampler created ...\n");
fprintf(stderr,"Give arguments of kernel ...\n");

error  = clSetKernelArg(kern, 0, sizeof(cl_mem), &Afbeelding2);
error |= clSetKernelArg(kern, 1, sizeof(int), &W);
error |= clSetKernelArg(kern, 2, sizeof(int), &H);
error |= clSetKernelArg(kern, 3, sizeof(cl_sampler), &Samp);
error |= clSetKernelArg(kern, 4, sizeof(cl_mem), &Afbeelding);

if(error == CL_INVALID_KERNEL){
	cout << "CL_INVALID_KERNEL" << endl;
}
if(error == CL_INVALID_ARG_INDEX){
	cout << "CL_INVALID_ARG_INDEX" << endl;
}
if(error == CL_INVALID_ARG_VALUE){
	cout << "CL_INVALID_ARG_VALUE" << endl;
}
if(error == CL_INVALID_MEM_OBJECT){
	cout << "CL_INVALID_MEM_OBJECT" << endl;
}
if(error == CL_INVALID_SAMPLER){
	cout << "CL_INVALID_SAMPLER" << endl;
}
if(error == CL_INVALID_ARG_SIZE){
	cout << "CL_INVALID_ARG_SIZE" << endl;
}

assert(error == CL_SUCCESS);

const size_t local_ws[] = {16,16};
const size_t global_ws[] = {W,H};
fprintf(stderr,"Execute kernel ...\n");

//Execute kernel
error = clEnqueueNDRangeKernel(queue,kern, 2, NULL, global_ws, local_ws, 0, NULL, NULL);
if(error == CL_INVALID_PROGRAM_EXECUTABLE)
	cout << "CL_INVALID_PROGRAM_EXECUTABLE" <if(error == CL_INVALID_COMMAND_QUEUE)
	cout << "CL_INVALID_COMMAND_QUEUE" <if(error == CL_INVALID_KERNEL)
	cout << "CL_INVALID_KERNEL" <if(error == CL_INVALID_CONTEXT)
	cout << "CL_INVALID_CONTEXT" <if(error == CL_INVALID_KERNEL_ARGS)
	cout << "CL_INVALID_KERNEL_ARGS" <if(error == CL_INVALID_WORK_DIMENSION)
	cout << "CL_INVALID_WORK_DIMENSION" <if(error == CL_INVALID_GLOBAL_WORK_SIZE)
	cout << "CL_INVALID_GLOBAL_WORK_SIZE" <if(error == CL_INVALID_WORK_GROUP_SIZE)
	cout << "CL_INVALID_WORK_GROUP_SIZE" <if(error == CL_INVALID_WORK_ITEM_SIZE)
	cout << "CL_INVALID_WORK_ITEM_SIZE" <if(error == CL_INVALID_GLOBAL_OFFSET)
	cout << "CL_INVALID_GLOBAL_OFFSET" <assert(error == CL_SUCCESS);

fprintf(stderr,"Kernel execution finished ...\n");
fprintf(stderr,"Read results from GPU ...\n");
cl_float *h_img = (cl_float*) malloc(W*H*sizeof(cl_float)*4);
clEnqueueReadImage(queue,Afbeelding2,CL_TRUE,ori,reg,4*sizeof(cl_float)*W,0,h_img,NULL,0,NULL);
fprintf(stderr,"Reading of results finished.. ...\n");

fprintf(stderr, "Printing Results...\n");
for(int j=0;j	for(int i=0;i		for(int B=0;B<4;B++)
			printf("%f ",h_img[j*W*4+i*4+B]);
		printf("\n");
	}
	printf("\n");
}

fprintf(stderr,"Free gpu memory ...\n");
free(h_img);
clReleaseKernel(kern);
clReleaseCommandQueue(queue);
clReleaseContext(context);
clReleaseMemObject(Afbeelding);
clReleaseMemObject(Afbeelding2);
clReleaseSampler(Samp);

fprintf(stderr,"Finishing program ...\n");

return 0;
}

I have to double the x-coordinate to prevent the content of pixels is overwritten by the next line. I only experiencing this behaviour on Ubuntu linux, with different versions of the toolkit and different drivers. The same code has been tested on windows systems, on both NVIDIA and AMD. Only on the linux-configuration the x-coordinate must be doubled.

Has someone an explanation/solution for this behaviour?

Greetings