kernel_code stringlengths 49 1.22M |
|---|
float Iq(float q, float rg);
float Iq(float q, float rg) {
float exponent = rg * rg * q * q / 3.0f;
float value = exp(-exponent);
return value;
}
float Iqxy(float qx, float qy, float rg);
float Iqxy(float qx, float qy, float rg) {
return Iq(sqrt(qx * qx + qy * qy), rg);
}
kernel void guinier_Iq(global const fl... |
float2 pair_force(float2 p1, float2 p2) {
float2 d = p2 - p1;
float r2 = dot(d, d);
if (r2 > 3.24)
return (float2)(0.0f, 0.0f);
float ir2 = 1 / (r2 + 1.0e-2);
float fr = (0.7 - ir2) * (3.24 - r2);
return d * fr;
}
kernel void NBody_force_naive(unsigned int num, global float2* pos, global float2* force)... |
kernel void vecadd4(global int4* A, global int4* B, global int4* C) {
int tid = get_global_id(0);
C[tid] = A[tid] + B[tid];
} |
float LaplacianXY(global float* C, int row, int column) {
float retval;
float dx = 1;
float dy = 1;
int current = row * (32 * 16) + column;
int left = row * (32 * 16) + column - 1;
int right = row * (32 * 16) + column + 1;
int top = (row - 1) * (32 * 16) + column;
int bottom = (row + 1) * (32 * 16) + c... |
kernel void vecadd(global int* A, global int* B, global int* C) {
int idx = get_global_id(0);
C[idx] = A[idx] + B[idx];
} |
kernel void multiply_uchar8uchar8(global uchar8* src_0, global uchar8* src_1, global uchar8* dst) {
int gid = get_global_id(0);
dst[gid] = src_0[gid] * src_1[gid];
} |
constant int cospi8sqrt2minus1 = 20091;
constant int sinpi8sqrt2 = 35468;
constant int rounding = 0;
void vp8_short_idct4x4llm(global short*, short*, int);
void cl_memset_short(global short*, int, size_t);
kernel void vp8_dequantize_b_kernel(global short* dqcoeff_base, int dqcoeff_offset, global short* qcoeff_base, int... |
kernel void scaled_sum_three_s_f(global float* output, global float* x, global float* y, const float multiplier, const unsigned int size) {
unsigned int tid = get_global_id(0);
if (tid < size)
output[tid] = x[tid] + y[tid] * multiplier;
} |
float linear_to_gamma_2_2(float value) {
if (value > 0.003130804954f)
return 1.055f * native_powr(value, (1.0f / 2.4f)) - 0.055f;
return 12.92f * value;
}
float gamma_2_2_to_linear(float value) {
if (value > 0.04045f)
return native_powr((value + 0.055f) / 1.055f, 2.4f);
return value / 12.92f;
}
kernel... |
kernel void test_arg_7_2_kern(global int4* a0, global int4* a1, global int4* a2, global int4* a3, global int4* a4, global int4* a5, global int4* a6, global int4* b0, global int4* b1) {
int4 za = (int4)(0, 1, 2, 3);
unsigned int gtid = get_global_id(0);
int4 tmp0 = a0[gtid] + 0 + za;
int4 tmp1 = a1[gtid] + 1 + z... |
kernel void kmeans_swap(global float* feature, global float* feature_swap, int npoints, int nfeatures) {
unsigned int tid = get_global_id(0);
if (tid < npoints) {
for (int i = 0; i < nfeatures; i++)
feature_swap[i * npoints + tid] = feature[tid * nfeatures + i];
}
} |
ulong a51(ulong start, int steps, char retstream) {
unsigned int lfsr1 = start & 0x7ffff;
unsigned int lfsr2 = (start >> 19) & 0x3fffff;
unsigned int lfsr3 = (start >> 41) & 0x7fffff;
ulong stream = 0;
for (int i = 0; i < steps; i++) {
int count = ((lfsr1 >> 8) & 0x01);
count += ((lfsr2 >> 10) & 0x0... |
kernel void dot_product_child(global const float4* a, global const float4* b, global float* c, global float4* d) {
int gid = get_global_id(0);
float4 prod = a[gid] * d[gid];
c[gid] = prod.x + prod.y + prod.z + prod.w;
} |
kernel void inplace_multiply_const_kernel(const float k, const unsigned size, global float* px) {
const unsigned i = get_global_id(0);
if (i < size)
px[i] *= k;
} |
kernel void kernelUInt(uint16 input, global uint16* output) {
output[0] = input;
} |
kernel void compiler_insert_vector(global int4* out) {
int tid = get_global_id(0);
int4 output = (int4)(0, 0, 0, 1);
if (tid > 16) {
output = (int4)(tid, tid, 1, 1);
}
out[tid] = output;
} |
kernel void rhadd_uint2uint2(global uint2* src_0, global uint2* src_1, global uint2* dst) {
int gid = get_global_id(0);
dst[gid] = rhadd(src_0[gid], src_1[gid]);
} |
int xy_to_fancy_index(int cols, int x, int y) {
int tile_row_words = cols * (1 << (5));
int tile_x = x >> (5);
int tile_y = y >> (5);
int major_index = (tile_y * tile_row_words) + (tile_x * (1 << (5)) * (1 << (5)));
int subtile_row_words = (1 << (5)) * (1 << (2));
int subtile_x = (x & (0x1f)) >> (2);
int... |
kernel void determineNativeAccuracy(global float8* restrict values, int numValues) {
for (int i = get_global_id(0); i < numValues; i += get_global_size(0)) {
float v = values[i].s0;
values[i] = (float8)(v, native_sqrt(v), native_rsqrt(v), native_recip(v), native_exp(v), native_log(v), 0.0f, 0.0f);
}
} |
kernel void min_distance(global int* visited, global int* distances, global int* minimums, const int size) {
int min = (__builtin_inff());
for (int k = 0; k < size; k++) {
if (!visited[k] && distances[k] <= min) {
min = distances[k];
*minimums = k;
}
}
} |
kernel void kernel_rootn_withoutDD1(global float* result_rootn, int N) {
float t1;
float t2;
float t3;
float t4;
float t5;
float t6;
float t7;
float t8;
float t9;
float t10;
float i = 1.0;
int j = 1;
float n = 7 * (float)(N);
for (i = 1.0; i < n; i = i + 1.0) {
t1 = rootn(i, j);
t2... |
kernel void user_event(global float4* v) {
*v *= -1.0f;
} |
kernel void test_fa1_2_1_kern(global float* a0, global float* a1, global float* b0) {
unsigned int gtid = get_global_id(0);
float tmp0 = a0[gtid] + 0.1f;
float tmp1 = a1[gtid] + 1.1f;
barrier(0x01);
b0[gtid] = (0.0f + 1.1f) * (+tmp0 + tmp1);
} |
kernel void game(global int* A, const int N, const int largeur, const int hauteur) {
int idx = get_global_id(0);
int y = idx / hauteur;
int x = idx - (y * largeur);
if (y >= hauteur || x >= largeur)
return;
int me = A[idx];
int north = 0;
int northEast = 0;
int northWest = 0;
int south = 0;
int... |
kernel void add_int2int2(global int2* src_0, global int2* src_1, global int2* dst) {
int gid = get_global_id(0);
dst[gid] = src_0[gid] + src_1[gid];
} |
kernel void sto_pool_backward(const int nthreads, global const float* rand_idx, global const float* const top_diff, const int channels, const int height, const int width, const int pooled_h, const int pooled_w, const int kernel_h, const int kernel_w, const int stride_h, const int stride_w, global float* bottom_diff) {
... |
kernel void inplace_mul_add(global float4* vec1, global const float4* float2, global const float* fac, unsigned int size) {
float factor = *fac;
unsigned int size_div_4 = size >> 2;
for (unsigned int i = get_global_id(0); i < size_div_4; i += get_global_size(0))
vec1[i] += float2[i] * factor;
} |
int get_pointed_value(global int* pointer);
void set_pointed_value(global int* pointer, int value);
int get_pointed_value(global int* pointer) {
return *pointer;
}
void set_pointed_value(
global int* pointer, int value) {
*pointer = value;
}
kernel void access_pointer(
global int* array) {
const int i... |
kernel void gpu_memcpy(global float4* dest, global float4* source) {
int x = get_global_id(0);
int size = get_global_size(0);
dest[x] = source[x];
dest[x + size] = source[x + size];
dest[x + size * 2] = source[x + size * 2];
dest[x + size * 3] = source[x + size * 3];
} |
kernel void calc_who_has_won(global int* whoHasWon, global float* fields, unsigned int fields_internal_size2) {
if (get_global_id(0) == 0) {
if (fields[0 * fields_internal_size2 + 0] != 0 && fields[0 * fields_internal_size2 + 0] == fields[0 * fields_internal_size2 + 1] && fields[0 * fields_internal_size2 + 1] == ... |
kernel void test_arg_4_3_kern(global int4* a0, global int4* a1, global int4* a2, global int4* a3, global int4* b0, global int4* b1, global int4* b2) {
int4 za = (int4)(0, 1, 2, 3);
unsigned int gtid = get_global_id(0);
int4 tmp0 = a0[gtid] + 0 + za;
int4 tmp1 = a1[gtid] + 1 + za;
int4 tmp2 = a2[gtid] + 2 + za... |
kernel void test5(global float* A) {
for (int i = 0; i < 1024; ++i)
A[i] = i;
} |
kernel void islessequal_float16float16(global float16* src_0, global float16* src_1, global int16* dst) {
int gid = get_global_id(0);
dst[gid] = (int16)(islessequal(src_0[gid], src_1[gid]));
} |
kernel void kernelDoubleVector(double2 input, global double2* output) {
output[0] = input;
} |
kernel void test_select_read_address_local(const local int* in0, global int* out) {
local int in1[16];
unsigned int gid = (unsigned int)get_global_id(0);
in1[gid] = (int)gid;
const local int* ptr = (gid & 1) ? in1 : in0;
int tmp = ptr[gid];
out[gid] = tmp + 17;
} |
kernel void advance_ptcls_cooling_along_x(global float* xGlob, global float* yGlob, global float* zGlob, global float* vxGlob, global float* vyGlob, global float* vzGlob, global float* randNumbers, const global float* charge, const global float* mass, float peakCoolingRate, float peakDiffusionConstant, float offset, fl... |
void transHSVtoRGB(float* dst, const float h, const float s, const float v) {
if (0.f == s) {
dst[0] = dst[1] = dst[2] = v;
return;
}
int Hi = (int)floor(h / 60.f) % 6;
float f = h / 60.f - (float)Hi;
float p = v * (1.f - s);
float q = v * (1.f - s * f);
float t = v * (1.f - (1.f - f) * s);
if... |
float distanceBetweenPositions(global float* pos1, global float* int2) {
return sqrt(pow(pos1[0] - int2[0], 2) + pow(pos1[1] - int2[1], 2));
}
kernel void calc_fitness(global float* pos, unsigned int pos_size, global float* consumers, global float* fitness) {
if (get_global_id(0) == 0) {
*fitness = 0;
for ... |
kernel void kernel5_init(global char* ptr, unsigned long memsize) {
int i;
global unsigned int* buf = (global unsigned int*)ptr;
int idx = get_global_id(0);
unsigned long n = memsize / 64;
int total_num_threads = get_global_size(0);
unsigned int p1 = 1;
unsigned int p2;
p1 = p1 << (idx % 32);
p2 = ~p... |
kernel void dotProduct(global float* input1, global float* input2, global float* output) {
int i = get_global_id(0);
output[i] = input1[i] * input2[i];
} |
kernel void real_subtraction(global float* a, global float* b, global float* out) {
if (get_global_id(0) == 0)
(*out) = (*a) - (*b);
} |
kernel void huehsv_pln(global double* input, global double* output, const double hue, const double sat, const unsigned int height, const unsigned int width) {
int id = get_global_id(0);
output[id] = input[id] + hue;
output[id + height * width] = input[id + height * width] + sat;
} |
kernel void init_kernel_gpu(global int* in) {
int i = get_global_id(0);
in[i] = (int)i;
} |
kernel void testSum(global float* v, unsigned int size, global float* sum) {
float sum2 = 0;
for (unsigned int i = get_global_id(0); i < size; i += get_global_size(0))
sum2 += v[i];
*sum += sum2;
} |
kernel void array_sub_i32(global const int* a, global const int* b, global int* c) {
unsigned int i = get_global_id(0);
c[i] = a[i] - b[i];
} |
kernel void test_arg_2_6_kern(global float* a0, global float* a1, global float* b0, global float* b1, global float* b2, global float* b3, global float* b4, global float* b5) {
unsigned int gtid = get_global_id(0);
float tmp0 = a0[gtid] + 0.1f;
float tmp1 = a1[gtid] + 1.1f;
b0[gtid] = (0.0f + 1.1f) * (+tmp0 + tm... |
kernel void cpu_csr(global int* rowptr, global int* colid, global int* randlist, global int* vplist, int float3, global int* over, int rownum, int mid, global int* rowinfo, int start) {
int tid = get_global_id(0);
int getnumsum = get_global_size(0);
int startRow = rowinfo[start];
int endRow = rowinfo[start + ... |
kernel void test_arg_2_5_kern(global float* a0, global float* a1, global float* b0, global float* b1, global float* b2, global float* b3, global float* b4) {
unsigned int gtid = get_global_id(0);
float tmp0 = a0[gtid] + 0.1f;
float tmp1 = a1[gtid] + 1.1f;
b0[gtid] = (0.0f + 1.1f) * (+tmp0 + tmp1);
b1[gtid] = ... |
kernel void im2col(global const float* im_src, int im_src_offset, int channels, int height_inp, int width_inp, int kernel_h, int kernel_w, int pad_h, int pad_w, int stride_h, int stride_w, int height_out, int width_out, global float* im_col, int im_col_offset) {
int index = get_global_id(0);
if (index >= height_out... |
kernel void defect_q1_d(global double* ll, global double* ld, global double* lu, global double* dl, global double* dd, global double* du, global double* ul, global double* ud, global double* uu, global double* rhs, global double* x, global double* y, unsigned long n, unsigned long m, local double* smvf_cache) {
unsig... |
kernel void BFdecKernel_cbc(global unsigned long* data, global unsigned int* p, global unsigned long* d_iv, global unsigned long* out) {
private
unsigned int l, r;
private
unsigned long block = data[get_global_id(0)];
l = ((block >> 24L) & 0x000000ff) | ((block >> 8L) & 0x0000ff00) | ((block << 8L) & 0x00ff000... |
kernel void test_arg_2_4_kern(global int4* a0, global int4* a1, global int4* b0, global int4* b1, global int4* b2, global int4* b3) {
int4 za = (int4)(0, 1, 2, 3);
unsigned int gtid = get_global_id(0);
int4 tmp0 = a0[gtid] + 0 + za;
int4 tmp1 = a1[gtid] + 1 + za;
b0[gtid] = (0 + 1) * (+tmp0 + tmp1);
b1[gtid... |
kernel void copy(global int* out, global int* in) {
*out = *in;
} |
typedef unsigned int u;
constant unsigned int K[64] = {0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0... |
kernel void normalize_hists_36_kernel(global float* block_hists, const float threshold, local float* squares) {
const int tid = get_local_id(0);
const int gid = get_global_id(0);
const int bid = tid / 36;
const int boffset = bid * 36;
const int hid = tid - boffset;
float elem = block_hists[gid];
squares[... |
kernel void copy(global const float* originalMatrix, global float* newMatrix) {
int id = get_global_id(0);
newMatrix[id] = originalMatrix[id];
} |
kernel void foo(global float3* in, global float3* out) {
*out = mix(in[0], in[1], in[2]);
} |
inline float sigmoid(float z) {
return 1.0f / (1.0f + exp(-z));
}
inline float sigmoid_gradient(float y) {
return y * (1.0f - y);
}
inline float relu(float z) {
return z > 0 ? z : 0;
}
inline float relu_gradient(float y) {
return y > 0 ? 1 : 0;
}
inline float tanh_gradient(float y) {
return 1.0f - y * y;
}
... |
kernel void mark_diff(global unsigned int* tally, global unsigned int* tallyCount, unsigned int segmentSize, unsigned int _segmentSizeModulor) {
unsigned int gIdx = get_global_id(0);
unsigned int localQueueIdx = gIdx & _segmentSizeModulor;
if (localQueueIdx != 0) {
tallyCount[gIdx] = (tally[gIdx] != tally[gI... |
kernel void remainder_ulong4ulong4(global ulong4* src_0, global ulong4* src_1, global ulong4* dst) {
int gid = get_global_id(0);
dst[gid] = src_0[gid] % src_1[gid];
} |
kernel void asbs_s_cpu_cpu(global float* s1, float fac2, unsigned int options2, global const float* s2, float fac3, unsigned int options3, global const float* s3) {
float alpha = fac2;
if (options2 & (1 << 0))
alpha = -alpha;
if (options2 & (1 << 1))
alpha = ((float)(1)) / alpha;
float beta = fac3;
i... |
kernel void islessgreater_floatfloat(global float* src_0, global float* src_1, global int* dst) {
int gid = get_global_id(0);
dst[gid] = (int)(islessgreater(src_0[gid], src_1[gid]));
} |
int findIndexSeq(double* CDF, int lengthCDF, double value) {
int index = -1;
int x;
for (x = 0; x < lengthCDF; x++) {
if (CDF[x] >= value) {
index = x;
break;
}
}
if (index == -1)
return lengthCDF - 1;
return index;
}
int findIndexBin(double* CDF, int beginIndex, int endIndex, doubl... |
kernel void avbv_v_gpu_gpu(global float* s1, global const float* fac2, unsigned int options2, global const float* s2, global const float* fac3, unsigned int options3, global const float* s3) {
float alpha = fac2[0];
if ((options2 >> 2) > 1) {
for (unsigned int i = 1; i < (options2 >> 2); ++i)
alpha += fac... |
constant float4 ZEROS = (float4)(0.0f, 0.0f, 0.0f, 0.0f);
constant float4 ONES = (float4)(1.0f, 1.0f, 1.0f, 1.0f);
constant float4 INFINITIES = (float4)((__builtin_inff()), (__builtin_inff()), (__builtin_inff()), (__builtin_inff()));
constant unsigned int ID_GROUP_MASK = 0x3;
int2 positionFromIndex(int i, int width) {
... |
kernel void abs_diff_shortshort(global short* src_0, global short* src_1, global ushort* dst) {
int gid = get_global_id(0);
dst[gid] = (ushort)(abs_diff(src_0[gid], src_1[gid]));
} |
float linear_to_gamma_2_2(float value);
float gamma_2_2_to_linear(float value);
float linear_to_gamma_2_2(float value) {
if (value > 0.003130804954f)
return 1.055f * native_powr(value, (1.0f / 2.4f)) - 0.055f;
return 12.92f * value;
}
float gamma_2_2_to_linear(float value) {
if (value > 0.04045f)
return ... |
kernel void compiler_uint16_copy(global uint16* src, global uint16* dst) {
int id = (int)get_global_id(0);
dst[id] = src[id];
} |
kernel void compiler_abs_diff_ulong16(global ulong16* x, global ulong16* y, global ulong16* diff) {
int i = get_global_id(0);
diff[i] = abs_diff(x[i], y[i]);
} |
kernel void multiply_long4long4(global long4* src_0, global long4* src_1, global long4* dst) {
int gid = get_global_id(0);
dst[gid] = src_0[gid] * src_1[gid];
} |
kernel void max_ushort4ushort4(global ushort4* src_0, global ushort4* src_1, global ushort4* dst) {
int gid = get_global_id(0);
dst[gid] = max(src_0[gid], src_1[gid]);
} |
kernel void find_extrema_on_cpu_max(unsigned int count, global int* output, global unsigned int* output_idx, global int* _buf0) {
unsigned int block = (unsigned int)ceil(((float)count) / get_global_size(0));
unsigned int index = get_global_id(0) * block;
unsigned int end = min(count, index + block);
unsigned in... |
kernel void rng(const unsigned int nseeds, global ulong* in, global ulong* out) {
size_t gid = get_global_id(0);
if (gid < nseeds) {
ulong state = in[gid];
state ^= (state << 21);
state ^= (state >> 35);
state ^= (state << 4);
out[gid] = state;
}
} |
kernel void tripleGrayScale(global char* v, global char* v2, global char* v3) {
unsigned int i = get_global_id(0);
if (i % 3 == 0) {
v[i] = v[i];
v[i + 1] = v[i];
v[i + 2] = v[i];
v2[i] = v2[i];
v2[i + 1] = v2[i];
v2[i + 2] = v2[i];
v3[i] = v3[i];
v3[i + 1] = v3[i];
v3[i + 2] = v... |
kernel void SingleAddition(global const unsigned int* A, global unsigned int* C) {
unsigned int a = A[0];
unsigned int c = 0;
unsigned int i = 0;
for (i = 0; i <= 640000000; i++) {
c = a + c;
}
C[0] = c;
} |
kernel void compiler_integer_division(global int* src, global int* dst, int x) {
dst[get_global_id(0)] = src[get_global_id(0)] / x;
} |
kernel void FindFirstOne(global int* sortedDeletionBuffer, global int* output) {
const int idx = get_global_id(0);
if (sortedDeletionBuffer[idx] == 1) {
if (idx == 0 || (idx > 0 && sortedDeletionBuffer[idx - 1] == 0)) {
output[0] = idx;
}
}
} |
kernel void block_kernel(global int* res) {
typedef int (^block_t)(int);
constant block_t b1 = ^(int i) {
return i + 1;
};
*res = b1(5);
} |
kernel void foo(global float* A, float x, float y) {
*A = atan2pi(x, y);
} |
kernel void STREAM_Copy(global double* a, global double* b, global int* len) {
int threadIdX = get_local_id(0);
int workGroupSize = get_global_size(0);
int idx = get_global_id(0);
if (idx < *len)
b[idx] = a[idx];
} |
kernel void d_vector_sum(global double* g_idata, global double* g_odata, unsigned int n, local volatile double* sdata) {
unsigned int tid = get_local_id(0);
unsigned int i = get_group_id(0) * (get_local_size(0) * 2) + get_local_id(0);
unsigned int gridSize = 256 * 2 * get_num_groups(0);
sdata[tid] = 0;
while... |
enum { C_SVC = 0, NU_SVC, ONE_CLASS, EPSILON_SVR, NU_SVR };
enum { LINEAR = 0, POLY, RBF, SIGMOID, PRECOMPUTED };
enum { LOWER_BOUND = 0, UPPER_BOUND, FREE };
double my_dot(global const double* px, global const double* py, const int xW) {
double sum = 0;
int i = 0;
while (i < xW - 1) {
int remain = xW - i;
... |
kernel void update_kk(global float* A, unsigned int N, unsigned int k) {
A[k * N + k] = sqrt(A[k * N + k]);
} |
kernel void set_array_to_constant(global int* array, int num_elements, int val) {
if (get_global_id(0) < num_elements)
array[get_global_id(0)] = val;
} |
kernel void kernel_div_withDD8(float p1, global float* result_div, int N) {
float t1 = p1;
float8 t2 = t1 + (float8)(0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7);
int i = 0;
for (i = 0; i < N; i++) {
t2 /= 1.0f;
t2 /= 1.0f;
t2 /= 1.0f;
t2 /= 1.0f;
t2 /= 1.0f;
t2 /= 1.0f;
t2 /= 1.0f;
t2 ... |
kernel void CopyIRKernel(const global float* IR_In, global float2* IR_Out, unsigned int Block_log2, unsigned int IR_In_sz) {
unsigned int id = get_global_id(0);
unsigned int id_rem = id - ((id >> Block_log2) << Block_log2);
unsigned int id_out = ((id >> Block_log2) << (Block_log2 + 1)) + id_rem;
float2 IR = (fl... |
kernel void ShuffleChannel(global const float* restrict src_data, global float* restrict dst_data, int C, int H, int W, int G) {
int c = get_global_id(0);
if (c >= C)
return;
int CX = C / G;
int CY = G;
int cy = c % G;
int cx = c / G;
global const float8* src_line = ((global const float8*)(src_data +... |
kernel void test_block_2_7_kern(global int* a0, global int* a1, global int* b0, global int* b1, global int* b2, global int* b3, global int* b4, global int* b5, global int* b6, local int* c0, local int* c1) {
int i;
unsigned int gtid = get_global_id(0);
unsigned int ltid = get_local_id(0);
size_t lsz = get_local... |
kernel void kernelShort(short16 input, global short16* output) {
output[0] = input;
} |
kernel void init_ones_dev(global float* ones_s_d, int nsymbols) {
unsigned int idx = get_group_id(0) * get_local_size(0) + get_local_id(0);
if (idx < nsymbols) {
ones_s_d[idx] = 1.0f;
}
} |
kernel void kern(global int4* a, global int4* b, global int4* c, global int4* result) {
result[0] = a[0] * b[0] + c[0] - a[0];
result[1] = mad_hi(a[1], b[1], c[1]);
result[2] = mad_sat(a[2], b[2], c[2]);
result[3] = mad24(a[3], b[3], c[3]);
} |
kernel void kernel_17(global float* inputA, global float* inputB, global float* output, const unsigned int count) {
float A = 0;
for (int i = 0; i < count; i++) {
A += ((inputA[i] + inputB[i]) / 2) * log((inputA[i] + inputB[i]) / (2 * sqrt(inputA[i] * inputB[i])));
}
output[17] = A;
} |
float calcFirstDer(float x11, float x21, float x31, float x12, float x22, float x32, float x13, float x23, float x33, float inputNodataValue, float outputNodataValue, float zFactor, float mCellSize) {
int weight = 0;
float sum = 0;
if (x31 != inputNodataValue && x11 != inputNodataValue) {
sum += (x31 - x11);... |
kernel void sync(global float* src, global float* dest, local float* tmp) {
int tid = get_local_id(0);
int i = get_global_id(0);
tmp[tid] = src[i];
barrier(0x01);
for (int s = get_local_size(0) / 2; s > 0; s >>= 1) {
if (tid < s) {
tmp[tid] += tmp[tid + s];
}
barrier(0x01);
}
if (tid... |
kernel void test_arg_2_6_kern(global int* a0, global int* a1, global int* b0, global int* b1, global int* b2, global int* b3, global int* b4, global int* b5) {
unsigned int gtid = get_global_id(0);
int tmp0 = a0[gtid] + 0;
int tmp1 = a1[gtid] + 1;
b0[gtid] = (0 + 1) * (+tmp0 + tmp1);
b1[gtid] = (1 + 1) * (+tm... |
kernel void BitonicSortParallel(global int* a, global int* b) {
int id = get_global_id(0);
int i = b[2];
int j = b[3];
int dist = 1;
int p;
for (p = 0; p < j; p++) {
dist = dist * 2;
}
int k = id + ((int)id / dist) * dist;
int z = 1;
for (p = 0; p < i + 1; p++) {
z = z * 2;
}
int ... |
kernel void clkernel_axpy(const int num, float alpha, global const float* in, global float* out) {
const int i = get_global_id(0);
if (i >= num)
return;
out[i] = fma(alpha, in[i], out[i]);
} |
kernel void ff(global float* fg, global float* bg1, global float* bg2, global float* df1, global float* df2, const float bgw, const float dfw, const float cutOff) {
int l = get_global_id(0);
float fgg = fg[l];
float bg;
if (bg1 && bg2)
bg = bg1[l] * bgw + bg2[l] * (1 - bgw);
else if (bg1)
bg = bg1[l... |
kernel void add_const_with_thresh_kernel(global float* input, float value) {
const float short_lim = log((float)65535);
const unsigned int idx = get_global_id(0);
const float out_val = input[idx] + value;
if (out_val < 0.0f) {
input[idx] = 0.0f;
} else if (out_val > short_lim) {
input[idx] = short_li... |
kernel void cl_weighted_blend(global const float4* in, global const float4* aux, global float4* out) {
int gid = get_global_id(0);
float4 in_v = in[gid];
float4 aux_v = aux[gid];
float4 out_v;
float in_weight;
float aux_weight;
float total_alpha = in_v.w + aux_v.w;
total_alpha = total_alpha == 0 ? 1 : ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.