does cuda code skip execution of unnecessary clauses in logical expressions? - cuda

Question

In ordinary C++, if I say the following, it is safe because the third clause will be skipped execution. I'm just wondering if cuda kernel code will also have this property or it doesn't in consideration of maximizing parallelism?
int x[100] = {...}, i = -1;
if (i < 0 || i >= 100 || x[i] == 0) {
// do something.
}
EDIT:
Taking from Jack's program, the following program runs OK and output "10". There is no error doing cuda-memcheck.
#include <stdio.h>
__global__ void test(float *input, float *output, int i, int N) {
float c = 10;
// NOTE: uncomment this will cause cuda-memcheck to give an error.
// c = input[-1];
if (i < 0 || i >= N || (c = input[-1])) {
output[0] = c;
}
}
int main(void) {
int i = -1;
int N = 10;
float* input;
float* output;
float* dev_input;
float* dev_output;
input = (float*)malloc(sizeof(float) * N);
output = (float*)malloc(sizeof(float));
for (int j = 0; j < N; j++) {
input[j] = 2.0f;
}
output[0] = 3.0f;
cudaMalloc((void**)&dev_input,sizeof(float) * N);
cudaMalloc((void**)&dev_output,sizeof(float));
cudaMemcpy(dev_input,input,sizeof(float) * N,cudaMemcpyHostToDevice);
cudaMemcpy(dev_output,output,sizeof(float),cudaMemcpyHostToDevice);
test<<<1,1>>>(dev_input,dev_output,i,N);
cudaMemcpy(output,dev_output,sizeof(float),cudaMemcpyDeviceToHost);
printf("%f\n", output[0]);
return 0;
}

Answer 1

The CUDA C/C++ compiler should obey the language requirements in this respect.
Specifically, the language requirements as far as order-of-operation and short-circuiting should be maintained for non-overloaded || and && operators.

Answer 2

Try the simple code below in which the kernel function tries to access input[-1]. You will realize it will get stuck.
#include <stdio.h>
__global__ void test(float *input, float *output, int i, int N) {
if (i < N || input[i] == 0) {
output[i] = input[i];
}
}
void main(void) {
int i = -1;
int N = 10;
float* input;
float* dev_input;
float* dev_output;
input = (float*)malloc(sizeof(float));
input[0] = 2.f;
cudaMalloc((void**)&dev_input,sizeof(float));
cudaMalloc((void**)&dev_output,sizeof(float));
cudaMemcpy(dev_input,input,sizeof(float),cudaMemcpyHostToDevice);
test<<<1,1>>>(dev_input,dev_output,i,N);
}
The reason can be explained by having a look at the disassembled code.
MOV R1, c[0x1][0x100]; R1 = c[0x1][0x100]
NOP;
MOV R3, c[0x0][0x28]; R3 = c[0x0][0x28]
SHL R2, R3, 0x2; R2 = shiftleft(R3)
IADD R0, R2, c[0x0][0x20]; R0 = R2 + 0x2
LDU R0, [R0]; Load the memory addressed by R0 to R0
FSETP.EQ.AND P0, PT, R0, RZ, PT; Predicate register P0 will contain result of test R0 == 0
ISETP.LT.OR P0, PT, R3, c[0x0][0x2c], P0; Predicate register P0 will contain result of test P0 || (R3 < c[0x0][0x2c])
#P0 IADD R2, R2, c[0x0][0x24]; ...
#P0 ST [R2], R0;
EXIT ;
As you can see, the device will attempt to load the data from global memory regardless from the result of the first clause.