Upload folder using huggingface_hub

.gitignore

@@ -0,0 +1 @@
+push.sh

cuda_code/04matrix_transposed.cu

@@ -0,0 +1,77 @@
+#include <assert.h>
+#include <stdio.h>
+#include "Error.h"
+
+#define N 4
+
+__global__ void transposedMatrixKernel(int* d_a, int* d_b) {
+    int i = threadIdx.x + blockDim.x * blockIdx.x;
+    int j = threadIdx.y + blockDim.y * blockIdx.y;
+
+    d_b[i * N + j] = d_a[j * N + i];
+}
+
+void onDevice(int h_a[][N], int h_b[][N]) {
+    // declare GPU memory pointers
+    int *d_a, *d_b;
+
+    const int ARRAY_BYTES = N * N * sizeof(int);
+
+    // allocate  memory on the GPU
+    HANDLER_ERROR_ERR(cudaMalloc((void**)&d_a, ARRAY_BYTES));
+    HANDLER_ERROR_ERR(cudaMalloc((void**)&d_b, ARRAY_BYTES));
+
+    // copy data from CPU the GPU
+    HANDLER_ERROR_ERR(
+        cudaMemcpy(d_a, h_a, ARRAY_BYTES, cudaMemcpyHostToDevice));
+    HANDLER_ERROR_ERR(
+        cudaMemcpy(d_b, h_b, ARRAY_BYTES, cudaMemcpyHostToDevice));
+
+    // execution configuration
+    dim3 GridBlocks(1, 1);
+    dim3 ThreadsBlocks(4, 4);
+
+    // run the kernel
+    transposedMatrixKernel<<<GridBlocks, ThreadsBlocks>>>(d_a, d_b);
+    HANDLER_ERROR_MSG("kernel panic!!!");
+
+    // copy data back from the GPU to the CPU
+    HANDLER_ERROR_ERR(
+        cudaMemcpy(h_b, d_b, ARRAY_BYTES, cudaMemcpyDeviceToHost));
+
+    // free GPU memory
+    HANDLER_ERROR_ERR(cudaFree(d_a));
+    HANDLER_ERROR_ERR(cudaFree(d_b));
+}
+
+void test(int h_a[][N], int h_b[][N]) {
+    // test  result
+    for (int i = 0; i < N; i++) {
+        for (int j = 0; j < N; j++) {
+            assert(h_a[j][i] == h_b[i][j]);
+        }
+    }
+
+    printf("-: successful execution :-\n");
+}
+
+void onHost() {
+    int i, j, k = 0;
+    int h_a[N][N], h_b[N][N];
+
+    for (i = 0; i < N; i++) {
+        for (j = 0; j < N; j++) {
+            h_a[i][j] = k;
+            h_b[i][j] = 0;
+            k++;
+        }
+    }
+
+    // call device configuration
+    onDevice(h_a, h_b);
+    test(h_a, h_b);
+}
+
+int main() {
+    onHost();
+}

cuda_code/11-convolution.cu

@@ -0,0 +1,50 @@
+extern "C" {
+    //#define Mask_width  5  
+    //#define Mask_radius Mask_width/2  
+    #define O_TILE_WIDTH 12  
+    #define BLOCK_WIDTH (O_TILE_WIDTH+4)  
+    #define clamp(x, start, end)    min(max(x, start), end)
+    __global__ void convolution_2D_kernel(float*P,float*N,int height,int width,int channels,const  float* __restrict__ M,int Mask_width){
+        int Mask_radius = Mask_width/2;
+        __shared__ float Ns[BLOCK_WIDTH][BLOCK_WIDTH*3]; 
+        int tx=threadIdx.x;  
+        int ty=threadIdx.y; 
+        int row_o=blockIdx.y*O_TILE_WIDTH+ty;
+        int col_o=blockIdx.x*O_TILE_WIDTH+tx;
+        
+        int row_i=row_o-2;
+        int col_i=col_o-2;
+        
+        int i=0;  
+        int j=0;  
+        int k=0;
+        if((row_i>=0)&&(row_i<height)&&(col_i>=0)&&(col_i<width)){
+            for(k=0;k<channels;++k){
+                Ns[ty][tx*channels+k]=P[(row_i*width+col_i)*channels+k];
+            }
+        }else{
+            for(k=0;k<channels;++k){
+                Ns[ty][tx*channels+k]=0.0f;
+            }
+        }
+        
+       __syncthreads();
+       float output=0.0f;
+       if(ty<O_TILE_WIDTH&&tx<O_TILE_WIDTH){
+          for(k=0;k<channels;++k){
+           output=0.0f;
+           for(i=0;i<Mask_width;++i){
+            for(j=0;j<Mask_width;++j){
+              output+=M[i*Mask_width+j]*Ns[i+ty][(j+tx)*channels+k];  
+            }   
+           }
+           if(row_o<height&&col_o<width){
+             N[(row_o*width+col_o)*channels+k]=output;  
+           }
+          } 
+       }
+    }
+    
+   
+
+}

cuda_code/1d1.cu

@@ -0,0 +1,105 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/time.h>
+#include <cuda_runtime.h>
+#define N 1024 * 1024 * 128
+#define KN 9
+#define THREADSPERBLOCK 1024
+#define BLOCKSPERGRID 1
+
+float data[N];
+float kernel[KN];
+float output[N-KN+1];
+float output_from_device[N-KN+1];
+
+__global__ void conv( float *data_cuda, float *kernel, float *output ){
+    int tid = threadIdx.x;
+    while (tid < N - KN + 1) {
+        for(int i = 0; i < KN; i++) {
+            output[tid] += data_cuda[tid + i] * kernel[i];
+        }
+        tid += blockDim.x;
+    }
+}
+
+int main(){
+    int cpu = true;
+    int pass = 1;
+    cudaError_t cuError = cudaSuccess ;
+
+    double elapsedTimeCPU;
+    struct timespec t_start, t_end;
+    
+    float elapsedTime;
+    cudaEvent_t start, stop;
+    cudaEventCreate(&start);
+    cudaEventCreate(&stop);
+
+    // generate dummy data
+    srand(time(NULL));
+    for (int i = 0; i < KN; i++) {
+        kernel[i] = rand() / (float)RAND_MAX;
+    }
+    
+    srand(time(NULL));
+    for (int i = 0; i < N; i++) {
+        data[i] = rand() / (float)RAND_MAX;
+    }
+
+    // CPU
+    if (cpu) {
+        clock_gettime( CLOCK_REALTIME, &t_start);
+        for (int i = 0; i < N-KN+1; i++) {
+            output[i] = 0;
+            for (int j = 0; j < KN; j++) {
+                output[i] += kernel[j] * data[i+j];
+            }
+        }
+        clock_gettime( CLOCK_REALTIME, &t_end);
+        elapsedTimeCPU = (t_end.tv_sec - t_start.tv_sec) * 1000.0;
+        elapsedTimeCPU += (t_end.tv_nsec - t_start.tv_nsec) / 1000000.0;
+        printf("CPU elapsedTime: %lf ms\n", elapsedTimeCPU);
+    }
+
+    // GPU
+    float *d_kernel, *d_data, *d_output;
+    if (cudaMalloc( (void**)&d_kernel, KN * sizeof(float) ) != cudaSuccess) return 1;
+    if (cudaMalloc( (void**)&d_data, N * sizeof(float) ) != cudaSuccess) return 1;
+    if (cudaMalloc( (void**)&d_output, (N-KN+1) * sizeof(float) ) != cudaSuccess) return 1;
+    if (cudaMemcpy( d_kernel, kernel, KN * sizeof(float), cudaMemcpyHostToDevice ) != cudaSuccess) return 1;
+    if (cudaMemcpy( d_data, data, N * sizeof(float), cudaMemcpyHostToDevice ) != cudaSuccess) return 1;
+
+    cudaEventRecord(start, 0);
+    conv<<<BLOCKSPERGRID, THREADSPERBLOCK>>>(d_data, d_kernel, d_output);
+    cudaEventRecord(stop, 0);
+    cudaEventSynchronize(stop); 
+    cudaEventElapsedTime(&elapsedTime, start, stop);
+    printf("GPU time: %13f msec\n", elapsedTime);
+    
+    cudaMemcpy( output_from_device, d_output, (N-KN+1) * sizeof(float), cudaMemcpyDeviceToHost );
+    cudaEventDestroy(start);
+    cudaEventDestroy(stop);
+
+    if (cudaGetLastError() != cudaSuccess)
+    {
+        printf ("Failed in kernel launch and reason is %s\n", cudaGetErrorString(cuError)) ;
+        return 1 ;
+    }
+
+    //check correctness
+    if (cpu) {
+        for (int i = 0; i < N-KN+1; i++){
+            if((output_from_device[i] - output[i]) > 0.001){
+                printf("CPU:%lf GPU:%lf\n",output[i], output_from_device[i] );
+                pass = 0;
+                break;
+            }
+        }
+        if(pass == 1) {
+            printf("Test pass!\n");
+            printf("GPU / CPU = %f\n", elapsedTimeCPU / elapsedTime);
+        }
+        else
+            printf("Test fail!\n");
+    }
+}

cuda_code/28-pyrup-pyrdown.cu

@@ -0,0 +1,90 @@
+extern "C" {
+
+    __global__ void pyrup_rgb_kernel(unsigned char *d_in,unsigned char *d_out,int colorWidthStep,int aabhas,int height,int width)
+    {
+        const int xIndex = blockIdx.x * blockDim.x + threadIdx.x;
+        const int yIndex = blockIdx.y * blockDim.y + threadIdx.y;
+        const int color_tid = (xIndex)* aabhas + (3 * (yIndex));
+        const int color_tid1= (xIndex/2)* colorWidthStep + (3 * (yIndex/2));
+        if(yIndex >=width || xIndex>=height)
+        {
+            return;
+        }
+       
+        if(yIndex%2==0 &&xIndex%2==0)
+        {
+            d_out[color_tid]=d_in[color_tid1];
+            d_out[color_tid+1]=d_in[color_tid1+1];
+            d_out[color_tid+2]=d_in[color_tid1+2];
+        }
+        else
+        {
+            d_out[color_tid]=0;
+            d_out[color_tid+1]=0;//d_in[color_tid1+1];
+            d_out[color_tid+2]=0;//d_in[color_tid1+2];
+
+        }
+    }
+    
+    __global__ void pyrup_gray_kernel(unsigned char *d_in,unsigned char *d_out,int colorWidthStep,int aabhas,int height,int width)
+    {
+        const int xIndex = blockIdx.x * blockDim.x + threadIdx.x;
+        const int yIndex = blockIdx.y * blockDim.y + threadIdx.y;
+        const int color_tid = (xIndex)* aabhas + yIndex;
+        const int color_tid1= (xIndex/2)* colorWidthStep + yIndex/2;
+        if(yIndex >=width || xIndex>=height)
+        {
+            return;
+        }
+       
+        if(yIndex%2==0 &&xIndex%2==0)
+        {
+            d_out[color_tid]=d_in[color_tid1];
+            //d_out[color_tid+1]=d_in[color_tid1+1];
+            //d_out[color_tid+2]=d_in[color_tid1+2];
+        }
+        else
+        {
+            d_out[color_tid]=255;
+            //d_out[color_tid+1]=0;//d_in[color_tid1+1];
+            //d_out[color_tid+2]=0;//d_in[color_tid1+2];
+
+        }
+    }    
+    
+    
+  __global__ void pyrdown_rgb_kernel(unsigned char *d_in,unsigned char *d_out,int colorWidthStep,int aabhas,int height,int width)
+    {
+        const int xIndex = blockIdx.x * blockDim.x + threadIdx.x;
+        const int yIndex = blockIdx.y * blockDim.y + threadIdx.y;
+        const int color_tid = (xIndex)* aabhas + (3 * (yIndex));
+        const int color_tid1= (2*xIndex)* colorWidthStep + (3 * (2*yIndex));
+        if(yIndex >=width || xIndex>=height)
+        {
+
+            return;
+        }
+
+        d_out[color_tid]=d_in[color_tid1];
+        d_out[color_tid+1]=d_in[color_tid1+1];
+        d_out[color_tid+2]=d_in[color_tid1+2];
+    }
+    
+   __global__ void pyrdown_gray_kernel(unsigned char *d_in,unsigned char *d_out,int colorWidthStep,int aabhas,int height,int width)
+    {
+        const int xIndex = blockIdx.x * blockDim.x + threadIdx.x;
+        const int yIndex = blockIdx.y * blockDim.y + threadIdx.y;
+        const int color_tid = (xIndex)* aabhas + yIndex;
+        const int color_tid1= (2*xIndex)* colorWidthStep + 2*yIndex;
+        if(yIndex >=width || xIndex>=height)
+        {
+
+            return;
+        }
+
+        d_out[color_tid]=d_in[color_tid1];
+        //d_out[color_tid+1]=d_in[color_tid1+1];
+        //d_out[color_tid+2]=d_in[color_tid1+2];
+    }
+
+}

cuda_code/2d_xyWENOADV_p.cu

@@ -0,0 +1,169 @@
+// Andrew Gloster
+// November 2018
+// Example of advection in 2D with upwinding WENO
+
+//   Copyright 2018 Andrew Gloster
+
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+
+//       http://www.apache.org/licenses/LICENSE-2.0
+
+//   Unless required by applicable law or agreed to in writing, software
+//   distributed under the License is distributed on an "AS IS" BASIS,
+//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//   See the License for the specific language governing permissions and
+//   limitations under the License.
+
+
+// ---------------------------------------------------------------------
+//  Standard Libraries and Headers
+// ---------------------------------------------------------------------
+
+#include <cmath>
+#include <iostream>
+#include <cstdio>
+#include "cuda.h"
+
+// ---------------------------------------------------------------------
+// cuSten - Note the file position is relative
+// ---------------------------------------------------------------------
+
+#include "../../cuSten/cuSten.h"
+
+// ---------------------------------------------------------------------
+// MACROS
+// ---------------------------------------------------------------------
+
+#define BLOCK_X 32
+#define BLOCK_Y 32
+
+// ---------------------------------------------------------------------
+// Main Program
+// ---------------------------------------------------------------------
+
+int main()
+{	
+	// Set the device number
+	int deviceNum = 0;
+
+	// Declare Domain Size
+	int nx = 8192;
+	int ny = 8192;
+
+	double lx = 2 * M_PI;
+	double ly = 2 * M_PI;
+
+	// Domain spacings
+	double dx = lx / (double) (nx);
+	double dy = ly / (double) (ny);
+
+	// Set the number of tiles per device
+	int numTiles = 4;
+
+	// Initial Conditions
+	double* dataInput;
+	double* dataOutput;
+	double* u;
+	double* v;
+
+	// -----------------------------
+	// Allocate the memory 
+	// -----------------------------
+
+	cudaMallocManaged(&dataInput, nx * ny * sizeof(double));
+	cudaMallocManaged(&dataOutput, nx * ny * sizeof(double));
+
+	cudaMallocManaged(&u, nx * ny * sizeof(double));
+	cudaMallocManaged(&v, nx * ny * sizeof(double));
+
+	// -----------------------------
+	// Set the initial conditions
+	// -----------------------------
+
+	// Indexing
+	int temp;
+	int index;
+
+	for (int j = 0; j < ny; j++)
+	{
+		temp = j * nx;
+
+		for (int i = 0; i < nx; i++)
+		{
+			index = temp + i;
+
+			dataInput[index] = cos(i * dx) * sin(j * dy);
+			dataOutput[index] = 0.0;
+
+			u[index] = sin(j * dy);
+			v[index] = - sin(i * dx);
+		}
+	}
+
+	// Ensure all the above is completed
+	cudaDeviceSynchronize();
+
+	// -----------------------------
+	// Set up device
+	// -----------------------------
+
+	// Set up the compute device structs
+	cuSten_t xyWENOCompute;
+
+	// Initialise the instance of the stencil
+	cuStenCreate2DXYWENOADVp(	
+		&xyWENOCompute,
+
+		deviceNum,
+
+		numTiles,
+
+		nx,
+		ny,
+
+		BLOCK_X,
+		BLOCK_Y,
+
+		dx,
+		dy,
+
+		u,
+		v,
+
+		dataOutput,
+
+		dataInput
+	);
+
+	// Synchronise to ensure everything initialised
+	cudaDeviceSynchronize();
+
+	// -----------------------------
+	// Compute
+	// -----------------------------
+
+	// Run the computation
+	cuStenCompute2DXYWENOADVp(&xyWENOCompute, HOST);
+
+	// // Synchronise at the end to ensure everything is complete
+	cudaDeviceSynchronize();
+
+	// -----------------------------
+	// Destroy struct and free memory
+	// -----------------------------
+
+	// Destroy struct
+	cuStenDestroy2DXYWENOADVp(&xyWENOCompute);
+
+	// Free memory at the end
+	cudaFree(dataInput);
+	cudaFree(dataOutput);
+
+	cudaFree(u);
+	cudaFree(v);
+	
+	// Return 0 when the program completes
+	return 0;
+}

cuda_code/2mm.cu

@@ -0,0 +1,244 @@
+/**
+ * 2mm.cu: This file is part of the PolyBench/GPU 1.0 test suite.
+ *
+ *
+ * Contact: Scott Grauer-Gray <[email protected]>
+ * Louis-Noel Pouchet <[email protected]>
+ * Web address: http://www.cse.ohio-state.edu/~pouchet/software/polybench/GPU
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <assert.h>
+#include <unistd.h>
+#include <sys/time.h>
+#include <cuda.h>
+
+#include "../../../common/polybenchUtilFuncts.h"
+
+//define the error threshold for the results "not matching"
+#define PERCENT_DIFF_ERROR_THRESHOLD 0.05
+
+#define GPU_DEVICE 0
+
+/* Problem size. */
+# define NI 2048 * 4
+# define NJ 2048 * 4 
+# define NK 2048 * 4
+# define NL 2048 * 4
+ 
+/* Thread block dimensions */
+#define DIM_THREAD_BLOCK_X 32
+#define DIM_THREAD_BLOCK_Y 8
+
+/* Can switch DATA_TYPE between float and double */
+typedef float DATA_TYPE;
+
+
+
+void init_array(DATA_TYPE* A, DATA_TYPE* B, DATA_TYPE* C, DATA_TYPE* D, DATA_TYPE* A_gpu, DATA_TYPE* B_gpu, DATA_TYPE* C_gpu, DATA_TYPE* D_gpu)
+{
+	int i, j;
+
+	for (i = 0; i < NI; i++)
+	{
+		for (j = 0; j < NK; j++)
+		{
+			A[i*NI + j] = ((DATA_TYPE) i*j) / NI;
+			A_gpu[i*NI + j] = ((DATA_TYPE) i*j) / NI;
+		}
+	}
+
+	for (i = 0; i < NK; i++)
+	{
+		for (j = 0; j < NJ; j++)
+		{
+			B[i*NK + j] = ((DATA_TYPE) i*(j+1)) / NJ;
+			B_gpu[i*NK + j] = ((DATA_TYPE) i*(j+1)) / NJ;
+		}
+	}
+
+	for (i = 0; i < NL; i++)
+	{
+		for (j = 0; j < NJ; j++)
+		{
+			C[i*NL + j] = ((DATA_TYPE) i*(j+3)) / NL;
+			C_gpu[i*NL + j] = ((DATA_TYPE) i*(j+3)) / NL;
+		}
+	}
+
+	for (i = 0; i < NI; i++)
+	{
+		for (j = 0; j < NL; j++)
+		{
+			D[i*NL + j] = ((DATA_TYPE) i*(j+2)) / NK;	
+			D_gpu[i*NL + j] = ((DATA_TYPE) i*(j+2)) / NK;
+		}
+	}
+}
+
+
+void compareResults(DATA_TYPE *E, DATA_TYPE *E_outputFromGpu)
+{
+	int i,j,fail;
+	fail = 0;
+
+	for (i=0; i < NL; i++)
+	{
+		for (j=0; j < NI; j++)
+		{
+			if (percentDiff(E[i*NI + j], E_outputFromGpu[i*NI + j]) > PERCENT_DIFF_ERROR_THRESHOLD)
+			{
+				fail++;
+			}
+		}
+	}
+	
+	// print results
+	printf("Non-Matching CPU-GPU Outputs Beyond Error Threshold of %4.2f Percent: %d\n", PERCENT_DIFF_ERROR_THRESHOLD, fail);
+}
+
+
+void GPU_argv_init()
+{
+	cudaDeviceProp deviceProp;
+	cudaGetDeviceProperties(&deviceProp, GPU_DEVICE);
+	printf("setting device %d with name %s\n",GPU_DEVICE,deviceProp.name);
+	cudaSetDevice( GPU_DEVICE );
+}
+
+
+__global__ void mm2_kernel1(DATA_TYPE *A, DATA_TYPE *B, DATA_TYPE *C)
+{
+	int j = blockIdx.x * blockDim.x + threadIdx.x;
+	int i = blockIdx.y * blockDim.y + threadIdx.y;
+
+	if ((i < NI) && (j < NJ))
+	{ 
+		int k;
+		for (k = 0; k < NK; k++)
+		{
+			C[i * NJ + j] += A[i * NK + k] * B[k * NJ + j];
+		}
+	}
+}
+
+
+__global__ void mm2_kernel2(DATA_TYPE *C, DATA_TYPE *D, DATA_TYPE *E)
+{
+	int j = blockIdx.x * blockDim.x + threadIdx.x;
+	int i = blockIdx.y * blockDim.y + threadIdx.y;
+
+	if ((i < NI) && (j < NL))
+	{ 
+		int k;
+		for (k = 0; k < NJ; k++)
+		{
+			E[i * NL + j] += C[i * NJ + k] * D[k * NL + j];
+		}
+	}
+}
+
+
+void mm2_cpu(DATA_TYPE* A, DATA_TYPE* B, DATA_TYPE* C, DATA_TYPE* D, DATA_TYPE* E)
+{
+	int i, j, k;
+	
+  	for (i = 0; i < NI; i++)
+	{
+		for (j = 0; j < NJ; j++)
+		{
+			C[i*NJ + j] = 0.0;
+			for (k = 0; k < NK; ++k)
+			{
+				C[i*NJ + j] += A[i*NK + k] * B[k*NJ + j];
+			}
+		}
+	}
+	
+	for (i = 0; i < NI; i++)
+	{
+		for (j = 0; j < NL; j++)
+		{
+			E[i*NL + j] = 0.0;
+			for (k = 0; k < NJ; ++k)
+			{
+				E[i*NL + j] += C[i*NJ + k] * D[k*NL + j];
+			}
+		}
+	}
+}
+
+
+void mm2Cuda(DATA_TYPE* A_gpu, DATA_TYPE* B_gpu, DATA_TYPE* C_gpu, DATA_TYPE* D_gpu, DATA_TYPE* E_gpu)
+{
+	double t_start, t_end;
+	dim3 block(DIM_THREAD_BLOCK_X, DIM_THREAD_BLOCK_Y);
+	dim3 grid1((size_t)ceil( ((float)NJ) / ((float)block.x) ), (size_t)ceil( ((float)NI) / ((float)block.y)) );
+	dim3 grid2((size_t)ceil( ((float)NL) / ((float)block.x) ), (size_t)ceil( ((float)NI) / ((float)block.y)) );
+	t_start = rtclock();
+	mm2_kernel1<<<grid1,block>>>(A_gpu, B_gpu, C_gpu);
+	cudaDeviceSynchronize();
+	mm2_kernel2<<<grid2,block>>>(C_gpu, D_gpu, E_gpu);
+	cudaDeviceSynchronize();
+	t_end = rtclock();
+	fprintf(stdout, "GPU Runtime: %0.6lfs\n", t_end - t_start);
+}
+
+
+int main(int argc, char** argv)
+{
+	double t_start, t_end;
+	
+	DATA_TYPE* C;
+	DATA_TYPE* A;
+	DATA_TYPE* B;
+	DATA_TYPE* D;
+	DATA_TYPE* E;
+
+	DATA_TYPE *A_gpu;
+	DATA_TYPE *B_gpu;
+	DATA_TYPE *C_gpu;
+	DATA_TYPE *D_gpu;
+	DATA_TYPE *E_gpu;
+
+	C = (DATA_TYPE*)malloc(NI*NJ*sizeof(DATA_TYPE));
+	A = (DATA_TYPE*)malloc(NI*NK*sizeof(DATA_TYPE));
+	B = (DATA_TYPE*)malloc(NK*NJ*sizeof(DATA_TYPE));
+	D = (DATA_TYPE*)malloc(NJ*NL*sizeof(DATA_TYPE));
+	E = (DATA_TYPE*)malloc(NI*NL*sizeof(DATA_TYPE));
+
+
+	cudaMallocManaged(&A_gpu, sizeof(DATA_TYPE) * NI * NK);
+	cudaMallocManaged(&B_gpu, sizeof(DATA_TYPE) * NK * NJ);
+	cudaMallocManaged(&C_gpu, sizeof(DATA_TYPE) * NI * NJ);
+	cudaMallocManaged(&D_gpu, sizeof(DATA_TYPE) * NJ * NL);
+	cudaMallocManaged(&E_gpu, sizeof(DATA_TYPE) * NI * NL);
+
+
+  	init_array(A, B, C, D, A_gpu, B_gpu, C_gpu, D_gpu);
+	GPU_argv_init();
+
+	mm2Cuda(A_gpu, B_gpu, C_gpu, D_gpu, E_gpu);
+
+	t_start = rtclock();
+	mm2_cpu(A, B, C, D, E);
+	t_end = rtclock();
+	fprintf(stdout, "CPU Runtime: %0.6lfs\n", t_end - t_start);
+
+	compareResults(E, E_gpu);
+
+	free(C);
+	free(A);
+	free(B);
+	free(D);
+	free(E);
+	cudaFree(A_gpu);
+	cudaFree(B_gpu);
+	cudaFree(C_gpu);
+	cudaFree(D_gpu);
+	cudaFree(E_gpu);
+  	return 0;
+}
+

cuda_code/ACNetHDNL3.cu

@@ -0,0 +1,1653 @@
+#include "CudaHelper.cuh"
+#include "CudaInterface.hpp"
+
+__device__ __constant__ static const float kernelsL1[9 * 8] =
+{
+-0.0461f,  0.1274f,  0.2976f,
+-0.0393f, -0.1251f,  0.2527f,
+ 0.0791f,  0.0600f, -0.0303f,
+-0.0520f, -0.5039f, -0.3305f,
+-0.0115f,  0.0456f,  0.4370f,
+ 0.0601f,  0.0780f,  0.3106f,
+-0.0017f, -0.0018f, -0.0017f,
+-0.0017f, -0.0018f, -0.0018f,
+-0.0017f, -0.0017f, -0.0017f,
+ 0.2666f,  0.1687f,  0.2303f,
+-0.1901f,  0.3825f,  0.3024f,
+ 0.1811f,  0.0581f,  0.2080f,
+-0.1246f,  0.0155f, -0.4075f,
+ 0.1156f,  0.5929f,  0.1449f,
+-0.1080f, -0.0171f, -0.0516f,
+-0.0817f,  0.2247f,  0.0472f,
+ 0.0394f,  0.1085f,  0.1435f,
+-0.0480f, -0.0135f, -0.0606f,
+-0.0083f,  0.2045f,  0.1056f,
+-0.2239f,  0.2823f, -0.1926f,
+ 0.2581f,  0.1362f, -0.1914f,
+-0.0833f,  0.0702f,  0.0234f,
+ 0.3616f,  0.3789f, -0.1840f,
+ 0.0128f,  0.1347f, -0.0187f
+};
+__device__ __constant__ static const float biasL1[8] =
+{
+-0.1329f, -0.0431f, -0.0031f, -0.0129f,  0.2294f, -0.2595f, -0.2370f, -0.0499f
+};
+__device__ __constant__ static const float kernelsL[8][9 * 8 * 8] =
+{
+{
+ 1.4090e-01f, -1.8985e-02f, -6.8589e-02f,
+ 6.6491e-02f,  1.4360e-02f,  8.5223e-02f,
+ 1.8782e-01f,  9.8042e-02f, -3.4558e-02f,
+ 2.5606e-01f,  2.2027e-01f,  2.7603e-01f,
+ 1.9424e-01f,  3.4537e-02f,  9.5975e-02f,
+ 1.1223e-02f, -4.3377e-01f, -1.4760e-01f,
+-3.4293e-40f, -5.5421e-40f, -4.4763e-41f,
+-6.3322e-40f, -3.1495e-40f, -7.8264e-41f,
+-1.5375e-40f, -3.3656e-40f,  5.2441e-40f,
+ 1.2413e-01f,  1.5682e-01f,  1.1465e-01f,
+ 1.6683e-02f,  7.8382e-02f,  1.0110e-01f,
+ 1.4902e-01f,  1.3608e-01f,  1.1674e-01f,
+-6.5160e-02f,  7.7748e-02f,  2.1773e-02f,
+ 2.0652e-02f,  2.7245e-01f,  1.0297e-01f,
+-2.0953e-02f,  6.1685e-02f,  4.4128e-02f,
+ 6.1538e-02f, -1.9746e-02f, -1.2785e-02f,
+ 2.5931e-02f,  1.2740e-01f,  9.0033e-02f,
+ 8.6448e-02f,  2.0684e-01f,  9.8063e-02f,
+-7.8384e-03f,  6.3277e-02f,  7.6751e-03f,
+ 3.5956e-02f,  1.0555e-01f,  4.2728e-02f,
+ 7.1578e-02f,  1.3253e-01f,  1.1171e-01f,
+-2.7538e-02f,  1.5836e-01f,  1.0014e-01f,
+-4.9113e-02f,  1.6911e-01f,  2.7329e-01f,
+ 7.9170e-03f,  9.5440e-02f,  1.3922e-01f,
+ 8.0151e-02f,  4.3438e-02f,  5.5314e-02f,
+ 3.4896e-02f,  1.6816e-01f, -4.5783e-03f,
+-1.4579e-03f,  2.0493e-01f,  2.6238e-02f,
+ 2.6499e-02f,  3.9490e-01f, -1.1582e-02f,
+ 3.5790e-01f,  1.4317e-01f, -2.1775e-01f,
+ 4.1794e-03f, -3.2513e-01f, -1.6729e-01f,
+ 3.4040e-41f, -6.2960e-42f, -1.0067e-40f,
+ 5.5978e-41f, -1.2353e-40f, -1.1347e-40f,
+ 5.4572e-40f, -6.4384e-40f, -4.1234e-40f,
+-9.3690e-02f,  1.7765e-01f,  1.1275e-01f,
+ 9.1159e-03f,  1.7375e-01f,  1.1427e-01f,
+-7.8385e-02f,  1.5658e-01f, -3.8399e-02f,
+-1.0756e-01f,  5.9943e-02f, -6.7273e-02f,
+-1.1117e-01f,  1.5267e-01f,  1.1563e-01f,
+-1.2964e-01f, -3.8604e-02f, -2.4532e-02f,
+ 1.6324e-02f,  1.3112e-01f,  6.1679e-03f,
+-7.7703e-03f,  2.6311e-01f,  8.9427e-02f,
+-2.8948e-02f,  1.9341e-01f,  4.4339e-02f,
+ 6.4559e-03f, -6.8885e-02f,  1.1481e-01f,
+-1.0665e-01f,  3.8613e-02f,  7.0410e-02f,
+-6.1680e-02f, -1.7374e-02f,  9.5475e-03f,
+-4.0081e-02f, -3.1549e-02f,  2.8311e-01f,
+-1.2178e-01f, -1.3848e-01f,  1.7416e-01f,
+-8.1756e-02f, -1.7718e-01f,  7.9533e-02f,
+-3.1299e-03f, -3.2305e-03f, -3.2094e-03f,
+-3.1548e-03f, -3.2553e-03f, -3.2453e-03f,
+-3.1459e-03f, -3.2278e-03f, -3.2076e-03f,
+-3.6554e-05f, -3.6715e-05f, -3.1284e-05f,
+-1.4927e-05f, -1.4357e-05f, -1.2185e-05f,
+-1.5771e-09f, -1.1439e-09f, -6.4952e-10f,
+ 3.7723e-40f,  4.9166e-40f, -2.1946e-40f,
+-4.7599e-40f, -4.3356e-40f, -8.3928e-41f,
+ 2.6127e-40f,  4.8634e-40f,  2.7720e-40f,
+-5.4972e-03f, -5.6409e-03f, -5.6919e-03f,
+-5.5818e-03f, -5.7079e-03f, -5.7542e-03f,
+-5.6338e-03f, -5.7437e-03f, -5.7600e-03f,
+-3.7940e-03f, -3.8853e-03f, -3.8693e-03f,
+-3.8995e-03f, -3.9616e-03f, -3.8945e-03f,
+-3.8438e-03f, -3.9156e-03f, -3.8269e-03f,
+-7.2342e-05f, -7.8682e-05f, -4.7701e-05f,
+-1.1126e-04f, -1.1918e-04f, -7.8931e-05f,
+-1.1644e-04f, -1.2418e-04f, -8.2350e-05f,
+-2.3881e-04f, -3.7971e-04f, -3.9448e-04f,
+-2.4112e-04f, -3.8395e-04f, -4.0189e-04f,
+-2.3451e-04f, -3.7525e-04f, -3.9222e-04f,
+-3.9853e-03f, -4.0748e-03f, -4.1134e-03f,
+-4.0685e-03f, -4.1456e-03f, -4.1548e-03f,
+-4.0547e-03f, -4.1388e-03f, -4.1357e-03f,
+ 5.3008e-02f,  2.2252e-02f, -7.1158e-02f,
+-6.6411e-02f, -3.0015e-02f, -2.2526e-02f,
+ 1.2259e-01f, -6.2488e-02f,  5.6190e-02f,
+ 1.5981e-02f, -7.6832e-02f,  1.7908e-02f,
+ 2.7618e-01f,  5.4054e-02f,  8.7282e-02f,
+ 1.5212e-02f, -1.1097e-01f, -2.2265e-02f,
+-6.8532e-41f, -6.0539e-40f,  4.6269e-40f,
+-2.9221e-40f, -3.8468e-40f, -4.6656e-40f,
+ 6.4572e-40f, -6.1625e-40f,  6.4545e-40f,
+ 3.5920e-02f,  9.0955e-02f, -1.7626e-02f,
+ 4.7826e-02f,  1.8832e-01f, -4.4043e-02f,
+-3.8405e-02f,  5.9176e-02f,  6.8182e-02f,
+ 3.7657e-03f,  2.6441e-02f, -2.5585e-01f,
+ 1.0969e-01f,  2.3914e-01f,  3.5120e-02f,
+-1.6252e-01f,  3.4371e-02f, -2.7501e-01f,
+ 4.9289e-02f,  2.2088e-02f, -1.4588e-02f,
+ 1.6384e-01f, -8.1421e-03f, -6.9613e-02f,
+ 1.0820e-01f,  1.1137e-01f,  7.2648e-03f,
+ 1.5243e-01f,  1.3659e-01f,  2.7553e-02f,
+ 1.3966e-01f,  1.1019e-01f,  1.9817e-02f,
+ 1.1420e-01f, -5.1386e-03f,  6.8617e-03f,
+-1.3264e-02f,  2.1508e-01f,  4.8430e-02f,
+ 5.1149e-02f,  2.9165e-01f,  2.8077e-01f,
+ 2.9288e-03f,  9.0611e-02f,  8.1538e-02f,
+-1.1812e-01f,  1.5603e-02f,  1.1571e-01f,
+-3.4958e-02f, -1.6688e-03f, -4.6619e-02f,
+-1.0417e-02f, -3.1802e-02f,  1.8357e-02f,
+ 1.1064e-01f,  1.8397e-01f,  4.8449e-02f,
+-8.3336e-03f,  1.6029e-01f,  3.9490e-02f,
+-4.0959e-01f, -2.6134e-01f,  2.0766e-02f,
+ 6.6073e-41f, -6.7490e-40f, -5.1131e-41f,
+-4.3320e-41f, -3.7194e-40f,  2.0674e-40f,
+-5.2359e-40f, -3.4006e-40f, -4.9257e-40f,
+-4.7260e-02f,  2.8518e-03f, -2.7764e-01f,
+ 6.9182e-03f,  1.3938e-01f, -1.3162e-01f,
+-6.0901e-03f,  1.0339e-01f,  6.0419e-02f,
+-1.4449e-01f, -3.2043e-02f, -9.1466e-02f,
+-1.4022e-02f,  3.1703e-01f,  5.8166e-02f,
+-1.5243e-02f,  1.4521e-01f,  2.0790e-04f,
+-1.0255e-01f, -7.8766e-02f, -1.2395e-01f,
+ 7.9894e-03f,  3.7079e-03f, -3.2134e-02f,
+ 1.1663e-01f,  1.4808e-01f,  2.0431e-01f,
+ 7.4026e-02f,  6.9632e-02f,  1.7156e-01f,
+-3.0385e-02f,  2.3218e-01f,  7.3855e-02f,
+-8.8530e-02f, -5.9224e-02f,  2.3431e-02f,
+ 1.4596e-02f,  3.2442e-02f, -1.1308e-01f,
+-6.3734e-02f,  2.5270e-01f,  7.8081e-02f,
+ 1.0468e-02f,  1.5473e-01f,  3.8676e-02f,
+-1.0842e-01f,  8.6778e-03f,  1.4985e-01f,
+ 8.1757e-03f, -8.2109e-02f,  8.5471e-02f,
+-2.1437e-01f, -6.1173e-02f,  4.8163e-02f,
+ 2.8965e-01f,  1.9748e-01f,  4.2651e-02f,
+ 1.8196e-01f,  3.3932e-01f,  3.9594e-01f,
+ 3.9657e-01f,  4.2167e-01f,  2.9290e-01f,
+ 7.4011e-41f,  6.5220e-40f, -5.9885e-40f,
+ 7.4011e-41f,  6.2047e-40f, -7.1533e-40f,
+ 4.1950e-40f, -1.1886e-40f, -5.9922e-40f,
+ 1.9662e-01f,  2.1402e-01f,  3.1041e-02f,
+-1.1079e-01f,  1.3361e-01f, -2.1608e-01f,
+-1.7962e-01f, -8.0576e-02f, -3.1277e-01f,
+ 1.0620e-02f,  2.4024e-01f,  1.0657e-01f,
+-7.9906e-05f,  2.8760e-01f,  4.1231e-02f,
+-1.3261e-02f, -1.0868e-01f, -1.1267e-01f,
+-1.0659e-02f, -2.6051e-02f, -4.5389e-02f,
+ 5.8261e-02f,  4.0288e-02f,  6.7050e-02f,
+-2.6462e-01f, -1.7846e-01f, -1.0002e-01f,
+-6.2904e-02f,  1.5275e-01f,  4.4282e-03f,
+ 1.4446e-01f,  1.1814e-01f, -8.0349e-02f,
+ 2.0331e-02f,  3.3014e-02f,  1.2710e-01f,
+ 1.6084e-01f,  3.8819e-01f,  1.0854e-01f,
+-6.8126e-03f,  3.5673e-01f,  1.8938e-01f,
+-1.1660e-01f, -5.7694e-02f, -2.9194e-01f,
+ 1.2775e-02f, -3.2769e-02f,  1.7228e-02f,
+ 1.8324e-01f,  1.1983e-01f, -1.6944e-02f,
+ 1.0593e-01f,  1.3451e-01f,  5.2536e-02f,
+ 1.9147e-01f,  1.3875e-01f,  1.0298e-01f,
+-2.0871e-01f, -1.7197e-01f,  1.1342e-01f,
+-1.7581e-01f,  4.0972e-02f,  2.9796e-01f,
+ 3.2588e-40f, -4.3663e-40f, -2.6518e-40f,
+ 3.2588e-40f, -4.3663e-40f, -2.6518e-40f,
+ 4.1600e-40f, -4.4350e-40f, -4.8744e-41f,
+ 3.7289e-02f,  8.1769e-03f,  1.7059e-02f,
+ 3.7735e-02f,  6.6571e-02f, -6.6137e-02f,
+-5.8890e-02f, -7.7019e-03f, -6.2128e-02f,
+-4.0751e-02f,  1.1710e-01f, -1.1586e-01f,
+-1.2999e-01f, -1.6384e-02f, -2.1858e-01f,
+-2.8028e-01f, -6.0443e-02f, -1.1880e-01f,
+ 1.8152e-01f,  1.5364e-01f,  1.1781e-01f,
+ 2.9010e-01f,  2.4612e-01f,  1.3170e-01f,
+ 1.9022e-01f,  1.8117e-01f,  1.6483e-01f,
+ 9.3342e-02f,  2.6607e-01f,  1.4679e-01f,
+ 1.6729e-01f,  2.5374e-01f,  1.1954e-01f,
+ 6.3258e-02f,  1.0557e-01f,  6.7221e-02f,
+-5.2017e-02f,  1.9628e-01f,  1.7243e-01f,
+-3.2667e-02f,  1.5756e-01f,  1.9347e-01f,
+-9.5252e-02f, -3.7525e-02f, -3.4543e-04f,
+-4.9759e-02f,  4.0383e-02f, -2.0231e-02f,
+-1.1776e-01f,  3.4182e-02f,  3.6720e-02f,
+-1.4822e-02f, -4.1658e-02f, -1.3729e-02f,
+-1.9215e-02f,  2.4427e-02f, -9.0638e-02f,
+-1.4438e-01f, -2.1785e-01f, -5.1789e-02f,
+-2.0279e-01f, -3.3918e-01f, -1.6871e-01f,
+ 6.1262e-41f,  2.4066e-40f,  6.6851e-40f,
+ 5.3430e-40f, -3.2335e-40f, -3.7400e-40f,
+-6.3256e-40f, -4.7491e-40f,  2.2854e-40f,
+-6.8701e-03f, -1.4849e-02f,  8.6332e-02f,
+ 1.1686e-01f,  1.8346e-01f,  1.8797e-01f,
+-2.3251e-02f,  7.3973e-02f,  1.0532e-01f,
+-6.1838e-02f,  5.6667e-02f,  8.1584e-02f,
+-3.8900e-02f,  7.0927e-02f,  9.5606e-02f,
+-4.5098e-02f, -1.0829e-01f, -1.2224e-01f,
+ 3.5047e-03f,  3.2898e-02f,  3.5622e-02f,
+ 1.6170e-02f,  4.3721e-02f,  9.7496e-02f,
+ 2.3445e-03f,  6.0417e-02f,  1.3482e-01f,
+ 6.0570e-02f, -5.7139e-03f, -1.0883e-03f,
+ 2.2701e-02f, -2.9113e-02f,  7.9178e-03f,
+ 8.1214e-02f, -4.1408e-02f,  1.3616e-02f,
+-4.7985e-02f,  1.0304e-02f, -3.3236e-02f,
+-1.6334e-02f, -8.1538e-02f,  1.8629e-02f,
+-9.3720e-02f, -1.2920e-01f, -4.0836e-02f
+}
+,
+{
+ 1.0443e-01f,  1.5461e-01f, -1.4743e-01f,
+ 1.6716e-01f,  1.0532e-01f, -2.3088e-01f,
+ 1.0218e-01f,  1.2393e-01f, -9.6646e-02f,
+ 1.7659e-01f, -7.3279e-02f,  1.9627e-02f,
+ 1.7721e-01f, -1.4329e-01f, -1.2533e-01f,
+ 1.6551e-01f, -3.4616e-01f,  9.5618e-02f,
+ 4.5827e-09f,  9.3413e-09f,  1.7015e-08f,
+ 1.2245e-08f,  9.9727e-09f,  6.7108e-09f,
+ 1.9612e-07f,  3.9479e-08f,  1.1537e-09f,
+ 2.2127e-02f,  9.2715e-02f, -1.2150e-01f,
+ 7.5652e-02f,  1.1548e-01f, -1.2420e-01f,
+-1.0693e-03f, -7.2839e-02f, -1.9664e-01f,
+ 1.4466e-01f, -1.8552e-03f, -1.3575e-01f,
+ 2.0699e-01f,  8.0396e-02f, -1.9651e-01f,
+-4.7075e-02f, -5.1259e-02f, -8.2593e-02f,
+-2.2385e-01f,  3.0066e-03f, -2.2659e-02f,
+ 6.1827e-02f,  2.5331e-02f, -5.3898e-02f,
+ 2.7091e-01f,  1.0991e-01f, -3.3600e-01f,
+-8.9499e-02f, -9.3821e-03f,  2.2675e-02f,
+ 1.1213e-01f,  1.3276e-01f,  2.0368e-02f,
+ 6.5408e-02f,  4.1598e-02f, -4.7917e-02f,
+ 6.0740e-03f,  1.2236e-04f, -1.0659e-01f,
+-1.8072e-02f, -9.1082e-02f, -9.0414e-02f,
+ 4.9052e-02f, -1.4298e-01f, -3.9721e-02f,
+ 1.1840e-01f,  2.2503e-01f,  2.4587e-02f,
+ 9.3023e-02f,  6.9650e-02f,  1.6798e-01f,
+-1.5640e-03f,  1.6300e-02f,  6.3585e-02f,
+ 1.4431e-01f,  3.7885e-02f,  1.6692e-02f,
+ 1.7345e-01f,  7.2315e-02f,  1.8942e-02f,
+ 1.1081e-01f,  8.2973e-02f, -9.7717e-02f,
+-5.2264e-03f, -5.2641e-03f, -5.2727e-03f,
+-5.2809e-03f, -5.3125e-03f, -5.3153e-03f,
+-5.2915e-03f, -5.3251e-03f, -5.3231e-03f,
+ 6.0008e-02f,  2.0268e-01f,  1.3396e-01f,
+-2.5202e-03f, -1.7750e-02f, -1.2019e-02f,
+ 1.1806e-01f, -2.2306e-02f,  3.6464e-02f,
+ 7.9324e-02f,  3.1883e-02f,  1.5483e-02f,
+-4.3537e-02f,  1.2204e-02f,  1.8905e-02f,
+-8.1581e-02f, -1.1307e-01f, -6.0718e-02f,
+-2.4865e-01f, -1.0199e-01f,  1.9886e-02f,
+-1.0519e-02f,  6.9972e-02f,  4.8012e-02f,
+-1.5282e-02f,  1.1979e-01f,  8.7968e-02f,
+-3.6752e-02f,  1.9523e-02f,  7.1321e-02f,
+-5.8295e-02f,  5.3242e-02f,  1.2773e-01f,
+-7.9671e-02f,  8.3249e-04f,  7.4904e-02f,
+ 1.1792e-01f,  2.2135e-03f, -9.0963e-03f,
+-2.8356e-03f, -4.2661e-02f,  6.9497e-02f,
+ 9.3561e-02f,  1.0475e-01f,  5.4745e-02f,
+-8.5901e-02f, -2.1969e-01f, -1.5572e-01f,
+ 3.6473e-02f,  1.1097e-01f, -2.6830e-02f,
+ 1.2199e-02f,  1.8917e-01f,  1.1906e-01f,
+ 1.0664e-01f, -2.7005e-01f,  1.5492e-01f,
+-4.1771e-02f, -1.6580e-01f,  2.9234e-02f,
+-1.9854e-02f,  2.1436e-01f, -1.1100e-01f,
+ 4.5382e-04f,  4.2085e-04f,  5.6852e-04f,
+ 3.4951e-04f,  3.7354e-04f,  3.2786e-04f,
+ 2.0790e-04f,  2.8606e-04f,  3.2415e-04f,
+-1.5500e-02f,  2.2865e-02f, -3.0070e-01f,
+ 1.8467e-01f,  2.4899e-01f,  1.4812e-02f,
+-1.2318e-01f,  2.3175e-01f,  7.2244e-02f,
+ 1.6713e-01f,  1.9089e-02f, -2.7494e-01f,
+ 1.0202e-01f,  2.9200e-01f, -3.6055e-03f,
+ 1.3265e-01f,  2.2551e-01f,  1.9897e-01f,
+-3.9474e-02f,  1.6262e-01f,  1.6726e-01f,
+-8.6222e-02f,  2.0573e-01f, -7.3247e-01f,
+-9.5391e-02f,  3.8933e-01f,  1.5861e-01f,
+-1.2202e-01f, -6.4735e-02f, -1.1762e-01f,
+-2.2427e-02f, -1.9171e-01f, -1.6092e-01f,
+ 3.2356e-01f, -2.2234e-01f, -1.3743e-01f,
+-1.1493e-01f, -2.4936e-02f,  2.9212e-02f,
+-9.8112e-02f, -1.8021e-02f, -1.0507e-01f,
+-1.0168e-01f,  1.1759e-01f, -9.8203e-02f,
+-2.8871e-02f,  1.3249e-01f,  7.8378e-02f,
+-1.1012e-01f, -4.0596e-02f,  5.4202e-02f,
+ 4.9022e-02f, -1.1744e-01f,  9.8888e-02f,
+ 1.3343e-02f,  1.4358e-01f, -8.7142e-02f,
+ 1.9952e-01f,  3.3708e-02f,  2.0721e-02f,
+ 2.6527e-02f, -2.3822e-01f,  2.4706e-01f,
+-3.2750e-04f, -2.8475e-04f, -6.3494e-05f,
+-2.2378e-04f, -1.8046e-04f, -1.9242e-05f,
+-4.2124e-05f, -2.2062e-05f,  4.5500e-07f,
+ 1.1692e-01f,  4.0366e-01f, -1.8709e-02f,
+ 8.2700e-02f,  1.7884e-01f, -1.3520e-01f,
+ 3.7758e-02f,  3.7048e-02f, -2.8109e-01f,
+-2.3438e-01f,  5.9423e-02f, -1.7300e-01f,
+ 1.0343e-02f,  7.2307e-02f, -4.3852e-01f,
+-5.7429e-02f, -4.9136e-02f, -8.0327e-02f,
+ 8.1094e-02f,  2.9118e-02f,  1.6677e-01f,
+ 1.2155e-01f,  6.5358e-01f,  2.4544e-01f,
+ 3.1163e-02f,  3.7463e-02f, -2.6613e-01f,
+ 1.2723e-01f,  1.2541e-01f,  1.4319e-02f,
+ 1.9055e-01f, -5.7441e-02f,  1.1146e-01f,
+-1.0690e-02f, -1.7567e-01f, -1.2238e-01f,
+-2.0879e-01f, -6.5278e-02f, -7.9327e-02f,
+-1.6564e-01f, -1.3659e-01f, -2.6231e-01f,
+-3.1916e-01f, -2.6553e-01f, -9.8647e-02f,
+-1.0617e-01f,  1.2782e-01f, -2.1053e-02f,
+-1.2329e-01f,  1.4952e-01f, -1.7466e-02f,
+-1.6969e-01f,  3.6980e-02f, -6.7732e-02f,
+-3.1220e-02f,  4.0615e-02f, -1.5251e-01f,
+-2.0017e-01f,  2.2421e-01f, -2.5682e-02f,
+-6.5873e-02f,  1.8346e-01f,  1.2982e-02f,
+ 1.4021e-06f, -1.6929e-05f, -8.4696e-05f,
+ 1.9580e-05f,  2.9943e-06f,  3.0084e-06f,
+ 2.0769e-04f,  1.4661e-05f,  2.9503e-06f,
+-1.4485e-01f,  1.8841e-01f, -1.7954e-01f,
+ 2.1551e-01f,  2.2601e-01f, -8.6689e-03f,
+ 8.6926e-02f, -6.8989e-02f, -1.2683e-01f,
+-8.7712e-02f,  6.3176e-02f,  1.1983e-01f,
+ 1.0790e-01f,  6.6418e-02f,  6.5849e-02f,
+ 1.2483e-01f,  1.2428e-01f,  4.4994e-02f,
+ 1.5139e-01f, -1.2116e-01f, -3.5497e-01f,
+-6.1889e-02f,  3.4088e-01f,  1.3148e-01f,
+-1.6478e-01f,  4.4477e-02f, -1.1979e-01f,
+ 3.8343e-02f,  1.7992e-01f,  3.6790e-01f,
+ 3.0426e-01f,  1.1235e-01f,  4.9815e-01f,
+ 2.6290e-01f,  1.9703e-01f,  1.5881e-01f,
+-6.4678e-03f,  2.4401e-01f,  1.9266e-01f,
+-1.4089e-01f,  1.2323e-01f,  4.4340e-02f,
+-8.8856e-02f,  8.4036e-02f, -9.8488e-02f,
+-1.7377e-03f, -1.7654e-03f, -1.7223e-03f,
+-1.7651e-03f, -1.7919e-03f, -1.7491e-03f,
+-1.7172e-03f, -1.7446e-03f, -1.7041e-03f,
+-3.0384e-04f, -2.9297e-04f, -2.4838e-04f,
+-3.2961e-04f, -3.1678e-04f, -2.7009e-04f,
+-3.1665e-04f, -3.0492e-04f, -2.6122e-04f,
+ 3.7109e-40f, -3.7915e-40f, -5.2536e-40f,
+ 5.8286e-41f, -5.6108e-40f,  4.3331e-40f,
+-3.0184e-42f, -4.8987e-40f, -5.1788e-40f,
+-4.0457e-04f, -4.3257e-04f, -4.1616e-04f,
+-4.2268e-04f, -4.5118e-04f, -4.3407e-04f,
+-3.9446e-04f, -4.2199e-04f, -4.0650e-04f,
+-1.1253e-16f, -1.1328e-14f, -2.0489e-14f,
+-3.0346e-19f, -1.7189e-16f, -4.5141e-16f,
+-2.4957e-30f, -1.8191e-23f, -3.5882e-22f,
+-3.1610e-36f, -1.7544e-24f, -2.2187e-21f,
+-4.2887e-19f, -1.5526e-15f, -1.5160e-14f,
+-1.7750e-16f, -6.8066e-14f, -3.3764e-13f,
+-6.9570e-24f, -5.1139e-23f, -2.9335e-23f,
+-1.9091e-22f, -1.0323e-21f, -4.5931e-22f,
+-2.0010e-22f, -9.3710e-22f, -3.5622e-22f,
+-2.9470e-04f, -2.9081e-04f, -2.5958e-04f,
+-3.2290e-04f, -3.1810e-04f, -2.8461e-04f,
+-3.1795e-04f, -3.1356e-04f, -2.8121e-04f,
+ 6.1623e-02f,  1.7057e-01f,  8.0478e-02f,
+ 1.2624e-01f,  1.8468e-01f,  2.1901e-02f,
+ 7.6033e-02f,  1.3455e-01f,  8.4037e-02f,
+ 8.4434e-02f, -1.7069e-02f, -7.8318e-02f,
+ 4.9244e-02f,  4.4782e-02f, -6.9747e-02f,
+ 1.2915e-01f,  1.1453e-01f, -6.5243e-02f,
+-5.0985e-03f, -5.1407e-03f, -5.1687e-03f,
+-5.1185e-03f, -5.1511e-03f, -5.1712e-03f,
+-5.0986e-03f, -5.1272e-03f, -5.1409e-03f,
+-1.8186e-02f,  6.2680e-02f,  3.3235e-02f,
+ 1.3398e-02f,  1.6497e-01f,  4.3523e-02f,
+-2.4101e-02f,  1.3316e-01f,  1.8373e-02f,
+-6.2677e-04f,  6.5026e-03f,  2.5948e-02f,
+ 6.6542e-02f,  1.2352e-01f,  1.5155e-02f,
+-8.6237e-02f, -2.0907e-02f,  1.0237e-02f,
+-1.7807e-01f, -8.6196e-02f, -3.2408e-02f,
+-8.1946e-03f, -1.3957e-02f, -1.6733e-01f,
+ 2.6269e-02f,  1.6817e-01f,  9.4029e-02f,
+ 3.4005e-02f, -1.2833e-02f, -1.2038e-01f,
+-4.8950e-02f,  3.9857e-02f,  1.4048e-02f,
+-6.4758e-02f,  9.9603e-02f,  1.0748e-01f,
+-1.0850e-02f,  9.8875e-02f, -4.4439e-02f,
+ 9.1219e-02f,  6.6400e-02f, -6.7693e-02f,
+ 5.3318e-02f,  1.1838e-02f, -1.5164e-01f,
+-5.8568e-02f,  1.1249e-01f, -3.8286e-02f,
+-7.1122e-02f,  9.5799e-02f,  3.8521e-02f,
+-1.3846e-01f,  1.4167e-01f, -3.5500e-03f,
+-1.0343e-01f, -3.3025e-02f,  3.7186e-02f,
+-2.0769e-03f,  1.3558e-01f, -1.3009e-01f,
+ 1.0167e-02f,  1.5358e-02f, -9.8009e-02f,
+ 2.4123e-05f, -1.1800e-05f, -1.4180e-04f,
+ 3.5217e-05f, -6.3838e-06f, -1.2243e-04f,
+ 8.5525e-05f,  2.1599e-06f, -5.3290e-05f,
+-1.4471e-01f,  2.0111e-02f, -1.2449e-01f,
+ 5.3368e-02f,  3.2918e-01f,  1.4034e-01f,
+-1.1833e-01f, -1.9225e-02f, -1.2658e-01f,
+-2.6966e-01f,  1.1751e-01f,  9.7072e-02f,
+-1.9929e-01f,  9.7986e-02f, -5.1240e-02f,
+-9.5073e-02f, -6.8070e-02f, -2.1318e-01f,
+ 9.5305e-02f, -4.0551e-02f, -1.0936e-01f,
+ 5.2687e-02f,  4.5340e-01f,  2.3531e-01f,
+-1.3385e-02f,  1.5922e-01f, -1.8371e-01f,
+-1.2203e-01f, -7.2567e-02f, -3.0000e-01f,
+-3.4356e-02f, -1.3471e-01f, -9.0995e-02f,
+-2.5230e-01f, -2.4846e-01f, -1.8529e-01f,
+-1.6962e-01f,  1.0905e-01f,  1.1557e-01f,
+-1.4405e-01f,  8.9191e-02f,  1.1715e-01f,
+-1.3237e-01f,  5.2092e-02f, -1.2227e-01f
+}
+,
+{
+ 2.0013e-01f,  2.2105e-01f,  1.9196e-01f,
+ 6.8158e-02f,  1.7154e-01f, -8.6677e-02f,
+ 9.2652e-02f,  1.0789e-01f,  1.6745e-01f,
+-2.9254e-01f, -7.6815e-02f,  5.8812e-02f,
+-4.6466e-02f,  1.3941e-02f,  2.3353e-01f,
+-1.5033e-01f,  7.5167e-02f,  1.4433e-01f,
+ 2.8008e-02f,  3.1625e-01f,  3.2877e-02f,
+-5.8835e-02f, -1.7305e-01f, -6.1558e-02f,
+-1.2227e-01f,  3.9931e-02f,  3.0300e-02f,
+ 2.3004e-01f,  4.1834e-02f, -5.7790e-02f,
+-2.2861e-01f,  2.9314e-01f,  1.6884e-01f,
+-2.8009e-02f,  4.7550e-02f, -4.4542e-02f,
+-2.4674e-01f, -1.5483e-01f,  3.2653e-02f,
+-2.1574e-01f,  3.1083e-01f, -1.4025e-03f,
+ 1.7354e-02f,  5.6417e-02f,  1.0844e-01f,
+-4.2681e-40f,  4.5893e-42f, -7.4234e-40f,
+ 1.7665e-40f,  4.0151e-40f,  4.6269e-40f,
+ 2.5452e-40f, -7.0179e-40f, -1.2338e-40f,
+-1.4957e-01f, -1.9087e-02f,  7.1170e-02f,
+-1.4435e-01f,  8.9560e-02f,  1.3879e-01f,
+-3.6992e-02f,  5.9822e-02f,  1.9241e-02f,
+-2.4402e-03f,  1.5097e-01f,  6.3958e-02f,
+-1.7630e-01f,  3.6009e-01f, -2.0383e-01f,
+-8.5106e-03f,  4.0863e-03f, -2.7575e-02f,
+ 7.8942e-02f, -1.8640e-01f, -6.7715e-02f,
+ 7.2777e-02f, -1.3804e-01f, -7.0332e-02f,
+ 1.5185e-01f, -4.3530e-02f,  1.4502e-01f,
+-3.2928e-02f, -3.0583e-02f,  9.2061e-02f,
+ 1.2493e-01f,  1.0400e-01f,  1.3780e-01f,
+ 1.4438e-01f,  8.2051e-02f,  1.6159e-02f,
+ 2.7478e-02f,  1.7768e-01f,  2.5945e-01f,
+-3.4662e-01f,  2.0330e-03f,  8.8118e-02f,
+-2.9628e-01f, -1.3212e-01f, -1.8145e-02f,
+-1.9330e-01f,  3.9238e-02f, -4.6944e-02f,
+-1.5668e-01f, -5.7104e-02f,  1.9558e-01f,
+ 6.5305e-02f,  5.9933e-02f,  7.7337e-02f,
+-2.4906e-02f, -1.1235e-01f,  1.3822e-02f,
+-3.9988e-02f, -9.1882e-03f,  1.9204e-02f,
+ 1.0504e-01f,  4.6820e-03f, -2.1836e-02f,
+-2.6953e-40f,  2.5334e-40f, -1.3028e-40f,
+ 1.4110e-41f,  5.6841e-40f,  3.6368e-40f,
+-1.1746e-41f, -7.0658e-41f, -3.9413e-40f,
+ 1.5025e-02f,  7.4419e-02f,  9.5652e-02f,
+ 5.0297e-02f,  6.6704e-02f,  5.7316e-02f,
+ 2.5102e-02f,  1.1985e-01f,  2.6043e-02f,
+ 3.3297e-02f, -7.7374e-02f, -1.1114e-01f,
+-7.5586e-02f, -1.9338e-02f, -1.3739e-02f,
+ 4.5616e-02f, -6.4946e-02f, -6.9372e-02f,
+-7.5874e-03f, -1.1141e-01f, -2.9135e-02f,
+-6.9436e-03f, -1.4418e-02f,  1.6436e-03f,
+-1.3051e-01f, -1.3324e-01f, -9.3934e-02f,
+ 1.2184e-01f,  1.9386e-01f,  1.7995e-01f,
+-2.7452e-02f,  9.9736e-02f,  1.0020e-01f,
+-6.3290e-02f, -2.1447e-02f, -1.7005e-01f,
+ 1.3857e-01f,  2.3338e-01f,  2.5410e-01f,
+ 2.3002e-01f,  1.9551e-01f,  1.4452e-01f,
+ 4.7040e-01f,  2.2647e-01f,  1.5215e-01f,
+ 2.6927e-02f, -2.1304e-01f, -1.4762e-01f,
+-5.6998e-02f,  2.9064e-01f,  1.8085e-01f,
+ 8.9393e-02f, -1.7463e-01f, -2.7095e-01f,
+ 3.8434e-02f,  1.7198e-01f, -1.8122e-02f,
+-1.3857e-01f,  1.9418e-01f,  1.5019e-01f,
+-5.6337e-02f, -5.3265e-01f,  3.2122e-01f,
+-2.4484e-40f, -5.3707e-40f,  1.5854e-41f,
+ 5.1791e-40f, -4.1875e-41f,  5.6732e-40f,
+ 1.3048e-40f,  1.6452e-40f, -4.5028e-40f,
+-3.0692e-02f,  1.8569e-01f,  2.0327e-01f,
+-7.4756e-02f, -5.1765e-02f,  4.2475e-02f,
+-9.0675e-02f, -3.0438e-01f, -3.5088e-01f,
+-1.9129e-02f, -1.5663e-03f,  4.9895e-02f,
+-1.9441e-02f,  9.3237e-02f,  1.2910e-01f,
+-2.3919e-02f, -4.0539e-01f,  2.8167e-02f,
+ 2.0203e-01f,  3.3424e-02f,  1.7927e-02f,
+ 4.1923e-02f, -1.6967e-01f,  2.5656e-02f,
+-1.5869e-01f, -1.8727e-01f,  2.7860e-03f,
+-4.0276e-02f, -6.7792e-03f,  3.3699e-02f,
+-6.7044e-03f,  1.7686e-02f,  2.9786e-02f,
+-1.5623e-02f,  3.7904e-02f,  2.4737e-02f,
+-1.2282e-01f, -3.6563e-02f,  4.1976e-02f,
+-9.9622e-03f,  8.8981e-02f,  2.1364e-02f,
+-8.5668e-02f, -1.6803e-01f, -4.4974e-02f,
+ 1.3164e-01f,  4.1294e-01f,  1.8897e-01f,
+ 2.1991e-01f,  1.6247e-02f,  1.1569e-01f,
+-3.0142e-02f,  1.4069e-02f,  3.6646e-02f,
+-2.6816e-02f, -3.9767e-02f,  1.4061e-01f,
+-1.3603e-01f, -2.0649e-01f,  7.5837e-02f,
+-1.6984e-02f, -8.3800e-03f,  2.3652e-04f,
+ 1.5049e-40f,  4.6504e-40f,  1.3625e-40f,
+-7.5358e-40f, -3.4257e-40f,  9.9763e-41f,
+ 4.7243e-40f,  7.4890e-40f, -7.9440e-42f,
+-5.9692e-02f, -2.8047e-02f,  2.3795e-02f,
+-3.5284e-02f,  1.1448e-02f,  5.0302e-04f,
+-3.5066e-02f,  4.6185e-02f,  1.2167e-02f,
+ 3.7583e-02f, -3.6598e-02f,  1.0206e-01f,
+-9.6229e-02f, -1.5977e-01f,  4.9157e-02f,
+ 3.7293e-02f,  5.8766e-02f,  1.0448e-02f,
+ 1.1490e-01f,  1.4459e-01f,  8.6936e-02f,
+ 2.8609e-01f, -4.8108e-02f,  9.0023e-02f,
+ 6.7941e-02f, -5.7148e-03f,  1.0021e-01f,
+ 7.3816e-02f,  7.3794e-02f,  8.0970e-03f,
+ 2.8307e-02f,  3.6635e-03f, -1.1769e-01f,
+ 4.1374e-02f,  3.9933e-02f, -4.4292e-02f,
+ 5.9423e-02f,  1.9009e-01f, -2.3735e-01f,
+-2.6670e-01f,  5.8789e-01f, -2.0048e-01f,
+-3.7082e-01f,  1.8045e-01f,  5.4820e-02f,
+-6.3567e-01f,  2.0098e-01f,  1.0653e-01f,
+-2.5056e-01f,  6.5065e-01f, -4.0471e-01f,
+ 5.4715e-02f,  2.4375e-01f, -2.7402e-01f,
+ 1.5982e-01f,  1.0923e-01f,  2.1566e-01f,
+ 2.0239e-01f, -9.0221e-02f, -4.4606e-01f,
+ 1.0550e-01f,  5.4666e-02f, -2.7134e-01f,
+-4.6424e-40f,  2.9137e-40f,  7.4968e-41f,
+ 1.2376e-41f, -5.6213e-40f, -6.3457e-40f,
+ 2.5404e-40f,  2.0013e-40f,  3.5611e-40f,
+ 5.5423e-02f,  3.9843e-02f, -1.7509e-01f,
+ 5.4480e-02f,  5.0331e-02f, -1.6793e-01f,
+ 6.6093e-02f,  3.0163e-02f, -8.2023e-02f,
+-1.5490e-01f,  1.7457e-01f,  2.7832e-01f,
+ 1.1482e-01f,  2.5759e-01f, -2.4199e-01f,
+-9.3891e-02f,  9.1921e-02f, -6.4480e-03f,
+ 1.9266e-01f,  5.2907e-02f,  7.0289e-02f,
+ 1.3582e-01f,  6.4246e-02f,  1.4989e-01f,
+ 6.2013e-03f, -6.8884e-02f,  6.8734e-02f,
+-1.0483e-01f, -7.7134e-02f, -3.6204e-02f,
+ 1.7590e-02f,  5.0844e-02f,  1.4234e-01f,
+ 7.2913e-02f,  6.0726e-02f,  6.4414e-02f,
+-8.5021e-02f, -1.0621e-03f,  5.5851e-02f,
+ 2.4666e-01f,  6.5652e-02f, -1.8180e-02f,
+ 1.5225e-01f,  1.2928e-01f,  3.1578e-03f,
+ 1.1468e-01f,  1.9544e-01f,  6.6637e-02f,
+ 6.3430e-02f,  2.0542e-01f,  7.0876e-02f,
+ 3.4779e-02f,  1.0037e-02f, -2.2134e-02f,
+-6.9304e-02f,  1.1184e-01f, -3.7015e-02f,
+-1.7634e-01f,  1.2475e-01f,  9.1947e-02f,
+-6.0550e-02f, -1.3904e-01f,  7.5192e-02f,
+-2.2871e-40f,  4.7367e-41f, -1.0711e-40f,
+-2.8662e-40f,  4.0542e-41f,  3.3067e-40f,
+-4.4395e-41f, -7.2684e-41f,  1.8695e-40f,
+-1.6702e-01f, -2.6654e-01f,  8.7902e-03f,
+-2.0108e-01f, -3.8093e-01f, -8.3700e-02f,
+-7.5433e-02f, -2.0689e-01f,  2.7951e-02f,
+ 2.9938e-03f,  1.1378e-01f,  7.1598e-02f,
+-1.6031e-01f,  1.3475e-01f,  1.5800e-01f,
+-7.2019e-02f, -1.1663e-01f,  8.0692e-02f,
+ 1.0610e-01f,  1.1163e-02f, -1.4959e-01f,
+-1.1576e-01f, -8.5645e-02f,  4.0414e-02f,
+ 5.6245e-02f,  1.7056e-01f,  2.5734e-01f,
+-6.1086e-02f, -7.0851e-02f,  7.6851e-02f,
+-2.7595e-02f, -6.0890e-02f,  4.7472e-02f,
+ 7.1059e-03f,  6.0942e-05f,  7.4915e-02f,
+ 1.9350e-01f, -1.8458e-02f, -2.3040e-02f,
+ 6.3477e-02f,  1.1923e-01f,  9.9319e-02f,
+ 6.4839e-02f,  2.7973e-01f,  1.2902e-01f,
+-1.7829e-01f,  5.7083e-03f, -6.1680e-03f,
+-1.1256e-01f, -2.7951e-02f, -2.1544e-01f,
+-2.1614e-02f, -7.1468e-02f, -2.2054e-02f,
+-8.7543e-02f, -1.2982e-01f,  1.9386e-01f,
+-5.7157e-03f, -1.0108e-01f,  1.4467e-01f,
+-6.5742e-02f, -7.2054e-02f,  1.7924e-01f,
+ 7.5418e-40f,  6.3043e-40f,  4.9815e-40f,
+-1.0952e-40f,  3.0327e-40f, -2.3848e-40f,
+ 4.1302e-40f,  2.0150e-40f, -1.6509e-40f,
+-1.3985e-02f, -1.0550e-01f,  5.8772e-02f,
+-1.7108e-02f, -7.3644e-02f,  3.3014e-02f,
+-1.8224e-03f,  2.8931e-03f,  9.2762e-02f,
+ 4.1531e-02f, -1.5139e-01f, -1.7773e-01f,
+ 9.6548e-02f, -1.1914e-01f, -4.6536e-02f,
+ 8.6754e-02f, -4.0057e-03f,  1.8983e-01f,
+ 1.6545e-01f, -4.7311e-02f, -7.2455e-03f,
+ 3.7567e-01f,  1.8883e-01f, -7.4325e-02f,
+-5.8252e-02f, -1.3811e-02f, -7.0470e-02f,
+-3.2943e-02f, -7.0770e-02f, -1.4700e-01f,
+ 1.7043e-02f,  9.4331e-02f,  4.2857e-03f,
+ 4.1247e-03f,  1.6690e-01f,  4.2146e-02f,
+ 1.1420e-01f, -7.4456e-02f, -3.8763e-02f,
+ 1.6807e-01f,  9.3636e-03f, -1.1796e-01f,
+ 1.7703e-01f,  1.1386e-03f, -6.8707e-02f,
+ 1.0259e-01f, -1.8918e-02f,  6.5902e-03f,
+ 1.2421e-02f, -7.8960e-02f,  2.1766e-02f,
+ 1.3062e-01f,  4.6001e-02f,  2.4199e-01f,
+-1.2955e-02f, -1.9329e-01f,  5.2074e-03f,
+ 5.9446e-02f,  1.8832e-01f,  2.2094e-01f,
+-1.0954e-01f, -8.1867e-02f, -4.3324e-02f,
+-3.9596e-41f,  2.8677e-40f, -6.5843e-40f,
+ 4.2812e-41f, -3.5323e-40f,  4.8298e-40f,
+ 7.6351e-40f, -2.4759e-40f,  7.3030e-40f,
+-1.1284e-01f, -8.4171e-02f, -1.5935e-01f,
+-3.2299e-02f,  1.5427e-01f,  8.9029e-02f,
+-3.8815e-02f,  1.3098e-01f, -4.3065e-02f,
+-2.5276e-01f, -1.7018e-01f,  9.7901e-02f,
+ 1.4218e-01f,  3.1236e-01f,  2.9636e-01f,
+-2.3613e-02f, -5.5258e-02f, -2.0550e-01f
+}
+,
+{
+ 0.0333f,  0.1145f, -0.0922f,
+ 0.1185f,  0.4533f, -0.2015f,
+-0.0774f,  0.1759f, -0.0496f,
+ 0.0954f, -0.0499f,  0.0824f,
+ 0.1059f,  0.0173f, -0.0586f,
+-0.0666f, -0.0287f, -0.0652f,
+-0.0558f, -0.1362f,  0.0015f,
+ 0.1277f,  0.1020f, -0.1369f,
+ 0.0020f, -0.0103f, -0.0804f,
+ 0.0507f,  0.1404f, -0.0241f,
+ 0.0520f,  0.1239f,  0.0633f,
+-0.0268f,  0.0335f,  0.0883f,
+-0.0549f, -0.1022f, -0.0515f,
+-0.0163f, -0.1167f, -0.0442f,
+ 0.0858f, -0.0804f, -0.0014f,
+ 0.0354f, -0.0666f, -0.2105f,
+-0.0950f,  0.1578f, -0.0920f,
+-0.1303f,  0.0299f, -0.0195f,
+-0.0281f, -0.1993f, -0.0154f,
+ 0.0796f,  0.0503f,  0.0954f,
+ 0.0540f,  0.0212f,  0.0389f,
+-0.1387f,  0.1091f, -0.1212f,
+ 0.1556f,  0.3573f,  0.0976f,
+-0.0587f, -0.2070f,  0.2067f,
+ 0.0138f,  0.0051f, -0.1008f,
+ 0.2877f,  0.1079f, -0.0681f,
+ 0.0953f, -0.0739f, -0.2349f,
+ 0.1482f,  0.0657f,  0.0480f,
+ 0.1590f, -0.0009f,  0.1402f,
+ 0.0700f,  0.0435f,  0.1190f,
+ 0.0957f,  0.0117f, -0.1010f,
+ 0.1790f, -0.0200f, -0.0765f,
+ 0.0797f,  0.1455f, -0.0340f,
+ 0.0008f, -0.0267f,  0.0089f,
+ 0.0644f,  0.0647f,  0.0397f,
+ 0.0463f, -0.0116f, -0.0771f,
+ 0.2237f,  0.0324f,  0.0192f,
+-0.0082f, -0.0345f,  0.0294f,
+ 0.0719f, -0.0185f,  0.1008f,
+-0.0307f,  0.0134f, -0.0747f,
+ 0.0776f, -0.1485f,  0.0135f,
+ 0.0965f, -0.0665f, -0.1263f,
+-0.0101f, -0.0097f, -0.0144f,
+-0.0022f, -0.0083f,  0.0277f,
+ 0.0136f, -0.0076f,  0.0314f,
+-0.0008f,  0.0722f, -0.0704f,
+ 0.0053f,  0.0767f,  0.0368f,
+-0.0189f, -0.1354f,  0.0231f,
+-0.1416f,  0.1945f, -0.1756f,
+ 0.2058f,  0.0401f, -0.1348f,
+-0.0945f, -0.2530f, -0.3082f,
+-0.0096f,  0.0871f,  0.0699f,
+-0.0092f,  0.0423f,  0.0995f,
+-0.0914f, -0.0570f, -0.0718f,
+-0.0739f, -0.2749f, -0.2320f,
+ 0.1488f, -0.2698f, -0.1977f,
+ 0.1445f, -0.1655f, -0.0758f,
+ 0.2035f, -0.0138f,  0.0332f,
+ 0.0282f, -0.2247f, -0.0945f,
+-0.0614f, -0.2484f, -0.0595f,
+-0.1174f, -0.1252f,  0.1969f,
+-0.1101f, -0.2950f, -0.2164f,
+-0.0348f, -0.0891f,  0.1250f,
+ 0.0195f,  0.0050f,  0.0300f,
+-0.0508f, -0.0316f, -0.0194f,
+ 0.0199f,  0.0345f,  0.0444f,
+-0.0022f, -0.0529f,  0.1604f,
+ 0.0756f, -0.2015f, -0.2117f,
+-0.0837f, -0.1270f,  0.1330f,
+ 0.0286f,  0.0952f,  0.1082f,
+ 0.0724f, -0.0446f, -0.1156f,
+ 0.0545f,  0.0444f, -0.0291f,
+ 0.0759f,  0.1110f,  0.0944f,
+ 0.1615f,  0.4302f, -0.1060f,
+ 0.0418f, -0.0281f, -0.1378f,
+-0.0757f, -0.0527f, -0.1578f,
+ 0.0123f, -0.0427f,  0.1504f,
+ 0.0694f,  0.0690f,  0.0203f,
+ 0.2132f, -0.3449f,  0.0936f,
+ 0.2491f,  0.0279f, -0.0884f,
+-0.0447f,  0.1589f, -0.0054f,
+-0.0246f,  0.1247f,  0.0403f,
+ 0.0513f, -0.0541f, -0.1141f,
+ 0.0712f, -0.1174f, -0.0051f,
+ 0.2304f,  0.2431f, -0.0517f,
+-0.1548f, -0.0401f,  0.2032f,
+-0.0087f, -0.1676f, -0.0600f,
+ 0.1094f, -0.0329f,  0.0530f,
+-0.0580f,  0.1499f, -0.0806f,
+-0.0086f, -0.1400f, -0.0636f,
+ 0.0708f, -0.1003f, -0.1113f,
+-0.0732f, -0.1199f,  0.0060f,
+-0.0534f, -0.0011f,  0.0965f,
+-0.0268f,  0.0116f, -0.1161f,
+ 0.0787f,  0.3925f, -0.0819f,
+-0.0041f, -0.0892f, -0.2063f,
+-0.1296f,  0.0924f, -0.0079f,
+ 0.5625f,  0.4013f,  0.1645f,
+-0.0137f, -0.1935f,  0.2714f,
+ 0.0980f,  0.0016f, -0.1461f,
+ 0.1576f,  0.0305f, -0.1450f,
+ 0.1503f, -0.0303f, -0.1403f,
+ 0.0262f, -0.0077f,  0.0459f,
+ 0.2718f,  0.0754f,  0.2404f,
+ 0.1381f, -0.1499f,  0.0016f,
+ 0.1454f, -0.1278f, -0.0085f,
+ 0.1674f, -0.0834f,  0.1993f,
+ 0.0874f, -0.0598f, -0.0188f,
+ 0.2003f,  0.3296f,  0.0153f,
+-0.0154f,  0.5550f, -0.0945f,
+ 0.0489f,  0.0415f, -0.0940f,
+ 0.0164f,  0.0791f,  0.1077f,
+-0.0893f,  0.1231f,  0.0473f,
+-0.0319f,  0.1444f,  0.1690f,
+-0.0518f, -0.1404f, -0.1778f,
+-0.0170f,  0.1395f, -0.0234f,
+ 0.0128f, -0.0112f, -0.0472f,
+ 0.1039f,  0.1982f, -0.0272f,
+ 0.0282f, -0.1199f, -0.2622f,
+-0.0449f,  0.0239f, -0.1030f,
+-0.0840f, -0.1044f, -0.0646f,
+ 0.0588f,  0.1937f, -0.2494f,
+ 0.0180f,  0.0747f,  0.1530f,
+ 0.0500f,  0.1756f,  0.0491f,
+-0.1113f, -0.0079f,  0.0854f,
+-0.1493f, -0.0559f, -0.0373f,
+ 0.1972f, -0.3158f, -0.0500f,
+ 0.1932f,  0.3177f, -0.0018f,
+-0.0516f, -0.1144f,  0.0686f,
+ 0.0175f,  0.0598f,  0.0345f,
+-0.0667f, -0.1078f,  0.0384f,
+ 0.0897f,  0.2198f, -0.0531f,
+-0.2596f, -0.1997f,  0.0195f,
+ 0.0332f,  0.4098f,  0.1381f,
+ 0.1985f, -0.0669f, -0.1275f,
+-0.0751f, -0.2388f, -0.0672f,
+ 0.0090f,  0.0891f, -0.0362f,
+ 0.1392f, -0.0518f,  0.2039f,
+ 0.2079f, -0.1202f,  0.0707f,
+ 0.0498f, -0.1237f, -0.0665f,
+-0.0398f, -0.1557f, -0.0928f,
+ 0.0505f,  0.1220f,  0.0352f,
+-0.0674f, -0.1159f,  0.0724f,
+-0.0331f, -0.1751f,  0.0766f,
+ 0.0992f, -0.0763f,  0.0090f,
+-0.1223f,  0.2621f, -0.2029f,
+ 0.0509f, -0.0279f, -0.1061f,
+ 0.0598f,  0.0353f, -0.1610f,
+ 0.0165f,  0.0835f,  0.0704f,
+-0.0079f, -0.0982f,  0.0187f,
+ 0.2331f, -0.1929f,  0.0684f,
+-0.0507f,  0.1476f, -0.0886f,
+-0.0275f,  0.1658f,  0.0697f,
+-0.1123f, -0.0069f, -0.0851f,
+-0.0377f, -0.0917f, -0.0629f,
+-0.0420f,  0.0506f,  0.1111f,
+ 0.1086f,  0.1351f, -0.0851f,
+ 0.0466f,  0.2750f,  0.0185f,
+-0.0208f,  0.2090f,  0.0271f,
+ 0.0217f, -0.0548f,  0.0078f,
+-0.0609f,  0.1029f, -0.1641f,
+ 0.1392f,  0.0115f,  0.0317f,
+-0.0570f,  0.1060f,  0.1814f,
+-0.2015f, -0.1301f,  0.1082f,
+ 0.2452f, -0.1815f, -0.0046f,
+ 0.0103f, -0.0466f, -0.0895f,
+ 0.0158f, -0.0594f, -0.1386f,
+-0.0073f, -0.0719f, -0.0716f,
+ 0.1308f, -0.0206f,  0.0511f,
+-0.0437f, -0.0763f,  0.0287f,
+ 0.0493f, -0.1239f,  0.0219f,
+-0.0041f,  0.0373f,  0.0262f,
+ 0.0078f, -0.0249f, -0.0284f,
+ 0.0598f, -0.0205f, -0.0276f,
+ 0.0115f, -0.1778f, -0.0395f,
+ 0.1673f, -0.0036f,  0.2334f,
+ 0.0706f, -0.0694f,  0.0177f,
+ 0.1123f, -0.0043f,  0.0716f,
+-0.0894f, -0.1609f,  0.0334f,
+-0.0046f, -0.2006f, -0.0977f,
+-0.0127f,  0.1198f, -0.0339f,
+-0.0283f,  0.1354f,  0.1637f,
+-0.1696f,  0.0187f, -0.2621f,
+ 0.0496f,  0.2834f,  0.0423f,
+ 0.1126f,  0.3962f,  0.1660f,
+-0.0750f,  0.1955f,  0.0590f,
+-0.1088f, -0.1146f, -0.1219f,
+ 0.1360f,  0.1524f,  0.0498f,
+-0.1151f,  0.0219f, -0.0063f,
+-0.0821f,  0.0247f, -0.1065f,
+ 0.1153f,  0.2085f,  0.0618f,
+-0.0383f,  0.0527f, -0.2067f
+}
+,
+{
+ 1.8014e-01f,  2.1908e-01f, -2.1088e-03f,
+ 1.7345e-01f,  2.7654e-01f,  1.3607e-02f,
+ 1.1363e-01f,  9.9105e-02f, -6.5730e-02f,
+-3.5679e-02f,  9.6072e-03f,  4.0721e-02f,
+-1.8771e-02f, -2.3484e-04f, -1.0230e-02f,
+ 1.6965e-02f, -1.3032e-02f, -6.3906e-02f,
+-4.5686e-02f, -3.6733e-02f, -4.8873e-02f,
+ 4.0752e-02f,  2.1615e-02f, -1.4822e-02f,
+ 1.1689e-01f,  3.0153e-02f, -5.0163e-04f,
+-7.0394e-03f, -1.2387e-01f, -8.9243e-02f,
+-1.8312e-01f, -1.3868e-01f, -6.2618e-02f,
+-8.1627e-02f, -2.0480e-01f, -3.0740e-01f,
+ 4.4296e-02f,  3.8572e-02f,  4.3754e-02f,
+ 1.7538e-01f,  5.3284e-02f, -7.5663e-03f,
+ 1.9670e-01f, -1.2397e-01f, -1.6266e-01f,
+ 1.4575e-01f, -5.7771e-02f,  2.7619e-02f,
+ 2.2757e-02f, -4.8910e-01f, -2.6201e-01f,
+ 3.6513e-02f, -2.0704e-01f, -1.3225e-01f,
+-6.7533e-02f,  1.1289e-02f,  7.1316e-02f,
+-7.6847e-02f,  6.8128e-02f,  7.4717e-02f,
+ 1.1269e-01f,  2.9978e-02f,  3.2132e-02f,
+-5.4557e-02f, -4.4599e-02f,  4.1835e-02f,
+ 5.7964e-02f, -2.1246e-03f,  1.5007e-01f,
+ 1.8432e-01f,  1.1463e-01f,  2.2691e-01f,
+ 9.6166e-02f,  4.7887e-02f, -3.8399e-02f,
+ 5.8153e-02f, -2.0255e-02f, -1.1362e-01f,
+ 2.6402e-02f,  2.5562e-02f,  1.9096e-02f,
+ 1.1588e-01f,  1.4540e-01f,  1.1948e-01f,
+ 1.0360e-01f,  5.9083e-02f,  1.9263e-01f,
+ 1.6953e-01f,  2.7390e-02f,  9.7883e-02f,
+ 1.5059e-01f,  6.7593e-02f, -4.5843e-03f,
+ 8.7031e-02f, -2.0926e-03f, -6.3056e-02f,
+-6.6960e-02f, -5.2056e-02f, -7.3570e-02f,
+ 1.4361e-02f,  1.1059e-01f, -4.9720e-02f,
+ 4.4270e-02f,  3.9995e-02f,  4.3101e-03f,
+-1.1042e-01f,  4.5028e-02f, -8.9124e-02f,
+-1.2906e-01f, -7.6972e-02f, -6.5449e-03f,
+-1.9269e-01f,  2.8349e-01f,  1.1573e-01f,
+-1.7983e-01f,  9.7615e-02f,  9.4003e-03f,
+-4.7802e-02f, -1.5889e-01f, -1.2693e-01f,
+ 7.4717e-02f,  2.8655e-01f, -7.2637e-02f,
+ 1.5837e-02f,  8.7125e-02f, -1.2198e-01f,
+-1.7754e-02f, -5.6443e-02f, -9.8661e-03f,
+ 6.3040e-02f,  2.0249e-02f, -3.5368e-02f,
+ 9.7756e-03f,  2.6760e-02f, -5.5172e-02f,
+-1.0406e-02f,  4.8313e-02f,  2.4717e-02f,
+-5.2851e-02f,  6.8496e-02f, -2.5933e-02f,
+ 4.5932e-02f,  5.9892e-02f,  1.9200e-02f,
+-5.1316e-40f, -5.1811e-40f, -1.5144e-40f,
+-6.7758e-38f, -5.4608e-40f, -3.9680e-40f,
+-1.9155e-39f,  2.0423e-41f,  1.5256e-41f,
+-2.5559e-08f, -3.2461e-08f, -2.6821e-08f,
+-3.6885e-08f, -4.6896e-08f, -3.9086e-08f,
+-3.4305e-08f, -4.4160e-08f, -3.7187e-08f,
+-3.7416e-40f,  3.6550e-40f,  5.0727e-40f,
+-1.6722e-40f,  3.9228e-40f,  5.4548e-40f,
+-5.7512e-40f, -2.8156e-40f,  9.4571e-41f,
+-4.7040e-40f, -1.6974e-40f,  6.3849e-40f,
+-3.7322e-40f,  2.6014e-40f,  2.3080e-40f,
+-2.8395e-40f, -3.7116e-40f,  4.4393e-40f,
+ 1.1597e-40f,  4.3291e-40f,  3.8219e-40f,
+ 3.3393e-40f,  3.1747e-40f, -1.8400e-36f,
+-5.5215e-40f,  1.7648e-40f, -1.6540e-35f,
+-3.0953e-40f,  5.3063e-40f, -1.6454e-40f,
+ 2.1341e-40f,  2.0790e-40f, -3.0226e-40f,
+-2.6807e-40f, -1.6601e-40f,  5.1829e-40f,
+-1.8897e-40f, -4.5956e-41f,  5.3784e-40f,
+-2.5661e-40f, -2.1726e-40f,  1.2010e-40f,
+ 1.8263e-41f,  1.1214e-40f, -3.7693e-40f,
+-4.2596e-40f,  1.8854e-40f,  5.5010e-40f,
+-6.6262e-40f, -4.8808e-40f,  3.3123e-40f,
+ 5.9379e-41f,  2.3249e-40f,  4.4504e-40f,
+-8.4836e-04f, -8.4397e-04f, -5.8640e-04f,
+-8.3506e-04f, -8.0192e-04f, -5.3901e-04f,
+-8.3539e-04f, -7.8069e-04f, -4.8720e-04f,
+-3.4706e-04f, -4.4640e-04f, -5.2353e-04f,
+-4.4518e-04f, -5.3374e-04f, -5.2734e-04f,
+-5.8780e-04f, -5.8730e-04f, -5.4362e-04f,
+-5.2452e-04f, -5.4578e-04f, -5.6266e-04f,
+-4.2387e-04f, -4.4643e-04f, -4.8936e-04f,
+-3.5880e-04f, -3.7886e-04f, -4.1998e-04f,
+-2.4479e-04f, -4.0736e-04f, -3.1189e-04f,
+-3.4922e-04f, -4.0173e-04f, -2.5042e-04f,
+-5.7091e-04f, -5.2665e-04f, -2.3293e-04f,
+-2.8505e-04f,  9.7283e-05f,  3.1209e-04f,
+-2.7463e-04f,  1.8704e-04f,  4.4351e-04f,
+-9.1436e-05f,  3.2602e-04f,  5.7573e-04f,
+-4.0112e-04f, -4.2566e-04f, -2.4300e-04f,
+-9.9362e-05f, -6.5499e-05f,  3.2872e-05f,
+ 1.1584e-04f,  2.3417e-04f,  3.4427e-04f,
+-7.5767e-05f,  3.9768e-06f,  6.2201e-05f,
+ 2.3151e-05f,  2.5595e-04f,  3.4038e-04f,
+-1.3871e-05f,  3.0295e-04f,  4.4170e-04f,
+-1.7802e-04f, -4.5376e-04f, -5.1847e-04f,
+-5.0687e-04f, -5.5837e-04f, -2.5917e-04f,
+-5.3992e-04f, -7.1375e-04f, -4.8728e-04f,
+-1.7543e-01f, -3.4151e-01f, -3.2619e-02f,
+-1.9701e-02f, -1.5494e-01f, -1.6534e-01f,
+ 3.5632e-02f, -1.0897e-01f, -3.8379e-02f,
+-6.1420e-02f, -1.0735e-01f,  1.4730e-01f,
+ 7.4386e-02f, -1.0487e-01f,  7.9646e-02f,
+ 1.7130e-02f,  4.4391e-02f, -5.1959e-03f,
+ 4.5682e-02f, -1.1543e-01f,  9.4035e-03f,
+-3.4376e-01f, -1.1961e-01f,  1.0099e-01f,
+ 1.1335e-01f,  7.5840e-02f,  1.0675e-01f,
+ 4.9539e-02f,  8.7406e-02f,  4.4951e-02f,
+ 1.8111e-01f,  2.6406e-01f, -1.5924e-02f,
+-1.1464e-01f,  8.4579e-04f, -6.6811e-02f,
+-8.9635e-03f,  1.8236e-03f,  3.6561e-02f,
+-7.0281e-02f,  2.9717e-01f,  3.1836e-02f,
+-1.3647e-01f, -6.5627e-02f,  9.3063e-02f,
+-2.1851e-01f, -6.0226e-02f, -1.0326e-01f,
+ 5.3441e-02f,  1.9103e-01f, -5.7999e-02f,
+-3.3512e-02f,  1.5496e-01f, -1.1111e-01f,
+ 2.3256e-03f, -1.5004e-01f, -9.1248e-02f,
+-9.7706e-02f,  1.9549e-01f, -1.5403e-01f,
+-1.5327e-01f,  8.3335e-02f,  5.6111e-03f,
+-1.5707e-01f,  8.0277e-03f, -7.3955e-02f,
+-1.4111e-01f, -1.3548e-01f, -1.0563e-01f,
+ 2.3054e-01f, -2.1822e-02f, -6.6938e-03f,
+-1.0259e-01f,  4.3577e-02f, -1.7630e-01f,
+ 1.6484e-01f,  4.2413e-01f,  6.9475e-02f,
+-2.4705e-01f,  2.5757e-01f, -9.5611e-02f,
+ 1.0236e-01f, -3.4820e-02f, -6.8818e-03f,
+-1.1434e-01f, -3.1800e-01f,  2.1337e-02f,
+-1.9939e-01f, -2.6532e-01f,  7.3361e-02f,
+ 6.5939e-02f,  9.5812e-02f, -7.0156e-02f,
+-1.6249e-02f, -1.5927e-02f, -1.1189e-01f,
+-9.3936e-03f, -1.0933e-01f, -2.9399e-02f,
+-2.8752e-02f, -4.5613e-02f, -1.2718e-02f,
+ 3.8781e-01f,  2.6776e-01f, -1.0373e-02f,
+-2.3927e-02f, -6.4398e-02f,  9.9117e-02f,
+-6.0732e-02f, -5.5917e-03f,  5.1716e-02f,
+-1.4168e-01f,  1.7661e-01f, -5.5893e-02f,
+-3.0419e-01f, -3.5537e-01f,  2.1978e-01f,
+-1.8610e-01f, -5.7743e-03f,  3.2649e-02f,
+ 1.9975e-01f,  1.6508e-01f,  1.3808e-02f,
+ 1.0733e-01f,  1.4722e-01f,  5.8671e-02f,
+ 6.4940e-02f,  1.6114e-01f,  3.9697e-02f,
+ 1.1530e-01f,  2.4021e-01f, -2.1669e-01f,
+ 6.0220e-02f,  2.0257e-01f, -1.5227e-01f,
+-6.1096e-02f,  6.6511e-02f, -1.3858e-01f,
+-6.5275e-02f,  1.0891e-01f,  8.2048e-02f,
+-6.7907e-02f,  2.2863e-02f, -1.0322e-01f,
+ 1.6542e-01f, -1.4436e-01f,  6.4125e-02f,
+-1.0378e-01f, -3.2346e-01f, -1.5123e-02f,
+ 3.8758e-03f,  1.1006e-01f, -4.4325e-02f,
+-1.0102e-01f, -3.7699e-02f,  9.2472e-02f,
+-6.8972e-02f, -1.2308e-02f,  1.6478e-01f,
+ 3.4351e-02f, -1.7461e-02f,  1.0301e-01f,
+-2.7125e-01f, -5.6730e-02f, -2.5989e-01f,
+-3.0163e-01f, -1.4826e-01f, -3.4955e-01f,
+-1.6259e-01f, -1.6708e-01f, -2.7964e-01f,
+-6.7134e-02f, -2.2385e-01f,  2.1776e-01f,
+-1.1351e-02f, -3.7861e-01f,  1.8687e-01f,
+ 4.0551e-02f,  8.1943e-02f,  1.0866e-01f,
+ 1.0273e-01f,  1.1844e-01f, -1.1852e-01f,
+ 2.6758e-02f, -8.5806e-02f,  5.9444e-02f,
+-5.1627e-02f,  7.1636e-02f,  2.2841e-01f,
+-3.7242e-03f,  2.9723e-01f,  1.1918e-01f,
+ 8.4994e-02f, -3.5747e-01f,  3.6148e-02f,
+ 9.9705e-02f, -1.3736e-01f, -6.0080e-02f,
+ 1.2370e-01f,  5.0668e-02f, -6.0246e-02f,
+ 6.0562e-02f, -3.5068e-01f, -3.2645e-01f,
+ 9.1020e-04f,  6.6203e-02f, -1.0770e-01f,
+ 1.9434e-02f,  3.0018e-01f,  2.8018e-01f,
+ 1.4021e-01f,  2.7481e-01f,  2.2868e-01f,
+ 4.8540e-02f,  1.7719e-01f, -4.5834e-02f,
+-9.6349e-02f, -2.3008e-02f, -1.4497e-01f,
+ 4.3053e-02f, -1.0161e-01f,  2.8750e-02f,
+-1.2594e-01f, -1.0388e-02f, -4.3966e-02f,
+ 7.5993e-02f, -7.1609e-02f,  1.4624e-02f,
+ 4.1110e-02f,  7.1258e-02f, -2.9109e-02f,
+-5.8698e-03f,  1.2389e-01f,  4.7648e-02f,
+-6.1585e-04f, -4.4556e-02f, -2.3373e-02f,
+-4.4883e-02f, -7.7722e-02f, -7.3635e-02f,
+-2.7750e-02f, -1.5117e-03f, -8.7368e-02f,
+ 2.5113e-02f,  7.7490e-02f,  2.9024e-02f,
+ 1.5426e-01f,  2.5472e-01f,  4.8057e-02f,
+-1.1969e-01f, -1.1487e-01f, -1.1802e-01f,
+-4.7392e-02f, -4.2226e-02f,  3.1968e-02f,
+-2.6717e-01f, -5.0206e-02f,  8.1946e-04f,
+-4.0426e-02f,  1.4373e-01f, -3.3121e-03f,
+-4.5292e-02f, -2.4538e-02f,  1.0377e-01f,
+-1.7780e-02f,  2.0058e-01f, -2.4343e-02f,
+-1.1714e-02f,  1.5984e-01f, -1.2638e-01f,
+ 6.4655e-02f,  3.7703e-02f,  3.7970e-02f,
+ 9.1864e-03f,  1.1468e-01f, -6.2760e-04f,
+-1.4812e-01f,  6.5670e-03f,  1.0765e-01f,
+ 1.5023e-01f, -7.0594e-02f, -1.3924e-01f,
+ 3.6016e-02f, -3.9078e-02f, -3.8950e-02f,
+ 1.8735e-02f, -1.5573e-01f, -1.2456e-01f
+}
+,
+{
+ 4.8634e-02f, -1.3617e-01f,  6.1231e-02f,
+-7.0235e-02f, -6.4110e-01f,  1.5985e-01f,
+ 8.6151e-02f,  1.1847e-01f,  1.3819e-01f,
+-3.6017e-04f, -3.2273e-02f, -8.5485e-02f,
+-7.0804e-03f,  2.1751e-01f,  7.2575e-03f,
+-8.3606e-02f, -1.4885e-01f, -1.2702e-01f,
+ 4.0848e-41f,  8.0934e-40f, -1.8889e-40f,
+-3.9103e-40f, -7.4709e-40f,  3.8377e-40f,
+-2.4159e-40f, -4.7610e-40f,  7.7359e-40f,
+-8.6217e-05f, -5.9763e-05f, -4.0558e-05f,
+-7.4966e-05f, -4.7074e-05f, -3.1656e-05f,
+-9.8390e-05f, -6.6833e-05f, -4.7669e-05f,
+ 3.5375e-02f,  2.8660e-02f,  4.1277e-02f,
+ 1.6289e-01f, -3.2199e-01f, -1.7845e-02f,
+ 2.4659e-01f, -3.9618e-02f,  4.1065e-03f,
+ 2.7267e-02f,  8.6819e-02f,  9.5070e-02f,
+-7.2700e-02f, -2.8826e-01f,  1.1750e-03f,
+ 2.5259e-02f,  2.4681e-03f,  6.4737e-02f,
+ 7.3023e-03f,  2.9631e-02f,  1.0820e-02f,
+-2.1400e-02f,  5.4244e-01f,  1.5639e-01f,
+-1.7561e-01f,  4.8947e-01f, -8.8305e-02f,
+ 6.5073e-02f,  3.4922e-01f,  1.3483e-01f,
+ 1.4506e-01f, -2.5472e-01f, -7.2894e-02f,
+ 4.5945e-02f,  1.4040e-01f,  1.2148e-01f,
+-2.6932e-01f, -1.1518e-01f, -9.3158e-03f,
+-2.3961e-01f, -1.2479e-01f, -8.9796e-02f,
+ 1.8688e-02f, -4.9267e-02f,  7.7189e-02f,
+-7.3691e-02f,  7.8186e-03f,  1.3761e-02f,
+-1.5689e-01f,  3.1138e-02f,  3.9231e-02f,
+-4.3607e-03f,  2.0813e-01f,  5.5635e-02f,
+-6.7000e-41f,  9.8995e-41f,  3.0043e-40f,
+ 6.7190e-40f,  4.0827e-40f,  7.6057e-40f,
+ 4.2208e-40f,  8.1141e-40f, -3.3569e-40f,
+ 1.0179e-03f,  5.1543e-04f,  3.8076e-04f,
+ 7.3507e-04f,  4.5432e-04f,  3.7410e-04f,
+ 9.3014e-04f,  6.7365e-04f,  6.0051e-04f,
+-5.1998e-02f,  6.5768e-02f,  3.1603e-02f,
+-3.0198e-02f, -3.1692e-02f, -6.9299e-02f,
+ 1.7672e-02f,  2.3766e-01f,  5.7877e-02f,
+-5.7944e-02f,  1.2624e-01f, -1.4396e-01f,
+-4.1542e-02f,  6.5110e-01f,  1.0942e-01f,
+-1.3133e-01f,  5.0538e-02f, -2.7371e-02f,
+-3.7515e-02f,  2.8703e-02f,  1.2382e-03f,
+ 3.8542e-01f, -2.2754e-02f,  3.4459e-02f,
+ 3.0545e-01f, -5.3817e-01f, -2.1389e-03f,
+ 1.3888e-02f, -2.2775e-01f, -6.3692e-02f,
+-1.8430e-01f,  5.8452e-02f,  4.5764e-02f,
+-8.5045e-02f, -1.7060e-01f, -1.8565e-02f,
+-2.0384e-02f, -3.3018e-02f, -5.1135e-02f,
+-4.5789e-02f, -1.8105e-01f,  3.5419e-02f,
+-5.0081e-02f,  8.7719e-02f,  1.0373e-01f,
+-1.0033e-02f,  7.0530e-02f, -7.8012e-03f,
+ 8.4042e-02f,  1.1982e-01f, -9.6046e-02f,
+-6.4009e-02f, -1.0711e-01f, -1.3523e-01f,
+ 1.8868e-41f, -7.0039e-40f, -7.2568e-40f,
+ 1.7408e-40f, -7.8143e-40f, -6.8130e-40f,
+-6.3142e-40f, -6.2560e-40f, -7.4238e-40f,
+ 2.6297e-04f,  7.0014e-05f, -4.0981e-04f,
+ 2.6263e-04f,  4.2811e-05f, -4.9950e-04f,
+ 3.9795e-04f,  1.2615e-04f, -4.7660e-04f,
+ 7.5933e-02f,  2.6295e-02f,  2.7984e-02f,
+-5.5914e-03f, -8.7981e-02f, -9.2618e-02f,
+ 4.2725e-02f, -3.1210e-01f,  1.3412e-01f,
+ 5.2683e-02f,  3.9891e-01f,  2.9150e-02f,
+-6.6090e-02f,  2.9455e-01f, -1.9710e-01f,
+ 1.4546e-02f, -2.5572e-02f,  8.1125e-02f,
+ 1.2271e-01f,  1.6097e-01f,  4.5644e-02f,
+ 3.6101e-02f, -1.7174e-02f,  6.6110e-02f,
+ 1.5078e-01f,  4.5180e-01f,  7.7154e-02f,
+-5.9725e-02f,  1.0185e-01f,  1.1363e-03f,
+ 6.7791e-02f,  1.7696e-02f,  5.2638e-02f,
+ 3.3051e-02f, -8.4049e-02f,  1.4380e-01f,
+ 1.8744e-02f, -2.0940e-01f, -2.1424e-01f,
+-2.1329e-01f, -1.3154e-01f, -3.2572e-01f,
+ 1.1292e-01f,  1.2361e-02f, -1.5506e-01f,
+-1.0362e-02f,  1.9955e-02f,  4.2639e-02f,
+-2.1952e-02f, -2.4682e-02f, -2.4453e-02f,
+-2.5606e-02f, -3.3580e-02f, -3.6340e-02f,
+-5.0830e-40f,  6.3797e-40f, -5.2775e-40f,
+-7.7988e-40f, -7.4579e-40f, -5.1901e-40f,
+-3.8275e-41f, -5.7607e-40f, -1.3656e-40f,
+ 2.7164e-04f,  5.9977e-04f,  8.6886e-04f,
+ 3.0116e-04f,  7.0106e-04f,  1.0248e-03f,
+ 2.9177e-04f,  6.4748e-04f,  9.4825e-04f,
+ 6.6310e-02f,  1.5240e-02f, -5.3044e-02f,
+ 1.2545e-01f,  5.0582e-02f,  2.7358e-02f,
+ 1.9338e-01f,  1.1377e-01f,  4.6110e-02f,
+-3.1997e-02f,  1.5171e-02f, -4.9372e-02f,
+ 5.4615e-04f,  1.7262e-01f, -2.2081e-01f,
+ 8.4871e-02f,  1.7824e-02f, -3.6429e-02f,
+ 4.2821e-02f, -1.0055e-01f,  4.8927e-02f,
+ 1.2524e-01f,  5.8859e-02f, -2.0980e-02f,
+ 2.2897e-01f,  1.7594e-01f,  3.4239e-02f,
+ 1.0915e-01f,  1.2088e-01f,  1.0151e-01f,
+ 6.8449e-03f, -1.5546e-01f,  1.2024e-01f,
+ 4.9036e-02f, -1.2245e-01f,  4.6713e-02f,
+ 7.5083e-03f, -4.8084e-02f,  9.7731e-03f,
+ 4.8779e-02f,  3.1848e-02f, -9.3517e-02f,
+ 6.4595e-02f,  3.9337e-02f, -7.2343e-02f,
+ 3.9519e-02f,  4.1867e-02f, -5.0485e-02f,
+ 2.5257e-02f,  1.4071e-01f,  1.3606e-01f,
+ 1.7481e-01f,  2.0210e-01f,  1.7241e-01f,
+-7.6295e-40f, -7.8460e-40f, -4.1806e-41f,
+-7.9994e-40f, -7.3271e-40f, -6.2665e-40f,
+-7.9602e-40f, -7.0226e-40f, -7.4131e-40f,
+-4.5544e-04f, -5.2379e-04f, -7.0755e-04f,
+-3.3807e-04f, -3.8123e-04f, -5.3222e-04f,
+-3.1771e-04f, -3.4586e-04f, -4.8784e-04f,
+-3.5257e-02f, -1.1866e-02f,  1.9717e-02f,
+-6.0777e-02f, -7.3127e-03f, -3.2825e-02f,
+-1.4952e-01f,  3.2117e-01f, -6.3786e-02f,
+-1.0255e-02f,  1.2961e-01f, -8.6823e-02f,
+ 1.6994e-01f,  4.7491e-01f,  2.7135e-01f,
+ 2.8538e-03f,  1.5572e-01f, -3.3736e-02f,
+ 8.5996e-02f, -1.0176e-02f,  2.6629e-02f,
+ 7.3362e-02f, -7.7525e-03f,  5.6261e-02f,
+ 1.0819e-01f, -2.5863e-01f, -5.7146e-03f,
+-7.1781e-02f,  2.8376e-03f,  7.8298e-02f,
+ 1.3183e-01f,  2.7149e-02f, -9.9786e-02f,
+ 9.0491e-02f,  8.7938e-02f, -2.1882e-02f,
+ 4.1396e-03f, -4.5816e-02f, -7.8892e-02f,
+-6.3855e-03f,  1.7502e-01f,  1.2053e-01f,
+ 1.2492e-01f,  6.1258e-02f, -4.0516e-02f,
+-4.5409e-02f, -4.5877e-02f, -7.6414e-02f,
+-1.0573e-02f, -1.2517e-01f, -4.3991e-02f,
+-2.6447e-02f, -9.5478e-02f, -2.4735e-02f,
+-4.6548e-41f, -1.6443e-40f, -3.1221e-40f,
+-3.2675e-40f, -2.7265e-40f, -3.1190e-40f,
+-2.2065e-40f, -2.5407e-40f, -6.9511e-40f,
+-1.2727e-04f, -2.6585e-04f, -3.5516e-04f,
+ 3.4272e-05f, -1.6810e-04f, -3.1677e-04f,
+-5.5355e-05f, -2.9924e-04f, -4.3692e-04f,
+-5.6428e-02f,  1.0771e-01f,  1.0185e-01f,
+ 2.2948e-01f, -7.8744e-02f,  6.0768e-04f,
+-2.2355e-03f, -2.0128e-03f, -5.7317e-03f,
+-7.1232e-03f,  1.0297e-01f,  1.6872e-01f,
+ 1.9194e-01f, -1.1578e-01f,  1.0732e-01f,
+-8.6952e-02f,  3.2901e-02f, -6.6658e-03f,
+ 7.3979e-02f,  8.3875e-02f, -7.6372e-03f,
+ 1.9577e-01f,  2.7391e-01f,  4.5275e-02f,
+ 1.5610e-01f,  2.3802e-01f,  1.6555e-02f,
+ 1.3814e-01f,  1.2870e-01f,  9.1626e-02f,
+-4.6890e-02f, -8.8734e-02f,  7.8866e-02f,
+ 1.0027e-01f,  2.2139e-01f,  1.0050e-01f,
+-6.5845e-02f, -1.0990e-01f, -6.9896e-02f,
+ 4.1687e-02f,  3.0631e-02f, -8.8441e-02f,
+-1.1868e-01f,  1.0836e-02f,  2.5873e-02f,
+-1.7114e-02f,  7.6295e-02f,  1.5439e-02f,
+-2.4271e-02f,  5.8538e-02f,  9.8190e-02f,
+ 4.9742e-02f,  8.7807e-02f,  6.5871e-02f,
+-7.2669e-40f, -7.5936e-41f, -7.4975e-40f,
+-1.6984e-42f, -1.7334e-40f, -8.4954e-41f,
+-2.1556e-41f, -1.5374e-40f, -1.5515e-40f,
+-6.2626e-04f, -7.2727e-04f, -8.1665e-04f,
+-5.6584e-04f, -6.1190e-04f, -6.9584e-04f,
+-5.6278e-04f, -5.8554e-04f, -6.3554e-04f,
+ 8.1550e-02f, -4.1817e-03f,  1.2301e-02f,
+-4.5800e-02f,  4.6708e-02f, -8.7972e-02f,
+-2.9880e-01f,  2.6456e-01f,  3.9363e-03f,
+-3.0939e-02f, -1.9921e-01f, -3.8689e-03f,
+-8.6803e-02f,  3.4857e-01f, -1.0201e-01f,
+ 2.1597e-02f,  1.4380e-02f,  4.3448e-02f,
+ 7.1195e-02f,  1.4980e-01f,  3.8079e-02f,
+-1.2678e-01f, -8.1274e-02f, -4.3445e-02f,
+ 5.2482e-02f, -1.8763e-01f,  1.1557e-01f,
+-9.4614e-02f,  5.4415e-02f, -3.1485e-02f,
+-3.6451e-02f,  1.4379e-01f,  5.2291e-02f,
+-9.2069e-02f,  9.5675e-02f, -5.8433e-02f,
+ 7.5768e-03f, -7.1280e-02f, -1.4576e-01f,
+-1.4671e-01f, -1.2446e-01f, -1.5207e-01f,
+-5.4368e-02f,  3.8303e-02f, -8.1794e-02f,
+ 2.0492e-02f,  4.0910e-02f,  1.1379e-02f,
+ 3.1582e-02f,  3.6039e-02f, -4.4040e-03f,
+ 1.7540e-02f,  1.4097e-04f, -6.4367e-02f,
+-7.9553e-40f, -5.3941e-40f, -7.1912e-40f,
+-5.8099e-40f, -6.8315e-40f, -6.6012e-40f,
+-7.6242e-40f, -5.4784e-40f, -7.0267e-40f,
+-2.9197e-04f, -2.1994e-04f, -1.9501e-04f,
+-2.6516e-05f, -1.2642e-05f, -8.4345e-05f,
+ 1.6763e-04f,  1.1268e-04f, -5.4516e-05f,
+-3.8007e-03f, -6.8765e-02f, -9.5716e-02f,
+ 6.3091e-02f, -8.1971e-02f, -9.2895e-02f,
+-6.8353e-03f,  7.3639e-02f,  1.3505e-01f,
+ 9.0083e-02f,  2.4352e-01f,  3.9708e-02f,
+-5.4051e-02f, -6.8748e-02f, -1.8937e-01f,
+-1.9808e-03f, -7.1337e-02f, -2.8316e-02f,
+ 8.1504e-02f,  8.3226e-03f,  6.9013e-03f,
+ 9.4393e-02f,  5.9322e-02f,  5.5023e-02f,
+ 1.0236e-01f, -4.0205e-02f,  3.5172e-02f,
+ 6.5381e-02f,  4.9075e-02f, -5.3931e-02f,
+ 4.3961e-02f,  9.0223e-03f, -4.1678e-02f,
+-6.4262e-02f, -5.0304e-02f, -9.3597e-02f
+}
+,
+{
+ 3.8496e-01f,  1.4287e-01f,  3.4530e-02f,
+-5.5398e-01f, -6.0381e-02f,  1.2078e-02f,
+ 7.9983e-02f,  2.1478e-01f, -5.7915e-02f,
+-1.4020e-01f, -2.6914e-02f,  1.5915e-02f,
+ 1.2371e-01f,  2.5496e-01f, -2.9867e-02f,
+ 1.3269e-02f, -9.9596e-02f, -2.3173e-01f,
+ 5.1471e-02f, -4.5507e-01f, -7.7620e-02f,
+-5.1328e-02f, -1.9808e-02f, -4.7051e-02f,
+ 3.0573e-02f,  7.8762e-02f, -7.2627e-02f,
+ 6.8690e-02f, -4.0125e-02f,  5.6657e-02f,
+ 8.0208e-02f, -2.0075e-02f,  1.4019e-01f,
+-5.7959e-02f, -7.3152e-02f,  2.0202e-02f,
+-8.8702e-02f, -1.9911e-01f, -1.5570e-01f,
+ 2.8401e-02f,  5.8802e-02f,  1.3050e-01f,
+ 2.1905e-02f, -3.4298e-02f,  4.0447e-02f,
+ 1.0184e-01f, -9.0101e-02f, -9.2770e-02f,
+ 1.1713e-02f, -3.2514e-01f,  1.9393e-01f,
+-9.4227e-02f,  2.7053e-01f, -9.7233e-02f,
+-1.0478e-01f,  6.0652e-02f,  8.3399e-02f,
+ 1.1104e-01f,  2.9008e-01f,  4.9208e-02f,
+-1.5414e-02f,  3.1718e-02f, -7.9083e-02f,
+-5.2358e-03f,  9.0101e-02f,  5.2973e-02f,
+ 5.5527e-02f, -1.6599e-02f, -8.5167e-02f,
+-5.1018e-02f,  7.2243e-03f, -9.5684e-02f,
+-5.0608e-02f, -6.7864e-02f, -8.9496e-02f,
+-2.4348e-01f,  2.7477e-01f, -1.7588e-01f,
+ 1.3927e-01f,  5.5502e-02f, -1.3370e-02f,
+-4.3509e-02f, -2.1511e-01f, -5.9070e-02f,
+ 1.0293e-01f,  4.2678e-01f, -8.7527e-02f,
+-6.8546e-02f, -5.6296e-02f, -8.7962e-02f,
+-8.6130e-02f,  9.2069e-02f,  7.2303e-02f,
+ 2.4365e-02f,  2.1988e-01f, -7.9408e-03f,
+-3.0063e-02f,  1.1554e-01f, -5.0311e-02f,
+ 1.0605e-02f,  5.4598e-02f,  1.3826e-02f,
+-1.4342e-02f,  1.5353e-01f, -5.3974e-03f,
+ 1.5583e-01f, -6.0889e-02f, -1.5772e-02f,
+-2.5956e-02f, -3.5285e-01f, -2.0338e-01f,
+ 2.6011e-01f,  2.2737e-01f, -1.4693e-01f,
+-7.7964e-02f,  1.0053e-01f, -5.4278e-02f,
+-3.0668e-02f,  3.4556e-02f, -3.4321e-02f,
+ 7.8695e-02f, -2.2357e-01f,  9.5733e-02f,
+ 1.7483e-01f, -1.5153e-01f, -1.8262e-03f,
+ 4.7605e-02f, -2.2834e-01f,  4.6383e-02f,
+ 1.5701e-01f,  3.2264e-01f,  1.0334e-02f,
+ 6.3351e-02f,  1.1340e-01f,  8.3478e-02f,
+ 6.4196e-02f,  3.3460e-02f,  8.8473e-02f,
+ 5.4663e-02f, -1.7665e-03f, -4.1935e-02f,
+-6.1346e-03f, -5.4463e-02f, -6.2960e-02f,
+ 2.8159e-02f,  2.9903e-02f,  9.2429e-03f,
+-3.0041e-02f, -9.7783e-02f, -4.9500e-02f,
+ 9.5350e-02f, -7.9143e-02f, -1.3244e-01f,
+-6.5129e-02f,  1.4568e-01f,  6.6843e-02f,
+ 1.5241e-01f, -7.8736e-02f,  1.0721e-01f,
+-5.9015e-02f,  1.5320e-01f,  3.0796e-01f,
+-5.4266e-03f, -6.0804e-02f,  3.7326e-02f,
+ 7.4844e-02f,  4.8340e-02f,  1.5251e-01f,
+ 3.8158e-02f,  1.2087e-01f, -8.9003e-02f,
+-5.8369e-02f, -7.3813e-02f,  1.2240e-02f,
+-4.5106e-03f,  7.4580e-02f,  1.2042e-01f,
+ 4.1959e-02f,  1.4529e-01f,  5.3636e-03f,
+-4.9708e-03f, -1.0775e-02f, -5.9374e-02f,
+ 1.5358e-02f,  1.7277e-02f, -1.5412e-01f,
+ 8.1647e-02f,  3.3503e-02f, -8.1934e-02f,
+-1.5807e-02f, -1.0001e-02f, -1.0059e-02f,
+-9.0493e-03f, -7.8954e-02f,  4.3891e-02f,
+-9.3815e-03f,  3.2241e-02f,  4.7962e-02f,
+-7.2252e-03f,  7.9324e-02f,  2.0662e-02f,
+-5.7710e-02f, -5.1142e-02f, -1.4296e-01f,
+ 2.1501e-02f, -1.9518e-02f, -2.7658e-02f,
+ 1.4983e-01f,  8.5447e-02f,  7.2092e-04f,
+ 1.1275e-01f,  6.1131e-02f,  5.7955e-02f,
+ 1.5624e-02f,  2.7225e-01f,  1.1716e-01f,
+-1.6322e-04f, -1.3368e-04f, -1.5575e-04f,
+-1.0525e-04f, -1.0765e-04f, -1.5306e-04f,
+-8.9692e-05f, -1.0857e-04f, -1.7316e-04f,
+-1.8015e-03f, -1.3733e-03f, -3.9154e-04f,
+-1.8453e-03f, -1.4238e-03f, -4.4163e-04f,
+-1.5511e-03f, -1.1131e-03f, -2.0087e-04f,
+-2.4082e-03f, -2.2576e-03f, -1.9231e-03f,
+-2.4913e-03f, -2.4136e-03f, -2.1678e-03f,
+-2.5057e-03f, -2.4650e-03f, -2.2732e-03f,
+-2.3901e-05f, -1.5870e-05f, -5.8255e-06f,
+-1.5163e-05f, -1.2370e-05f, -6.0712e-06f,
+-1.3098e-05f, -1.1132e-05f, -5.7866e-06f,
+-5.9760e-03f, -5.9998e-03f, -6.0295e-03f,
+-5.9962e-03f, -6.0100e-03f, -6.0277e-03f,
+-6.0003e-03f, -6.0059e-03f, -6.0148e-03f,
+-3.2764e-05f, -2.9574e-05f, -2.8001e-05f,
+-1.0846e-05f, -1.1569e-05f, -1.4282e-05f,
+-1.6255e-06f, -2.5666e-06f, -4.7808e-06f,
+-5.1999e-03f, -5.2334e-03f, -5.2847e-03f,
+-5.2057e-03f, -5.2283e-03f, -5.2713e-03f,
+-5.2195e-03f, -5.2321e-03f, -5.2633e-03f,
+-3.0782e-06f, -9.2118e-06f, -1.6177e-05f,
+-1.6382e-06f, -6.9559e-06f, -1.4245e-05f,
+-1.1471e-06f, -6.5984e-06f, -1.4903e-05f,
+ 7.7574e-02f, -1.2866e-02f,  4.1348e-03f,
+-6.7298e-02f, -1.3691e-01f,  6.4079e-02f,
+ 3.7962e-02f,  8.7737e-02f, -4.1046e-02f,
+-2.8471e-02f,  1.7647e-01f,  6.4232e-02f,
+ 1.2316e-01f,  3.6800e-01f, -1.5740e-01f,
+-6.0839e-02f,  1.5449e-02f, -1.0761e-01f,
+-6.6869e-02f, -1.2867e-01f, -4.0195e-02f,
+-4.9651e-02f, -5.5500e-02f, -2.5879e-02f,
+ 2.0179e-02f,  6.8467e-02f,  2.6575e-02f,
+-6.7728e-04f, -7.6269e-02f,  2.3470e-02f,
+ 7.1869e-02f, -1.1855e-01f, -2.1067e-02f,
+ 1.3263e-01f, -3.2957e-02f, -3.4365e-03f,
+ 8.1936e-02f,  1.3073e-01f,  1.1477e-01f,
+ 1.2429e-01f,  1.6129e-01f,  1.6251e-01f,
+ 1.5476e-02f,  3.2862e-02f,  2.1999e-02f,
+-2.9189e-02f, -3.3615e-02f,  5.5616e-04f,
+-2.4059e-02f, -9.6181e-03f, -4.1175e-02f,
+-6.3680e-04f, -9.6559e-02f, -9.1448e-02f,
+ 3.0238e-02f,  1.2534e-01f,  1.5256e-02f,
+-4.2118e-02f,  1.5723e-01f,  2.6929e-03f,
+ 1.9873e-02f,  5.3050e-02f, -1.0153e-03f,
+ 2.0634e-02f,  9.2825e-03f, -6.8027e-03f,
+ 3.1335e-03f, -7.7443e-03f, -1.8307e-02f,
+ 7.9974e-03f, -1.0283e-03f, -6.2520e-03f,
+ 4.5050e-02f,  9.9504e-02f, -1.3404e-01f,
+-6.7271e-01f, -5.7290e-02f,  2.6919e-02f,
+ 2.3673e-01f,  2.4688e-02f, -2.0227e-02f,
+ 5.1389e-02f, -3.9810e-02f, -8.9700e-02f,
+ 2.8445e-02f,  3.9136e-01f, -1.1508e-01f,
+-1.0449e-01f, -6.2005e-02f,  6.5721e-02f,
+-1.9123e-01f, -4.2613e-02f,  3.5371e-02f,
+ 1.9207e-01f,  8.7916e-02f,  4.8089e-02f,
+-5.7912e-02f,  1.0014e-01f, -9.4659e-02f,
+ 1.1240e-02f, -6.2254e-03f,  1.3399e-01f,
+ 1.6483e-01f, -3.5079e-01f,  1.1612e-02f,
+ 2.9215e-01f,  5.6875e-02f,  6.9505e-02f,
+ 1.3721e-02f,  1.2607e-01f,  2.6426e-02f,
+-2.0529e-01f,  2.1768e-01f,  2.1232e-01f,
+-6.3574e-02f,  2.3504e-02f, -1.0811e-01f,
+-1.3470e-02f, -3.6446e-02f, -5.4379e-02f,
+-1.3257e-01f, -8.3412e-02f,  3.7745e-02f,
+ 5.8778e-02f, -2.6060e-01f,  3.8262e-02f,
+-4.3689e-03f, -6.6703e-02f, -2.2025e-01f,
+-9.0961e-02f,  1.3855e-01f,  3.4573e-04f,
+-2.9613e-01f, -3.6138e-02f, -1.3827e-01f,
+ 4.5896e-02f, -5.3871e-02f, -1.0037e-01f,
+ 1.8457e-01f,  1.0338e-01f, -5.7306e-02f,
+ 5.5510e-02f, -9.4938e-02f, -5.6527e-05f,
+ 1.6372e-01f, -3.3854e-02f,  5.6332e-02f,
+-4.0251e-01f, -5.9428e-02f, -9.1470e-02f,
+-1.5921e-02f, -5.7948e-02f,  8.1682e-03f,
+-3.7833e-03f,  1.6293e-01f,  5.3784e-02f,
+ 1.1053e-01f, -1.3867e-01f,  2.6772e-02f,
+-1.3133e-02f,  3.7614e-01f,  3.6361e-03f,
+-1.4205e-01f,  3.1312e-02f, -9.9928e-02f,
+-1.5755e-01f,  4.2016e-01f,  9.4065e-02f,
+ 2.7536e-02f,  1.2620e-01f, -1.4894e-01f,
+-4.2137e-02f, -9.8700e-02f, -1.7479e-01f,
+ 4.5836e-02f,  5.3893e-02f, -1.0138e-01f,
+ 8.3609e-02f,  2.1849e-02f, -1.0648e-01f,
+ 7.4801e-02f, -1.2671e-01f, -1.5007e-02f,
+ 2.7440e-01f, -3.1351e-01f,  6.5787e-02f,
+-6.7820e-02f,  1.6312e-01f, -1.3254e-02f,
+-2.5770e-02f, -2.0041e-02f,  5.8243e-02f,
+ 1.6055e-02f,  1.1971e-02f, -4.6112e-02f,
+-1.6276e-01f, -1.5313e-02f, -7.9826e-03f,
+ 9.1668e-02f,  9.7722e-02f,  1.3754e-01f,
+-7.4817e-02f, -4.1923e-01f, -1.2337e-01f,
+ 1.3472e-01f, -4.0745e-02f, -5.4055e-02f,
+-1.2943e-02f,  4.8796e-02f,  4.2007e-02f,
+ 9.4668e-02f,  8.6149e-02f,  1.2362e-01f,
+ 7.0637e-02f,  2.3565e-01f,  1.4582e-01f,
+ 5.6904e-02f, -8.2166e-02f,  1.0563e-01f,
+ 9.3969e-02f, -2.2909e-01f,  4.6537e-02f,
+ 6.5257e-02f,  1.4804e-01f, -6.2092e-02f,
+-1.5699e-02f, -1.5303e-02f,  1.6671e-01f,
+-6.1947e-03f,  2.5749e-01f,  1.5257e-01f,
+ 3.2908e-02f, -5.9907e-02f,  1.1502e-01f,
+ 7.5876e-02f, -2.6699e-01f, -1.5891e-02f,
+-8.0426e-02f,  1.3406e-01f, -1.9881e-02f,
+ 3.5472e-02f, -8.2140e-02f,  1.6509e-02f,
+ 8.3390e-03f, -7.8291e-02f, -2.0754e-01f,
+ 3.4490e-02f,  2.7913e-01f,  5.9566e-02f,
+ 2.5288e-02f,  1.1725e-01f, -1.0356e-01f,
+-5.0955e-02f,  9.2093e-02f, -5.8477e-02f,
+ 4.4325e-02f,  3.2973e-02f, -1.9477e-01f,
+ 3.9582e-02f, -8.6877e-02f, -1.1753e-01f,
+ 3.0401e-02f, -2.8757e-02f, -2.5563e-02f,
+ 5.0741e-02f, -3.5056e-01f, -2.5584e-01f,
+ 9.1709e-02f, -4.0932e-02f,  2.3812e-01f,
+ 5.0945e-02f,  4.9246e-02f,  1.2738e-01f,
+ 5.1440e-03f,  1.5703e-01f,  5.5743e-02f,
+-3.9492e-02f,  1.2114e-01f,  2.0531e-02f,
+ 8.0800e-02f,  2.6680e-03f, -1.6660e-02f,
+ 1.0684e-01f,  1.2308e-01f,  1.7882e-02f,
+ 1.8280e-02f,  1.0972e-01f, -5.2912e-03f
+}
+,
+{
+-1.3812e-02f, -4.6271e-02f,  7.3790e-02f,
+-6.3801e-02f, -3.6817e-01f, -1.7880e-02f,
+ 5.2986e-02f,  1.8626e-01f,  1.5645e-03f,
+ 1.2367e-02f, -6.2923e-02f,  3.0844e-02f,
+ 9.3623e-02f,  1.9527e-01f, -2.6366e-02f,
+-2.0837e-02f, -3.4424e-02f,  4.0256e-02f,
+ 4.1482e-02f,  6.1795e-02f, -1.1293e-02f,
+-8.9944e-02f, -1.3608e-01f,  1.8067e-02f,
+ 3.6974e-02f,  5.2530e-03f, -2.7474e-02f,
+ 1.1872e-05f,  1.9000e-05f,  2.0729e-05f,
+ 1.0139e-05f,  1.6832e-05f,  1.9392e-05f,
+ 6.5445e-06f,  1.0973e-05f,  1.3521e-05f,
+-5.3340e-02f,  1.3108e-03f,  4.0436e-02f,
+ 5.7068e-02f, -2.7923e-02f, -5.4781e-02f,
+-2.9293e-02f,  2.7145e-02f,  2.7340e-02f,
+ 5.3520e-03f,  1.8766e-02f,  4.0297e-01f,
+ 2.6473e-02f, -3.4675e-02f, -1.1783e-01f,
+-2.5038e-02f, -1.7702e-02f, -3.4908e-02f,
+ 1.4847e-02f,  2.3237e-01f, -6.3687e-02f,
+-6.5672e-02f, -2.1888e-01f, -1.7233e-02f,
+ 4.0608e-02f, -6.9580e-02f, -2.2200e-02f,
+ 5.8163e-02f,  1.3695e-01f, -2.6257e-02f,
+-1.3328e-01f, -3.5730e-01f,  2.4507e-02f,
+-4.5611e-03f,  2.0424e-01f, -3.9821e-02f,
+ 5.5300e-02f, -1.6006e-01f,  1.1717e-01f,
+-2.6107e-02f, -8.6995e-02f,  8.3720e-02f,
+ 7.5494e-02f,  3.2189e-01f,  1.5527e-01f,
+-6.6869e-02f,  1.4469e-01f,  5.1805e-02f,
+ 9.8760e-02f, -1.6759e-01f, -1.2350e-01f,
+ 5.7005e-02f,  8.4904e-02f,  8.9713e-02f,
+-1.4263e-02f,  2.8914e-02f,  3.2239e-02f,
+-2.4871e-02f,  5.6014e-02f, -4.4469e-02f,
+ 3.1209e-02f,  1.3677e-02f, -2.1052e-02f,
+-1.6548e-03f, -1.8796e-03f, -1.9883e-03f,
+-1.6186e-03f, -1.8494e-03f, -1.9670e-03f,
+-1.5841e-03f, -1.8173e-03f, -1.9345e-03f,
+ 3.5726e-02f,  1.8013e-01f,  1.6913e-02f,
+-1.2168e-01f, -6.3848e-02f,  3.0555e-02f,
+ 3.0269e-02f, -1.0260e-01f, -1.5259e-02f,
+-4.7375e-03f,  5.5115e-02f,  6.2642e-01f,
+ 9.9776e-03f, -2.1988e-01f, -2.0984e-01f,
+ 7.0470e-03f,  6.3178e-02f, -1.3607e-02f,
+ 1.1918e-01f, -2.4081e-01f,  1.7889e-01f,
+-1.0514e-01f,  2.9220e-01f, -1.3263e-01f,
+ 5.6091e-03f, -4.1623e-02f,  2.5589e-02f,
+-1.8496e-01f,  2.7698e-02f, -6.5768e-02f,
+ 2.9677e-01f,  4.4163e-02f,  5.8530e-02f,
+-1.1010e-01f, -7.6787e-02f,  3.9844e-02f,
+ 5.2113e-03f, -1.8202e-02f,  1.4129e-03f,
+-6.1402e-03f, -2.7222e-01f,  7.4690e-02f,
+ 1.9131e-02f,  2.2753e-01f,  1.9587e-02f,
+-2.7391e-02f,  6.7917e-03f,  2.0496e-03f,
+ 6.7333e-02f,  7.8262e-02f,  2.1110e-03f,
+-5.4519e-02f,  3.0763e-02f,  1.5628e-02f,
+ 9.5055e-02f,  3.8855e-02f,  1.2446e-02f,
+-1.5152e-01f,  7.8124e-02f, -1.2616e-02f,
+ 9.3100e-03f, -1.6528e-02f, -1.2873e-02f,
+-1.8377e-03f, -1.9231e-03f, -1.8930e-03f,
+-1.8058e-03f, -1.8841e-03f, -1.8678e-03f,
+-1.7387e-03f, -1.7966e-03f, -1.7781e-03f,
+-4.5122e-02f,  1.7027e-03f, -3.5534e-03f,
+ 8.5222e-03f,  1.0130e-01f,  4.7893e-02f,
+ 6.5574e-02f,  7.2150e-03f, -2.1820e-03f,
+-5.5105e-03f, -1.8990e-01f,  2.6527e-02f,
+ 6.6140e-03f,  2.1537e-01f, -2.2183e-02f,
+-8.0628e-03f,  6.8398e-03f,  9.4474e-03f,
+ 1.2239e-01f, -1.3337e-01f,  7.3391e-02f,
+-1.2205e-01f,  1.3145e-01f, -2.0063e-02f,
+ 2.2168e-02f,  3.6097e-03f,  2.7146e-02f,
+ 4.6717e-02f,  2.1122e-02f,  1.5491e-02f,
+-1.3077e-01f,  1.1635e-01f,  1.0849e-02f,
+ 8.0113e-02f, -8.4028e-02f,  1.2863e-03f,
+-2.9796e-02f, -8.4537e-02f, -2.6766e-03f,
+-7.7771e-03f, -2.4274e-03f,  8.6274e-02f,
+-2.0354e-02f,  4.1245e-02f,  8.4227e-02f,
+ 5.5894e-02f,  1.0706e-01f,  5.2965e-02f,
+-7.8731e-03f,  5.5825e-01f,  1.0373e-01f,
+-1.1975e-01f, -2.0071e-02f, -2.5286e-02f,
+-7.7477e-02f,  5.3589e-02f, -1.5710e-03f,
+-1.2753e-01f,  2.5166e-01f,  8.2205e-03f,
+-9.8349e-02f, -4.9539e-02f, -5.4941e-02f,
+-4.9916e-03f, -4.9986e-03f, -5.0660e-03f,
+-4.9770e-03f, -4.9840e-03f, -5.0543e-03f,
+-4.9997e-03f, -5.0114e-03f, -5.0809e-03f,
+ 6.1819e-02f,  1.5061e-01f,  1.1984e-02f,
+ 1.2905e-01f,  2.5921e-01f,  1.4768e-01f,
+ 4.5548e-02f,  1.4902e-01f, -4.8961e-03f,
+-1.3605e-02f,  8.2896e-02f, -4.1931e-01f,
+-2.2657e-02f,  2.4768e-01f,  2.6528e-01f,
+-1.1566e-02f, -8.7819e-03f,  4.3618e-02f,
+-3.4332e-02f, -1.8392e-01f,  4.4471e-02f,
+-3.7073e-02f, -5.4620e-02f,  1.0899e-01f,
+ 3.7891e-02f,  9.9487e-02f,  3.2383e-02f,
+-6.3628e-02f, -5.0303e-03f,  5.4617e-02f,
+-8.7802e-02f,  2.1977e-01f, -6.0249e-03f,
+ 6.3554e-02f, -5.4291e-02f, -2.6709e-02f,
+-1.5505e-02f, -6.7104e-02f,  3.8607e-02f,
+-1.1427e-01f, -3.2524e-01f,  4.0077e-02f,
+-6.5144e-03f,  1.2313e-01f, -2.7924e-02f,
+ 1.4265e-02f, -3.8338e-02f,  8.6780e-02f,
+ 1.5341e-01f,  1.2174e-01f, -7.3160e-02f,
+ 2.6326e-04f,  7.3690e-02f,  5.2187e-02f,
+-3.3114e-02f, -3.6588e-02f,  1.1635e-02f,
+-3.3521e-02f,  1.0767e-01f, -8.9125e-03f,
+-2.2431e-02f, -4.5655e-03f,  7.5531e-03f,
+ 6.7227e-04f,  7.2856e-04f,  7.3907e-04f,
+ 6.5335e-04f,  7.0702e-04f,  7.1233e-04f,
+ 6.1540e-04f,  6.7286e-04f,  6.7797e-04f,
+-3.1496e-02f,  6.0514e-02f,  4.2013e-02f,
+-2.8617e-02f,  1.4846e-02f,  4.0016e-03f,
+ 4.7006e-03f, -4.0017e-02f, -3.0411e-02f,
+-9.6037e-03f,  8.8522e-02f,  9.8616e-02f,
+ 4.1297e-02f, -3.2645e-01f, -7.6144e-03f,
+-1.0711e-02f,  3.9324e-02f,  4.0144e-02f,
+ 5.2899e-02f, -7.8668e-02f, -5.4798e-02f,
+-2.0428e-01f,  5.7238e-02f, -3.6937e-02f,
+-3.6103e-02f, -8.2683e-02f, -2.8101e-02f,
+ 8.2479e-02f,  5.7766e-02f, -1.2019e-01f,
+-3.8373e-01f,  6.8272e-02f, -1.1758e-02f,
+ 5.1129e-02f, -2.7931e-01f,  4.5608e-02f,
+-2.5151e-02f, -5.0816e-02f,  1.7231e-02f,
+-3.6376e-02f,  1.5916e-01f,  2.9192e-02f,
+-4.1947e-02f,  5.3183e-02f, -9.7289e-02f,
+ 4.6138e-02f,  7.0842e-02f,  1.6673e-02f,
+-1.7243e-03f,  2.7203e-01f,  3.8262e-02f,
+-1.4000e-01f, -7.3793e-02f, -2.0050e-02f,
+-1.8750e-02f, -8.5319e-02f, -3.0858e-02f,
+-5.9981e-02f,  1.2729e-01f,  1.4094e-02f,
+-5.4088e-02f, -2.3694e-02f, -9.7485e-03f,
+-4.7840e-03f, -4.8359e-03f, -4.8727e-03f,
+-4.7882e-03f, -4.8380e-03f, -4.8755e-03f,
+-4.7859e-03f, -4.8321e-03f, -4.8633e-03f,
+ 4.9511e-02f,  1.0935e-01f, -3.7430e-03f,
+ 1.1834e-01f,  7.7243e-02f,  4.3074e-02f,
+ 6.7446e-02f,  2.9734e-02f, -1.1276e-02f,
+-2.0080e-02f,  1.3561e-01f, -1.3455e-01f,
+-1.4505e-02f,  2.2100e-01f,  4.9635e-02f,
+-1.0040e-02f,  3.4560e-02f, -7.4607e-03f,
+-6.8873e-02f, -5.6221e-02f,  1.2255e-02f,
+-2.9198e-02f,  7.1612e-02f,  2.9402e-02f,
+ 4.1036e-02f,  4.6417e-02f,  6.0284e-03f,
+-6.5261e-02f,  2.1426e-03f,  2.4192e-02f,
+-1.6073e-03f, -6.2222e-03f, -1.8295e-02f,
+ 2.4952e-04f, -2.0623e-02f, -3.3064e-03f,
+ 5.9188e-02f, -4.8839e-02f,  7.9840e-02f,
+-6.7952e-02f, -4.7191e-01f,  1.5117e-01f,
+ 1.5668e-01f,  2.4733e-01f,  1.1354e-01f,
+ 1.7742e-02f, -4.4059e-02f,  9.5374e-03f,
+ 3.2049e-01f, -1.3779e-01f,  9.6608e-02f,
+ 8.4580e-02f,  1.4293e-01f,  6.1574e-02f,
+ 2.8777e-03f,  7.8795e-02f, -5.1902e-02f,
+ 1.2212e-01f,  1.0321e-01f,  3.2360e-02f,
+-9.6617e-02f,  7.8941e-03f, -7.0876e-02f,
+ 3.5869e-03f,  3.5891e-03f,  3.5923e-03f,
+ 3.5746e-03f,  3.5840e-03f,  3.5967e-03f,
+ 3.5785e-03f,  3.5932e-03f,  3.6080e-03f,
+ 1.5454e-03f,  3.0582e-03f,  4.3737e-02f,
+-5.9833e-02f, -1.1247e-01f,  4.4380e-02f,
+-1.3206e-01f,  8.2778e-03f,  4.7963e-02f,
+-4.3720e-02f, -7.5722e-03f,  2.0510e-01f,
+ 3.0133e-02f, -4.0506e-01f,  2.7867e-01f,
+ 5.5586e-02f,  2.8926e-02f,  1.3360e-03f,
+ 1.9490e-05f,  3.3326e-01f, -7.7241e-02f,
+-1.5648e-01f,  1.5195e-01f, -1.3995e-01f,
+ 8.6519e-02f,  1.0447e-01f, -4.1413e-02f,
+-3.8667e-03f,  1.6159e-01f,  1.1627e-01f,
+-2.2646e-01f, -3.4758e-02f, -6.7956e-03f,
+-3.2689e-01f,  1.9606e-01f, -9.1523e-02f,
+ 1.1238e-02f,  1.5084e-03f,  4.2113e-02f,
+-1.1154e-02f, -3.6596e-01f, -7.2252e-02f,
+ 6.6621e-02f,  1.0188e-01f,  4.1032e-01f,
+ 3.5892e-02f, -4.8304e-02f,  6.6142e-03f,
+ 1.3374e-01f,  2.2720e-01f, -7.1224e-02f,
+ 6.8952e-02f,  2.0467e-01f,  5.0251e-02f,
+-6.2016e-02f,  2.2175e-01f, -1.7764e-02f,
+ 2.7542e-02f,  1.4905e-01f,  3.6637e-02f,
+-7.2231e-02f,  5.0271e-03f, -7.1823e-02f,
+ 3.5760e-03f,  3.5540e-03f,  3.5692e-03f,
+ 3.5664e-03f,  3.5490e-03f,  3.5689e-03f,
+ 3.5671e-03f,  3.5619e-03f,  3.5864e-03f,
+ 2.7470e-02f, -3.9752e-02f,  4.1063e-02f,
+-2.4985e-02f, -1.7969e-01f,  8.2186e-02f,
+-5.4251e-02f, -5.9651e-03f,  2.5079e-02f,
+-2.1197e-02f,  2.5426e-02f,  1.3585e-01f,
+-1.3460e-02f, -1.1377e-01f,  1.2278e-01f,
+ 3.6533e-02f,  1.2843e-02f,  5.6219e-02f,
+ 5.8141e-04f,  2.8354e-01f, -6.2016e-02f,
+-1.0289e-01f,  1.8724e-01f, -9.9475e-02f,
+ 5.1193e-02f,  7.5986e-02f, -1.2951e-03f,
+-8.2587e-02f,  1.8498e-01f,  1.0891e-01f,
+ 1.3538e-01f, -4.7728e-01f,  1.0868e-01f,
+-8.6415e-02f, -1.7061e-01f,  1.0457e-02f
+}
+};
+__device__ __constant__ static const float biasL[8][8] =
+{
+{
+-0.1175f, -0.0258f, -0.0053f, -0.0437f, -0.0563f, -0.1047f, -0.3449f,  0.0568f
+}
+,
+{
+ 0.0339f, -0.1738f,  0.0061f,  0.1565f, -0.0316f, -0.0016f, -0.0032f, -0.0554f
+}
+,
+{
+-0.0508f, -0.0609f,  0.0347f, -0.0802f, -0.0438f,  0.2512f, -0.0491f, -0.0259f
+}
+,
+{
+ 0.0655f,  0.0255f,  0.0228f, -0.0027f, -0.0155f, -0.0163f, -0.0174f, -0.1095f
+}
+,
+{
+ 4.9947e-03f,  5.3372e-03f, -4.5286e-09f, -1.3756e-03f,  3.8858e-03f, -4.4197e-02f,  3.3970e-02f,  2.8411e-02f
+}
+,
+{
+-0.0396f,  0.0007f,  0.1735f,  0.0109f,  0.1177f,  0.0919f,  0.0567f, -0.0005f
+}
+,
+{
+ 0.0127f, -0.0688f,  0.1102f, -0.0052f,  0.1602f, -0.0191f, -0.0322f,  0.0311f
+}
+,
+{
+ 0.0063f, 0.0093f, 0.0729f, 0.3734f, 0.0006f, 0.1915f, 0.3186f, 0.2636f
+}
+};
+__device__ __constant__ static const float kernelsL10[4 * 8] =
+{
+-0.0967f, -0.3094f,
+ 0.3537f,  0.5705f,
+ 0.2547f,  0.3360f,
+-0.0718f, -0.0700f,
+-0.3013f, -0.1602f,
+ 0.4520f,  0.0495f,
+ 0.1564f,  0.3773f,
+-0.0216f,  0.4367f,
+-0.4855f, -0.1972f,
+-0.2026f, -0.4390f,
+ 0.3743f, -0.1156f,
+ 0.4408f, -0.3123f,
+-0.3577f,  0.0753f,
+-0.3396f,  0.0336f,
+ 0.1052f, -0.4180f,
+ 0.0799f, -0.3587f
+};
+
+#include "ACNetCommon.cuh"
+
+DECLARE_ACNET_HDN_INTERFACE_FUNCTION(3)

cuda_code/Activation_27.cu

@@ -0,0 +1,587 @@
+#define _USE_MATH_DEFINES
+
+#include <ATen/native/Activation.h>
+
+#include <cmath>
+
+#include <thrust/tuple.h>
+
+#include <ATen/ATen.h>
+#include <ATen/AccumulateType.h>
+#include <ATen/Dispatch.h>
+#include <ATen/NativeFunctions.h>
+#include <ATen/core/Array.h>
+#include <ATen/cuda/CUDAApplyUtils.cuh>
+#include <ATen/cuda/detail/IndexUtils.cuh>
+#include <ATen/cuda/detail/OffsetCalculator.cuh>
+#include <ATen/native/cuda/Loops.cuh>
+#include <c10/cuda/CUDAMathCompat.h>
+
+namespace at {
+namespace native {
+
+// -----------------------------------
+// prelu forward
+// -----------------------------------
+template <typename scalar_t>
+void prelu_cuda_kernel_share_weights(
+  const Tensor& input,
+  Tensor& result,
+  const scalar_t* weight_data)
+{
+  auto iter = TensorIterator::unary_op(result, input);
+
+  at::native::gpu_kernel(iter,
+    [weight_data] GPU_LAMBDA (scalar_t input_val) {
+        return (input_val > 0) ? input_val : *weight_data * input_val;
+    });
+}
+
+template <typename scalar_t>
+__global__ void prelu_cuda_kernel_multi_weights(
+  scalar_t* result_data,
+  const scalar_t* input_data,
+  const scalar_t* weight_data,
+  int64_t input_stride0,
+  int64_t input_stride1,
+  int64_t input_numel) {
+
+  int64_t linearId = blockIdx.x * blockDim.x + threadIdx.x;
+  if (linearId >= input_numel) return;
+
+  // multiply values at each channel with weight[channel_index]
+  int64_t channel = (linearId % input_stride0) / input_stride1;
+  scalar_t input_data_val = input_data[linearId];
+  result_data[linearId] = (input_data_val > 0) ? input_data_val : weight_data[channel] * input_data_val;
+}
+
+Tensor prelu_cuda(const Tensor& self, const Tensor& weight_) {
+  TORCH_CHECK(self.is_cuda());
+  TORCH_CHECK(weight_.is_cuda());
+
+  auto input = self.contiguous();
+  auto weight = weight_.contiguous();
+
+  TORCH_CHECK(input.is_contiguous());
+  TORCH_CHECK(weight.is_contiguous());
+
+  int64_t weight_num = weight.numel();
+  Tensor result = at::empty_like(input, LEGACY_CONTIGUOUS_MEMORY_FORMAT);
+  auto strides = input.strides();
+
+  // case1: shared weight for all channels
+  if (weight_num == 1) {
+    AT_DISPATCH_FLOATING_TYPES_AND(at::ScalarType::Half, input.scalar_type(), "prelu_cuda", [&] {
+      prelu_cuda_kernel_share_weights<scalar_t>(
+        input,
+        result,
+        weight.data_ptr<scalar_t>());
+    });
+  }
+  else { // case2: multiple weights, one for each channel
+    int64_t input_ndim = input.dim();
+    TORCH_CHECK(input_ndim > 0, "Not allow zero-dim input tensor.");
+
+    int64_t channel_size = 1; // channel_size default to 1
+    int64_t input_stride0 = 1, input_stride1 = 1;
+
+    if (input_ndim > 1) {
+      channel_size = input.size(1); // channel is the 2nd dim of input
+      input_stride0 = strides[0];
+      input_stride1 = strides[1];
+    }
+    TORCH_CHECK(channel_size == weight_num,
+      "Mismatch of parameter numbers and input channel size. Found parameter numbers = ", weight_num,
+      " and channel size = ", channel_size, ".");
+
+    // config to run cuda kernel
+    int64_t input_numel = input.numel();
+    const dim3 block = dim3(std::min(static_cast<int64_t>(cuda::getApplyBlock().x), input_numel));
+    dim3 grid;
+    int curDevice = -1;
+    cudaGetDevice(&curDevice);
+    cudaStream_t stream = at::cuda::getCurrentCUDAStream(curDevice);
+    TORCH_CHECK(cuda::getApplyGrid(input_numel, grid, curDevice), "prelu: input too large or too many dimensions");
+
+    AT_DISPATCH_FLOATING_TYPES_AND(at::ScalarType::Half, input.scalar_type(), "prelu_cuda", [&] {
+      prelu_cuda_kernel_multi_weights<scalar_t>
+      <<<grid, block, 0, stream>>>(
+        result.data_ptr<scalar_t>(),
+        input.data_ptr<scalar_t>(),
+        weight.data_ptr<scalar_t>(),
+        input_stride0,
+        input_stride1,
+        input_numel);
+      C10_CUDA_KERNEL_LAUNCH_CHECK();
+    });
+  }
+  return result;
+}
+
+// -----------------------------------
+// prelu backward
+// -----------------------------------
+template <typename scalar_t>
+void prelu_cuda_backward_kernel_share_weights(
+  const Tensor& input,
+  const Tensor& grad_out,
+  Tensor& input_grad,
+  Tensor& weight_grad_collector,
+  const scalar_t* weight_data) {
+  at::TensorIterator iter = TensorIteratorConfig()
+      .add_borrowed_output(input_grad)
+      .add_borrowed_output(weight_grad_collector)
+      .add_borrowed_input(input)
+      .add_borrowed_input(grad_out)
+      .build();
+
+  // N.B. `std::tuple` does not support `::operator=` on device code.
+  gpu_kernel_multiple_outputs(iter, [=] GPU_LAMBDA (scalar_t input, scalar_t grad_out) -> thrust::tuple<scalar_t, scalar_t> {
+    scalar_t input_grad = input > 0 ? grad_out : (*weight_data) * grad_out;
+    scalar_t weight_grad_collector = input > 0 ? scalar_t(0) : input * grad_out;
+    return {input_grad, weight_grad_collector};
+  });
+}
+
+template <typename scalar_t>
+__global__ void prelu_cuda_backward_kernel_multi_weights(
+  const scalar_t* input_data,
+  const scalar_t* weight_data,
+  const scalar_t* grad_out_data,
+  scalar_t* input_grad_data,
+  scalar_t* weight_grad_collector,
+  int64_t input_stride0,
+  int64_t input_stride1,
+  int64_t input_numel) {
+
+  int64_t linearId = blockIdx.x * blockDim.x + threadIdx.x;
+  if (linearId >= input_numel) return;
+  int64_t channel = (linearId % input_stride0) / input_stride1;
+  scalar_t input_data_val = input_data[linearId];
+  scalar_t grad_out_data_val = grad_out_data[linearId];
+  input_grad_data[linearId] = (input_data_val > 0) ? grad_out_data_val : weight_data[channel] * grad_out_data_val;
+  weight_grad_collector[linearId] = (input_data_val > 0) ? scalar_t(0) : input_data_val * grad_out_data_val;
+}
+
+std::tuple<Tensor, Tensor> prelu_backward_cuda(const Tensor& grad_out_, const Tensor& self, const Tensor& weight_) {
+  TORCH_CHECK(grad_out_.is_cuda());
+  TORCH_CHECK(self.is_cuda());
+  TORCH_CHECK(weight_.is_cuda());
+
+  auto input = self.contiguous();
+  auto grad_out = grad_out_.contiguous();
+  auto weight = weight_.contiguous();
+
+  TORCH_CHECK(input.is_contiguous());
+  TORCH_CHECK(weight.is_contiguous());
+  TORCH_CHECK(grad_out.is_contiguous());
+
+  int64_t weight_num = weight.numel();
+  auto strides = input.strides();
+  auto dims = input.dim();
+  Tensor input_grad = at::empty_like(input, LEGACY_CONTIGUOUS_MEMORY_FORMAT);
+  Tensor weight_grad = at::empty_like(weight, LEGACY_CONTIGUOUS_MEMORY_FORMAT);
+  Tensor weight_grad_collector = at::empty_like(input, LEGACY_CONTIGUOUS_MEMORY_FORMAT);
+  // case1: shared parameter for all channels
+  if (weight_num == 1) {
+    AT_DISPATCH_FLOATING_TYPES_AND(at::ScalarType::Half, input.scalar_type(), "prelu_backward_cuda", [&] {
+      prelu_cuda_backward_kernel_share_weights<scalar_t>(
+        input,
+        grad_out,
+        input_grad,
+        weight_grad_collector,
+        weight.data_ptr<scalar_t>());
+    });
+    weight_grad.fill_(weight_grad_collector.sum());
+  }
+  else { // case2: multiple parameters, one for each channel
+    int64_t input_ndim = input.dim();
+    TORCH_CHECK(input_ndim > 0, "Not allow zero-dim input tensor.");
+
+    int64_t channel_size = 1; // channel_size default to 1
+    int64_t input_stride0 = 1, input_stride1 = 1;
+
+    if (input_ndim > 1) {
+      channel_size = input.size(1); // channel is the 2nd dim of input
+      input_stride0 = strides[0];
+      input_stride1 = strides[1];
+    }
+    TORCH_CHECK(channel_size == weight_num,
+      "Mismatch of parameter numbers and input channel size. Found parameter numbers = ", weight_num,
+      " and channel size = ", channel_size, ".");
+
+    // config to run cuda kernel
+    int64_t input_numel = input.numel();
+    const dim3 block = dim3(std::min(static_cast<int64_t>(cuda::getApplyBlock().x), input_numel));
+    dim3 grid;
+    int curDevice = -1;
+    cudaGetDevice(&curDevice);
+    cudaStream_t stream = at::cuda::getCurrentCUDAStream(curDevice);
+    TORCH_CHECK(cuda::getApplyGrid(input_numel, grid, curDevice), "prelu_backward_cuda: input too large or too many dimensions");
+
+    AT_DISPATCH_FLOATING_TYPES_AND(at::ScalarType::Half, input.scalar_type(), "prelu_backward_cuda", [&] {
+      prelu_cuda_backward_kernel_multi_weights<scalar_t>
+      <<<grid, block, 0, stream>>>(
+        input.data_ptr<scalar_t>(),
+        weight.data_ptr<scalar_t>(),
+        grad_out.data_ptr<scalar_t>(),
+        input_grad.data_ptr<scalar_t>(),
+        weight_grad_collector.data_ptr<scalar_t>(),
+        input_stride0,
+        input_stride1,
+        input_numel);
+      C10_CUDA_KERNEL_LAUNCH_CHECK();
+    });
+    // update weight_grad
+    std::vector<int64_t> reduce_dims;
+    reduce_dims.push_back(0);
+    if (dims > 2) {
+      for(int64_t i = 2; i < dims; i++) reduce_dims.push_back(i);
+    }
+    weight_grad = weight_grad_collector.sum(reduce_dims);
+  }
+  return std::tuple<Tensor, Tensor>{input_grad, weight_grad};
+}
+
+// -----------------------------------
+// hardshrink
+// -----------------------------------
+void hardshrink_kernel(TensorIterator& iter, const Scalar& value) {
+  AT_DISPATCH_FLOATING_TYPES_AND2(at::ScalarType::Half, at::ScalarType::BFloat16, iter.dtype(), "hardshrink_cuda", [&]() {
+    auto lambd = value.to<scalar_t>();
+    gpu_kernel(iter, [lambd]GPU_LAMBDA(scalar_t a) -> scalar_t {
+      return (a >= -lambd && a <= lambd) ? scalar_t(0) : a;
+    });
+  });
+}
+
+void softshrink_kernel(TensorIteratorBase& iter, const Scalar& value) {
+  AT_DISPATCH_FLOATING_TYPES_AND2(at::ScalarType::Half, at::ScalarType::BFloat16, iter.dtype(), "softshrink_cuda", [&]() {
+    auto lambd = value.to<scalar_t>();
+    gpu_kernel(iter, [lambd]GPU_LAMBDA(scalar_t a) -> scalar_t {
+      return a > lambd ? a - lambd : (a < -lambd ? a + lambd : scalar_t(0));
+    });
+  });
+}
+
+void shrink_backward_kernel(TensorIterator& iter, const Scalar& value) {
+  AT_DISPATCH_FLOATING_TYPES_AND2(at::ScalarType::Half, at::ScalarType::BFloat16, iter.dtype(), "shrink_backward_cuda", [&]() {
+    auto lambd = value.to<scalar_t>();
+    gpu_kernel(iter, [lambd]GPU_LAMBDA(scalar_t grad_val, scalar_t self_val) -> scalar_t {
+      return (self_val >= -lambd && self_val <= lambd) ? scalar_t(0) : grad_val;
+    });
+  });
+}
+
+void hardtanh_backward_kernel(TensorIterator& iter, const Scalar& min, const Scalar& max) {
+  AT_DISPATCH_FLOATING_TYPES_AND(at::ScalarType::Half, iter.dtype(), "hardtanh_backward_cuda", [&]() {
+    auto min_val = min.to<scalar_t>();
+    auto max_val = max.to<scalar_t>();
+    gpu_kernel(iter, [min_val, max_val]GPU_LAMBDA(scalar_t a, scalar_t b) -> scalar_t {
+      return (b <= min_val) || (b >= max_val) ? scalar_t(0) : a;
+    });
+  });
+}
+
+void softplus_kernel(TensorIteratorBase& iter, const Scalar& beta_, const Scalar& threshold_) {
+  AT_DISPATCH_FLOATING_TYPES_AND2(at::ScalarType::Half, at::ScalarType::BFloat16, iter.dtype(), "softplus_cuda", [&]() {
+    auto beta = beta_.to<scalar_t>();
+    auto threshold = threshold_.to<scalar_t>();
+    gpu_kernel(iter, [beta, threshold]GPU_LAMBDA(scalar_t a) -> scalar_t {
+      return (a * beta) > threshold ? a : static_cast<scalar_t>(::log1p(std::exp(a * beta))) / beta;
+    });
+  });
+}
+
+void softplus_backward_kernel(TensorIteratorBase& iter, const Scalar& beta_, const Scalar& threshold_) {
+  AT_DISPATCH_FLOATING_TYPES_AND2(at::ScalarType::Half, at::ScalarType::BFloat16, iter.dtype(), "softplus_backward_cuda", [&]() {
+    auto beta = beta_.to<scalar_t>();
+    auto threshold = threshold_.to<scalar_t>();
+    gpu_kernel(iter, [beta, threshold]GPU_LAMBDA(scalar_t a, scalar_t b) -> scalar_t {
+      scalar_t z = std::exp(b * beta);
+      return (b * beta) > threshold ? a : a * z / (z + scalar_t(1.));
+    });
+  });
+}
+
+template <typename scalar_t>
+void threshold_kernel_impl(TensorIteratorBase& iter, scalar_t threshold, scalar_t value) {
+  gpu_kernel_with_scalars(iter, [=]GPU_LAMBDA(scalar_t x, scalar_t other) -> scalar_t {
+    return x <= threshold ? value : other;
+  });
+}
+
+static void threshold_kernel_cuda(TensorIteratorBase& iter, const Scalar& threshold, const Scalar& value) {
+  AT_DISPATCH_ALL_TYPES_AND2(at::ScalarType::Half, at::ScalarType::BFloat16, iter.dtype(), "threshold_cuda", [&] {
+    threshold_kernel_impl<scalar_t>(iter, threshold.to<scalar_t>(), value.to<scalar_t>());
+  });
+}
+
+void elu_kernel(TensorIteratorBase& iter, const Scalar& alpha, const Scalar& scale, const Scalar& input_scale) {
+  AT_DISPATCH_FLOATING_TYPES_AND2(at::ScalarType::Half, at::ScalarType::BFloat16, iter.dtype(), "elu_cuda", [&]() {
+    auto negcoef = alpha.to<scalar_t>() * scale.to<scalar_t>();
+    auto poscoef = scale.to<scalar_t>();
+    auto negiptcoef = input_scale.to<scalar_t>();
+    gpu_kernel(iter, [negcoef, poscoef, negiptcoef]GPU_LAMBDA(scalar_t a) -> scalar_t {
+      return a > scalar_t(0) ? a * poscoef : (static_cast<scalar_t>(std::exp(a * negiptcoef)) - scalar_t(1.)) * negcoef;
+    });
+  });
+}
+
+void elu_backward_kernel(TensorIteratorBase& iter, const Scalar& alpha, const Scalar& scale, const Scalar& input_scale, bool is_result) {
+  AT_DISPATCH_FLOATING_TYPES_AND2(at::ScalarType::Half, at::ScalarType::BFloat16, iter.dtype(), "elu_backward_cuda", [&]() {
+    auto negcoef = alpha.to<scalar_t>() * scale.to<scalar_t>();
+    auto poscoef = scale.to<scalar_t>();
+    auto negiptcoef = input_scale.to<scalar_t>();
+    gpu_kernel(iter, [negcoef, poscoef, negiptcoef, is_result]GPU_LAMBDA(scalar_t a, scalar_t b) -> scalar_t {
+      if (is_result) {
+        return b <= scalar_t(0) ? a * negiptcoef * (b + negcoef) : a * poscoef;
+      } else {
+        return b <= scalar_t(0) ? a * negiptcoef * negcoef * (static_cast<scalar_t>(std::exp(b * negiptcoef))) : a * poscoef;
+      }
+    });
+  });
+}
+
+namespace {
+
+void GeluCUDAKernelImpl(TensorIterator& it) {
+  AT_DISPATCH_FLOATING_TYPES_AND2(at::ScalarType::Half, at::ScalarType::BFloat16, it.dtype(), "GeluCUDAKernelImpl", [&]() {
+    using T_ACC = acc_type<scalar_t, true>;
+    gpu_kernel(it, [] GPU_LAMBDA(scalar_t x) -> scalar_t {
+      return static_cast<T_ACC>(x) *
+          c10::cuda::compat::normcdf(static_cast<T_ACC>(x));
+    });
+  });
+}
+
+void GeluBackwardCUDAKernelImpl(TensorIterator& it) {
+  AT_DISPATCH_FLOATING_TYPES_AND2(at::ScalarType::Half, at::ScalarType::BFloat16,
+      it.dtype(), "GeluBackwardCUDAKernelImpl", [&]() {
+        using T_ACC = acc_type<scalar_t, true>;
+        gpu_kernel(it, [] GPU_LAMBDA(scalar_t dy, scalar_t x) -> scalar_t {
+          constexpr T_ACC kBeta = M_2_SQRTPI * M_SQRT1_2 * T_ACC(0.5);
+          const T_ACC cdf = c10::cuda::compat::normcdf(static_cast<T_ACC>(x));
+          const T_ACC pdf =
+              c10::cuda::compat::exp(
+                  T_ACC(-0.5) * static_cast<T_ACC>(x) * static_cast<T_ACC>(x)) *
+              kBeta;
+          return static_cast<T_ACC>(dy) * (cdf + static_cast<T_ACC>(x) * pdf);
+        });
+      });
+}
+
+void leaky_relu_kernel(TensorIteratorBase& iter, const Scalar& negval_) {
+  AT_DISPATCH_FLOATING_TYPES_AND2(at::ScalarType::Half, at::ScalarType::BFloat16, iter.dtype(), "leaky_relu_cuda", [&]() {
+    auto negval = negval_.to<scalar_t>();
+    gpu_kernel(iter, [negval]GPU_LAMBDA(scalar_t a) -> scalar_t {
+      return a > scalar_t(0) ? a : a * negval;
+    });
+  });
+}
+
+void leaky_relu_backward_kernel(TensorIteratorBase& iter, const Scalar& negval_) {
+  AT_DISPATCH_FLOATING_TYPES_AND2(at::ScalarType::Half, at::ScalarType::BFloat16, iter.dtype(), "leaky_relu_backward_cuda", [&]() {
+    auto negval = negval_.to<scalar_t>();
+    gpu_kernel(iter, [negval]GPU_LAMBDA(scalar_t a, scalar_t b) -> scalar_t {
+      return a > scalar_t(0) ? b : b * negval;
+    });
+  });
+}
+
+void hardswish_kernel(TensorIterator& iter) {
+  AT_DISPATCH_FLOATING_TYPES_AND2(at::ScalarType::Half, at::ScalarType::BFloat16, iter.dtype(), "hardswish_cuda", [&]() {
+    using T_ACC = acc_type<scalar_t, true>;
+    const T_ACC zero(0.0f);
+    const T_ACC one_sixth(1.0f / 6.0f);
+    const T_ACC three(3.0f);
+    const T_ACC six(6.0f);
+    gpu_kernel(iter, [zero, one_sixth, three, six]GPU_LAMBDA(scalar_t self_val) -> scalar_t {
+      T_ACC x = static_cast<T_ACC>(self_val);
+      return x * std::min(std::max(x + three, zero), six) * one_sixth;
+    });
+  });
+}
+
+void hardswish_backward_kernel(TensorIterator& iter) {
+  AT_DISPATCH_FLOATING_TYPES_AND2(at::ScalarType::Half, at::ScalarType::BFloat16, iter.dtype(), "hardswish_backward_cuda", [&]() {
+    using T_ACC = acc_type<scalar_t, true>;
+    const T_ACC zero(0.0f);
+    const T_ACC three(3.0f);
+    const T_ACC neg_three(-3.0f);
+    const T_ACC one_half(0.5f);
+    gpu_kernel(
+      iter,
+      [zero, three, neg_three, one_half]GPU_LAMBDA(scalar_t grad_val_, scalar_t self_val_) -> scalar_t {
+        T_ACC grad_val = static_cast<T_ACC>(grad_val_);
+        T_ACC self_val = static_cast<T_ACC>(self_val_);
+        if (self_val < neg_three) {
+          return zero;
+        } else if (self_val <= three) {
+          return grad_val * ((self_val / three) + one_half);
+        } else {
+          return grad_val;
+        }
+    });
+  });
+}
+
+void hardsigmoid_kernel(TensorIteratorBase& iter) {
+  AT_DISPATCH_FLOATING_TYPES_AND2(at::ScalarType::Half, at::ScalarType::BFloat16, iter.dtype(), "hardsigmoid_cuda", [&]() {
+    using T_ACC = acc_type<scalar_t, true>;
+    const T_ACC zero(0.0f);
+    const T_ACC one_sixth(1.0f / 6.0f);
+    const T_ACC three(3.0f);
+    const T_ACC six(6.0f);
+    gpu_kernel(iter, [zero, one_sixth, three, six]GPU_LAMBDA(scalar_t self_val) -> scalar_t {
+      T_ACC x = static_cast<T_ACC>(self_val);
+      return std::min(std::max(x + three, zero), six) * one_sixth;
+    });
+  });
+}
+
+void hardsigmoid_backward_kernel(TensorIteratorBase& iter) {
+  AT_DISPATCH_FLOATING_TYPES_AND2(at::ScalarType::Half, at::ScalarType::BFloat16, iter.dtype(), "hardsigmoid_backward_cuda", [&]() {
+    using T_ACC = acc_type<scalar_t, true>;
+    const T_ACC zero(0.0f);
+    const T_ACC three(3.0f);
+    const T_ACC neg_three(-3.0f);
+    const T_ACC one_sixth(1.0f / 6.0f);
+    gpu_kernel(
+      iter,
+      [zero, three, neg_three, one_sixth]GPU_LAMBDA(scalar_t grad_val_, scalar_t self_val_) -> scalar_t {
+        T_ACC grad_val = static_cast<T_ACC>(grad_val_);
+        T_ACC self_val = static_cast<T_ACC>(self_val_);
+        return (self_val > neg_three && self_val < three)
+          ? grad_val * one_sixth
+          : zero;
+    });
+  });
+}
+
+void silu_kernel(TensorIteratorBase& iter) {
+  AT_DISPATCH_FLOATING_TYPES_AND2(
+      at::ScalarType::Half,
+      at::ScalarType::BFloat16,
+      iter.dtype(),
+      "silu_cuda",
+      [&]() {
+        gpu_kernel(
+            iter,
+            [] GPU_LAMBDA(scalar_t x) -> scalar_t {
+              using T_ACC = acc_type<scalar_t, true>;
+              const T_ACC x_acc = static_cast<T_ACC>(x);
+              return x_acc / (T_ACC(1) + c10::cuda::compat::exp(-x_acc));
+            });
+      });
+}
+
+void silu_backward_kernel(TensorIterator& iter) {
+  AT_DISPATCH_FLOATING_TYPES_AND2(
+      at::ScalarType::Half,
+      at::ScalarType::BFloat16,
+      iter.dtype(),
+      "silu_backward_cuda",
+      [&]() {
+        gpu_kernel(
+            iter,
+            [] GPU_LAMBDA(scalar_t dy, scalar_t x) -> scalar_t {
+              using T_ACC = acc_type<scalar_t, true>;
+              const T_ACC dy_acc = static_cast<T_ACC>(dy);
+              const T_ACC x_acc = static_cast<T_ACC>(x);
+              const T_ACC s_acc =
+                  T_ACC(1) / (T_ACC(1) + c10::cuda::compat::exp(-x_acc));
+              return dy_acc * s_acc * (T_ACC(1) + x_acc * (T_ACC(1) - s_acc));
+            });
+      });
+}
+
+void mish_kernel(TensorIteratorBase& iter) {
+  AT_DISPATCH_FLOATING_TYPES_AND2(
+      at::ScalarType::Half,
+      at::ScalarType::BFloat16,
+      iter.dtype(),
+      "mish_cuda",
+      [&]() {
+        gpu_kernel(
+            iter,
+            [] GPU_LAMBDA(scalar_t x) -> scalar_t {
+          using T_ACC = acc_type<scalar_t, true>;
+          const T_ACC x_acc = static_cast<T_ACC>(x);
+          return x_acc * c10::cuda::compat::tanh(c10::cuda::compat::log1p(c10::cuda::compat::exp(x_acc)));
+      });
+      });
+}
+
+void mish_backward_kernel(TensorIterator& iter) {
+  AT_DISPATCH_FLOATING_TYPES_AND2(
+      at::ScalarType::Half,
+      at::ScalarType::BFloat16,
+      iter.dtype(),
+      "mish_backward_cuda",
+      [&]() {
+        gpu_kernel(
+            iter,
+            [] GPU_LAMBDA(scalar_t dy, scalar_t x) -> scalar_t {
+          using T_ACC = acc_type<scalar_t, true>;
+          const T_ACC dy_acc = static_cast<T_ACC>(dy);
+          const T_ACC x_acc = static_cast<T_ACC>(x);
+          const T_ACC s_acc =
+              T_ACC(1) / (T_ACC(1) + c10::cuda::compat::exp(-x_acc));
+          const T_ACC t_acc =
+              c10::cuda::compat::tanh(c10::cuda::compat::log1p(c10::cuda::compat::exp(x_acc)));
+          return dy_acc * (t_acc + x_acc * s_acc * (T_ACC(1) - t_acc * t_acc));
+      });
+      });
+}
+
+} // namespace
+
+Tensor gelu_cuda(const Tensor& self) {
+  Tensor Y = at::native::empty_like(
+      self,
+      c10::nullopt /* dtype */,
+      c10::nullopt /* layout */,
+      c10::nullopt /* device */,
+      c10::nullopt /* pin_memory */,
+      LEGACY_CONTIGUOUS_MEMORY_FORMAT);
+  auto it = TensorIterator::unary_op(Y, self);
+  GeluCUDAKernelImpl(it);
+  return Y;
+}
+
+Tensor gelu_backward_cuda(const Tensor& grad, const Tensor& self) {
+  Tensor dX = at::native::empty_like(
+      self,
+      c10::nullopt /* dtype */,
+      c10::nullopt /* layout */,
+      c10::nullopt /* device */,
+      c10::nullopt /* pin_memory */,
+      LEGACY_CONTIGUOUS_MEMORY_FORMAT);
+  auto it = TensorIterator::borrowing_binary_op(dX, grad, self);
+  GeluBackwardCUDAKernelImpl(it);
+  return dX;
+}
+
+REGISTER_DISPATCH(hardtanh_backward_stub, &hardtanh_backward_kernel);
+REGISTER_DISPATCH(hardshrink_stub, &hardshrink_kernel);
+REGISTER_DISPATCH(softshrink_stub, &softshrink_kernel);
+REGISTER_DISPATCH(shrink_backward_stub, &shrink_backward_kernel);
+REGISTER_DISPATCH(elu_stub, &elu_kernel);
+REGISTER_DISPATCH(elu_backward_stub, &elu_backward_kernel);
+REGISTER_DISPATCH(leaky_relu_stub, &leaky_relu_kernel);
+REGISTER_DISPATCH(leaky_relu_backward_stub, &leaky_relu_backward_kernel);
+REGISTER_DISPATCH(hardswish_stub, &hardswish_kernel);
+REGISTER_DISPATCH(hardswish_backward_stub, &hardswish_backward_kernel);
+REGISTER_DISPATCH(hardsigmoid_stub, &hardsigmoid_kernel);
+REGISTER_DISPATCH(hardsigmoid_backward_stub, &hardsigmoid_backward_kernel);
+REGISTER_DISPATCH(softplus_stub, &softplus_kernel);
+REGISTER_DISPATCH(softplus_backward_stub, &softplus_backward_kernel);
+REGISTER_DISPATCH(silu_stub, &silu_kernel);
+REGISTER_DISPATCH(silu_backward_stub, &silu_backward_kernel);
+REGISTER_DISPATCH(mish_stub, &mish_kernel);
+REGISTER_DISPATCH(mish_backward_stub, &mish_backward_kernel);
+REGISTER_DISPATCH(threshold_stub, &threshold_kernel_cuda);
+
+} // namespace native
+} // namespace at

cuda_code/AimetOpUtilsGpu_4.cu

@@ -0,0 +1,76 @@
+//==============================================================================
+//
+//  @@-COPYRIGHT-START-@@
+//
+//  Copyright (c) 2020, Qualcomm Innovation Center, Inc. All rights reserved.
+//
+//  Redistribution and use in source and binary forms, with or without
+//  modification, are permitted provided that the following conditions are met:
+//
+//  1. Redistributions of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//  2. Redistributions in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//  3. Neither the name of the copyright holder nor the names of its contributors
+//     may be used to endorse or promote products derived from this software
+//     without specific prior written permission.
+//
+//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+//  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+//  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+//  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+//  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+//  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+//  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+//  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+//  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+//  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+//  POSSIBILITY OF SUCH DAMAGE.
+//
+//  SPDX-License-Identifier: BSD-3-Clause
+//
+//  @@-COPYRIGHT-END-@@
+//
+//==============================================================================
+
+#ifdef GOOGLE_CUDA
+
+#define EIGEN_USE_GPU
+#define EIGEN_USE_THREADS
+
+#include "AimetOpUtils.h"
+
+using namespace tensorflow;
+
+#define EIGEN_USE_GPU
+typedef Eigen::GpuDevice GPUDevice;
+
+
+// GPU specialization of actual computations.
+template <typename T>
+void copyInputTensorsToOutputTensors(const GPUDevice& d, const T* inTensor, size_t count, T* outTensor)
+{
+    // copy input_tensor to output_tensor
+    cudaMemcpy(outTensor, inTensor, count * sizeof(float), cudaMemcpyDeviceToDevice);
+}
+
+template <typename T>
+T copyLiteralToHost(const GPUDevice& d, const T* deviceValue)
+{
+    T hostValue;
+    cudaMemcpy(&hostValue, deviceValue, sizeof(T), cudaMemcpyDeviceToHost);
+
+    return hostValue;
+}
+
+template void copyInputTensorsToOutputTensors(const GPUDevice& d, const float* inTensor, size_t count, float* outTensor);
+template int8 copyLiteralToHost<int8>(const GPUDevice&, const int8* deviceValue);
+template int32 copyLiteralToHost<int32>(const GPUDevice&, const int32* deviceValue);
+template uint64 copyLiteralToHost<uint64>(const GPUDevice&, const uint64* deviceValue);
+template double copyLiteralToHost<double>(const GPUDevice&, const double* deviceValue);
+template bool copyLiteralToHost<bool>(const GPUDevice&, const bool* deviceValue);
+
+#endif   // GOOGLE_CUDA

cuda_code/ArrayManip_1.cu

@@ -0,0 +1,70 @@
+#include "AbstractAPI.h"
+#include "interfaces/cuda/Internals.h"
+#include <cassert>
+#include <device.h>
+
+namespace device {
+template <typename T> __global__ void kernel_scaleArray(T *array, const T scalar, const size_t numElements) {
+  size_t index = threadIdx.x + blockIdx.x * blockDim.x;
+  if (index < numElements) {
+    array[index] *= scalar;
+  }
+}
+
+template <typename T> void Algorithms::scaleArray(T *devArray,
+                                                  T scalar,
+                                                  const size_t numElements,
+                                                  void* streamPtr) {
+  dim3 block(64, 1, 1);
+  dim3 grid = internals::computeGrid1D(block, numElements);
+  auto stream = reinterpret_cast<internals::deviceStreamT>(streamPtr);
+  kernel_scaleArray<<<grid, block, 0, stream>>>(devArray, scalar, numElements);
+  CHECK_ERR;
+}
+template void Algorithms::scaleArray(real *devArray, real scalar, const size_t numElements, void* streamPtr);
+template void Algorithms::scaleArray(int *devArray, int scalar, const size_t numElements, void* streamPtr);
+template void Algorithms::scaleArray(char *devArray, char scalar, const size_t numElements, void* streamPtr);
+
+//--------------------------------------------------------------------------------------------------
+template <typename T> __global__ void kernel_fillArray(T *array, T scalar, const size_t numElements) {
+  size_t index = threadIdx.x + blockIdx.x * blockDim.x;
+  if (index < numElements) {
+    array[index] = scalar;
+  }
+}
+
+template <typename T> void Algorithms::fillArray(T *devArray, const T scalar, const size_t numElements, void* streamPtr) {
+  dim3 block(64, 1, 1);
+  dim3 grid = internals::computeGrid1D(block, numElements);
+  auto stream = reinterpret_cast<internals::deviceStreamT>(streamPtr);
+  kernel_fillArray<<<grid, block, 0, stream>>>(devArray, scalar, numElements);
+  CHECK_ERR;
+}
+template void Algorithms::fillArray(real *devArray, real scalar, const size_t numElements, void* streamPtr);
+template void Algorithms::fillArray(int *devArray, int scalar, const size_t numElements, void* streamPtr);
+template void Algorithms::fillArray(char *devArray, char scalar, const size_t numElements, void* streamPtr);
+
+//--------------------------------------------------------------------------------------------------
+__global__ void kernel_touchMemory(real *ptr, size_t size, bool clean) {
+  int id = threadIdx.x + blockIdx.x * blockDim.x;
+  if (id < size) {
+    if (clean) {
+      ptr[id] = 0;
+    } else {
+      real value = ptr[id];
+      // Do something dummy here. We just need to check the pointers point to valid memory locations.
+      // Avoid compiler optimization. Possibly, implement a dummy code with asm.
+      value += 1;
+      value -= 1;
+    }
+  }
+}
+
+void Algorithms::touchMemory(real *ptr, size_t size, bool clean, void* streamPtr) {
+  dim3 block(256, 1, 1);
+  dim3 grid = internals::computeGrid1D(block, size);
+  auto stream = reinterpret_cast<internals::deviceStreamT>(streamPtr);
+  kernel_touchMemory<<<grid, block, 0, stream>>>(ptr, size, clean);
+  CHECK_ERR;
+}
+} // namespace device

cuda_code/BE_L1D_HIT.cu

@@ -0,0 +1,179 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <cutil.h>
+#include <math.h>
+// Includes
+#include <stdio.h>
+#include "../include/ContAcq-IntClk.h"
+
+// includes, project
+#include "../include/sdkHelper.h"  // helper for shared functions common to CUDA SDK samples
+//#include <shrQATest.h>
+//#include <shrUtils.h>
+
+// includes CUDA
+#include <cuda_runtime.h>
+
+#define THREADS_PER_BLOCK 256
+#define NUM_OF_BLOCKS 60
+#define ITERATIONS REPLACE_ITERATIONS
+
+#define LINE_SIZE 	128
+#define SETS		64
+#define ASSOC		6
+#define SIMD_WIDTH	32
+
+// Variables
+int* h_A;
+int* h_B;
+int* h_C;
+int* d_A;
+int* d_B;
+int* d_C;
+bool noprompt = false;
+unsigned int my_timer;
+
+// Functions
+void CleanupResources(void);
+void RandomInit(int*, int);
+void ParseArguments(int, char**);
+
+////////////////////////////////////////////////////////////////////////////////
+// These are CUDA Helper functions
+
+// This will output the proper CUDA error strings in the event that a CUDA host call returns an error
+#define checkCudaErrors(err)  __checkCudaErrors (err, __FILE__, __LINE__)
+
+inline void __checkCudaErrors(cudaError err, const char *file, const int line ){
+  if(cudaSuccess != err){
+	fprintf(stderr, "%s(%i) : CUDA Runtime API error %d: %s.\n",file, line, (int)err, cudaGetErrorString( err ) );
+	 exit(-1);
+  }
+}
+
+// This will output the proper error string when calling cudaGetLastError
+#define getLastCudaError(msg)      __getLastCudaError (msg, __FILE__, __LINE__)
+
+inline void __getLastCudaError(const char *errorMessage, const char *file, const int line ){
+  cudaError_t err = cudaGetLastError();
+  if (cudaSuccess != err){
+	fprintf(stderr, "%s(%i) : getLastCudaError() CUDA error : %s : (%d) %s.\n",file, line, errorMessage, (int)err, cudaGetErrorString( err ) );
+	exit(-1);
+  }
+}
+
+// end of CUDA Helper Functions
+
+
+
+
+// Device code
+__global__ void PowerKernal(int* A, int* C, int N){
+    int tid = blockDim.x * blockIdx.x + threadIdx.x;
+    //Do Some Computation
+
+    int size = (LINE_SIZE*ASSOC*SETS)/sizeof(int);
+    unsigned j=0, k=0;
+    int m_sum=0;
+	// Fill the L1 cache, Miss on first LD, Hit on subsequent LDs
+	for(k=0; k<ITERATIONS; ++k){
+		//for(j=0; j<(size); j+=THREADS_PER_BLOCK){
+			m_sum += A[tid];
+		//}
+	}
+	C[tid]=m_sum;
+    __syncthreads();
+}
+
+
+// Host code
+
+int main(){
+
+	 printf("Power Microbenchmarks\n");
+	 //int N = LINE_SIZE*SETS*ASSOC;
+	 int N = NUM_OF_BLOCKS*THREADS_PER_BLOCK;
+	 size_t size = N * sizeof(int) * NUM_OF_BLOCKS;
+
+	 // Allocate input vectors h_A and h_B in host memory
+	 h_A = (int*)malloc(size);
+	 if (h_A == 0) CleanupResources();
+	 //h_B = (float*)malloc(size);
+	 //if (h_B == 0) CleanupResources();
+	 h_C = (int*)malloc(size);
+	 if (h_C == 0) CleanupResources();
+
+	 // Initialize input vectors
+	 RandomInit(h_A, N);
+	 //RandomInit(h_B, N);
+
+	 // Allocate vectors in device memory
+	 checkCudaErrors( cudaMalloc((void**)&d_A, size) );
+	 //checkCudaErrors( cudaMalloc((void**)&d_B, size) );
+	 checkCudaErrors( cudaMalloc((void**)&d_C, size) );
+
+	 // Copy vectors from host memory to device memory
+	 checkCudaErrors( cudaMemcpy(d_A, h_A, size, cudaMemcpyHostToDevice) );
+	 //checkCudaErrors( cudaMemcpy(d_B, h_B, size, cudaMemcpyHostToDevice) );
+
+	 //VecAdd<<<blocksPerGrid, threadsPerBlock>>>(d_A, d_B, d_C, N);
+	 dim3 dimGrid(NUM_OF_BLOCKS,1);
+	 dim3 dimBlock(THREADS_PER_BLOCK,1);
+
+	CUT_SAFE_CALL(cutCreateTimer(&my_timer)); 
+	TaskHandle taskhandle = LaunchDAQ();
+	CUT_SAFE_CALL(cutStartTimer(my_timer)); 
+
+	 PowerKernal<<<dimGrid,dimBlock>>>(d_A, d_C, N);
+
+	CUDA_SAFE_CALL( cudaThreadSynchronize() );
+	printf("execution time = %f\n", cutGetTimerValue(my_timer));
+	TurnOffDAQ(taskhandle, cutGetTimerValue(my_timer));
+	CUT_SAFE_CALL(cutStopTimer(my_timer));
+	CUT_SAFE_CALL(cutDeleteTimer(my_timer)); 
+
+	 getLastCudaError("kernel launch failure");
+
+	#ifdef _DEBUG
+	 checkCudaErrors( cudaDeviceSynchronize() );
+	#endif
+
+	 // Copy result from device memory to host memory
+	 // h_C contains the result in host memory
+	 checkCudaErrors( cudaMemcpy(h_C, d_C, size, cudaMemcpyDeviceToHost) );
+
+	 CleanupResources();
+
+	 return 0;
+}
+
+void CleanupResources(void){
+  // Free device memory
+  if (d_A)
+	cudaFree(d_A);
+  //if (d_B)
+//	cudaFree(d_B);
+  if (d_C)
+	cudaFree(d_C);
+
+  // Free host memory
+  if (h_A)
+	free(h_A);
+ // if (h_B)
+//	free(h_B);
+  if (h_C)
+	free(h_C);
+
+}
+
+// Allocates an array with random float entries.
+void RandomInit(int* data, int n){
+  for (int i = 0; i < n; ++i)
+	data[i] = (int)(rand() / RAND_MAX);
+}
+
+
+
+
+
+

cuda_code/BE_L1D_MISS_L2D_HIT_13.cu

@@ -0,0 +1,189 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <cutil.h>
+#include <math.h>
+// Includes
+#include <stdio.h>
+#include "../include/ContAcq-IntClk.h"
+//#include "REPEATL.h"
+#include "../include/REPEATW.h"
+// includes, project
+#include "../include/sdkHelper.h"  // helper for shared functions common to CUDA SDK samples
+//#include <shrQATest.h>
+//#include <shrUtils.h>
+
+// includes CUDA
+#include <cuda_runtime.h>
+
+#define THREADS_PER_BLOCK 256
+#define NUM_OF_BLOCKS 60
+#define max_tid THREADS_PER_BLOCK*NUM_OF_BLOCKS    
+#define LINE_SIZE 	32
+#define SETS		64
+#define ASSOC		6
+#define SIMD_WIDTH	32
+#define ITERATIONS REPLACE_ITERATIONS
+// Variables
+int* h_A;
+int* h_B;
+int* h_C;
+int* d_A;
+int* d_B;
+int* d_C;
+bool noprompt = false;
+unsigned int my_timer;
+
+// Functions
+void CleanupResources(void);
+void RandomInit(int*, int);
+void ParseArguments(int, char**);
+
+////////////////////////////////////////////////////////////////////////////////
+// These are CUDA Helper functions
+
+// This will output the proper CUDA error strings in the event that a CUDA host call returns an error
+#define checkCudaErrors(err)  __checkCudaErrors (err, __FILE__, __LINE__)
+
+inline void __checkCudaErrors(cudaError err, const char *file, const int line ){
+  if(cudaSuccess != err){
+	fprintf(stderr, "%s(%i) : CUDA Runtime API error %d: %s.\n",file, line, (int)err, cudaGetErrorString( err ) );
+	 exit(-1);
+  }
+}
+
+// This will output the proper error string when calling cudaGetLastError
+#define getLastCudaError(msg)      __getLastCudaError (msg, __FILE__, __LINE__)
+
+inline void __getLastCudaError(const char *errorMessage, const char *file, const int line ){
+  cudaError_t err = cudaGetLastError();
+  if (cudaSuccess != err){
+	fprintf(stderr, "%s(%i) : getLastCudaError() CUDA error : %s : (%d) %s.\n",file, line, errorMessage, (int)err, cudaGetErrorString( err ) );
+	exit(-1);
+  }
+}
+
+// end of CUDA Helper Functions
+
+
+
+
+// Device code
+__global__ void PowerKernal(int* A, int* C, int N){
+    int tid = blockDim.x * blockIdx.x + threadIdx.x;
+    //Do Some Computation
+
+    int size = (400*max_tid*LINE_SIZE)/sizeof(int); 
+    unsigned j=0, k=0;
+
+    int sum=0;
+
+	// Fill the L1 cache, Miss on every iteration
+	for (int i=0; i<ITERATIONS ; i++){
+    	//REPEAT_L3(tid);
+		REPEAT_L6(0);
+	}
+
+
+	/*
+	// Fill the L1 cache, Miss on first LD, Hit on subsequent LDs
+	for(k=0; k<ITERATIONS; ++k){
+		for(j=0; j<(size/2); j+=THREADS_PER_BLOCK){
+			C[tid+j] = A[tid+j];
+		}
+	}
+	*/
+	C[0]=sum;
+    __syncthreads();
+
+
+}
+
+
+// Host code
+
+int main(){
+
+	 printf("Power Microbenchmarks\n");
+	 int N = (400*max_tid*LINE_SIZE);
+	 size_t size = N * sizeof(int) ;
+
+
+	 // Allocate input vectors h_A and h_B in host memory
+	 h_A = (int*)malloc(size);
+	 if (h_A == 0) CleanupResources();
+	 //h_B = (float*)malloc(size);
+	 //if (h_B == 0) CleanupResources();
+	 h_C = (int*)malloc(size);
+	 if (h_C == 0) CleanupResources();
+
+	 // Initialize input vectors
+	 RandomInit(h_A, N);
+	 //RandomInit(h_B, N);
+
+	 // Allocate vectors in device memory
+	 checkCudaErrors( cudaMalloc((void**)&d_A, size) );
+	 //checkCudaErrors( cudaMalloc((void**)&d_B, size) );
+	 checkCudaErrors( cudaMalloc((void**)&d_C, size) );
+
+	 // Copy vectors from host memory to device memory
+	 checkCudaErrors( cudaMemcpy(d_A, h_A, size, cudaMemcpyHostToDevice) );
+	 //checkCudaErrors( cudaMemcpy(d_B, h_B, size, cudaMemcpyHostToDevice) );
+
+	 //VecAdd<<<blocksPerGrid, threadsPerBlock>>>(d_A, d_B, d_C, N);
+	 dim3 dimGrid(NUM_OF_BLOCKS,1);
+	 dim3 dimBlock(THREADS_PER_BLOCK,1);
+	CUT_SAFE_CALL(cutCreateTimer(&my_timer)); 
+	TaskHandle taskhandle = LaunchDAQ();
+	CUT_SAFE_CALL(cutStartTimer(my_timer)); 
+	 PowerKernal<<<dimGrid,dimBlock>>>(d_A, d_C, N);
+	CUDA_SAFE_CALL( cudaThreadSynchronize() );
+	printf("execution time = %f\n", cutGetTimerValue(my_timer));
+	TurnOffDAQ(taskhandle, cutGetTimerValue(my_timer));
+	CUT_SAFE_CALL(cutStopTimer(my_timer));
+	CUT_SAFE_CALL(cutDeleteTimer(my_timer)); 
+
+	 getLastCudaError("kernel launch failure");
+
+	#ifdef _DEBUG
+	 checkCudaErrors( cudaDeviceSynchronize() );
+	#endif
+
+	 // Copy result from device memory to host memory
+	 // h_C contains the result in host memory
+	 checkCudaErrors( cudaMemcpy(h_C, d_C, size, cudaMemcpyDeviceToHost) );
+
+	 CleanupResources();
+
+	 return 0;
+}
+
+void CleanupResources(void){
+  // Free device memory
+  if (d_A)
+	cudaFree(d_A);
+  //if (d_B)
+//	cudaFree(d_B);
+  if (d_C)
+	cudaFree(d_C);
+
+  // Free host memory
+  if (h_A)
+	free(h_A);
+ // if (h_B)
+//	free(h_B);
+  if (h_C)
+	free(h_C);
+
+}
+
+// Allocates an array with random float entries.
+void RandomInit(int* data, int n){
+  for (int i = 0; i < n; ++i)
+	data[i] = (int)(rand() / RAND_MAX);
+}
+
+
+
+
+
+

cuda_code/BE_L1D_MISS_L2D_HIT_19.cu

@@ -0,0 +1,171 @@
+// Includes
+#include <stdio.h>
+#include <stdlib.h>
+
+
+// includes CUDA
+#include <cuda_runtime.h>
+
+// includes, project
+#include "../include/REPEATW.h"
+
+
+#define THREADS_PER_BLOCK 256
+#define NUM_OF_BLOCKS 640
+#define max_tid THREADS_PER_BLOCK*NUM_OF_BLOCKS    
+#define LINE_SIZE 12
+// Variables
+int* h_A;
+int* h_B;
+int* h_C;
+int* d_A;
+int* d_B;
+int* d_C;
+bool noprompt = false;
+unsigned int my_timer;
+
+// Functions
+void CleanupResources(void);
+void RandomInit(int*, int);
+
+////////////////////////////////////////////////////////////////////////////////
+// These are CUDA Helper functions
+
+// This will output the proper CUDA error strings in the event that a CUDA host call returns an error
+#define checkCudaErrors(err)  __checkCudaErrors (err, __FILE__, __LINE__)
+
+inline void __checkCudaErrors(cudaError err, const char *file, const int line ){
+  if(cudaSuccess != err){
+	fprintf(stderr, "%s(%i) : CUDA Runtime API error %d: %s.\n",file, line, (int)err, cudaGetErrorString( err ) );
+	 exit(-1);
+  }
+}
+
+// This will output the proper error string when calling cudaGetLastError
+#define getLastCudaError(msg)      __getLastCudaError (msg, __FILE__, __LINE__)
+
+inline void __getLastCudaError(const char *errorMessage, const char *file, const int line ){
+  cudaError_t err = cudaGetLastError();
+  if (cudaSuccess != err){
+	fprintf(stderr, "%s(%i) : getLastCudaError() CUDA error : %s : (%d) %s.\n",file, line, errorMessage, (int)err, cudaGetErrorString( err ) );
+	exit(-1);
+  }
+}
+
+// end of CUDA Helper Functions
+
+
+
+
+// Device code
+__global__ void PowerKernal(int* A, int* C, int iterations){
+    int tid = blockDim.x * blockIdx.x + threadIdx.x;
+    //Do Some Computation
+
+    int sum=0;
+
+	// Fill the L1 cache, Miss on every iteration
+	for (int i=0; i<iterations ; i++){
+		//REPLACE_ITERATIONS
+		REPEAT_L6(0);
+	}
+    
+	C[0]=sum;
+    __syncthreads();
+
+
+}
+
+
+// Host code
+int main(int argc, char** argv) 
+{
+	int iterations;
+	if (argc != 2){
+		fprintf(stderr,"usage: %s #iterations\n",argv[0]);
+		exit(1);
+	}
+	else{
+		iterations = atoi(argv[1]);
+	}
+
+	printf("Power Microbenchmark with %d iterations\n",iterations);
+	int N = (400*max_tid*LINE_SIZE);
+	size_t size = N * sizeof(int) ;
+	// Allocate input vectors h_A and h_B in host memory
+	h_A = (int*)malloc(size);
+	if (h_A == 0) CleanupResources();
+	// h_B = (int*)malloc(size);
+	// if (h_B == 0) CleanupResources();
+	h_C = (int*)malloc(size);
+	if (h_C == 0) CleanupResources();
+
+
+
+	// Initialize input vectors
+	RandomInit(h_A, N);
+	// RandomInit(h_B, N);
+
+	// Allocate vectors in device memory
+	checkCudaErrors( cudaMalloc((void**)&d_A, size) );
+	// checkCudaErrors( cudaMalloc((void**)&d_B, size) );
+	checkCudaErrors( cudaMalloc((void**)&d_C, size) );
+
+	cudaEvent_t start, stop;
+	float elapsedTime = 0;
+	checkCudaErrors(cudaEventCreate(&start));
+	checkCudaErrors(cudaEventCreate(&stop));
+
+	// Copy vectors from host memory to device memory
+	checkCudaErrors( cudaMemcpy(d_A, h_A, size, cudaMemcpyHostToDevice) );
+	// checkCudaErrors( cudaMemcpy(d_B, h_B, size, cudaMemcpyHostToDevice) );
+
+
+	dim3 dimGrid(NUM_OF_BLOCKS,1);
+	dim3 dimBlock(THREADS_PER_BLOCK,1);
+
+	checkCudaErrors(cudaEventRecord(start));
+	PowerKernal<<<dimGrid,dimBlock>>>(d_A, d_C, iterations);
+	checkCudaErrors(cudaEventRecord(stop));
+
+	checkCudaErrors(cudaEventSynchronize(stop));
+	checkCudaErrors(cudaEventElapsedTime(&elapsedTime, start, stop));
+	printf("gpu execution time = %.2f s\n", elapsedTime/1000);
+
+	getLastCudaError("kernel launch failure");
+	cudaThreadSynchronize();
+
+	// Copy result from device memory to host memory
+	// h_C contains the result in host memory
+	checkCudaErrors( cudaMemcpy(h_C, d_C, size, cudaMemcpyDeviceToHost) );
+
+	checkCudaErrors(cudaEventDestroy(start));
+	checkCudaErrors(cudaEventDestroy(stop));
+	CleanupResources();
+
+	return 0;
+}
+
+void CleanupResources(void){
+  // Free device memory
+  if (d_A)
+	cudaFree(d_A);
+  //if (d_B)
+//	cudaFree(d_B);
+  if (d_C)
+	cudaFree(d_C);
+
+  // Free host memory
+  if (h_A)
+	free(h_A);
+ // if (h_B)
+//	free(h_B);
+  if (h_C)
+	free(h_C);
+}
+
+// Allocates an array with random float entries.
+void RandomInit(int* data, int n){
+  for (int i = 0; i < n; ++i)
+	data[i] = (int)(rand() / RAND_MAX);
+}

cuda_code/BE_MEM_SHRD_Acss.cu

@@ -0,0 +1,174 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <cutil.h>
+// Includes
+#include <stdio.h>
+#include "../include/ContAcq-IntClk.h"
+
+// includes, project
+#include "../include/sdkHelper.h"  // helper for shared functions common to CUDA SDK samples
+//#include <shrQATest.h>
+//#include <shrUtils.h>
+
+// includes CUDA
+#include <cuda_runtime.h>
+
+#define THREADS_PER_BLOCK 256
+#define NUM_OF_BLOCKS 60
+#define ITERATIONS REPLACE_ITERATIONS
+
+// Variables
+unsigned* h_C1;
+float* h_C2;
+unsigned* d_C1;
+float* d_C2;
+bool noprompt = false;
+unsigned int my_timer;
+
+// Functions
+void CleanupResources(void);
+void RandomInit(unsigned*, int);
+void ParseArguments(int, char**);
+
+////////////////////////////////////////////////////////////////////////////////
+// These are CUDA Helper functions
+
+// This will output the proper CUDA error strings in the event that a CUDA host call returns an error
+#define checkCudaErrors(err)  __checkCudaErrors (err, __FILE__, __LINE__)
+
+inline void __checkCudaErrors(cudaError err, const char *file, const int line )
+{
+  if(cudaSuccess != err){
+	fprintf(stderr, "%s(%i) : CUDA Runtime API error %d: %s.\n",file, line, (int)err, cudaGetErrorString( err ) );
+	 exit(-1);
+  }
+}
+
+// This will output the proper error string when calling cudaGetLastError
+#define getLastCudaError(msg)      __getLastCudaError (msg, __FILE__, __LINE__)
+
+inline void __getLastCudaError(const char *errorMessage, const char *file, const int line )
+{
+  cudaError_t err = cudaGetLastError();
+  if (cudaSuccess != err){
+	fprintf(stderr, "%s(%i) : getLastCudaError() CUDA error : %s : (%d) %s.\n",file, line, errorMessage, (int)err, cudaGetErrorString( err ) );
+	exit(-1);
+  }
+}
+
+// end of CUDA Helper Functions
+
+
+
+
+// Device code
+__global__ void PowerKernal(unsigned* C1, float* C2, int N)
+{
+    int i = threadIdx.x;
+    //Do Some Computation
+   __device__  __shared__ unsigned I1[THREADS_PER_BLOCK];
+   __device__  __shared__ unsigned I2[THREADS_PER_BLOCK];
+   __device__ __shared__ float I3[THREADS_PER_BLOCK];
+   __device__  __shared__ float I4[THREADS_PER_BLOCK];
+	
+    I1[i]=i*2;
+    I2[i]=i;
+    I3[i]=i/2;
+    I4[i]=i;
+
+    __syncthreads();
+
+    for(unsigned k=0; k<ITERATIONS ;k++) {
+        		I1[i]=I2[(i+k)%THREADS_PER_BLOCK];
+        		I2[i]=I1[(i+k+1)%THREADS_PER_BLOCK];
+    }		
+         
+    for(unsigned k=0; k<ITERATIONS ;k++) {
+    			I3[i]=I4[(i+k)%THREADS_PER_BLOCK];
+    			I4[i]=I3[(i+k+1)%THREADS_PER_BLOCK];
+    } 
+    //C1[i]=I2[i];
+    //C2[i]=I4[i];
+    __syncthreads();
+
+}
+
+
+// Host code
+
+int main()
+{
+ printf("Power Microbenchmarks\n");
+ int N = THREADS_PER_BLOCK*NUM_OF_BLOCKS;
+ size_t size1 = N * sizeof(unsigned);
+ size_t size2 = N * sizeof(float); 
+
+ // Allocate vectors in device memory
+ h_C1 = (unsigned *) malloc(size1);
+ h_C2 = (float *) malloc(size2);
+ checkCudaErrors( cudaMalloc((void**)&d_C1, size1) );
+ checkCudaErrors( cudaMalloc((void**)&d_C2, size2) ); 
+
+ //VecAdd<<<blocksPerGrid, threadsPerBlock>>>(d_A, d_B, d_C, N);
+ dim3 dimGrid(NUM_OF_BLOCKS,1);
+ dim3 dimBlock(THREADS_PER_BLOCK,1);
+
+	CUT_SAFE_CALL(cutCreateTimer(&my_timer)); 
+	TaskHandle taskhandle = LaunchDAQ();
+	CUT_SAFE_CALL(cutStartTimer(my_timer)); 
+
+ PowerKernal<<<dimGrid,dimBlock>>>(d_C1, d_C2, N);
+
+	CUDA_SAFE_CALL( cudaThreadSynchronize() );
+	printf("execution time = %f\n", cutGetTimerValue(my_timer));
+	TurnOffDAQ(taskhandle, cutGetTimerValue(my_timer));
+	CUT_SAFE_CALL(cutStopTimer(my_timer));
+	CUT_SAFE_CALL(cutDeleteTimer(my_timer)); 
+
+ getLastCudaError("kernel launch failure");
+
+#ifdef _DEBUG
+ checkCudaErrors( cudaDeviceSynchronize() );
+#endif
+
+ // Copy result from device memory to host memory
+ // h_C contains the result in host memory
+ checkCudaErrors( cudaMemcpy(h_C1, d_C1, size1, cudaMemcpyDeviceToHost) );
+ checkCudaErrors( cudaMemcpy(h_C2, d_C2, size2, cudaMemcpyDeviceToHost) );
+
+ CleanupResources();
+
+ return 0;
+}
+
+void CleanupResources(void)
+{
+  // Free device memory
+  if (d_C1)
+	cudaFree(d_C1);
+  if (d_C2)
+	cudaFree(d_C2);
+
+
+  // Free host memory
+  if (h_C1)
+	free(h_C1);
+  if (d_C2)
+	cudaFree(d_C2);
+
+}
+
+// Allocates an array with random float entries.
+void RandomInit(unsigned* data, int n)
+{
+  for (int i = 0; i < n; ++i){
+	srand((unsigned)time(0));  
+	data[i] = rand() / RAND_MAX;
+  }
+}
+
+
+
+
+
+

cuda_code/BE_SP_FP_DIV_1.cu

@@ -0,0 +1,220 @@
+#include <stdio.h>
+#include <stdlib.h>
+//#include <cutil.h>
+// Includes
+//#include <stdio.h>
+
+// includes, project
+//#include "../include/sdkHelper.h"  // helper for shared functions common to CUDA SDK samples
+//#include <shrQATest.h>
+//#include <shrUtils.h>
+
+// includes CUDA
+#include <cuda_runtime.h>
+
+#define THREADS_PER_BLOCK 256
+#define NUM_OF_BLOCKS 640
+//#define ITERATIONS 40
+//#include "../include/ContAcq-IntClk.h"
+
+// Variables
+float* h_A;
+float* h_B;
+float* h_C;
+float* d_A;
+float* d_B;
+float* d_C;
+//bool noprompt = false;
+//unsigned int my_timer;
+
+// Functions
+void CleanupResources(void);
+void RandomInit(float*, int);
+//void ParseArguments(int, char**);
+
+////////////////////////////////////////////////////////////////////////////////
+// These are CUDA Helper functions
+
+// This will output the proper CUDA error strings in the event that a CUDA host call returns an error
+#define checkCudaErrors(err)  __checkCudaErrors (err, __FILE__, __LINE__)
+
+inline void __checkCudaErrors(cudaError err, const char *file, const int line )
+{
+  if(cudaSuccess != err){
+	fprintf(stderr, "%s(%i) : CUDA Runtime API error %d: %s.\n",file, line, (int)err, cudaGetErrorString( err ) );
+	 exit(-1);
+  }
+}
+
+// This will output the proper error string when calling cudaGetLastError
+#define getLastCudaError(msg)      __getLastCudaError (msg, __FILE__, __LINE__)
+
+inline void __getLastCudaError(const char *errorMessage, const char *file, const int line )
+{
+  cudaError_t err = cudaGetLastError();
+  if (cudaSuccess != err){
+	fprintf(stderr, "%s(%i) : getLastCudaError() CUDA error : %s : (%d) %s.\n",file, line, errorMessage, (int)err, cudaGetErrorString( err ) );
+	exit(-1);
+  }
+}
+
+// end of CUDA Helper Functions
+
+
+
+
+__global__ void PowerKernal3(const float* A, const float* B, float* C, int N)
+{
+    int i = blockDim.x * blockIdx.x + threadIdx.x;
+    //Do Some Computation
+    float Value1;
+    float Value2 = 999999;
+    float Value3;
+    float Value;
+    float I1=A[i];
+    float I2=B[i];
+
+
+    __syncthreads();
+    #pragma unroll 100
+   // Excessive Division Operations
+    for(unsigned k=0; k<N;k++) {
+	Value1=I1/I2;
+	Value3=I1/I2;
+	Value1/=Value2;
+	Value1/=Value2;
+	Value2=Value3/Value1;
+	Value1=Value2/Value3;
+    }
+
+    __syncthreads();
+    Value=Value1;
+    C[i]=Value/Value2;
+}
+
+
+
+int main(int argc, char** argv)
+{
+ int iterations;
+ if(argc!=2) {
+   fprintf(stderr,"usage: %s #iterations\n",argv[0]);
+   exit(1);
+ }
+ else {
+   iterations = atoi(argv[1]);
+ }
+ 
+ printf("Power Microbenchmarks with iterations %d\n",iterations);
+ int N = THREADS_PER_BLOCK*NUM_OF_BLOCKS;
+ size_t size = N * sizeof(float);
+ // Allocate input vectors h_A and h_B in host memory
+ h_A = (float*)malloc(size);
+ if (h_A == 0) CleanupResources();
+ h_B = (float*)malloc(size);
+ if (h_B == 0) CleanupResources();
+ h_C = (float*)malloc(size);
+ if (h_C == 0) CleanupResources();
+
+ // Initialize input vectors
+ RandomInit(h_A, N);
+ RandomInit(h_B, N);
+
+ // Allocate vectors in device memory
+printf("before\n");
+ checkCudaErrors( cudaMalloc((void**)&d_A, size) );
+ checkCudaErrors( cudaMalloc((void**)&d_B, size) );
+ checkCudaErrors( cudaMalloc((void**)&d_C, size) );
+printf("after\n");
+
+ cudaEvent_t start, stop;                   
+ float elapsedTime = 0;                     
+ checkCudaErrors(cudaEventCreate(&start));  
+ checkCudaErrors(cudaEventCreate(&stop));
+
+ // Copy vectors from host memory to device memory
+ checkCudaErrors( cudaMemcpy(d_A, h_A, size, cudaMemcpyHostToDevice) );
+ checkCudaErrors( cudaMemcpy(d_B, h_B, size, cudaMemcpyHostToDevice) );
+
+ //VecAdd<<<blocksPerGrid, threadsPerBlock>>>(d_A, d_B, d_C, N);
+ dim3 dimGrid(NUM_OF_BLOCKS,1);
+ dim3 dimBlock(THREADS_PER_BLOCK,1);
+ dim3 dimGrid2(1,1);
+ dim3 dimBlock2(1,1);
+
+ checkCudaErrors(cudaEventRecord(start));              
+ PowerKernal3<<<dimGrid,dimBlock>>>(d_A, d_B, d_C, iterations);  
+ checkCudaErrors(cudaEventRecord(stop));               
+ 
+ checkCudaErrors(cudaEventSynchronize(stop));           
+ checkCudaErrors(cudaEventElapsedTime(&elapsedTime, start, stop));  
+ printf("execution time = %.2f s\n", elapsedTime/1000);  
+ getLastCudaError("kernel launch failure");              
+ cudaThreadSynchronize();
+ 
+/*CUT_SAFE_CALL(cutCreateTimer(&my_timer)); 
+TaskHandle taskhandle = LaunchDAQ();
+CUT_SAFE_CALL(cutStartTimer(my_timer)); 
+printf("execution time = %f\n", cutGetTimerValue(my_timer));
+
+
+
+PowerKernal3<<<dimGrid,dimBlock>>>(d_A, d_B, d_C, N);
+CUDA_SAFE_CALL( cudaThreadSynchronize() );
+printf("execution time = %f\n", cutGetTimerValue(my_timer));
+
+
+getLastCudaError("kernel launch failure");
+CUDA_SAFE_CALL( cudaThreadSynchronize() );
+CUT_SAFE_CALL(cutStopTimer(my_timer));
+TurnOffDAQ(taskhandle, cutGetTimerValue(my_timer));
+printf("execution time = %f\n", cutGetTimerValue(my_timer));
+CUT_SAFE_CALL(cutDeleteTimer(my_timer)); 
+
+#ifdef _DEBUG
+ checkCudaErrors( cudaDeviceSynchronize() );
+#endif*/
+
+ // Copy result from device memory to host memory
+ // h_C contains the result in host memory
+ checkCudaErrors( cudaMemcpy(h_C, d_C, size, cudaMemcpyDeviceToHost) );
+  checkCudaErrors(cudaEventDestroy(start));
+ checkCudaErrors(cudaEventDestroy(stop));
+ CleanupResources();
+
+ return 0;
+}
+
+void CleanupResources(void)
+{
+  // Free device memory
+  if (d_A)
+	cudaFree(d_A);
+  if (d_B)
+	cudaFree(d_B);
+  if (d_C)
+	cudaFree(d_C);
+
+  // Free host memory
+  if (h_A)
+	free(h_A);
+  if (h_B)
+	free(h_B);
+  if (h_C)
+	free(h_C);
+
+}
+
+// Allocates an array with random float entries.
+void RandomInit(float* data, int n)
+{
+  for (int i = 0; i < n; ++i){ 
+	data[i] = rand() / RAND_MAX;
+  }
+}
+
+
+
+
+
+

cuda_code/BE_SP_INT_ADD_l32_1.cu

@@ -0,0 +1,184 @@
+// Includes
+#include <stdio.h>
+#include <stdlib.h>
+// includes from project
+
+
+// includes from CUDA
+#include <cuda_runtime.h>
+//#include <helper_math.h>
+
+#define THREADS_PER_BLOCK 256
+#define NUM_OF_BLOCKS 640
+
+
+// Variables
+unsigned* h_A;
+unsigned* h_B;
+unsigned* h_C;
+unsigned* d_A;
+unsigned* d_B;
+unsigned* d_C;
+
+// Functions
+void CleanupResources(void);
+void RandomInit(unsigned*, int);
+
+////////////////////////////////////////////////////////////////////////////////
+// These are CUDA Helper functions
+
+// This will output the proper CUDA error strings in the event that a CUDA host call returns an error
+#define checkCudaErrors(err)  __checkCudaErrors (err, __FILE__, __LINE__)
+
+inline void __checkCudaErrors(cudaError err, const char *file, const int line )
+{
+  if(cudaSuccess != err){
+  fprintf(stderr, "%s(%i) : CUDA Runtime API error %d: %s.\n",file, line, (int)err, cudaGetErrorString( err ) );
+   exit(-1);
+  }
+}
+
+// This will output the proper error string when calling cudaGetLastError
+#define getLastCudaError(msg)      __getLastCudaError (msg, __FILE__, __LINE__)
+
+inline void __getLastCudaError(const char *errorMessage, const char *file, const int line )
+{
+  cudaError_t err = cudaGetLastError();
+  if (cudaSuccess != err){
+  fprintf(stderr, "%s(%i) : getLastCudaError() CUDA error : %s : (%d) %s.\n",file, line, errorMessage, (int)err, cudaGetErrorString( err ) );
+  exit(-1);
+  }
+}
+// end of CUDA Helper Functions
+
+__global__ void PowerKernal2(const unsigned* A, const unsigned* B, unsigned* C, int iterations)
+{
+  int i = blockDim.x * blockIdx.x + threadIdx.x;
+  //Do Some Computation
+  unsigned Value1=0;
+  unsigned Value2=0;
+  unsigned Value3=0;
+  unsigned Value=0;
+  unsigned I1=A[i];
+  unsigned I2=B[i];
+
+  // Excessive INT addition access
+  if((i%32)<=31){
+    #pragma unroll 100
+    for(unsigned k=0; k<iterations;k++) {
+      Value2= I1+I2;
+      Value3=I1-I2;
+      Value1-=Value2;
+      Value3+=Value1;
+      Value2-=Value3;
+      Value1+=Value3;
+    }
+  }
+  __syncthreads();
+
+  Value=Value1;
+  C[i]=Value;
+  __syncthreads();
+}
+
+int main(int argc, char** argv) 
+{
+
+  int iterations;
+  if (argc != 2){
+  fprintf(stderr,"usage: %s #iterations\n",argv[0]);
+  exit(1);
+  }
+  else{
+    iterations = atoi(argv[1]);
+  }
+
+ printf("Power Microbenchmark with %d iterations\n",iterations);
+ int N = THREADS_PER_BLOCK*NUM_OF_BLOCKS;
+ size_t size = N * sizeof(unsigned);
+ // Allocate input vectors h_A and h_B in host memory
+ h_A = (unsigned*)malloc(size);
+ if (h_A == 0) CleanupResources();
+ h_B = (unsigned*)malloc(size);
+ if (h_B == 0) CleanupResources();
+ h_C = (unsigned*)malloc(size);
+ if (h_C == 0) CleanupResources();
+
+
+
+ // Initialize input vectors
+ RandomInit(h_A, N);
+ RandomInit(h_B, N);
+
+ // Allocate vectors in device memory
+ printf("before\n");
+ checkCudaErrors( cudaMalloc((void**)&d_A, size) );
+ checkCudaErrors( cudaMalloc((void**)&d_B, size) );
+ checkCudaErrors( cudaMalloc((void**)&d_C, size) );
+ printf("after\n");
+
+ cudaEvent_t start, stop;
+ float elapsedTime = 0;
+ checkCudaErrors(cudaEventCreate(&start));
+ checkCudaErrors(cudaEventCreate(&stop));
+
+ // Copy vectors from host memory to device memory
+ checkCudaErrors( cudaMemcpy(d_A, h_A, size, cudaMemcpyHostToDevice) );
+ checkCudaErrors( cudaMemcpy(d_B, h_B, size, cudaMemcpyHostToDevice) );
+
+
+ dim3 dimGrid(NUM_OF_BLOCKS,1);
+ dim3 dimBlock(THREADS_PER_BLOCK,1);
+ dim3 dimGrid2(1,1);
+ dim3 dimBlock2(1,1);
+
+ checkCudaErrors(cudaEventRecord(start));
+ PowerKernal2<<<dimGrid,dimBlock>>>(d_A, d_B, d_C, iterations);
+ checkCudaErrors(cudaEventRecord(stop));
+
+ checkCudaErrors(cudaEventSynchronize(stop));
+ checkCudaErrors(cudaEventElapsedTime(&elapsedTime, start, stop));
+ printf("gpu execution time = %.2f s\n", elapsedTime/1000);
+
+ getLastCudaError("kernel launch failure");
+ cudaThreadSynchronize();
+
+ // Copy result from device memory to host memory
+ // h_C contains the result in host memory
+ checkCudaErrors( cudaMemcpy(h_C, d_C, size, cudaMemcpyDeviceToHost) );
+ 
+ checkCudaErrors(cudaEventDestroy(start));
+ checkCudaErrors(cudaEventDestroy(stop));
+ CleanupResources();
+
+ return 0;
+}
+
+void CleanupResources(void)
+{
+  // Free device memory
+  if (d_A)
+  cudaFree(d_A);
+  if (d_B)
+  cudaFree(d_B);
+  if (d_C)
+  cudaFree(d_C);
+
+  // Free host memory
+  if (h_A)
+  free(h_A);
+  if (h_B)
+  free(h_B);
+  if (h_C)
+  free(h_C);
+
+}
+
+// Allocates an array with random unsigned entries.
+void RandomInit(unsigned* data, int n)
+{
+  for (int i = 0; i < n; ++i){
+  srand((unsigned)time(0));  
+  data[i] = rand() / RAND_MAX;
+  }
+}

cuda_code/BE_SP_INT_MUL_3.cu

@@ -0,0 +1,225 @@
+#include <stdio.h>
+#include <stdlib.h>
+//#include <cutil.h>
+// Includes
+//#include <stdio.h>
+//#include "../include/ContAcq-IntClk.h"
+
+// includes, project
+//#include "../include/sdkHelper.h"  // helper for shared functions common to CUDA SDK samples
+//#include <shrQATest.h>
+//#include <shrUtils.h>
+
+// includes CUDA
+#include <cuda_runtime.h>
+
+#define THREADS_PER_BLOCK 256
+#define NUM_OF_BLOCKS 640
+//#define ITERATIONS 40
+
+// Variables
+unsigned* h_A;
+unsigned* h_B;
+unsigned* h_C;
+unsigned* d_A;
+unsigned* d_B;
+unsigned* d_C;
+//bool noprompt = false;
+//unsigned int my_timer;
+
+// Functions
+void CleanupResources(void);
+void RandomInit(unsigned*, int);
+//void ParseArguments(int, char**);
+
+////////////////////////////////////////////////////////////////////////////////
+// These are CUDA Helper functions
+
+// This will output the proper CUDA error strings in the event that a CUDA host call returns an error
+#define checkCudaErrors(err)  __checkCudaErrors (err, __FILE__, __LINE__)
+
+inline void __checkCudaErrors(cudaError err, const char *file, const int line )
+{
+  if(cudaSuccess != err){
+	fprintf(stderr, "%s(%i) : CUDA Runtime API error %d: %s.\n",file, line, (int)err, cudaGetErrorString( err ) );
+	 exit(-1);
+  }
+}
+
+// This will output the proper error string when calling cudaGetLastError
+#define getLastCudaError(msg)      __getLastCudaError (msg, __FILE__, __LINE__)
+
+inline void __getLastCudaError(const char *errorMessage, const char *file, const int line )
+{
+  cudaError_t err = cudaGetLastError();
+  if (cudaSuccess != err){
+	fprintf(stderr, "%s(%i) : getLastCudaError() CUDA error : %s : (%d) %s.\n",file, line, errorMessage, (int)err, cudaGetErrorString( err ) );
+	exit(-1);
+  }
+}
+
+// end of CUDA Helper Functions
+
+
+
+
+// Device code
+
+
+__global__ void PowerKernal3(const unsigned* A, const unsigned* B, unsigned* C, int N)
+{
+    int i = blockDim.x * blockIdx.x + threadIdx.x;
+    //Do Some Computation
+    unsigned Value1;
+    unsigned Value2 = 999999;
+    unsigned Value3;
+    unsigned Value;
+    unsigned I1=A[i];
+    unsigned I2=B[i];
+
+
+#pragma unroll 100
+    // Excessive Multiplication
+    for(unsigned k=0; k<N;k++) {
+    	Value1=I1*I2;
+    	Value1*=Value2;
+    	Value3=Value1*I2;
+    	Value2*=I1*Value3;
+    	Value1*=Value2;
+        Value3*=Value1;
+    }
+
+    __syncthreads();
+    Value=Value3;
+
+    C[i]=Value;
+    __syncthreads();
+
+}
+
+
+
+
+int main(int argc, char** argv)
+{
+ int iterations;
+ if(argc!=2) {
+   fprintf(stderr,"usage: %s #iterations\n",argv[0]);
+   exit(1);
+ }
+ else {
+   iterations = atoi(argv[1]);
+ }
+ 
+ printf("Power Microbenchmarks with iterations %d\n",iterations);
+ int N = THREADS_PER_BLOCK*NUM_OF_BLOCKS;
+ size_t size = N * sizeof(unsigned);
+ // Allocate input vectors h_A and h_B in host memory
+ h_A = (unsigned*)malloc(size);
+ if (h_A == 0) CleanupResources();
+ h_B = (unsigned*)malloc(size);
+ if (h_B == 0) CleanupResources();
+ h_C = (unsigned*)malloc(size);
+ if (h_C == 0) CleanupResources();
+
+ // Initialize input vectors
+ RandomInit(h_A, N);
+ RandomInit(h_B, N);
+
+ // Allocate vectors in device memory
+ checkCudaErrors( cudaMalloc((void**)&d_A, size) );
+ checkCudaErrors( cudaMalloc((void**)&d_B, size) );
+ checkCudaErrors( cudaMalloc((void**)&d_C, size) );
+
+ // Copy vectors from host memory to device memory
+ checkCudaErrors( cudaMemcpy(d_A, h_A, size, cudaMemcpyHostToDevice) );
+ checkCudaErrors( cudaMemcpy(d_B, h_B, size, cudaMemcpyHostToDevice) );
+
+ cudaEvent_t start, stop;                   
+ float elapsedTime = 0;                     
+ checkCudaErrors(cudaEventCreate(&start));  
+ checkCudaErrors(cudaEventCreate(&stop)); 
+
+ //VecAdd<<<blocksPerGrid, threadsPerBlock>>>(d_A, d_B, d_C, N);
+ dim3 dimGrid(NUM_OF_BLOCKS,1);
+ dim3 dimBlock(THREADS_PER_BLOCK,1);
+ dim3 dimGrid2(1,1);
+ dim3 dimBlock2(1,1);
+
+ checkCudaErrors(cudaEventRecord(start));              
+ PowerKernal3<<<dimGrid,dimBlock>>>(d_A, d_B, d_C, iterations);  
+ checkCudaErrors(cudaEventRecord(stop));               
+ 
+ checkCudaErrors(cudaEventSynchronize(stop));           
+ checkCudaErrors(cudaEventElapsedTime(&elapsedTime, start, stop));  
+ printf("execution time = %.2f s\n", elapsedTime/1000);  
+ getLastCudaError("kernel launch failure");              
+ cudaThreadSynchronize();
+
+ /*CUT_SAFE_CALL(cutCreateTimer(&my_timer)); 
+ TaskHandle taskhandle = LaunchDAQ();
+ CUT_SAFE_CALL(cutStartTimer(my_timer)); 
+ printf("execution time = %f\n", cutGetTimerValue(my_timer));
+ 
+
+
+PowerKernal3<<<dimGrid,dimBlock>>>(d_A, d_B, d_C, N);
+CUDA_SAFE_CALL( cudaThreadSynchronize() );
+printf("execution time = %f\n", cutGetTimerValue(my_timer));
+
+
+getLastCudaError("kernel launch failure");
+CUDA_SAFE_CALL( cudaThreadSynchronize() );
+CUT_SAFE_CALL(cutStopTimer(my_timer));
+TurnOffDAQ(taskhandle, cutGetTimerValue(my_timer));
+printf("execution time = %f\n", cutGetTimerValue(my_timer));
+CUT_SAFE_CALL(cutDeleteTimer(my_timer)); 
+
+#ifdef _DEBUG
+ checkCudaErrors( cudaDeviceSynchronize() );
+#endif*/
+
+ // Copy result from device memory to host memory
+ // h_C contains the result in host memory
+ checkCudaErrors( cudaMemcpy(h_C, d_C, size, cudaMemcpyDeviceToHost) );
+ checkCudaErrors(cudaEventDestroy(start));
+ checkCudaErrors(cudaEventDestroy(stop)); 
+ CleanupResources();
+
+ return 0;
+}
+
+void CleanupResources(void)
+{
+  // Free device memory
+  if (d_A)
+	cudaFree(d_A);
+  if (d_B)
+	cudaFree(d_B);
+  if (d_C)
+	cudaFree(d_C);
+
+  // Free host memory
+  if (h_A)
+	free(h_A);
+  if (h_B)
+	free(h_B);
+  if (h_C)
+	free(h_C);
+
+}
+
+// Allocates an array with random float entries.
+void RandomInit(unsigned* data, int n)
+{
+  for (int i = 0; i < n; ++i){
+	srand((unsigned)time(0));  
+	data[i] = rand() / RAND_MAX;
+  }
+}
+
+
+
+
+
+

cuda_code/BK5_1.cu

@@ -0,0 +1,812 @@
+/*
+
+See LICENSE file.
+
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <cuda.h>
+#include <cuda_runtime.h>
+#include "meshBasis.hpp"
+
+void matrixPrint(int Nrows, int Ncols, dfloat *A, const char *mess){
+#if 0
+  printf("%s = [\n", mess);
+  for(int i=0;i<Nrows;++i){
+    for(int a=0;a<Ncols;++a){
+      printf(" % e", A[i*Ncols+a]);
+    }
+    printf("\n");
+  }
+  printf("]\n");
+#endif
+}
+
+
+
+__forceinline__ __device__ __host__  int ijN(const int i, const int j, const int N){
+
+  return i + j*N;
+
+}
+
+__forceinline__ __device__ __host__ int ijkN(const int i, const int j, const int k, const int N){
+
+  return i + j*N + k*N*N;
+
+}
+
+__forceinline__ __device__ __host__ int ijklN(const int i, const int j, const int k, const int l, const int N){
+
+  return i + j*N + k*N*N + l*N*N*N;
+
+}
+
+// switch:
+// 1 to use CUDA 10.0 stream recording
+// 0 to use traditional enqueing of kernels
+#define USE_GRAPH 0
+
+#define MAX_DOFS_1D 14
+#define MAX_HALF_DOFS_1D 7
+
+
+#define HALF_DOFS_1D ((NUM_DOFS_1D+1)/2)
+
+#define NUM_DOFS_2D (NUM_DOFS_1D*NUM_DOFS_1D)
+#define NUM_DOFS_3D (NUM_DOFS_1D*NUM_DOFS_1D*NUM_DOFS_1D)
+
+__constant__ dfloat const_DofToDofD[MAX_DOFS_1D*MAX_DOFS_1D];
+__constant__ dfloat const_oddDofToDofD[MAX_HALF_DOFS_1D*MAX_HALF_DOFS_1D];
+__constant__ dfloat const_evenDofToDofD[MAX_HALF_DOFS_1D*MAX_HALF_DOFS_1D];
+
+void randAlloc(int N, dfloat **h_a, dfloat **c_a){
+
+  *h_a = (dfloat*) calloc(N, sizeof(dfloat));
+
+  for(int n=0;n<N;++n)
+    h_a[0][n] = drand48();
+
+  cudaMalloc(c_a, N*sizeof(dfloat));
+
+  cudaMemcpy(c_a[0], h_a[0], N*sizeof(dfloat), cudaMemcpyHostToDevice);
+
+}
+
+__global__ void nothingKernel(){  }
+
+
+template <int NUM_DOFS_1D, int p_Nblock >
+  __forceinline__ __device__ 
+  void BK5Device(const int numElements,
+		 const int element,
+		 const dfloat lambda,
+		 const dfloat * __restrict__ op,
+		 const dfloat * __restrict__ DofToDofD,
+		 const dfloat * __restrict__ oddDofToDofD,
+		 const dfloat * __restrict__ evenDofToDofD,
+		 dfloat * __restrict__ r_p,
+		 dfloat * __restrict__ r_Ap){
+  
+  __shared__ dfloat s_p[p_Nblock][NUM_DOFS_1D][NUM_DOFS_1D];
+  __shared__ dfloat s_Gpr[p_Nblock][NUM_DOFS_1D][NUM_DOFS_1D];
+  __shared__ dfloat s_Gps[p_Nblock][NUM_DOFS_1D][NUM_DOFS_1D];
+  
+  // assumes NUM_DOFS_2D threads
+  int t = threadIdx.x;
+  int blk = threadIdx.y;
+  
+  int i = t%NUM_DOFS_1D;
+  int j = t/NUM_DOFS_1D;
+  
+  for(int k = 0; k < NUM_DOFS_1D; k++) {
+    r_Ap[k] = 0.f; // zero the accumulator
+  }
+  
+  // Layer by layer
+#pragma unroll
+  for(int k = 0; k < NUM_DOFS_1D; k++) {
+
+    // share r_p[k]
+    __syncthreads();
+
+    s_p[blk][j][i] = r_p[k];
+
+    __syncthreads();
+    
+    dfloat G00 = 0, G01 =0, G02 =0, G11 =0, G12 =0, G22 =0, GWJ =0;
+    
+    // prefetch geometric factors
+    const int gbase = element*p_Nggeo*NUM_DOFS_3D + ijkN(i,j,k,NUM_DOFS_1D);
+
+    if(element<numElements){
+      G00 = op[gbase+p_G00ID*NUM_DOFS_3D];
+      G01 = op[gbase+p_G01ID*NUM_DOFS_3D];
+      G02 = op[gbase+p_G02ID*NUM_DOFS_3D];
+      G11 = op[gbase+p_G11ID*NUM_DOFS_3D];
+      G12 = op[gbase+p_G12ID*NUM_DOFS_3D];
+      G22 = op[gbase+p_G22ID*NUM_DOFS_3D];
+      GWJ = op[gbase+p_GWJID*NUM_DOFS_3D];
+    }
+    
+    dfloat pr = 0.f;
+    dfloat ps = 0.f;
+    dfloat pt = 0.f;
+
+#pragma unroll
+    for(int m = 0; m < NUM_DOFS_1D; m++) {
+      int im = ijN(m,i,NUM_DOFS_1D);
+      int jm = ijN(m,j,NUM_DOFS_1D);
+      int km = ijN(m,k,NUM_DOFS_1D);
+      pr += DofToDofD[im]*s_p[blk][j][m];
+      ps += DofToDofD[jm]*s_p[blk][m][i];
+      pt += DofToDofD[km]*r_p[m];
+    }
+    
+    s_Gpr[blk][j][i] = (G00*pr + G01*ps + G02*pt);
+    s_Gps[blk][j][i] = (G01*pr + G11*ps + G12*pt);
+    
+    dfloat Gpt = (G02*pr + G12*ps + G22*pt);
+    
+    dfloat Apk = GWJ*lambda*r_p[k];
+    
+    __syncthreads();
+    
+#pragma unroll
+    for(int m = 0; m < NUM_DOFS_1D; m++){
+      int mi = ijN(i,m,NUM_DOFS_1D);
+      int mj = ijN(j,m,NUM_DOFS_1D);
+      int km = ijN(m,k,NUM_DOFS_1D);
+      Apk     += DofToDofD[mi]*s_Gpr[blk][j][m];
+      Apk     += DofToDofD[mj]*s_Gps[blk][m][i];
+      r_Ap[m] += DofToDofD[km]*Gpt; // DT(m,k)*ut(i,j,k,e)
+    }
+    
+    r_Ap[k] += Apk;
+  }
+  
+}
+
+template <int NUM_DOFS_1D, int p_Nblock >
+__global__ void BK5ConstantKernel(const int numElements,
+				  const dfloat lambda,
+				  const dfloat * __restrict__ op,
+				  const dfloat * __restrict__ DofToDofD,
+				  const dfloat * __restrict__ oddDofToDofD,
+				  const dfloat * __restrict__ evenDofToDofD,
+				  const dfloat * __restrict__ solIn,
+				  dfloat * __restrict__ solOut){
+  
+  __shared__ dfloat s_DofToDofD[NUM_DOFS_2D];
+
+  dfloat r_q[NUM_DOFS_1D];
+  dfloat r_Aq[NUM_DOFS_1D];
+
+  const unsigned int t = threadIdx.x;
+  const int blk = threadIdx.y;
+  
+  const int element = blockIdx.x*p_Nblock + blk;
+  
+  const unsigned int a = t%NUM_DOFS_1D;
+  const unsigned int b = t/NUM_DOFS_1D;
+
+  s_DofToDofD[t] = DofToDofD[t];
+  
+  if(element < numElements){
+    for(int c=0;c<NUM_DOFS_1D;++c){
+      
+      int id = ijklN(a,b,c,element,NUM_DOFS_1D);
+      
+      r_q[c] = solIn[id];
+    }
+  }
+  
+  __syncthreads();
+  
+  BK5Device  <NUM_DOFS_1D, p_Nblock>
+    (numElements, element, lambda, op, s_DofToDofD, const_oddDofToDofD, const_evenDofToDofD, r_q, r_Aq);
+  
+  if(element<numElements){
+#pragma unroll
+    for(int c=0;c<NUM_DOFS_1D;++c){
+      int id = ijklN(a,b,c,element,NUM_DOFS_1D);
+      solOut[id] = r_Aq[c];
+    }
+  }
+}
+
+template <int NUM_DOFS_1D>
+  __forceinline__ __device__ 
+  dfloat BK5CubeDevice(const int numElements,
+		       const int element,
+		       const dfloat lambda,
+		       const dfloat * __restrict__ op,
+		       const dfloat * __restrict__ DofToDofD,
+		       dfloat r_p){
+  
+  __shared__ dfloat s_p[NUM_DOFS_1D][NUM_DOFS_1D][NUM_DOFS_1D];
+  
+  // assumes NUM_DOFS_2D threads
+  int i = threadIdx.x;
+  int j = threadIdx.y;
+  int k = threadIdx.z;
+  
+  dfloat r_Ap = 0; // zero the accumulator
+
+  s_p[k][j][i] = r_p;
+
+  __syncthreads();
+  
+  dfloat G00 = 0, G01 =0, G02 =0, G11 =0, G12 =0, G22 =0, GWJ =0;
+  
+  // prefetch geometric factors
+  const int gbase = element*p_Nggeo*NUM_DOFS_3D + ijkN(i,j,k,NUM_DOFS_1D);
+  
+  if(element<numElements){
+    G00 = op[gbase+p_G00ID*NUM_DOFS_3D];
+    G01 = op[gbase+p_G01ID*NUM_DOFS_3D];
+    G02 = op[gbase+p_G02ID*NUM_DOFS_3D];
+    G11 = op[gbase+p_G11ID*NUM_DOFS_3D];
+    G12 = op[gbase+p_G12ID*NUM_DOFS_3D];
+    G22 = op[gbase+p_G22ID*NUM_DOFS_3D];
+    GWJ = op[gbase+p_GWJID*NUM_DOFS_3D];
+  }
+
+  r_Ap = GWJ*lambda*r_p;
+  
+  dfloat pr = 0.f;
+  dfloat ps = 0.f;
+  dfloat pt = 0.f;
+  
+#pragma unroll
+  for(int m = 0; m < NUM_DOFS_1D; m++) {
+    int im = ijN(m,i,NUM_DOFS_1D);
+    int jm = ijN(m,j,NUM_DOFS_1D);
+    int km = ijN(m,k,NUM_DOFS_1D);
+    pr += DofToDofD[im]*s_p[k][j][m];
+    ps += DofToDofD[jm]*s_p[k][m][i];
+    pt += DofToDofD[km]*s_p[m][j][i];
+  }
+  
+  dfloat Gpr = (G00*pr + G01*ps + G02*pt);
+  dfloat Gps = (G01*pr + G11*ps + G12*pt);
+  dfloat Gpt = (G02*pr + G12*ps + G22*pt);
+  
+  
+  __syncthreads();
+
+  s_p[k][j][i] = Gpr;
+
+  __syncthreads();
+  
+#pragma unroll
+  for(int m = 0; m < NUM_DOFS_1D; m++){
+    int mi = ijN(i,m,NUM_DOFS_1D);
+    r_Ap += DofToDofD[mi]*s_p[k][j][m];
+  }
+
+
+  __syncthreads();
+  
+  s_p[k][j][i] = Gps;
+
+  __syncthreads();
+  
+#pragma unroll
+  for(int m = 0; m < NUM_DOFS_1D; m++){
+    int mj = ijN(j,m,NUM_DOFS_1D);
+    r_Ap += DofToDofD[mj]*s_p[k][m][i];
+  }
+
+  __syncthreads();
+  
+  s_p[k][j][i] = Gpt;
+
+  __syncthreads();
+  
+#pragma unroll
+  for(int m = 0; m < NUM_DOFS_1D; m++){
+    int mk= ijN(k,m,NUM_DOFS_1D);
+    r_Ap += DofToDofD[mk]*s_p[m][j][i];
+  }
+  
+  return r_Ap;
+}
+
+template <int NUM_DOFS_1D>
+__global__ void BK5CubeKernel(const int numElements,
+			       const dfloat lambda,
+			       const dfloat * __restrict__ op,
+			       const dfloat * __restrict__ DofToDofD,
+			       const dfloat * __restrict__ solIn,
+			       dfloat * __restrict__ solOut){
+  
+  __shared__ dfloat s_DofToDofD[NUM_DOFS_2D];
+  
+  const int element = blockIdx.x;
+  
+  int a = threadIdx.x;
+  int b = threadIdx.y;
+  int c = threadIdx.z;
+
+  if(c==0)
+    s_DofToDofD[b*NUM_DOFS_1D+a] = DofToDofD[b*NUM_DOFS_1D+a];
+  
+  int id = ijklN(a,b,c,element,NUM_DOFS_1D);
+  
+  dfloat r_p  = solIn[id];
+  
+  __syncthreads();
+  
+  dfloat r_Ap = BK5CubeDevice  <NUM_DOFS_1D>
+    (numElements, element, lambda, op, s_DofToDofD, r_p);
+  
+  solOut[id] = r_Ap;
+
+}
+
+
+
+double bandwidthTest(cudaStream_t stream, int Ntests, size_t bwNtotal){
+
+  cudaEvent_t start, end;
+  cudaEventCreate(&start);
+  cudaEventCreate(&end);	
+  
+  dfloat *h_bwTest1, *c_bwTest1;
+  dfloat *h_bwTest2, *c_bwTest2;
+  
+  randAlloc(bwNtotal/2, &h_bwTest1, &c_bwTest1);
+  randAlloc(bwNtotal/2, &h_bwTest2, &c_bwTest2);
+  
+  cudaDeviceSynchronize();
+  cudaEventRecord(start, stream);
+  
+  for(int test=0;test<Ntests/2;++test){
+    cudaMemcpy(c_bwTest2, c_bwTest1, (bwNtotal/2)*sizeof(dfloat), cudaMemcpyDeviceToDevice);
+    cudaMemcpy(c_bwTest1, c_bwTest2, (bwNtotal/2)*sizeof(dfloat), cudaMemcpyDeviceToDevice);
+  }
+  
+  cudaEventRecord(end, stream);
+  cudaEventSynchronize(end);
+  cudaDeviceSynchronize();
+
+  float elapsed;
+  cudaEventElapsedTime(&elapsed, start, end);
+  elapsed /= 1000.; // convert to s
+  elapsed /= (double) Ntests;
+  
+  double estimatedActualDeviceBandwidth = (bwNtotal*sizeof(dfloat)/elapsed)/1.e9;
+  
+  cudaFree(c_bwTest1);
+  cudaFree(c_bwTest2);
+  
+  free(h_bwTest1);
+  free(h_bwTest2);
+  
+  cudaEventDestroy(start);
+  cudaEventDestroy(end);	
+  
+  return estimatedActualDeviceBandwidth;
+}
+
+// leave this here in case we add odd-even versions
+void buildOddEvenMatrices(int NUM_COLS_OP, int NUM_ROWS_OP,
+			  dfloat *h_OP,   dfloat **c_OP, dfloat **c_oddOP,  dfloat **c_evenOP){
+
+  int HALF_COLS_OP = ((NUM_COLS_OP+1)/2);
+  int HALF_ROWS_OP = ((NUM_ROWS_OP+1)/2);
+  
+  dfloat *X = (dfloat*) calloc(NUM_COLS_OP*NUM_COLS_OP, sizeof(dfloat));
+  dfloat *invX = (dfloat*) calloc(NUM_COLS_OP*NUM_COLS_OP, sizeof(dfloat));
+
+  dfloat *cubX = (dfloat*) calloc(NUM_ROWS_OP*NUM_ROWS_OP, sizeof(dfloat));
+  dfloat *cubInvX = (dfloat*) calloc(NUM_ROWS_OP*NUM_ROWS_OP, sizeof(dfloat));
+
+  for(int n=0;n<NUM_ROWS_OP;++n){
+    cubX[n*NUM_ROWS_OP + n] = 1;
+    cubInvX[n*NUM_ROWS_OP + n] = 0.5;
+
+    if(n<NUM_ROWS_OP/2){
+      cubX[n*NUM_ROWS_OP + NUM_ROWS_OP-1-n] = -1;
+      cubInvX[n*NUM_ROWS_OP + NUM_ROWS_OP-1-n] = +0.5;
+    }
+    
+    if(n>=(NUM_ROWS_OP/2)){
+      cubX[n*NUM_ROWS_OP + NUM_ROWS_OP-1-n] = +1;
+      cubInvX[n*NUM_ROWS_OP + NUM_ROWS_OP-1-n] = -0.5;
+    }
+  }
+
+  for(int n=0;n<NUM_COLS_OP;++n){
+    X[n*NUM_COLS_OP + n] = 1;
+    invX[n*NUM_COLS_OP + n] = 0.5;
+
+    if(n<NUM_COLS_OP/2){
+      X[n*NUM_COLS_OP + NUM_COLS_OP-1-n] = 1;
+      invX[n*NUM_COLS_OP + NUM_COLS_OP-1-n] = -0.5;
+    }
+    
+    if(n>=NUM_COLS_OP/2){
+      X[n*NUM_COLS_OP + NUM_COLS_OP-1-n] = -1;
+      invX[n*NUM_COLS_OP + NUM_COLS_OP-1-n] = 0.5;
+    }
+  }
+  
+  if(NUM_COLS_OP%2) X[(NUM_COLS_OP)*(NUM_COLS_OP)/2] = 1;
+  if(NUM_COLS_OP%2) invX[(NUM_COLS_OP)*(NUM_COLS_OP)/2] = 1;
+  
+  if(NUM_ROWS_OP%2) cubX[(NUM_ROWS_OP)*(NUM_ROWS_OP)/2] = 1;
+  if(NUM_ROWS_OP%2) cubInvX[(NUM_ROWS_OP)*(NUM_ROWS_OP)/2] = 1;
+
+  //  if(NUM_COLS_OP%2) invX[(NUM_COLS_OP)*(NUM_COLS_OP)/2] = 1;
+  //  if(NUM_ROWS_OP%2) cubInvX[(NUM_ROWS_OP+1)*(NUM_ROWS_OP+1)/2] = 1;
+  
+  dfloat *IinvX = (dfloat*) calloc(NUM_COLS_OP*NUM_ROWS_OP, sizeof(dfloat));
+  dfloat *cubInvXIinvX = (dfloat*) calloc(NUM_COLS_OP*NUM_ROWS_OP, sizeof(dfloat));
+
+  // post multiply by invX
+  for(int i=0;i<NUM_ROWS_OP;++i){
+    for(int a=0;a<NUM_COLS_OP;++a){
+      dfloat resI = 0;
+      for(int n=0;n<NUM_COLS_OP;++n){
+	resI += h_OP [i*NUM_COLS_OP+n]*invX[n*NUM_COLS_OP+a];
+      }
+      IinvX[i*NUM_COLS_OP+a] = resI;
+    }
+  }
+  
+  // pre multiply by invX
+  for(int i=0;i<NUM_ROWS_OP;++i){
+    for(int a=0;a<NUM_COLS_OP;++a){
+      dfloat resI = 0;
+      for(int n=0;n<NUM_ROWS_OP;++n){
+	resI += cubInvX[i*NUM_ROWS_OP+n]*IinvX[n*NUM_COLS_OP + a];
+      }
+      cubInvXIinvX[i*NUM_COLS_OP+a] = resI;
+    }
+  }
+  
+  // now interleave the two non-zero blocks
+  // [ A 0 ]  => [ A[0][0] B[0][0] A[0][1] B[0][1] .. A[0][HALF_DOFS_1D-1] B[0][HALF_DOFS_1D-1] .. 
+  // [ 0 B ] 
+
+  dfloat *oddOP  = (dfloat*) calloc(NUM_ROWS_OP*HALF_ROWS_OP, sizeof(dfloat));
+  dfloat *evenOP = (dfloat*) calloc(NUM_ROWS_OP*HALF_ROWS_OP, sizeof(dfloat));
+  
+  for(int i=0;i<HALF_ROWS_OP;++i){
+    for(int a=0;a<HALF_COLS_OP;++a){
+
+      oddOP[i*HALF_COLS_OP+a]  = cubInvXIinvX[i*NUM_COLS_OP+a];
+      evenOP[i*HALF_COLS_OP+a]  = cubInvXIinvX[(NUM_ROWS_OP-1-i)*NUM_COLS_OP + NUM_COLS_OP-1-a];
+    }
+  }
+
+  if((NUM_ROWS_OP%2)) // zero duplicate
+    evenOP[HALF_ROWS_OP*HALF_COLS_OP-1] = 0;
+  
+  int NoddOP  = HALF_ROWS_OP*HALF_COLS_OP;
+  int NevenOP = HALF_ROWS_OP*HALF_COLS_OP;
+  
+  cudaMalloc(c_oddOP, NoddOP*sizeof(dfloat));
+  cudaMalloc(c_evenOP, NevenOP*sizeof(dfloat));
+  
+  cudaMemcpy(*c_oddOP,  oddOP,  NoddOP*sizeof(dfloat),  cudaMemcpyHostToDevice);
+  cudaMemcpy(*c_evenOP, evenOP, NoddOP*sizeof(dfloat), cudaMemcpyHostToDevice);
+
+  cudaMemcpy(*c_OP, h_OP,  NUM_COLS_OP*NUM_ROWS_OP*sizeof(dfloat),  cudaMemcpyHostToDevice);
+
+  matrixPrint(NUM_COLS_OP, NUM_COLS_OP, X, "X");
+  matrixPrint(NUM_ROWS_OP, NUM_ROWS_OP, cubX, "cubX");
+
+  
+  matrixPrint(NUM_COLS_OP, NUM_COLS_OP, invX, "invX");
+  matrixPrint(NUM_ROWS_OP, NUM_ROWS_OP, cubInvX, "cubInvX");
+
+
+  
+}
+
+
+void runBK5Kernel(cudaStream_t stream, int Nq, int numElements, dfloat lambda,
+		  dfloat *c_op,
+		  dfloat *c_DofToDofD, dfloat *c_oddDofToDofD, dfloat *c_evenDofToDofD,
+		  dfloat *c_solIn, dfloat *c_solOut, int mode){
+  
+#define BK5Kernel(Nq,Nblock)						\
+  {									\
+    if(mode==0){							\
+      dim3 G((numElements+Nblock-1)/Nblock, 1, 1);			\
+      dim3 B(Nq*Nq, Nblock, 1);						\
+      BK5ConstantKernel<Nq,Nblock> <<< G, B, 0, stream >>>		\
+	(numElements, lambda, c_op, c_DofToDofD, c_oddDofToDofD,c_evenDofToDofD, c_solIn, c_solOut); \
+    }									\
+    else{								\
+      dim3 G(numElements,1,1);						\
+      dim3 B(Nq, Nq, Nq);						\
+      BK5CubeKernel<Nq> <<< G, B, 0, stream >>>				\
+	(numElements, lambda, c_op, c_DofToDofD, c_solIn, c_solOut);	\
+    }									\
+}
+  
+  
+#define ERR printf("massMatrixMultiplyRegister with Nq=%d not available", Nq); exit(-1)
+  
+  if(Nq==2){
+    BK5Kernel(2,16);
+    return;
+  }
+  
+  if(Nq==3){
+    BK5Kernel(3,7);
+    return;
+  }
+
+  if(Nq==4){
+    BK5Kernel(4,4);
+    return;
+  }
+
+  if(Nq==5){
+    BK5Kernel(5,5);
+    return;
+  }
+
+  if(Nq==6){
+    BK5Kernel(6,3);
+    return;
+  }
+
+  if(Nq==7){
+    BK5Kernel(7,2);
+    return;
+  }
+
+  if(Nq==8){
+    BK5Kernel(8,1);
+    return;
+  }
+
+  if(Nq==9){
+    BK5Kernel(9,1);
+    return;
+  }
+
+  if(Nq==10){
+    BK5Kernel(10,1);
+    return;
+  }
+
+  if(Nq==11){
+    BK5Kernel(11,1);
+    return;
+  }
+  
+  if(Nq==12){
+    BK5Kernel(12,1);
+    return;
+  }
+
+  if(Nq==13){
+    BK5Kernel(13,1);
+    return;
+  }
+
+  ERR;
+}
+
+
+dfloat nothingTest(cudaStream_t stream, int Ntests){
+
+  cudaEvent_t start, end;
+  cudaEventCreate(&start);
+  cudaEventCreate(&end);	
+
+  cudaDeviceSynchronize();
+  
+  float nothingElapsed = 0;
+  {
+    
+    // time kernel that does nothing
+    
+#if USE_GRAPH==1
+    // cuda stream capture sequence for nothingKernel
+    cudaGraph_t nothingGraph;
+    
+    cudaStreamBeginCapture(stream, cudaStreamCaptureModeGlobal);
+    
+    for(int test=0;test<Ntests;++test){
+      nothingKernel <<< 1, 1, 0, stream >>> ();
+    }
+    
+    cudaStreamEndCapture(stream, &nothingGraph);
+    
+    // time graph sequence for nothing
+    cudaGraphExec_t nothingInstance;
+    cudaGraphInstantiate(&nothingInstance, nothingGraph, NULL, NULL, 0);
+    
+    cudaEventRecord(start, stream);
+    
+    cudaGraphLaunch(nothingInstance, stream);
+    
+    cudaEventRecord(end, stream);
+#else
+    
+    cudaEventRecord(start, stream);
+    
+    for(int test=0;test<Ntests;++test)
+      nothingKernel <<< 1, 1, 0, stream >>> ();
+    
+    cudaEventRecord(end, stream);
+    
+#endif
+    
+    cudaDeviceSynchronize();
+    
+    cudaEventElapsedTime(&nothingElapsed, start, end);
+    nothingElapsed /= 1000.;
+    nothingElapsed /= (double) Ntests;
+    
+  }
+
+  return nothingElapsed;
+}
+
+
+int main(int argc, char **argv){
+
+  cudaStream_t stream;
+  cudaStreamCreate(&stream);
+  
+  if(argc!=4){
+    printf("Usage: ./BK5 Nq numElements mode\n");
+    exit(-1);
+  }
+
+  // read number of elements
+  int          Nq = atoi(argv[1]);
+  int numElements = atoi(argv[2]);
+  int        mode = atoi(argv[3]);
+  
+  dfloat lambda = 0;
+  
+  printf("Running: NUM_DOFS_1D=%d, numElements=%d\n", Nq, numElements);
+
+  int   Np = Nq*Nq*Nq;
+  int halfNq = ((Nq+1)/2);
+
+  int    Ntotal = numElements*Np;
+
+  int Ntests = 10;
+  
+  double estimatedActualDeviceBandwidth = bandwidthTest(stream, Ntests, (Ntotal*2+7*Ntotal)*sizeof(dfloat));
+  
+  dfloat *h_op,      *c_op;
+  dfloat *h_solOut,       *c_solOut;
+  dfloat *h_solIn,        *c_solIn;
+
+  dfloat *h_DofToDofD,    *c_DofToDofD;
+  dfloat *c_oddDofToDofD, *c_evenDofToDofD;
+
+  // float fields
+  randAlloc(Ntotal*p_Nggeo, &h_op, &c_op);
+  
+  randAlloc(Ntotal, &h_solIn, &c_solIn);
+  randAlloc(Ntotal, &h_solOut, &c_solOut);
+  
+  randAlloc(Nq*Nq, &h_DofToDofD, &c_DofToDofD);
+  
+  // give D the correct symmetry
+  for(int i=0;i<halfNq;++i){
+    for(int a=0;a<Nq;++a){
+      h_DofToDofD[(Nq-1-i)*Nq + Nq-1-a] = -h_DofToDofD[i*Nq+a];
+    }
+  }
+
+  // create Odd-even packed storage for I and transpose(I) and push to constant memory
+  buildOddEvenMatrices (Nq,Nq, h_DofToDofD, &c_DofToDofD, &c_oddDofToDofD, &c_evenDofToDofD);
+
+  cudaMemcpyToSymbol(const_DofToDofD,     c_DofToDofD,     Nq*Nq*sizeof(dfloat), 0, cudaMemcpyDeviceToDevice);
+  cudaMemcpyToSymbol(const_oddDofToDofD,  c_oddDofToDofD,  halfNq*halfNq*sizeof(dfloat), 0, cudaMemcpyDeviceToDevice);
+  cudaMemcpyToSymbol(const_evenDofToDofD, c_evenDofToDofD, halfNq*halfNq*sizeof(dfloat), 0, cudaMemcpyDeviceToDevice);
+  
+  cudaEvent_t start, end;
+  cudaEventCreate(&start);
+  cudaEventCreate(&end);	
+
+  // KERNEL GRID
+  // do nothing kernel test
+  dfloat nothingElapsed = nothingTest(stream, Ntests);
+  nothingElapsed = nothingTest(stream, Ntests);
+  
+  // warm up call
+  runBK5Kernel (stream, Nq, numElements, lambda,
+		c_op,
+		c_DofToDofD, c_oddDofToDofD, c_evenDofToDofD,
+		c_solIn, c_solOut, mode);
+  
+#if USE_GRAPH==1
+  // cuda stream capture
+  cudaGraph_t graph;
+  
+  cudaStreamBeginCapture(stream, cudaStreamCaptureModeGlobal);
+
+  for(int test=0;test<Ntests;++test){
+
+    runMassBK5Kernel (stream, Nq, numElements, lambda,
+		      c_op,
+		      c_DofToDofD, c_oddDofToDofD, c_evenDofToDofD,
+		      c_solIn, c_solOut, mode);
+  }
+  
+  cudaStreamEndCapture(stream, &graph);
+  
+  cudaGraphExec_t instance;
+  cudaGraphInstantiate(&instance, graph, NULL, NULL, 0);
+#endif
+  
+  cudaDeviceSynchronize();
+
+  {
+    cudaEventRecord(start, stream);
+    
+#if USE_GRAPH==0
+    for(int test=0;test<Ntests;++test){
+
+      runBK5Kernel (stream, Nq, numElements, lambda,
+		    c_op,
+		    c_DofToDofD, c_oddDofToDofD, c_evenDofToDofD,
+		    c_solIn, c_solOut, mode);
+      
+    }
+#else
+    cudaGraphLaunch(instance, stream);
+#endif
+
+    cudaEventRecord(end, stream);
+    
+    cudaEventSynchronize(end);
+    
+    float elapsed;
+    cudaEventElapsedTime(&elapsed, start, end);
+    elapsed /= 1000.;
+    elapsed /= (double) Ntests;
+
+    int bytesMoved = (2*Np+7*Np)*sizeof(dfloat); // x, Mx, opa   
+    double bw = (bytesMoved*numElements/elapsed)/1.e9;
+
+    double flopCount = Np*(6*2*Nq + 17);
+    double gflops = (flopCount*numElements/elapsed)/1.e9;
+    
+    printf("%2d %8d %8d %e %e %e %e %e %e %%%% [BK5: N, numElements, Ndofs,"
+	   " elapsed, dofsPerSecond, nothingElapsed, BW in GB/s, estimatedActualDeviceBandwidth, GFLOPS/s]\n",
+	   Nq-1, numElements, Np*numElements, elapsed, numElements*(Np/elapsed),
+	   nothingElapsed, bw, estimatedActualDeviceBandwidth, gflops);
+  }
+
+  // check output is correct
+  //  BK5Host (Nq, numElements, lambda, h_op, h_DofToDofD, h_solIn, h_solOut);
+  meshReferenceBK5(Nq, numElements, lambda, h_op, h_DofToDofD, h_solIn, h_solOut);
+
+  // copy device version to host old qh
+  dfloat *fromDevice = (dfloat*) calloc(numElements*Np, sizeof(dfloat));
+  cudaMemcpy(fromDevice, c_solOut, numElements*Np*sizeof(dfloat), cudaMemcpyDeviceToHost);
+
+  dfloat maxDiff = 0;
+  
+  for(int e=0;e<numElements;++e){
+    for(int n=0;n<Np;++n){
+      int id = e*Np + n;
+      dfloat diff = fabs(h_solOut[id]-fromDevice[id]);
+      maxDiff = (diff>maxDiff) ? diff:maxDiff;
+    }
+  }
+  printf("|| Mq_{host} - Mq_{device} ||_linf = %lg\n", maxDiff);
+  
+  cudaEventDestroy(start);
+  cudaEventDestroy(end);	
+  
+  return 0;
+
+}

cuda_code/BatchNormalization_8.cu

@@ -0,0 +1,99 @@
+#ifndef THC_GENERIC_FILE
+#define THC_GENERIC_FILE "generic/BatchNormalization.cu"
+#else
+
+#define DeviceTensor3 THCDeviceTensor<real, 3>
+#define DeviceTensor1 THCDeviceTensor<real, 1>
+
+template <int Dim>
+static THCDeviceTensor<real, Dim> devicetensor(THCState *state, THCTensor *t) {
+  if (!t) {
+    return THCDeviceTensor<real, Dim>();
+  }
+
+  int inDim = THCTensor_(nDimension)(state, t);
+  if (inDim == Dim) {
+    return toDeviceTensor<real, Dim>(state, t);
+  }
+
+  // View in which the last dimensions are collapsed or expanded as needed
+  THAssert(THCTensor_(isContiguous)(state, t));
+  int size[Dim];
+  for (int i = 0; i < Dim || i < inDim; ++i) {
+    if (i < Dim && i < inDim) {
+      size[i] = t->size[i];
+    } else if (i < Dim) {
+      size[i] = 1;
+    } else {
+      size[Dim - 1] *= t->size[i];
+    }
+  }
+  return THCDeviceTensor<real, Dim>(THCTensor_(data)(state, t), size);
+}
+
+void THNN_(BatchNormalization_updateOutput)(
+  THCState *state, THCTensor *input_, THCTensor *output_,
+  THCTensor *weight_, THCTensor *bias_, THCTensor *runningMean_,
+  THCTensor *runningVar_, THCTensor *saveMean_, THCTensor *saveStd_,
+  bool train, double momentum, double eps) {
+
+  THCTensor_(resizeAs)(state, output_, input_);
+  DeviceTensor3 input = devicetensor<3>(state, input_);
+  DeviceTensor3 output = devicetensor<3>(state, output_);
+  DeviceTensor1 weight = devicetensor<1>(state, weight_);
+  DeviceTensor1 bias = devicetensor<1>(state, bias_);
+  DeviceTensor1 runningMean = devicetensor<1>(state, runningMean_);
+  DeviceTensor1 runningVar = devicetensor<1>(state, runningVar_);
+  DeviceTensor1 saveMean = devicetensor<1>(state, saveMean_);
+  DeviceTensor1 saveStd = devicetensor<1>(state, saveStd_);
+
+  cudaStream_t s = THCState_getCurrentStream(state);
+  cudaDeviceProp *prop = THCState_getCurrentDeviceProperties(state);
+
+  if (!train) {
+    dim3 blocks(input.getSize(1));
+    dim3 threads(getNumThreads(input.getSize(2)));
+    BatchNormalizationUpdateOutputInference_kernel<real, accreal, DeviceTensor1, DeviceTensor3> <<<blocks, threads, 0, s>>>(
+      input, output, runningMean, runningVar, weight, bias, eps);
+  } else {
+    dim3 blocks(input.getSize(1));
+    dim3 threads(getNumThreads(input.getSize(2)));
+    BatchNormalizationUpdateOutput_kernel<real, accreal, DeviceTensor1, DeviceTensor3> <<<blocks, threads, 0, s>>>(
+      input, output, weight, bias, eps, momentum, runningMean, runningVar,
+      saveMean, saveStd);
+  }
+  THCudaCheck(cudaGetLastError());
+}
+
+void THNN_(BatchNormalization_backward)(
+  THCState *state, THCTensor *input_, THCTensor *gradOutput_,
+  THCTensor *gradInput_, THCTensor *gradWeight_, THCTensor *gradBias_,
+  THCTensor *weight_, THCTensor *runningMean_, THCTensor *runningVar_,
+  THCTensor *saveMean_, THCTensor *saveStd_, bool train, float scale, double eps) {
+
+  THCUNN_check_shape(state, input_, gradOutput_);
+  DeviceTensor3 input = devicetensor<3>(state, input_);
+  DeviceTensor3 gradOutput = devicetensor<3>(state, gradOutput_);
+  DeviceTensor3 gradInput = devicetensor<3>(state, gradInput_);
+  DeviceTensor1 gradWeight = devicetensor<1>(state, gradWeight_);
+  DeviceTensor1 gradBias = devicetensor<1>(state, gradBias_);
+  DeviceTensor1 weight = devicetensor<1>(state, weight_);
+  DeviceTensor1 runningMean = devicetensor<1>(state, runningMean_);
+  DeviceTensor1 runningVar = devicetensor<1>(state, runningVar_);
+  DeviceTensor1 saveMean = devicetensor<1>(state, saveMean_);
+  DeviceTensor1 saveStd = devicetensor<1>(state, saveStd_);
+
+  cudaStream_t s = THCState_getCurrentStream(state);
+
+  dim3 blocks(gradOutput.getSize(1));
+  dim3 threads(getNumThreads(gradOutput.getSize(2)));
+  BatchNormalizationBackward_kernel<real,  accreal,  DeviceTensor1, DeviceTensor3> <<<blocks, threads, 0, s>>>(
+    input, gradOutput, gradInput, gradWeight, gradBias, weight, runningMean, runningVar,
+    saveMean, saveStd, train, scale, eps);
+  THCudaCheck(cudaGetLastError());
+}
+
+#undef DeviceTensor3
+#undef DeviceTensor1
+
+#endif

cuda_code/BlockSelectFloat_1.cu

@@ -0,0 +1,122 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD+Patents license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+// Copyright 2004-present Facebook. All Rights Reserved.
+#include "blockselect/BlockSelectImpl.cuh"
+
+namespace faiss { namespace gpu {
+
+// warp Q to thread Q:
+// 1, 1
+// 32, 2
+// 64, 3
+// 128, 3
+// 256, 4
+// 512, 8
+// 1024, 8
+
+BLOCK_SELECT_DECL(float, true, 1);
+BLOCK_SELECT_DECL(float, true, 32);
+BLOCK_SELECT_DECL(float, true, 64);
+BLOCK_SELECT_DECL(float, true, 128);
+BLOCK_SELECT_DECL(float, true, 256);
+BLOCK_SELECT_DECL(float, true, 512);
+BLOCK_SELECT_DECL(float, true, 1024);
+
+BLOCK_SELECT_DECL(float, false, 1);
+BLOCK_SELECT_DECL(float, false, 32);
+BLOCK_SELECT_DECL(float, false, 64);
+BLOCK_SELECT_DECL(float, false, 128);
+BLOCK_SELECT_DECL(float, false, 256);
+BLOCK_SELECT_DECL(float, false, 512);
+BLOCK_SELECT_DECL(float, false, 1024);
+
+void runBlockSelect(Tensor<float, 2, true>& in,
+                    Tensor<float, 2, true>& outK,
+                    Tensor<int, 2, true>& outV,
+                    bool dir, int k, cudaStream_t stream) {
+  FAISS_ASSERT(k <= 1024);
+
+  if (dir) {
+    if (k == 1) {
+      BLOCK_SELECT_CALL(float, true, 1);
+    } else if (k <= 32) {
+      BLOCK_SELECT_CALL(float, true, 32);
+    } else if (k <= 64) {
+      BLOCK_SELECT_CALL(float, true, 64);
+    } else if (k <= 128) {
+      BLOCK_SELECT_CALL(float, true, 128);
+    } else if (k <= 256) {
+      BLOCK_SELECT_CALL(float, true, 256);
+    } else if (k <= 512) {
+      BLOCK_SELECT_CALL(float, true, 512);
+    } else if (k <= 1024) {
+      BLOCK_SELECT_CALL(float, true, 1024);
+    }
+  } else {
+    if (k == 1) {
+      BLOCK_SELECT_CALL(float, false, 1);
+    } else if (k <= 32) {
+      BLOCK_SELECT_CALL(float, false, 32);
+    } else if (k <= 64) {
+      BLOCK_SELECT_CALL(float, false, 64);
+    } else if (k <= 128) {
+      BLOCK_SELECT_CALL(float, false, 128);
+    } else if (k <= 256) {
+      BLOCK_SELECT_CALL(float, false, 256);
+    } else if (k <= 512) {
+      BLOCK_SELECT_CALL(float, false, 512);
+    } else if (k <= 1024) {
+      BLOCK_SELECT_CALL(float, false, 1024);
+    }
+  }
+}
+
+void runBlockSelectPair(Tensor<float, 2, true>& inK,
+                        Tensor<int, 2, true>& inV,
+                        Tensor<float, 2, true>& outK,
+                        Tensor<int, 2, true>& outV,
+                        bool dir, int k, cudaStream_t stream) {
+  FAISS_ASSERT(k <= 1024);
+
+  if (dir) {
+    if (k == 1) {
+      BLOCK_SELECT_PAIR_CALL(float, true, 1);
+    } else if (k <= 32) {
+      BLOCK_SELECT_PAIR_CALL(float, true, 32);
+    } else if (k <= 64) {
+      BLOCK_SELECT_PAIR_CALL(float, true, 64);
+    } else if (k <= 128) {
+      BLOCK_SELECT_PAIR_CALL(float, true, 128);
+    } else if (k <= 256) {
+      BLOCK_SELECT_PAIR_CALL(float, true, 256);
+    } else if (k <= 512) {
+      BLOCK_SELECT_PAIR_CALL(float, true, 512);
+    } else if (k <= 1024) {
+      BLOCK_SELECT_PAIR_CALL(float, true, 1024);
+    }
+  } else {
+    if (k == 1) {
+      BLOCK_SELECT_PAIR_CALL(float, false, 1);
+    } else if (k <= 32) {
+      BLOCK_SELECT_PAIR_CALL(float, false, 32);
+    } else if (k <= 64) {
+      BLOCK_SELECT_PAIR_CALL(float, false, 64);
+    } else if (k <= 128) {
+      BLOCK_SELECT_PAIR_CALL(float, false, 128);
+    } else if (k <= 256) {
+      BLOCK_SELECT_PAIR_CALL(float, false, 256);
+    } else if (k <= 512) {
+      BLOCK_SELECT_PAIR_CALL(float, false, 512);
+    } else if (k <= 1024) {
+      BLOCK_SELECT_PAIR_CALL(float, false, 1024);
+    }
+  }
+}
+
+} } // namespace

cuda_code/BounceBackNVEGPU_6.cu

@@ -0,0 +1,103 @@
+// Copyright (c) 2018-2020, Michael P. Howard
+// Copyright (c) 2021, Auburn University
+// This file is part of the azplugins project, released under the Modified BSD License.
+
+/*!
+ * \file BounceBackNVEGPU.cu
+ * \brief Template specialization of CUDA kernels for BounceBackNVEGPU geometries. Each instance of the
+ *        nve_bounce_step_one must be templated explicitly for each geometry.
+ */
+
+#include "BounceBackNVEGPU.cuh"
+#include "BounceBackGeometry.h"
+
+namespace azplugins
+{
+namespace gpu
+{
+
+//! Template instantiation of slit geometry streaming
+template cudaError_t nve_bounce_step_one<mpcd::detail::SlitGeometry>
+    (const bounce_args_t& args, const mpcd::detail::SlitGeometry& geom);
+
+namespace kernel
+{
+//! Kernel for applying second step of velocity Verlet algorithm with bounce back
+/*!
+ * \param d_vel Particle velocities
+ * \param d_accel Particle accelerations
+ * \param d_net_force Net force on each particle
+ * \param d_group Indexes in particle group
+ * \param dt Timestep
+ * \param N Number of particles in group
+ *
+ * \b Implementation:
+ * Using one thread per particle, the particle velocities are updated according to the second step of the velocity Verlet
+ * algorithm. This is the standard update as in MD, and is only reimplemented here in case future modifications are necessary.
+ */
+__global__ void nve_bounce_step_two(Scalar4 *d_vel,
+                                    Scalar3 *d_accel,
+                                    const Scalar4 *d_net_force,
+                                    const unsigned int *d_group,
+                                    const Scalar dt,
+                                    const unsigned int N)
+    {
+    // one thread per particle
+    unsigned int idx = blockIdx.x * blockDim.x + threadIdx.x;
+    if (idx >= N)
+        return;
+    const unsigned int pid = d_group[idx];
+
+    const Scalar4 net_force = d_net_force[pid];
+    Scalar3 accel = make_scalar3(net_force.x, net_force.y, net_force.z);
+    Scalar4 vel = d_vel[pid];
+    accel.x /= vel.w;
+    accel.y /= vel.w;
+    accel.z /= vel.w;
+
+    // then, update the velocity
+    vel.x += Scalar(0.5) * accel.x * dt;
+    vel.y += Scalar(0.5) * accel.y * dt;
+    vel.z += Scalar(0.5) * accel.z * dt;
+
+    d_vel[pid] = vel;
+    d_accel[pid] = accel;
+    }
+} // end namespace kernel
+
+/*!
+ * \param d_vel Particle velocities
+ * \param d_accel Particle accelerations
+ * \param d_net_force Net force on each particle
+ * \param d_group Indexes in particle group
+ * \param dt Timestep
+ * \param N Number of particles in group
+ * \param block_size Number of threads per block
+ *
+ * \sa kernel::nve_bounce_step_two
+ */
+cudaError_t nve_bounce_step_two(Scalar4 *d_vel,
+                                Scalar3 *d_accel,
+                                const Scalar4 *d_net_force,
+                                const unsigned int *d_group,
+                                const Scalar dt,
+                                const unsigned int N,
+                                const unsigned int block_size)
+    {
+    static unsigned int max_block_size = UINT_MAX;
+    if (max_block_size == UINT_MAX)
+        {
+        cudaFuncAttributes attr;
+        cudaFuncGetAttributes(&attr, (const void*)kernel::nve_bounce_step_two);
+        max_block_size = attr.maxThreadsPerBlock;
+        }
+
+    unsigned int run_block_size = min(block_size, max_block_size);
+    dim3 grid(N / run_block_size + 1);
+    kernel::nve_bounce_step_two<<<grid, run_block_size>>>(d_vel, d_accel, d_net_force, d_group, dt, N);
+
+    return cudaSuccess;
+    }
+
+} // end namespace gpu
+} // end namespace azplugins

cuda_code/COOtoCSR_2.cu

@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2020, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <functions.hpp>
+#include "COOtoCSR.cuh"
+
+namespace cugraph {
+
+// Explicit instantiation for uint32_t + float
+template std::unique_ptr<GraphCSR<uint32_t, uint32_t, float>> coo_to_csr<uint32_t, uint32_t, float>(
+  GraphCOOView<uint32_t, uint32_t, float> const &graph, rmm::mr::device_memory_resource *);
+
+// Explicit instantiation for uint32_t + double
+template std::unique_ptr<GraphCSR<uint32_t, uint32_t, double>>
+coo_to_csr<uint32_t, uint32_t, double>(GraphCOOView<uint32_t, uint32_t, double> const &graph,
+                                       rmm::mr::device_memory_resource *);
+
+// Explicit instantiation for int + float
+template std::unique_ptr<GraphCSR<int32_t, int32_t, float>> coo_to_csr<int32_t, int32_t, float>(
+  GraphCOOView<int32_t, int32_t, float> const &graph, rmm::mr::device_memory_resource *);
+
+// Explicit instantiation for int + double
+template std::unique_ptr<GraphCSR<int32_t, int32_t, double>> coo_to_csr<int32_t, int32_t, double>(
+  GraphCOOView<int32_t, int32_t, double> const &graph, rmm::mr::device_memory_resource *);
+
+// Explicit instantiation for int64_t + float
+template std::unique_ptr<GraphCSR<int64_t, int64_t, float>> coo_to_csr<int64_t, int64_t, float>(
+  GraphCOOView<int64_t, int64_t, float> const &graph, rmm::mr::device_memory_resource *);
+
+// Explicit instantiation for int64_t + double
+template std::unique_ptr<GraphCSR<int64_t, int64_t, double>> coo_to_csr<int64_t, int64_t, double>(
+  GraphCOOView<int64_t, int64_t, double> const &graph, rmm::mr::device_memory_resource *);
+
+// in-place versions:
+//
+// Explicit instantiation for uint32_t + float
+template void coo_to_csr_inplace<uint32_t, uint32_t, float>(
+  GraphCOOView<uint32_t, uint32_t, float> &graph, GraphCSRView<uint32_t, uint32_t, float> &result);
+
+// Explicit instantiation for uint32_t + double
+template void coo_to_csr_inplace<uint32_t, uint32_t, double>(
+  GraphCOOView<uint32_t, uint32_t, double> &graph,
+  GraphCSRView<uint32_t, uint32_t, double> &result);
+
+// Explicit instantiation for int + float
+template void coo_to_csr_inplace<int32_t, int32_t, float>(
+  GraphCOOView<int32_t, int32_t, float> &graph, GraphCSRView<int32_t, int32_t, float> &result);
+
+// Explicit instantiation for int + double
+template void coo_to_csr_inplace<int32_t, int32_t, double>(
+  GraphCOOView<int32_t, int32_t, double> &graph, GraphCSRView<int32_t, int32_t, double> &result);
+
+// Explicit instantiation for int64_t + float
+template void coo_to_csr_inplace<int64_t, int64_t, float>(
+  GraphCOOView<int64_t, int64_t, float> &graph, GraphCSRView<int64_t, int64_t, float> &result);
+
+// Explicit instantiation for int64_t + double
+template void coo_to_csr_inplace<int64_t, int64_t, double>(
+  GraphCOOView<int64_t, int64_t, double> &graph, GraphCSRView<int64_t, int64_t, double> &result);
+
+}  // namespace cugraph

cuda_code/CPU_GPU_time.cu

@@ -0,0 +1,110 @@
+/*
+ * =====================================================================================
+ *
+ *       Filename:  testLironPaper.cu
+ *
+ *    Description:  This tries to match computation results with those in
+ *    Liron's paper.
+ *
+ *        Version:  1.0
+ *        Created:  04/04/2014 07:58:39 AM
+ *       Revision:  none
+ *       Compiler:  gcc
+ *
+ *         Author:  Hoang-Ngan Nguyen (), zhoangngan-gmail
+ *   Organization:  
+ *
+ * =====================================================================================
+ */
+
+#include "periodicStokes.h"
+#include <cstdlib>  /* srand, rand */
+#include <ctime>    /* time */
+#include <string>
+#include <fstream>
+#include <iostream>
+#include <eigen3/Eigen/Dense>
+using namespace std;
+using namespace Eigen;
+
+int main( int argc, char *argv[] ) {
+  MatrixOnHost L(3, 1, 1);
+
+  //open binary file to save GPU and CPU times
+  //char timeName[80];
+  //sprintf(timeName, "CPU_GPU_time", filename);
+  //ofstream outTime(timeName, ios::binary);
+
+  //if (!outTime) {
+    //std::cout << "Error: Could not open file \"" << timeName << "\"" 
+      //<< ". Error occurs on line " << __LINE__ 
+      //<< " in source file \"" << __FILE__ << "\"" << std::endl;;
+    //exit(1);
+  //}
+  MatrixOnHost timeM(2, 4);
+
+  int maxShell = 4;
+  double d = 1.0/sqrt(atan(1)*4);
+  double e = 0;
+  
+  clock_t start, end;
+  cudaEvent_t eStart, eStop;
+  HANDLE_ERROR( cudaEventCreate( &eStart ) );
+  HANDLE_ERROR( cudaEventCreate( &eStop  ) );
+
+  MatrixOnHost newM(2, 1), oldM(2, 1);
+  float elapsedTime;
+  size_t size = 10;
+  size_t maxCol = 10;
+  for (int i = 0; i < 4; i++) {
+    cout << "Round " << i << endl;
+    MatrixOnHost x(3, size), x0(3, maxCol);
+    x.setRandom();
+    x0 = x;
+    //MatrixOnDevice dx = x, dx0 = x0;
+    //MatrixOnDevice dA(3*dx.columns(), 3*dx0.columns());
+
+    // record GPU time
+    //for (int j = 0; j * maxCol < size; j++) {
+      //for (int l = 0; l < 3; l++) {
+        //for (int k = 0; k < maxCol; k++) {
+          //x0(l, k) = x(l, j * maxCol + k);
+        //}
+      //}
+      //dx0 = x0;
+      //HANDLE_ERROR( cudaEventRecord( eStart, 0) );
+      //imageStokeslet( dA, dx, dx0, d, e, maxShell, maxShell-1, L(0), L(1) ); 
+      //HANDLE_ERROR( cudaEventRecord( eStop , 0) );
+      //HANDLE_ERROR( cudaEventSynchronize( eStop ) );
+      //HANDLE_ERROR( cudaEventElapsedTime( &elapsedTime, eStart, eStop ) );
+      //timeM(0, i) = elapsedTime;
+    //}
+
+    //record CPU time
+    MatrixOnHost    A(3*x.columns(), 3*x.columns());
+    MatrixOnHost    absA = A, refSol = A;
+    start = clock();
+    newM(0) = newM(1) = oldM(0) = oldM(1) = 0;
+    realShells ( refSol, absA, x, x, newM, oldM, L, d, e );
+    fourierShells(A, absA, x, x, newM, oldM, L, d, e);
+    refSol = refSol + A;
+    newM(0) = newM(1) = maxShell;
+    realShells ( refSol, absA, x, x, newM, oldM, L, d, e );
+    newM(0) = newM(1) = maxShell-1;
+    fourierShells(refSol, absA, x, x, newM, oldM, L, d, e);
+    end   = clock();
+    timeM(1, i) = 1000.0 * ((double) (end - start)) / CLOCKS_PER_SEC ;
+    size *= 8;
+    cout << "maxShell = " << maxShell << endl;
+    cout << "time is " << timeM(1, i) << "ms" << endl;
+  }
+  timeM.write("CPU_GPU_time");
+  HANDLE_ERROR( cudaEventDestroy( eStart ) );
+  HANDLE_ERROR( cudaEventDestroy( eStop  ) );
+  //outTime.close();
+  
+	cout << "Done!!!!!!!!!!!!!!" << endl;
+
+	return EXIT_SUCCESS;
+}				// ----------  end of function main  ----------
+

cuda_code/CUAPI_Asyn_PoissonGravitySolver_8.cu

@@ -0,0 +1,473 @@
+#include "CUAPI.h"
+#include "CUPOT.h"
+
+#if ( defined GPU  &&  defined GRAVITY )
+
+
+
+// Poisson solver prototypes
+#if   ( POT_SCHEME == SOR )
+#ifdef USE_PSOLVER_10TO14
+__global__ void CUPOT_PoissonSolver_SOR_10to14cube( const real g_Rho_Array    [][ RHO_NXT*RHO_NXT*RHO_NXT ],
+                                                    const real g_Pot_Array_In [][ POT_NXT*POT_NXT*POT_NXT ],
+                                                          real g_Pot_Array_Out[][ GRA_NXT*GRA_NXT*GRA_NXT ],
+                                                    const int Min_Iter, const int Max_Iter, const real Omega_6,
+                                                    const real Const, const IntScheme_t IntScheme );
+#else
+__global__ void CUPOT_PoissonSolver_SOR_16to18cube( const real g_Rho_Array    [][ RHO_NXT*RHO_NXT*RHO_NXT ],
+                                                    const real g_Pot_Array_In [][ POT_NXT*POT_NXT*POT_NXT ],
+                                                          real g_Pot_Array_Out[][ GRA_NXT*GRA_NXT*GRA_NXT ],
+                                                    const int Min_Iter, const int Max_Iter, const real Omega_6,
+                                                    const real Const, const IntScheme_t IntScheme );
+#endif // #ifdef USE_PSOLVER_10TO14 ... else ...
+
+#elif ( POT_SCHEME == MG  )
+__global__ void CUPOT_PoissonSolver_MG( const real g_Rho_Array    [][ RHO_NXT*RHO_NXT*RHO_NXT ],
+                                        const real g_Pot_Array_In [][ POT_NXT*POT_NXT*POT_NXT ],
+                                              real g_Pot_Array_Out[][ GRA_NXT*GRA_NXT*GRA_NXT ],
+                                        const real dh_Min, const int Max_Iter, const int NPre_Smooth,
+                                        const int NPost_Smooth, const real Tolerated_Error, const real Poi_Coeff,
+                                        const IntScheme_t IntScheme );
+#endif // POT_SCHEME
+
+
+// Gravity solver prototypes
+#if   ( MODEL == HYDRO )
+__global__
+void CUPOT_HydroGravitySolver(
+         real   g_Flu_Array_New[][GRA_NIN][ CUBE(PS1) ],
+   const real   g_Pot_Array_New[][ CUBE(GRA_NXT) ],
+   const double g_Corner_Array [][3],
+   const real   g_Pot_Array_USG[][ CUBE(USG_NXT_G) ],
+   const real   g_Flu_Array_USG[][GRA_NIN-1][ CUBE(PS1) ],
+         char   g_DE_Array     [][ CUBE(PS1) ],
+   const real   g_EngyB_Array  [][ CUBE(PS1) ],
+   const real dt, const real dh, const bool P5_Gradient,
+   const OptGravityType_t GravityType,
+   const double TimeNew, const double TimeOld, const real MinEint );
+
+#elif ( MODEL == ELBDM )
+__global__ void CUPOT_ELBDMGravitySolver(       real g_Flu_Array[][GRA_NIN][ PS1*PS1*PS1 ],
+                                          const real g_Pot_Array[][ GRA_NXT*GRA_NXT*GRA_NXT ],
+                                          const double g_Corner_Array[][3],
+                                          const real EtaDt, const real dh, const real Lambda, const bool ExtPot,
+                                          const double TimeNew );
+
+#else
+#error : ERROR : unsupported MODEL !!
+#endif // MODEL
+
+
+// declare all device pointers
+extern real (*d_Rho_Array_P    )[ CUBE(RHO_NXT) ];
+extern real (*d_Pot_Array_P_In )[ CUBE(POT_NXT) ];
+extern real (*d_Pot_Array_P_Out)[ CUBE(GRA_NXT) ];
+extern real (*d_Flu_Array_G    )[GRA_NIN][ CUBE(PS1)];
+extern double (*d_Corner_Array_G)[3];
+#if ( MODEL == HYDRO )
+#ifdef UNSPLIT_GRAVITY
+extern real (*d_Pot_Array_USG_G)[ CUBE(USG_NXT_G) ];
+extern real (*d_Flu_Array_USG_G)[GRA_NIN-1][ CUBE(PS1) ];
+#else
+static real (*d_Pot_Array_USG_G)[ CUBE(USG_NXT_G) ] = NULL;
+static real (*d_Flu_Array_USG_G)[GRA_NIN-1][ CUBE(PS1) ] = NULL;
+#endif
+#ifdef DUAL_ENERGY
+extern char (*d_DE_Array_G)[ CUBE(PS1) ];
+#else
+static char (*d_DE_Array_G)[ CUBE(PS1) ] = NULL;
+#endif
+#ifdef MHD
+extern real (*d_EngyB_Array_G)[ CUBE(PS1) ];
+#else
+static real (*d_EngyB_Array_G)[ CUBE(PS1) ] = NULL;
+#endif
+#endif // #if ( MODEL == HYDRO )
+
+extern cudaStream_t *Stream;
+
+
+
+
+//-------------------------------------------------------------------------------------------------------
+// Function    :  CUAPI_Asyn_PoissonGravitySolver
+// Description :  Invoke the CUPOT_PoissonSolver_XXtoXXcube and/or CUPOT_GravitySolver kernel(s) to evaluate
+//                the gravitational potential and/or advance the fluid variables by the gravitational
+//                acceleration for a group of patches
+//
+//                ***********************************************************
+//                **                Asynchronous Function                  **
+//                **                                                       **
+//                **  will return before the execution in GPU is complete  **
+//                ***********************************************************
+//
+// Note        :  a. Use streams for the asychronous memory copy between device and host
+//                b. Prefix "d" : for pointers pointing to the "Device" memory space
+//                   Prefix "h" : for pointers pointing to the "Host"   memory space
+//
+// Parameter   :  h_Rho_Array          : Host array storing the input density
+//                h_Pot_Array_In       : Host array storing the input "coarse-grid" potential for interpolation
+//                h_Pot_Array_Out      : Host array to store the output potential
+//                h_Flu_Array          : Host array to store the fluid variables for the Gravity solver
+//                h_Corner_Array       : Host array storing the physical corner coordinates of each patch
+//                h_Pot_Array_USG      : Host array storing the prepared potential for UNSPLIT_GRAVITY
+//                h_Flu_Array_USG      : Host array storing the prepared density + momentum for UNSPLIT_GRAVITY
+//                h_DE_Array           : Host array storing the dual-energy status (for both input and output)
+//                h_EngyB_Array        : Host array storing the cell-centered magnetic energy (MHD only)
+//                NPatchGroup          : Number of patch groups evaluated simultaneously by GPU
+//                dt                   : Time interval to advance solution
+//                dh                   : Grid size
+//                SOR_Min_Iter         : Minimum # of iterations for SOR
+//                SOR_Max_Iter         : Maximum # of iterations for SOR
+//                SOR_Omega            : Over-relaxation parameter
+//                MG_Max_Iter          : Maximum number of iterations for multigrid
+//                MG_NPre_Smooth       : Number of pre-smoothing steps for multigrid
+//                MG_NPos_tSmooth      : Number of post-smoothing steps for multigrid
+//                MG_Tolerated_Error   : Maximum tolerated error for multigrid
+//                Poi_Coeff            : Coefficient in front of density in the Poisson equation (4*Pi*Newton_G*a)
+//                IntScheme            : Interpolation scheme for potential
+//                                       --> currently supported schemes include
+//                                           INT_CQUAD : conservative quadratic interpolation
+//                                           INT_QUAD  : quadratic interpolation
+//                P5_Gradient          : Use 5-points stencil to evaluate the potential gradient
+//                ELBDM_Eta            : Particle mass / Planck constant in ELBDM
+//                ELBDM_Lambda         : Quartic self-interaction coefficient in ELBDM
+//                Poisson              : true --> invoke the Poisson solver
+//                GraAcc               : true --> invoke the Gravity solver
+//                GPU_NStream          : Number of CUDA streams for the asynchronous memory copy
+//                GravityType          : Types of gravity --> self-gravity, external gravity, both
+//                TimeNew              : Physical time at the current  step (for the external gravity solver)
+//                TimeOld              : Physical time at the previous step (for the external gravity solver in UNSPLIT_GRAVITY)
+//                ExtPot               : Add the external potential
+//                MinEint              : Minimum allowed internal energy (== MIN_PRES / (GAMMA-1))
+//
+// Useless parameters in HYDRO : ELBDM_Eta, ELBDM_Lambda
+// Useless parameters in ELBDM : P5_Gradient
+//-------------------------------------------------------------------------------------------------------
+void CUAPI_Asyn_PoissonGravitySolver( const real h_Rho_Array    [][RHO_NXT][RHO_NXT][RHO_NXT],
+                                      const real h_Pot_Array_In [][POT_NXT][POT_NXT][POT_NXT],
+                                            real h_Pot_Array_Out[][GRA_NXT][GRA_NXT][GRA_NXT],
+                                            real h_Flu_Array    [][GRA_NIN][PS1][PS1][PS1],
+                                      const double h_Corner_Array[][3],
+                                      const real h_Pot_Array_USG[][USG_NXT_G][USG_NXT_G][USG_NXT_G],
+                                      const real h_Flu_Array_USG[][GRA_NIN-1][PS1][PS1][PS1],
+                                            char h_DE_Array     [][PS1][PS1][PS1],
+                                      const real h_EngyB_Array  [][PS1][PS1][PS1],
+                                      const int NPatchGroup, const real dt, const real dh, const int SOR_Min_Iter,
+                                      const int SOR_Max_Iter, const real SOR_Omega, const int MG_Max_Iter,
+                                      const int MG_NPre_Smooth, const int MG_NPost_Smooth,
+                                      const real MG_Tolerated_Error, const real Poi_Coeff,
+                                      const IntScheme_t IntScheme, const bool P5_Gradient, const real ELBDM_Eta,
+                                      const real ELBDM_Lambda, const bool Poisson, const bool GraAcc, const int GPU_NStream,
+                                      const OptGravityType_t GravityType, const double TimeNew, const double TimeOld,
+                                      const bool ExtPot, const real MinEint )
+{
+
+// model-independent constants
+#  if   ( POT_SCHEME == SOR )
+   const dim3 Poi_Block_Dim( RHO_NXT/2, RHO_NXT, POT_BLOCK_SIZE_Z );
+#  elif ( POT_SCHEME == MG )
+   const dim3 Poi_Block_Dim( POT_BLOCK_SIZE_X, 1, 1 );
+#  endif
+   const dim3 Gra_Block_Dim( GRA_BLOCK_SIZE );
+   const int  NPatch      = NPatchGroup*8;
+#  if   ( POT_SCHEME == SOR )
+   const real Poi_Const   = Poi_Coeff*dh*dh;
+   const real SOR_Omega_6 = SOR_Omega/6.0;
+#  endif
+
+// model-dependent constants
+#  if   ( MODEL == HYDRO )
+
+#  elif ( MODEL == ELBDM )
+   const real ELBDM_EtaDt = ELBDM_Eta*dt;
+
+#  else
+#  error : ERROR : unsupported MODEL !!
+#  endif
+
+
+// check
+#  if ( MODEL == ELBDM  &&  !defined STORE_POT_GHOST  &&  GRA_GHOST_SIZE != 0 )
+#  warning : WARNING : GRA_GHOST_SIZE != 0 in ELBDM (without STORE_POT_GHOST) !!
+#  endif
+
+#  ifdef GAMER_DEBUG
+   const int Poi_NThread = Poi_Block_Dim.x * Poi_Block_Dim.y * Poi_Block_Dim.z;
+
+// minimum number of threads for spatial interpolation
+   if ( Poisson  &&  Poi_NThread < (POT_NXT-2)*(POT_NXT-2) )
+      Aux_Error( ERROR_INFO, "Poi_NThread (%d) < (POT_NXT-2)*(POT_NXT-2) (%d) !!\n",
+                 Poi_NThread, (POT_NXT-2)*(POT_NXT-2) );
+
+// constraint due to the reduction operation in "CUPOT_Poisson_10to14cube" and "CUPOT_PoissonSolver_MG"
+#  if (  ( POT_SCHEME == SOR && defined USE_PSOLVER_10TO14 )  ||  POT_SCHEME == MG  )
+   if ( Poisson  &&  Poi_NThread < 64 )
+      Aux_Error( ERROR_INFO, "incorrect parameter %s = %d (must >= 64) !!\n", "Poi_NThread", Poi_NThread );
+#  endif
+
+// constraint in "CUPOT_PoissonSolver_SOR_16to18cube"
+#  if ( POT_SCHEME == SOR  &&  !defined USE_PSOLVER_10TO14 )
+   if ( Poisson  &&  Poi_NThread != RHO_NXT*RHO_NXT/2 )
+      Aux_Error( ERROR_INFO, "incorrect parameter %s = %d (must == %d) !!\n", "Poi_NThread", Poi_NThread,
+                 RHO_NXT*RHO_NXT/2 );
+#  endif
+
+   if ( GraAcc )
+   {
+      if ( GravityType == GRAVITY_EXTERNAL  ||  GravityType == GRAVITY_BOTH  ||  ExtPot )
+      {
+         if ( h_Corner_Array   == NULL )     Aux_Error( ERROR_INFO, "h_Corner_Array == NULL !!\n" );
+         if ( d_Corner_Array_G == NULL )     Aux_Error( ERROR_INFO, "d_Corner_Array_G == NULL !!\n" );
+      }
+
+#     ifdef UNSPLIT_GRAVITY
+      if ( GravityType == GRAVITY_SELF  ||  GravityType == GRAVITY_BOTH )
+      {
+         if ( h_Pot_Array_USG   == NULL )    Aux_Error( ERROR_INFO, "h_Pot_Array_USG == NULL !!\n" );
+         if ( d_Pot_Array_USG_G == NULL )    Aux_Error( ERROR_INFO, "d_Pot_Array_USG_G == NULL !!\n" );
+      }
+
+      if ( h_Flu_Array_USG   == NULL )       Aux_Error( ERROR_INFO, "h_Flu_Array_USG == NULL !!\n" );
+      if ( d_Flu_Array_USG_G == NULL )       Aux_Error( ERROR_INFO, "d_Flu_Array_USG_G == NULL !!\n" );
+#     endif
+
+#     ifdef DUAL_ENERGY
+      if ( h_DE_Array   == NULL )            Aux_Error( ERROR_INFO, "h_DE_Array == NULL !!\n" );
+      if ( d_DE_Array_G == NULL )            Aux_Error( ERROR_INFO, "d_DE_Array_G == NULL !!\n" );
+#     endif
+
+#     ifdef MHD
+      if ( h_EngyB_Array   == NULL )         Aux_Error( ERROR_INFO, "h_EngyB_Array == NULL !!\n" );
+      if ( d_EngyB_Array_G == NULL )         Aux_Error( ERROR_INFO, "d_EngyB_Array_G == NULL !!\n" );
+#     endif
+   }
+#  endif // #ifdef GAMER_DEBUG
+
+   if ( Poisson  &&  ( IntScheme != INT_CQUAD  &&  IntScheme != INT_QUAD )  )
+      Aux_Error( ERROR_INFO, "incorrect parameter %s = %d !!\n", "IntScheme", IntScheme );
+
+
+   int *NPatch_per_Stream = new int [GPU_NStream];
+   int *Rho_MemSize       = new int [GPU_NStream];
+   int *Pot_MemSize_In    = new int [GPU_NStream];
+   int *Pot_MemSize_Out   = new int [GPU_NStream];
+   int *Flu_MemSize       = new int [GPU_NStream];
+   int *Corner_MemSize    = new int [GPU_NStream];
+   int *UsedPatch         = new int [GPU_NStream];
+#  ifdef UNSPLIT_GRAVITY
+   int *Pot_USG_MemSize   = new int [GPU_NStream];
+   int *Flu_USG_MemSize   = new int [GPU_NStream];
+#  endif
+#  ifdef DUAL_ENERGY
+   int *DE_MemSize        = new int [GPU_NStream];
+#  endif
+#  ifdef MHD
+   int *EngyB_MemSize     = new int [GPU_NStream];
+#  endif
+
+
+// set the number of patches in each stream
+   UsedPatch[0] = 0;
+
+   if ( GPU_NStream == 1 )    NPatch_per_Stream[0] = NPatch;
+   else
+   {
+      for (int s=0; s<GPU_NStream-1; s++)
+      {
+         NPatch_per_Stream[s] = NPatch/GPU_NStream;
+         UsedPatch[s+1] = UsedPatch[s] + NPatch_per_Stream[s];
+      }
+
+      NPatch_per_Stream[GPU_NStream-1] = NPatch - UsedPatch[GPU_NStream-1];
+   }
+
+
+// set the size of data to be transferred into GPU in each stream
+   for (int s=0; s<GPU_NStream; s++)
+   {
+      Rho_MemSize    [s] = NPatch_per_Stream[s]*CUBE(RHO_NXT  )*sizeof(real);
+      Pot_MemSize_In [s] = NPatch_per_Stream[s]*CUBE(POT_NXT  )*sizeof(real);
+      Pot_MemSize_Out[s] = NPatch_per_Stream[s]*CUBE(GRA_NXT  )*sizeof(real);
+      Flu_MemSize    [s] = NPatch_per_Stream[s]*CUBE(PS1      )*sizeof(real)*GRA_NIN;
+      Corner_MemSize [s] = NPatch_per_Stream[s]*3              *sizeof(double);
+#     ifdef UNSPLIT_GRAVITY
+      Pot_USG_MemSize[s] = NPatch_per_Stream[s]*CUBE(USG_NXT_G)*sizeof(real);
+      Flu_USG_MemSize[s] = NPatch_per_Stream[s]*CUBE(PS1      )*sizeof(real)*(GRA_NIN-1);
+#     endif
+#     ifdef DUAL_ENERGY
+      DE_MemSize     [s] = NPatch_per_Stream[s]*CUBE(PS1      )*sizeof(char);
+#     endif
+#     ifdef MHD
+      EngyB_MemSize  [s] = NPatch_per_Stream[s]*CUBE(PS1      )*sizeof(real);
+#     endif
+   }
+
+
+// a. copy data from host to device
+//=========================================================================================
+   for (int s=0; s<GPU_NStream; s++)
+   {
+      if ( NPatch_per_Stream[s] == 0 )    continue;
+
+      if ( Poisson )
+      {
+         CUDA_CHECK_ERROR(  cudaMemcpyAsync( d_Rho_Array_P     + UsedPatch[s], h_Rho_Array     + UsedPatch[s],
+                                             Rho_MemSize[s],     cudaMemcpyHostToDevice, Stream[s] )  );
+
+         CUDA_CHECK_ERROR(  cudaMemcpyAsync( d_Pot_Array_P_In  + UsedPatch[s], h_Pot_Array_In  + UsedPatch[s],
+                                             Pot_MemSize_In[s],  cudaMemcpyHostToDevice, Stream[s] )  );
+      }
+
+      if ( GraAcc )
+      {
+         if (  ( GravityType == GRAVITY_SELF  ||  GravityType == GRAVITY_BOTH )  &&  !Poisson  )
+         CUDA_CHECK_ERROR(  cudaMemcpyAsync( d_Pot_Array_P_Out + UsedPatch[s], h_Pot_Array_Out + UsedPatch[s],
+                                             Pot_MemSize_Out[s], cudaMemcpyHostToDevice, Stream[s] )  );
+
+         CUDA_CHECK_ERROR(  cudaMemcpyAsync( d_Flu_Array_G     + UsedPatch[s], h_Flu_Array     + UsedPatch[s],
+                                             Flu_MemSize[s],     cudaMemcpyHostToDevice, Stream[s] )  );
+
+         if ( GravityType == GRAVITY_EXTERNAL  ||  GravityType == GRAVITY_BOTH  ||  ExtPot )
+         CUDA_CHECK_ERROR(  cudaMemcpyAsync( d_Corner_Array_G  + UsedPatch[s], h_Corner_Array  + UsedPatch[s],
+                                             Corner_MemSize[s],  cudaMemcpyHostToDevice, Stream[s] )  );
+#        ifdef UNSPLIT_GRAVITY
+         if ( GravityType == GRAVITY_SELF  ||  GravityType == GRAVITY_BOTH )
+         CUDA_CHECK_ERROR(  cudaMemcpyAsync( d_Pot_Array_USG_G + UsedPatch[s], h_Pot_Array_USG + UsedPatch[s],
+                                             Pot_USG_MemSize[s], cudaMemcpyHostToDevice, Stream[s] )  );
+
+         CUDA_CHECK_ERROR(  cudaMemcpyAsync( d_Flu_Array_USG_G + UsedPatch[s], h_Flu_Array_USG + UsedPatch[s],
+                                             Flu_USG_MemSize[s], cudaMemcpyHostToDevice, Stream[s] )  );
+#        endif
+
+#        ifdef DUAL_ENERGY
+         CUDA_CHECK_ERROR(  cudaMemcpyAsync( d_DE_Array_G      + UsedPatch[s], h_DE_Array      + UsedPatch[s],
+                                             DE_MemSize[s],      cudaMemcpyHostToDevice, Stream[s] )  );
+#        endif
+
+#        ifdef MHD
+         CUDA_CHECK_ERROR(  cudaMemcpyAsync( d_EngyB_Array_G   + UsedPatch[s], h_EngyB_Array   + UsedPatch[s],
+                                             EngyB_MemSize[s],   cudaMemcpyHostToDevice, Stream[s] )  );
+#        endif
+      } // if ( GraAcc )
+   } // for (int s=0; s<GPU_NStream; s++)
+
+
+// b. execute the kernel
+//=========================================================================================
+   for (int s=0; s<GPU_NStream; s++)
+   {
+      if ( NPatch_per_Stream[s] == 0 )    continue;
+
+//    b1. Poisson solver
+      if ( Poisson )
+      {
+#        if ( POT_SCHEME == SOR )
+
+#        ifdef USE_PSOLVER_10TO14
+         CUPOT_PoissonSolver_SOR_10to14cube <<< NPatch_per_Stream[s], Poi_Block_Dim, 0, Stream[s] >>>
+                                            ( d_Rho_Array_P     + UsedPatch[s],
+                                              d_Pot_Array_P_In  + UsedPatch[s],
+                                              d_Pot_Array_P_Out + UsedPatch[s],
+                                              SOR_Min_Iter, SOR_Max_Iter, SOR_Omega_6, Poi_Const, IntScheme );
+#        else
+         CUPOT_PoissonSolver_SOR_16to18cube <<< NPatch_per_Stream[s], Poi_Block_Dim, 0, Stream[s] >>>
+                                            ( d_Rho_Array_P     + UsedPatch[s],
+                                              d_Pot_Array_P_In  + UsedPatch[s],
+                                              d_Pot_Array_P_Out + UsedPatch[s],
+                                              SOR_Min_Iter, SOR_Max_Iter, SOR_Omega_6, Poi_Const, IntScheme );
+#        endif // #ifdef USE_PSOLVER_10TO14 ... else ...
+
+#        elif ( POT_SCHEME == MG  )
+
+         CUPOT_PoissonSolver_MG             <<< NPatch_per_Stream[s], Poi_Block_Dim, 0, Stream[s] >>>
+                                            ( d_Rho_Array_P     + UsedPatch[s],
+                                              d_Pot_Array_P_In  + UsedPatch[s],
+                                              d_Pot_Array_P_Out + UsedPatch[s],
+                                              dh, MG_Max_Iter, MG_NPre_Smooth, MG_NPost_Smooth, MG_Tolerated_Error,
+                                              Poi_Coeff, IntScheme );
+
+#        else
+
+#        error : unsupported GPU Poisson solver
+
+#        endif // POT_SCHEME
+      } // if ( Poisson )
+
+
+//    b2. Gravity solver
+      if ( GraAcc )
+      {
+#        if   ( MODEL == HYDRO )
+         CUPOT_HydroGravitySolver <<< NPatch_per_Stream[s], Gra_Block_Dim, 0, Stream[s] >>>
+                                  ( d_Flu_Array_G     + UsedPatch[s],
+                                    d_Pot_Array_P_Out + UsedPatch[s],
+                                    d_Corner_Array_G  + UsedPatch[s],
+                                    d_Pot_Array_USG_G + UsedPatch[s],
+                                    d_Flu_Array_USG_G + UsedPatch[s],
+                                    d_DE_Array_G      + UsedPatch[s],
+                                    d_EngyB_Array_G   + UsedPatch[s],
+                                    dt, dh, P5_Gradient, GravityType, TimeNew, TimeOld, MinEint );
+
+#        elif ( MODEL == ELBDM )
+         CUPOT_ELBDMGravitySolver <<< NPatch_per_Stream[s], Gra_Block_Dim, 0, Stream[s] >>>
+                                  ( d_Flu_Array_G     + UsedPatch[s],
+                                    d_Pot_Array_P_Out + UsedPatch[s],
+                                    d_Corner_Array_G  + UsedPatch[s],
+                                    ELBDM_EtaDt, dh, ELBDM_Lambda, ExtPot, TimeNew );
+
+#        else
+#        error : ERROR : unsupported MODEL !!
+#        endif // MODEL
+      } // if ( GraAcc )
+
+      CUDA_CHECK_ERROR( cudaGetLastError() );
+   } // for (int s=0; s<GPU_NStream; s++)
+
+
+// c. copy data from device to host
+//=========================================================================================
+   for (int s=0; s<GPU_NStream; s++)
+   {
+      if ( NPatch_per_Stream[s] == 0 )    continue;
+
+      if ( Poisson )
+         CUDA_CHECK_ERROR(  cudaMemcpyAsync( h_Pot_Array_Out + UsedPatch[s], d_Pot_Array_P_Out + UsedPatch[s],
+                                             Pot_MemSize_Out[s], cudaMemcpyDeviceToHost, Stream[s] )  );
+
+      if ( GraAcc )
+      {
+         CUDA_CHECK_ERROR(  cudaMemcpyAsync( h_Flu_Array     + UsedPatch[s], d_Flu_Array_G     + UsedPatch[s],
+                                             Flu_MemSize[s],     cudaMemcpyDeviceToHost, Stream[s] )  );
+
+#        ifdef DUAL_ENERGY
+         CUDA_CHECK_ERROR(  cudaMemcpyAsync( h_DE_Array      + UsedPatch[s], d_DE_Array_G      + UsedPatch[s],
+                                             DE_MemSize[s],      cudaMemcpyDeviceToHost, Stream[s] )  );
+#        endif
+      }
+   } // for (int s=0; s<GPU_NStream; s++)
+
+
+   delete [] NPatch_per_Stream;
+   delete [] Rho_MemSize;
+   delete [] Pot_MemSize_In;
+   delete [] Pot_MemSize_Out;
+   delete [] Flu_MemSize;
+   delete [] Corner_MemSize;
+   delete [] UsedPatch;
+#  ifdef UNSPLIT_GRAVITY
+   delete [] Pot_USG_MemSize;
+   delete [] Flu_USG_MemSize;
+#  endif
+#  ifdef DUAL_ENERGY
+   delete [] DE_MemSize;
+#  endif
+#  ifdef MHD
+   delete [] EngyB_MemSize;
+#  endif
+
+} // FUNCTION : CUAPI_Asyn_PoissonGravitySolver
+
+
+
+#endif // #if ( defined GPU  &&  defined GRAVITY )

cuda_code/CUFLU_Shared_FullStepUpdate_1.cu

@@ -0,0 +1,188 @@
+#ifndef __CUFLU_FULLSTEPUPDATE__
+#define __CUFLU_FULLSTEPUPDATE__
+
+
+
+#include "CUFLU.h"
+
+#if (  MODEL == HYDRO  &&  ( FLU_SCHEME == MHM || FLU_SCHEME == MHM_RP || FLU_SCHEME == CTU )  )
+
+
+
+// external functions
+#ifdef __CUDACC__
+
+#if ( NCOMP_PASSIVE > 0 )
+# include "CUFLU_Shared_FluUtility.cu"
+#endif
+
+#ifdef DUAL_ENERGY
+# include "CUFLU_Shared_DualEnergy.cu"
+#endif
+
+#endif // #ifdef __CUDACC__
+
+
+
+
+//-------------------------------------------------------------------------------------------------------
+// Function    :  Hydro_FullStepUpdate
+// Description :  Evaluate the full-step solution
+//
+// Note        :  1. This function is shared by MHM, MHM_RP, and CTU schemes
+//                2. Invoke dual-energy check if DualEnergySwitch is on
+//
+// Parameter   :  g_Input          : Array storing the input fluid data
+//                g_Output         : Array to store the updated fluid data
+//                g_DE_Status      : Array to store the dual-energy status
+//                g_FC_B           : Array storing the updated face-centered B field
+//                                   --> For the dual-energy formalism only
+//                g_Flux           : Array storing the input face-centered fluxes
+//                                   --> Accessed with the array stride N_FL_FLUX even thought its actually
+//                                       allocated size is N_FC_FLUX^3
+//                dt               : Time interval to advance solution
+//                dh               : Cell size
+//                MinDens/Eint     : Density and internal energy floors
+//                DualEnergySwitch : Use the dual-energy formalism if E_int/E_kin < DualEnergySwitch
+//                NormPassive      : true --> normalize passive scalars so that the sum of their mass density
+//                                            is equal to the gas mass density
+//                NNorm            : Number of passive scalars to be normalized
+//                                   --> Should be set to the global variable "PassiveNorm_NVar"
+//                NormIdx          : Target variable indices to be normalized
+//                                   --> Should be set to the global variable "PassiveNorm_VarIdx"
+//                EoS              : EoS object
+//                                   --> Only for obtaining Gamma used by the dual-energy formalism
+//-------------------------------------------------------------------------------------------------------
+GPU_DEVICE
+void Hydro_FullStepUpdate( const real g_Input[][ CUBE(FLU_NXT) ], real g_Output[][ CUBE(PS2) ], char g_DE_Status[],
+                           const real g_FC_B[][ PS2P1*SQR(PS2) ], const real g_Flux[][NCOMP_TOTAL_PLUS_MAG][ CUBE(N_FC_FLUX) ],
+                           const real dt, const real dh, const real MinDens, const real MinEint,
+                           const real DualEnergySwitch, const bool NormPassive, const int NNorm, const int NormIdx[],
+                           const EoS_t *EoS )
+{
+
+   const int  didx_flux[3] = { 1, N_FL_FLUX, SQR(N_FL_FLUX) };
+   const real dt_dh        = dt/dh;
+
+   real dFlux[3][NCOMP_TOTAL], Output_1Cell[NCOMP_TOTAL], Emag;
+
+
+   const int size_ij = SQR(PS2);
+   CGPU_LOOP( idx_out, CUBE(PS2) )
+   {
+      const int i_out    = idx_out % PS2;
+      const int j_out    = idx_out % size_ij / PS2;
+      const int k_out    = idx_out / size_ij;
+
+//    for MHD, one additional flux is evaluated along each transverse direction for computing the CT electric field
+#     ifdef MHD
+      const int i_flux   = i_out + 1;
+      const int j_flux   = j_out + 1;
+      const int k_flux   = k_out + 1;
+#     else
+      const int i_flux   = i_out;
+      const int j_flux   = j_out;
+      const int k_flux   = k_out;
+#     endif
+      const int idx_flux = IDX321( i_flux, j_flux, k_flux, N_FL_FLUX, N_FL_FLUX );
+
+      const int i_in     = i_out + FLU_GHOST_SIZE;
+      const int j_in     = j_out + FLU_GHOST_SIZE;
+      const int k_in     = k_out + FLU_GHOST_SIZE;
+      const int idx_in   = IDX321( i_in, j_in, k_in, FLU_NXT, FLU_NXT );
+
+
+//    1. calculate flux difference to update the fluid data
+      for (int d=0; d<3; d++)
+      for (int v=0; v<NCOMP_TOTAL; v++)
+      {
+#        ifdef MHD
+         dFlux[d][v] = g_Flux[d][v][idx_flux] - g_Flux[d][v][ idx_flux - didx_flux[d] ];
+#        else
+         dFlux[d][v] = g_Flux[d][v][ idx_flux + didx_flux[d] ] - g_Flux[d][v][idx_flux];
+#        endif
+      }
+
+      for (int v=0; v<NCOMP_TOTAL; v++)
+         Output_1Cell[v] = g_Input[v][idx_in] - dt_dh*( dFlux[0][v] + dFlux[1][v] + dFlux[2][v] );
+
+
+//    we no longer ensure positive density and pressure here
+//    --> these checks have been moved to Flu_Close()->CorrectUnphysical()
+//        because we want to apply 1st-order-flux correction BEFORE setting a minimum density and pressure
+//    --> this consideration holds even when DUAL_ENERGY is adopted (e.g., when density is negative,
+//        even when DUAL_ENERGY is on, we still want to try the 1st-order-flux correction before setting a floor value)
+//    --> but for barotropic EoS, we apply Eint floor here to avoid any false alarm caused by Eint<0
+#     ifdef BAROTROPIC_EOS
+#     ifdef MHD
+      Emag = MHD_GetCellCenteredBEnergy( g_FC_B[MAGX], g_FC_B[MAGY], g_FC_B[MAGZ],
+                                         PS2, PS2, PS2, i_out, j_out, k_out );
+#     else
+      Emag = NULL_REAL;
+#     endif
+//    Output_1Cell[DENS] = FMAX( Output_1Cell[DENS], MinDens );
+      Output_1Cell[ENGY] = Hydro_CheckMinEintInEngy( Output_1Cell[DENS], Output_1Cell[MOMX],
+                                                     Output_1Cell[MOMY], Output_1Cell[MOMZ],
+                                                     Output_1Cell[ENGY], MinEint, Emag );
+#     endif // #ifdef BAROTROPIC_EOS
+
+
+//    2. floor and normalize passive scalars
+#     if ( NCOMP_PASSIVE > 0 )
+      for (int v=NCOMP_FLUID; v<NCOMP_TOTAL; v++)  Output_1Cell[v] = FMAX( Output_1Cell[v], TINY_NUMBER );
+
+      if ( NormPassive )
+         Hydro_NormalizePassive( Output_1Cell[DENS], Output_1Cell+NCOMP_FLUID, NNorm, NormIdx );
+#     endif
+
+
+//    3. apply the dual-energy formalism to correct the internal energy
+//    --> currently, even when UNSPLIT_GRAVITY is on (which would update the internal energy), we still invoke
+//        Hydro_DualEnergyFix() here and will fix the internal energy in the gravity solver for cells updated
+//        by the dual-energy formalism (i.e., for cells with their dual-energy status marked as DE_UPDATED_BY_DUAL)
+//    --> this feature might be modified in the future
+#     ifdef DUAL_ENERGY
+//    B field must be updated in advance
+#     ifdef MHD
+      Emag = MHD_GetCellCenteredBEnergy( g_FC_B[MAGX], g_FC_B[MAGY], g_FC_B[MAGZ],
+                                         PS2, PS2, PS2, i_out, j_out, k_out );
+#     else
+      Emag = NULL_REAL;
+#     endif
+//    we no longer apply density and pressure floors here since we want to enable 1st-order-flux correction for that
+      const bool CheckMinPres_No = false;
+//    Output_1Cell[DENS] = FMAX( Output_1Cell[DENS], MinDens );
+
+      Hydro_DualEnergyFix( Output_1Cell[DENS], Output_1Cell[MOMX], Output_1Cell[MOMY], Output_1Cell[MOMZ],
+                           Output_1Cell[ENGY], Output_1Cell[ENPY], g_DE_Status[idx_out],
+                           EoS->AuxArrayDevPtr_Flt[1], EoS->AuxArrayDevPtr_Flt[2], CheckMinPres_No, NULL_REAL,
+                           DualEnergySwitch, Emag );
+#     endif // #ifdef DUAL_ENERGY
+
+
+//    4. store results to the output array
+      for (int v=0; v<NCOMP_TOTAL; v++)   g_Output[v][idx_out] = Output_1Cell[v];
+
+
+//    5. check the negative density and energy
+#     ifdef CHECK_NEGATIVE_IN_FLUID
+      if ( Hydro_CheckNegative(Output_1Cell[DENS]) )
+         printf( "WARNING : invalid density (%14.7e) at file <%s>, line <%d>, function <%s>\n",
+                 Output_1Cell[DENS], __FILE__, __LINE__, __FUNCTION__ );
+
+      if ( Hydro_CheckNegative(Output_1Cell[ENGY]) )
+         printf( "WARNING : invalid energy (%14.7e) at file <%s>, line <%d>, function <%s>\n",
+                 Output_1Cell[ENGY], __FILE__, __LINE__, __FUNCTION__ );
+#     endif
+
+   } // CGPU_LOOP( idx_out, CUBE(PS2) )
+
+} // FUNCTION : Hydro_FullStepUpdate
+
+
+
+#endif // #if ( FLU_SCHEME == MHM  ||  FLU_SCHEME == MHM_RP  ||  FLU_SCHEME == CTU )
+
+
+
+#endif // #ifndef __CUFLU_FULLSTEPUPDATE__

cuda_code/Col2Im_9.cu

@@ -0,0 +1,207 @@
+#include <ATen/ATen.h>
+#include <ATen/AccumulateType.h>
+#include <ATen/NativeFunctions.h>
+#include <ATen/TensorUtils.h>
+#include <ATen/Utils.h>
+#include <ATen/div_rtn.h>
+
+#include <ATen/cuda/CUDAContext.h>
+#include <ATen/cuda/CUDAApplyUtils.cuh>
+
+#include <ATen/native/cuda/im2col.cuh>
+#include <ATen/native/im2col_shape_check.h>
+
+namespace at {
+namespace native {
+namespace {
+
+void col2im_out_cuda_template(
+    Tensor& output,
+    const Tensor& input_,
+    IntArrayRef output_size,
+    IntArrayRef kernel_size,
+    IntArrayRef dilation,
+    IntArrayRef padding,
+    IntArrayRef stride) {
+  TensorArg input_arg{input_, "input", 1};
+  TensorArg output_arg{output, "output", 2};
+  checkAllSameGPU("col2im_out_cuda", {input_arg, output_arg});
+
+  TORCH_CHECK(
+      output_size.size() == 2,
+      "It is expected output_size equals to 2, but got size ",
+      output_size.size());
+
+  TORCH_CHECK(
+      kernel_size.size() == 2,
+      "It is expected kernel_size equals to 2, but got size ",
+      kernel_size.size());
+
+  TORCH_CHECK(
+      dilation.size() == 2,
+      "It is expected dilation equals to 2, but got size ",
+      dilation.size());
+
+  TORCH_CHECK(
+      padding.size() == 2,
+      "It is expected padding equals to 2, but got size ",
+      padding.size());
+
+  TORCH_CHECK(
+      stride.size() == 2,
+      "It is expected stride equals to 2, but got size ",
+      stride.size());
+
+  int64_t output_height = output_size[0];
+  int64_t output_width = output_size[1];
+  int64_t kernel_height = kernel_size[0];
+  int64_t kernel_width = kernel_size[1];
+  int64_t dilation_height = dilation[0];
+  int64_t dilation_width = dilation[1];
+  int64_t pad_height = padding[0];
+  int64_t pad_width = padding[1];
+  int64_t stride_height = stride[0];
+  int64_t stride_width = stride[1];
+
+  col2im_shape_check(
+      input_,
+      Tensor(),
+      output_height,
+      output_width,
+      kernel_height,
+      kernel_width,
+      dilation_height,
+      dilation_width,
+      pad_height,
+      pad_width,
+      stride_height,
+      stride_width);
+
+  Tensor input = input_.contiguous();
+
+  bool batched_input = true;
+  if (input.dim() == 2) {
+    // Force batch
+    batched_input = false;
+    input.resize_({1, input.size(0), input.size(1)});
+  }
+
+  int64_t batch_size = input.size(0);
+  int64_t n_input_plane = input.size(1);
+  int64_t n_output_plane = n_input_plane / (kernel_width * kernel_height);
+
+  output.resize_({batch_size, n_output_plane, output_height, output_width});
+  output.zero_();
+
+  AT_DISPATCH_FLOATING_TYPES_AND_HALF(input.scalar_type(), "col2im_out_cuda", [&] {
+    using accscalar_t = at::acc_type<scalar_t, true>;
+
+    Tensor input_n;
+    Tensor output_n;
+
+    int64_t height_col = (output_height + 2 * pad_height -
+                          (dilation_height * (kernel_height - 1) + 1)) /
+            stride_height +
+        1;
+    int64_t width_col = (output_width + 2 * pad_width -
+                         (dilation_width * (kernel_width - 1) + 1)) /
+            stride_width +
+        1;
+
+    for (int64_t elt = 0; elt < batch_size; elt++) {
+      input_n = input.select(0, elt);
+      output_n = output.select(0, elt);
+
+      col2im<scalar_t, accscalar_t>(
+          at::cuda::getCurrentCUDAStream(),
+          input_n.data_ptr<scalar_t>(),
+          n_output_plane,
+          output_height,
+          output_width,
+          height_col,
+          width_col,
+          kernel_height,
+          kernel_width,
+          pad_height,
+          pad_width,
+          stride_height,
+          stride_width,
+          dilation_height,
+          dilation_width,
+          output_n.data_ptr<scalar_t>());
+    }
+
+    if (!batched_input) {
+      output.resize_({n_output_plane, output_height, output_width});
+    }
+  });
+}
+
+void col2im_backward_out_cuda_template(
+    Tensor& grad_input,
+    const Tensor& grad_output,
+    IntArrayRef kernel_size,
+    IntArrayRef dilation,
+    IntArrayRef padding,
+    IntArrayRef stride) {
+  // im2col_out_cuda checks size of kernel_size, dilation, padding and stride
+  im2col_out_cuda(
+      grad_input, grad_output, kernel_size, dilation, padding, stride);
+}
+
+} // namespace
+
+Tensor& col2im_out_cuda(
+    Tensor& output,
+    const Tensor& input,
+    IntArrayRef output_size,
+    IntArrayRef kernel_size,
+    IntArrayRef dilation,
+    IntArrayRef padding,
+    IntArrayRef stride) {
+  col2im_out_cuda_template(
+      output, input, output_size, kernel_size, dilation, padding, stride);
+  return output;
+}
+
+Tensor col2im_cuda(
+    const Tensor& input,
+    IntArrayRef output_size,
+    IntArrayRef kernel_size,
+    IntArrayRef dilation,
+    IntArrayRef padding,
+    IntArrayRef stride) {
+  Tensor output = at::empty_like(input, LEGACY_CONTIGUOUS_MEMORY_FORMAT);
+
+  col2im_out_cuda_template(
+      output, input, output_size, kernel_size, dilation, padding, stride);
+  return output;
+}
+
+Tensor& col2im_backward_out_cuda(
+    Tensor& grad_input,
+    const Tensor& grad_output,
+    IntArrayRef kernel_size,
+    IntArrayRef dilation,
+    IntArrayRef padding,
+    IntArrayRef stride) {
+  col2im_backward_out_cuda_template(
+      grad_input, grad_output, kernel_size, dilation, padding, stride);
+  return grad_input;
+}
+
+Tensor col2im_backward_cuda(
+    const Tensor& grad_output,
+    IntArrayRef kernel_size,
+    IntArrayRef dilation,
+    IntArrayRef padding,
+    IntArrayRef stride) {
+  Tensor grad_input = at::empty_like(grad_output, LEGACY_CONTIGUOUS_MEMORY_FORMAT);
+
+  col2im_backward_out_cuda_template(
+      grad_input, grad_output, kernel_size, dilation, padding, stride);
+  return grad_input;
+}
+
+} // namespace native
+} // namespace at

cuda_code/CommunicatorGridGPU_1.cu

@@ -0,0 +1,191 @@
+// Copyright (c) 2009-2022 The Regents of the University of Michigan.
+// Part of HOOMD-blue, released under the BSD 3-Clause License.
+
+#include "hip/hip_runtime.h"
+
+#ifdef __HIP_PLATFORM_HCC__
+#include <hipfft.h>
+#else
+#include <cufft.h>
+typedef cufftComplex hipfftComplex;
+#endif
+
+#include "CommunicatorGridGPU.cuh"
+//! Define plus operator for complex data type (needed by CommunicatorMesh)
+__device__ inline hipfftComplex operator+(hipfftComplex& lhs, const hipfftComplex& rhs)
+    {
+    hipfftComplex res;
+    res.x = lhs.x + rhs.x;
+    res.y = lhs.y + rhs.y;
+    return res;
+    }
+
+namespace hoomd
+    {
+namespace md
+    {
+namespace kernel
+    {
+template<typename T>
+__global__ void gpu_gridcomm_scatter_send_cells_kernel(unsigned int n_send_cells,
+                                                       unsigned int* d_send_idx,
+                                                       const T* d_grid,
+                                                       T* d_send_buf)
+    {
+    unsigned int idx = blockIdx.x * blockDim.x + threadIdx.x;
+
+    if (idx >= n_send_cells)
+        return;
+    d_send_buf[idx] = d_grid[d_send_idx[idx]];
+    }
+
+template<typename T, bool add_outer>
+__global__ void gpu_gridcomm_scatter_add_recv_cells_kernel(unsigned int n_unique_recv_cells,
+                                                           const T* d_recv_buf,
+                                                           T* d_grid,
+                                                           const unsigned int* d_cell_recv,
+                                                           const unsigned int* d_cell_recv_begin,
+                                                           const unsigned int* d_cell_recv_end,
+                                                           const unsigned int* d_recv_idx)
+    {
+    unsigned int idx = blockIdx.x * blockDim.x + threadIdx.x;
+    if (idx >= n_unique_recv_cells)
+        return;
+
+    unsigned int begin = d_cell_recv_begin[idx];
+    unsigned int end = d_cell_recv_end[idx];
+
+    T val = d_recv_buf[d_cell_recv[begin]];
+
+    // add together multiple received cells
+    for (unsigned int i = begin + 1; i < end; i++)
+        val = val + d_recv_buf[d_cell_recv[i]];
+
+    unsigned int recv_cell = d_recv_idx[d_cell_recv[begin]];
+    if (add_outer)
+        {
+        // add to grid
+        d_grid[recv_cell] = d_grid[recv_cell] + val;
+        }
+    else
+        {
+        // write out to grid
+        d_grid[recv_cell] = val;
+        }
+    }
+
+template<typename T>
+void gpu_gridcomm_scatter_send_cells(unsigned int n_send_cells,
+                                     unsigned int* d_send_idx,
+                                     const T* d_grid,
+                                     T* d_send_buf)
+    {
+    unsigned int block_size = 256;
+    unsigned int n_blocks = n_send_cells / block_size + 1;
+
+    hipLaunchKernelGGL((gpu_gridcomm_scatter_send_cells_kernel<T>),
+                       dim3(n_blocks),
+                       dim3(block_size),
+                       0,
+                       0,
+                       n_send_cells,
+                       d_send_idx,
+                       d_grid,
+                       d_send_buf);
+    }
+
+template<typename T>
+void gpu_gridcomm_scatter_add_recv_cells(unsigned int n_unique_recv_cells,
+                                         const T* d_recv_buf,
+                                         T* d_grid,
+                                         const unsigned int* d_cell_recv,
+                                         const unsigned int* d_cell_recv_begin,
+                                         const unsigned int* d_cell_recv_end,
+                                         const unsigned int* d_recv_idx,
+                                         bool add_outer)
+    {
+    unsigned int block_size = 256;
+    unsigned int n_blocks = n_unique_recv_cells / block_size + 1;
+
+    if (add_outer)
+        {
+        hipLaunchKernelGGL((gpu_gridcomm_scatter_add_recv_cells_kernel<T, true>),
+                           dim3(n_blocks),
+                           dim3(block_size),
+                           0,
+                           0,
+                           n_unique_recv_cells,
+                           d_recv_buf,
+                           d_grid,
+                           d_cell_recv,
+                           d_cell_recv_begin,
+                           d_cell_recv_end,
+                           d_recv_idx);
+        }
+    else
+        {
+        hipLaunchKernelGGL((gpu_gridcomm_scatter_add_recv_cells_kernel<T, false>),
+                           dim3(n_blocks),
+                           dim3(block_size),
+                           0,
+                           0,
+                           n_unique_recv_cells,
+                           d_recv_buf,
+                           d_grid,
+                           d_cell_recv,
+                           d_cell_recv_begin,
+                           d_cell_recv_end,
+                           d_recv_idx);
+        }
+    }
+
+//! Template instantiation for hipfftComplex
+template void gpu_gridcomm_scatter_send_cells<hipfftComplex>(unsigned int n_send_cells,
+                                                             unsigned int* d_send_idx,
+                                                             const hipfftComplex* d_grid,
+                                                             hipfftComplex* d_send_buf);
+
+template void
+gpu_gridcomm_scatter_add_recv_cells<hipfftComplex>(unsigned int n_unique_recv_cells,
+                                                   const hipfftComplex* d_recv_buf,
+                                                   hipfftComplex* d_grid,
+                                                   const unsigned int* d_cell_recv,
+                                                   const unsigned int* d_cell_recv_begin,
+                                                   const unsigned int* d_cell_recv_end,
+                                                   const unsigned int* d_recv_idx,
+                                                   bool add_outer);
+
+//! Template instantiation for Scalar
+template void gpu_gridcomm_scatter_send_cells<Scalar>(unsigned int n_send_cells,
+                                                      unsigned int* d_send_idx,
+                                                      const Scalar* d_grid,
+                                                      Scalar* d_send_buf);
+
+template void gpu_gridcomm_scatter_add_recv_cells<Scalar>(unsigned int n_unique_recv_cells,
+                                                          const Scalar* d_recv_buf,
+                                                          Scalar* d_grid,
+                                                          const unsigned int* d_cell_recv,
+                                                          const unsigned int* d_cell_recv_begin,
+                                                          const unsigned int* d_cell_recv_end,
+                                                          const unsigned int* d_recv_idx,
+                                                          bool add_outer);
+
+//! Template instantiation for unsigned int
+template void gpu_gridcomm_scatter_send_cells<unsigned int>(unsigned int n_send_cells,
+                                                            unsigned int* d_send_idx,
+                                                            const unsigned int* d_grid,
+                                                            unsigned int* d_send_buf);
+
+template void
+gpu_gridcomm_scatter_add_recv_cells<unsigned int>(unsigned int n_unique_recv_cells,
+                                                  const unsigned int* d_recv_buf,
+                                                  unsigned int* d_grid,
+                                                  const unsigned int* d_cell_recv,
+                                                  const unsigned int* d_cell_recv_begin,
+                                                  const unsigned int* d_cell_recv_end,
+                                                  const unsigned int* d_recv_idx,
+                                                  bool add_outer);
+
+    } // end namespace kernel
+    } // end namespace md
+    } // end namespace hoomd

cuda_code/CompareEQKernel.cu

@@ -0,0 +1,28 @@
+#include <ATen/Dispatch.h>
+#include <ATen/native/BinaryOps.h>
+#include <ATen/native/DispatchStub.h>
+#include <ATen/native/TensorIterator.h>
+#include <ATen/native/cuda/Loops.cuh>
+
+
+// NOTE: CUDA on Windows requires that the enclosing function
+// of a __device__ lambda not have internal linkage.
+
+namespace at { namespace native {
+
+template<typename scalar_t>
+struct CompareEqFunctor {
+  __device__ __forceinline__ bool operator() (scalar_t a, scalar_t b) const {
+    return a == b;
+  }
+};
+
+void eq_kernel_cuda(TensorIteratorBase& iter) {
+  AT_DISPATCH_ALL_TYPES_AND_COMPLEX_AND3(kHalf, kBFloat16, kBool, iter.common_dtype(), "eq_cuda", [&]() {
+    gpu_kernel_with_scalars(iter, CompareEqFunctor<scalar_t>());
+  });
+}
+
+REGISTER_DISPATCH(eq_stub, &eq_kernel_cuda);
+
+}} // namespace at::native

cuda_code/CompareGEKernel_3.cu

@@ -0,0 +1,29 @@
+#define TORCH_ASSERT_NO_OPERATORS
+#include <ATen/Dispatch.h>
+#include <ATen/native/BinaryOps.h>
+#include <ATen/native/DispatchStub.h>
+#include <ATen/native/TensorIterator.h>
+#include <ATen/native/cuda/Loops.cuh>
+
+
+// NOTE: CUDA on Windows requires that the enclosing function
+// of a __device__ lambda not have internal linkage.
+
+namespace at { namespace native {
+
+template<typename scalar_t>
+struct CompareGEFunctor {
+  __device__ __forceinline__ bool operator() (scalar_t a, scalar_t b) const {
+    return a >= b;
+  }
+};
+
+void ge_kernel_cuda(TensorIteratorBase& iter) {
+  AT_DISPATCH_ALL_TYPES_AND3(kHalf, kBFloat16, kBool, iter.common_dtype(), "ge_cuda", [&]() {
+    gpu_kernel_with_scalars(iter, CompareGEFunctor<scalar_t>());
+  });
+}
+
+REGISTER_DISPATCH(ge_stub, &ge_kernel_cuda);
+
+}} // namespace at::native

cuda_code/CompareGTKernel.cu

@@ -0,0 +1,28 @@
+#include <ATen/Dispatch.h>
+#include <ATen/native/BinaryOps.h>
+#include <ATen/native/DispatchStub.h>
+#include <ATen/native/TensorIterator.h>
+#include <ATen/native/cuda/Loops.cuh>
+
+
+// NOTE: CUDA on Windows requires that the enclosing function
+// of a __device__ lambda not have internal linkage.
+
+namespace at { namespace native {
+
+template<typename scalar_t>
+struct CompareGTFunctor {
+  __device__ __forceinline__ bool operator() (scalar_t a, scalar_t b) const {
+    return a > b;
+  }
+};
+
+void gt_kernel_cuda(TensorIterator& iter) {
+  AT_DISPATCH_ALL_TYPES_AND3(kHalf, kBFloat16, kBool, iter.common_dtype(), "gt_cuda", [&]() {
+    gpu_kernel_with_scalars(iter, CompareGTFunctor<scalar_t>());
+  });
+}
+
+REGISTER_DISPATCH(gt_stub, &gt_kernel_cuda);
+
+}} // namespace at::native

cuda_code/CompressKernel_8.cu

@@ -0,0 +1,2022 @@
+// Copyright (c) 2009-2011 Ignacio Castano <[email protected]>
+// Copyright (c) 2007-2009 NVIDIA Corporation -- Ignacio Castano <[email protected]>
+// 
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+
+#include <math.h>
+#include <float.h> // FLT_MAX
+
+#include "CudaMath.h"
+
+
+#define NUM_THREADS 64		// Number of threads per block.
+
+typedef unsigned char uchar;
+typedef unsigned short ushort;
+typedef unsigned int uint;
+
+template <class T> 
+__device__ inline void swap(T & a, T & b)
+{
+    T tmp = a;
+    a = b;
+    b = tmp;
+}
+
+__constant__ uchar OMatch5[256][2];
+__constant__ uchar OMatch6[256][2];
+
+__constant__ float3 kColorMetric = { 1.0f, 1.0f, 1.0f };
+__constant__ float3 kColorMetricSqr = { 1.0f, 1.0f, 1.0f };
+
+// Some kernels read the input through texture.
+texture<uchar4, 2, cudaReadModeNormalizedFloat> tex;
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Color helpers
+////////////////////////////////////////////////////////////////////////////////
+
+__device__ inline uint float_to_u8(float value)
+{
+    return min(max(__float2int_rn((255 * value + 0.5f) / (1.0f + 1.0f/255.0f)), 0), 255);
+}
+
+__device__ inline uint float_to_u6(float value)
+{
+    return min(max(__float2int_rn((63 * value + 0.5f) / (1.0f + 1.0f/63.0f)), 0), 63);
+}
+
+__device__ inline uint float_to_u5(float value)
+{
+    return min(max(__float2int_rn((31 * value + 0.5f) / (1.0f + 1.0f/31.0f)), 0), 31);
+}
+
+__device__ inline float u8_to_float(uint value)
+{
+    return __saturatef(__uint2float_rn(value) / 255.0f);
+    //return (value) / 255.0f;
+}
+
+__device__ float3 color32ToFloat3(uint c)
+{
+    float3 color;
+    color.z = u8_to_float((c >> 0) & 0xFF);
+    color.y = u8_to_float((c >> 8) & 0xFF);
+    color.x = u8_to_float((c >> 16) & 0xFF);
+    return color;
+}
+
+__device__ int3 color16ToInt3(ushort c)
+{
+    int3 color;
+
+    color.z = ((c >> 0) & 0x1F);
+    color.z = (color.z << 3) | (color.z >> 2);
+
+    color.y = ((c >> 5) & 0x3F);
+    color.y = (color.y << 2) | (color.y >> 4);
+
+    color.x = ((c >> 11) & 0x1F);
+    color.x = (color.x << 3) | (color.x >> 2);
+    
+    return color;
+}
+
+__device__ float3 color16ToFloat3(ushort c)
+{
+    int3 color = color16ToInt3(c);
+    return make_float3(color.x, color.y, color.z) * (1.0f / 255.0f);
+}
+
+__device__ int3 float3ToInt3(float3 c)
+{
+    return make_int3(c.x * 255, c.y * 255, c.z * 255);
+}
+
+__device__ float3 int3ToFloat3(int3 c)
+{
+    return make_float3(float_to_u8(c.x), float_to_u8(c.y), float_to_u8(c.z));
+}
+
+
+__device__ int colorDistance(int3 c0, int3 c1)
+{
+    int dx = c0.x-c1.x;
+    int dy = c0.y-c1.y;
+    int dz = c0.z-c1.z;
+    return __mul24(dx, dx) + __mul24(dy, dy) + __mul24(dz, dz);
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Round color to RGB565 and expand
+////////////////////////////////////////////////////////////////////////////////
+
+
+#if 0
+__device__ inline uint float_to_u8(float value)
+{
+    //uint result;
+    //asm("cvt.sat.rni.u8.f32 %0, %1;" : "=r" (result) : "f" (value));
+    //return result;
+    //return __float2uint_rn(__saturatef(value) * 255.0f);
+    
+    int result = __float2int_rn((255 * value + 0.5f) / (1.0f + 1.0f/255.0f));
+    result = max(result, 0);
+    result = min(result, 255);
+    return result;
+}
+
+__device__ inline float u8_to_float(uint value)
+{
+    //float result;
+    //asm("cvt.sat.rn.f32.u8 %0, %1;" : "=f" (result) : "r" (value)); // this is wrong!
+    //return result;
+    return __saturatef(__uint2float_rn(value) / 255.0f);
+}
+
+inline __device__ float3 roundAndExpand565(float3 v, ushort * w)
+{
+    uint x = float_to_u8(v.x) >> 3;
+    uint y = float_to_u8(v.y) >> 2;
+    uint z = float_to_u8(v.z) >> 3;
+    *w = (x << 11) | (y << 5) | z;
+    v.x = u8_to_float((x << 3) | (x >> 2));
+    v.y = u8_to_float((y << 2) | (y >> 4));
+    v.z = u8_to_float((z << 3) | (z >> 2));
+//    v.x = u8_to_float(x) * 255.0f / 31.0f;
+//    v.y = u8_to_float(y) * 255.0f / 63.0f;
+//    v.z = u8_to_float(z) * 255.0f / 31.0f;
+    return v;
+}
+#else
+
+inline __device__ float3 roundAndExpand565(float3 v, ushort * w)
+{
+    uint x = __float2uint_rn(__saturatef(v.x) * 31.0f);
+    uint y = __float2uint_rn(__saturatef(v.y) * 63.0f);
+    uint z = __float2uint_rn(__saturatef(v.z) * 31.0f);
+
+    //uint x = float_to_u5(v.x);
+    //uint y = float_to_u6(v.y);
+    //uint z = float_to_u5(v.z);
+
+    *w = (x << 11) | (y << 5) | z;
+
+    v.x = __uint2float_rn(x) * 1.0f / 31.0f;
+    v.y = __uint2float_rn(y) * 1.0f / 63.0f;
+    v.z = __uint2float_rn(z) * 1.0f / 31.0f;
+
+    //v.x = u8_to_float((x << 3) | (x >> 2));
+    //v.y = u8_to_float((y << 2) | (y >> 4));
+    //v.z = u8_to_float((z << 3) | (z >> 2));
+
+    return v;
+}
+#endif
+inline __device__ float2 roundAndExpand56(float2 v, ushort * w)
+{
+    uint x = __float2uint_rn(__saturatef(v.x) * 31.0f);
+    uint y = __float2uint_rn(__saturatef(v.y) * 63.0f);
+    *w = (x << 11) | (y << 5);
+    v.x = __uint2float_rn(x) * 1.0f / 31.0f;
+    v.y = __uint2float_rn(y) * 1.0f / 63.0f;
+    return v;
+}
+
+inline __device__ float2 roundAndExpand88(float2 v, ushort * w)
+{
+    uint x = __float2uint_rn(__saturatef(v.x) * 255.0f);
+    uint y = __float2uint_rn(__saturatef(v.y) * 255.0f);
+    *w = (x << 8) | y;
+    v.x = __uint2float_rn(x) * 1.0f / 255.0f;
+    v.y = __uint2float_rn(y) * 1.0f / 255.0f;
+    return v;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Block errors
+////////////////////////////////////////////////////////////////////////////////
+
+__device__ float3 blockError4(const float3 * colors, uint permutation, float3 a, float3 b)
+{
+    float3 error = make_float3(0.0f, 0.0f, 0.0f);
+
+    for (int i = 0; i < 16; i++)
+    {
+        const uint bits = permutation >> (2*i);
+
+        float beta = (bits & 1);
+        if (bits & 2) beta = (1 + beta) / 3.0f;
+        float alpha = 1.0f - beta;
+
+        float3 diff = colors[i] - (a*alpha + b*beta);
+
+        error += diff*diff;
+    }
+
+    return error;
+}
+
+__device__ float3 blockError4(const float3 * colors, uint permutation, ushort c0, ushort c1)
+{
+    float3 error = make_float3(0.0f, 0.0f, 0.0f);
+    
+    int3 color0 = color16ToInt3(c0);
+    int3 color1 = color16ToInt3(c1);
+
+    for (int i = 0; i < 16; i++)
+    {
+        const uint bits = permutation >> (2*i);
+
+        int beta = (bits & 1);
+        if (bits & 2) beta = (1 + beta);
+        float alpha = 3 - beta;
+
+        int3 color;
+        color.x = (color0.x * alpha + color1.x * beta) / 3;
+        color.y = (color0.y * alpha + color1.y * beta) / 3;
+        color.z = (color0.z * alpha + color1.z * beta) / 3;
+
+        float3 diff = colors[i] - int3ToFloat3(color);
+
+        error += diff*diff;
+    }
+
+    return error;
+}
+
+
+__device__ float3 blockError3(const float3 * colors, uint permutation, float3 a, float3 b)
+{
+    float3 error = make_float3(0.0f, 0.0f, 0.0f);
+
+    for (int i = 0; i < 16; i++)
+    {
+        const uint bits = permutation >> (2*i);
+
+        float beta = (bits & 1);
+        if (bits & 2) beta = 0.5f;
+        float alpha = 1.0f - beta;
+
+        float3 diff = colors[i] - (a*alpha + b*beta);
+
+        error += diff*diff;
+    }
+
+    return error;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Sort colors
+////////////////////////////////////////////////////////////////////////////////
+
+// @@ Experimental code to avoid duplicate colors for faster compression.
+// We could first sort along the best fit line and only compare colors that have the same projection.
+// The hardest part is to maintain the indices to map packed/sorted colors to the input colors.
+// We also need to update several functions that assume the number of colors is fixed to 16.
+// And compute different bit maps for the different color counts.
+// This is a fairly high amount of work.
+__device__ int packColors(float3 * values, float * weights, int * ranks)
+{
+    const int tid = threadIdx.x;
+
+    __shared__ int count;
+    count = 0;
+
+    bool alive = true;
+
+    // Append this
+    for (int i = 0; i < 16; i++)
+    {
+        // One thread leads on each iteration.
+        if (tid == i) {
+
+            // If thread alive, then append element.
+            if (alive) {
+                values[count] = values[i];
+                weights[count] = weights[i];
+                count++;
+            }
+
+            // Otherwise update weight.
+            else {
+                weights[ranks[i]] += weights[i];
+            }
+        }
+
+        // Kill all threads that have the same element and record rank.
+        if (values[i] == values[tid]) {
+            alive = false;
+            ranks[tid] = count - 1;
+        }
+    }
+
+    return count;
+}
+
+
+__device__ void sortColors(const float * values, int * ranks)
+{
+    const int tid = threadIdx.x;
+
+    int rank = 0;
+
+    #pragma unroll
+    for (int i = 0; i < 16; i++)
+    {
+        rank += (values[i] < values[tid]);
+    }
+    
+    ranks[tid] = rank;
+
+    // Resolve elements with the same index.
+    #pragma unroll
+    for (int i = 0; i < 15; i++)
+    {
+        if ((tid > i) & (ranks[tid] == ranks[i])) ++ranks[tid];
+    }
+}
+
+__device__ void sortColors(const float * values, int * ranks, int count)
+{
+    const int tid = threadIdx.x;
+
+    int rank = 0;
+
+    #pragma unroll
+    for (int i = 0; i < count; i++)
+    {
+        rank += (values[i] < values[tid]);
+    }
+    
+    ranks[tid] = rank;
+
+    // Resolve elements with the same index.
+    #pragma unroll
+    for (int i = 0; i < count-1; i++)
+    {
+        if ((tid > i) & (ranks[tid] == ranks[i])) ++ranks[tid];
+    }
+}
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Load color block to shared mem
+////////////////////////////////////////////////////////////////////////////////
+
+__device__ void loadColorBlockTex(uint firstBlock, uint blockWidth, float3 colors[16], float3 sums[16], int xrefs[16], int * sameColor)
+{
+    const int bid = blockIdx.x;
+    const int idx = threadIdx.x;
+
+    __shared__ float dps[16];
+
+    if (idx < 16)
+    {
+        float x = 4 * ((firstBlock + bid) % blockWidth) + idx % 4; // @@ Avoid mod and div by using 2D grid?
+        float y = 4 * ((firstBlock + bid) / blockWidth) + idx / 4;
+
+        // Read color and copy to shared mem.
+        float4 c = tex2D(tex, x, y);
+
+        colors[idx].x = c.z;
+        colors[idx].y = c.y;
+        colors[idx].z = c.x;
+
+        // Sort colors along the best fit line.
+        colorSums(colors, sums);
+        float3 axis = bestFitLine(colors, sums[0], kColorMetric);
+
+        *sameColor = (axis == make_float3(0, 0, 0));
+
+        dps[idx] = dot(colors[idx], axis);
+
+        sortColors(dps, xrefs);
+
+        float3 tmp = colors[idx];
+        colors[xrefs[idx]] = tmp;
+    }
+}
+
+/*
+__device__ void loadColorBlockTex(uint firstBlock, uint w, float3 colors[16], float3 sums[16], float weights[16], int xrefs[16], int * sameColor)
+{
+	const int bid = blockIdx.x;
+	const int idx = threadIdx.x;
+
+	__shared__ float dps[16];
+
+	if (idx < 16)
+	{
+		float x = 4 * ((firstBlock + bid) % w) + idx % 4; // @@ Avoid mod and div by using 2D grid?
+		float y = 4 * ((firstBlock + bid) / w) + idx / 4;
+
+		// Read color and copy to shared mem.
+		float4 c = tex2D(tex, x, y);
+
+		colors[idx].x = c.z;
+		colors[idx].y = c.y;
+		colors[idx].z = c.x;
+		weights[idx] = 1;
+
+		int count = packColors(colors, weights);
+		if (idx < count)
+		{
+			// Sort colors along the best fit line.
+			colorSums(colors, sums);
+			float3 axis = bestFitLine(colors, sums[0], kColorMetric);
+			
+			*sameColor = (axis == make_float3(0, 0, 0));
+			
+			dps[idx] = dot(colors[idx], axis);
+			
+			sortColors(dps, xrefs);
+			
+			float3 tmp = colors[idx];
+			colors[xrefs[idx]] = tmp;
+		}
+	}
+}
+*/
+
+__device__ void loadColorBlockTex(uint firstBlock, uint width, float3 colors[16], float3 sums[16], float weights[16], int xrefs[16], int * sameColor)
+{
+    const int bid = blockIdx.x;
+    const int idx = threadIdx.x;
+
+    __shared__ float3 rawColors[16];
+    __shared__ float dps[16];
+
+    if (idx < 16)
+    {
+        float x = 4 * ((firstBlock + bid) % width) + idx % 4; // @@ Avoid mod and div by using 2D grid?
+        float y = 4 * ((firstBlock + bid) / width) + idx / 4;
+
+        // Read color and copy to shared mem.
+        float4 c = tex2D(tex, x, y);
+
+        rawColors[idx].x = c.z;
+        rawColors[idx].y = c.y;
+        rawColors[idx].z = c.x;
+        weights[idx] = c.w;
+
+        colors[idx] = rawColors[idx] * weights[idx];
+
+        // Sort colors along the best fit line.
+        colorSums(colors, sums);
+        float3 axis = bestFitLine(colors, sums[0], kColorMetric);
+
+        *sameColor = (axis == make_float3(0, 0, 0));
+
+        // Single color compressor needs unweighted colors.
+        if (*sameColor) colors[idx] = rawColors[idx];
+
+        dps[idx] = dot(colors[idx], axis);
+
+        sortColors(dps, xrefs);
+
+        float3 tmp = colors[idx];
+        float w = weights[idx];
+        colors[xrefs[idx]] = tmp;
+        weights[xrefs[idx]] = w;
+    }
+}
+
+__device__ void loadColorBlock(const uint * image, float2 colors[16], float2 sums[16], int xrefs[16], int * sameColor)
+{
+    const int bid = blockIdx.x;
+    const int idx = threadIdx.x;
+
+    __shared__ float dps[16];
+
+    if (idx < 16)
+    {
+        // Read color and copy to shared mem.
+        uint c = image[(bid) * 16 + idx];
+
+        colors[idx].y = ((c >> 8) & 0xFF) * (1.0f / 255.0f);
+        colors[idx].x = ((c >> 16) & 0xFF) * (1.0f / 255.0f);
+
+        // Sort colors along the best fit line.
+        colorSums(colors, sums);
+        float2 axis = bestFitLine(colors, sums[0]);
+
+        *sameColor = (axis == make_float2(0, 0));
+
+        dps[idx] = dot(colors[idx], axis);
+
+        sortColors(dps, xrefs);
+
+        float2 tmp = colors[idx];
+        colors[xrefs[idx]] = tmp;
+    }
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Evaluate permutations
+////////////////////////////////////////////////////////////////////////////////
+__device__ float evalPermutation4(const float3 * colors, uint permutation, ushort * start, ushort * end)
+{
+    // Compute endpoints using least squares.
+    float alpha2_sum = 0.0f;
+    float beta2_sum = 0.0f;
+    float alphabeta_sum = 0.0f;
+    float3 alphax_sum = make_float3(0.0f, 0.0f, 0.0f);
+    float3 betax_sum = make_float3(0.0f, 0.0f, 0.0f);
+
+    // Compute alpha & beta for this permutation.
+    for (int i = 0; i < 16; i++)
+    {
+        const uint bits = permutation >> (2*i);
+
+        float beta = (bits & 1);
+        if (bits & 2) beta = (1 + beta) / 3.0f;
+        float alpha = 1.0f - beta;
+
+        alpha2_sum += alpha * alpha;
+        beta2_sum += beta * beta;
+        alphabeta_sum += alpha * beta;
+        alphax_sum += alpha * colors[i];
+        betax_sum += beta * colors[i];
+    }
+
+    const float factor = 1.0f / (alpha2_sum * beta2_sum - alphabeta_sum * alphabeta_sum);
+
+    float3 a = (alphax_sum * beta2_sum - betax_sum * alphabeta_sum) * factor;
+    float3 b = (betax_sum * alpha2_sum - alphax_sum * alphabeta_sum) * factor;
+
+    // Round a, b to the closest 5-6-5 color and expand...
+    a = roundAndExpand565(a, start);
+    b = roundAndExpand565(b, end);
+
+    // compute the error
+    float3 e = a * a * alpha2_sum + b * b * beta2_sum + 2.0f * (a * b * alphabeta_sum - a * alphax_sum - b * betax_sum);
+
+    return dot(e, kColorMetricSqr);
+}
+
+__device__ float evalPermutation3(const float3 * colors, uint permutation, ushort * start, ushort * end)
+{
+    // Compute endpoints using least squares.
+    float alpha2_sum = 0.0f;
+    float beta2_sum = 0.0f;
+    float alphabeta_sum = 0.0f;
+    float3 alphax_sum = make_float3(0.0f, 0.0f, 0.0f);
+    float3 betax_sum = make_float3(0.0f, 0.0f, 0.0f);
+
+    // Compute alpha & beta for this permutation.
+    for (int i = 0; i < 16; i++)
+    {
+        const uint bits = permutation >> (2*i);
+
+        float beta = (bits & 1);
+        if (bits & 2) beta = 0.5f;
+        float alpha = 1.0f - beta;
+
+        alpha2_sum += alpha * alpha;
+        beta2_sum += beta * beta;
+        alphabeta_sum += alpha * beta;
+        alphax_sum += alpha * colors[i];
+        betax_sum += beta * colors[i];
+    }
+
+    const float factor = 1.0f / (alpha2_sum * beta2_sum - alphabeta_sum * alphabeta_sum);
+
+    float3 a = (alphax_sum * beta2_sum - betax_sum * alphabeta_sum) * factor;
+    float3 b = (betax_sum * alpha2_sum - alphax_sum * alphabeta_sum) * factor;
+
+    // Round a, b to the closest 5-6-5 color and expand...
+    a = roundAndExpand565(a, start);
+    b = roundAndExpand565(b, end);
+
+    // compute the error
+    float3 e = a * a * alpha2_sum + b * b * beta2_sum + 2.0f * (a * b * alphabeta_sum - a * alphax_sum - b * betax_sum);
+
+    return dot(e, kColorMetricSqr);
+}
+
+__constant__ const float alphaTable4[4] = { 9.0f, 0.0f, 6.0f, 3.0f };
+__constant__ const float alphaTable3[4] = { 4.0f, 0.0f, 2.0f, 2.0f };
+__constant__ const uint prods4[4] = { 0x090000,0x000900,0x040102,0x010402 };
+__constant__ const uint prods3[4] = { 0x040000,0x000400,0x040101,0x010401 };
+
+__device__ float evalPermutation4(const float3 * colors, float3 color_sum, uint permutation, ushort * start, ushort * end)
+{
+    // Compute endpoints using least squares.
+    float3 alphax_sum = make_float3(0.0f, 0.0f, 0.0f);
+    uint akku = 0;
+
+    // Compute alpha & beta for this permutation.
+    #pragma unroll
+    for (int i = 0; i < 16; i++)
+    {
+        const uint bits = permutation >> (2*i);
+
+        alphax_sum += alphaTable4[bits & 3] * colors[i];
+        akku += prods4[bits & 3];
+    }
+
+    float alpha2_sum = float(akku >> 16);
+    float beta2_sum = float((akku >> 8) & 0xff);
+    float alphabeta_sum = float(akku & 0xff);
+    float3 betax_sum = 9.0f * color_sum - alphax_sum;
+
+    const float factor = 1.0f / (alpha2_sum * beta2_sum - alphabeta_sum * alphabeta_sum);
+
+    float3 a = (alphax_sum * beta2_sum - betax_sum * alphabeta_sum) * factor;
+    float3 b = (betax_sum * alpha2_sum - alphax_sum * alphabeta_sum) * factor;
+
+    // Round a, b to the closest 5-6-5 color and expand...
+    a = roundAndExpand565(a, start);
+    b = roundAndExpand565(b, end);
+
+    // compute the error
+    float3 e = a * a * alpha2_sum + b * b * beta2_sum + 2.0f * (a * b * alphabeta_sum - a * alphax_sum - b * betax_sum);
+
+    //float3 e = blockError4(colors, permutation, *start, *end);
+
+    return (1.0f / 9.0f) * dot(e, kColorMetricSqr);
+}
+
+__device__ float evalPermutation3(const float3 * colors, float3 color_sum, uint permutation, ushort * start, ushort * end)
+{
+    // Compute endpoints using least squares.
+    float3 alphax_sum = make_float3(0.0f, 0.0f, 0.0f);
+    uint akku = 0;
+
+    // Compute alpha & beta for this permutation.
+    #pragma unroll
+    for (int i = 0; i < 16; i++)
+    {
+        const uint bits = permutation >> (2*i);
+
+        alphax_sum += alphaTable3[bits & 3] * colors[i];
+        akku += prods3[bits & 3];
+    }
+
+    float alpha2_sum = float(akku >> 16);
+    float beta2_sum = float((akku >> 8) & 0xff);
+    float alphabeta_sum = float(akku & 0xff);
+    float3 betax_sum = 4.0f * color_sum - alphax_sum;
+
+    const float factor = 1.0f / (alpha2_sum * beta2_sum - alphabeta_sum * alphabeta_sum);
+
+    float3 a = (alphax_sum * beta2_sum - betax_sum * alphabeta_sum) * factor;
+    float3 b = (betax_sum * alpha2_sum - alphax_sum * alphabeta_sum) * factor;
+
+    // Round a, b to the closest 5-6-5 color and expand...
+    a = roundAndExpand565(a, start);
+    b = roundAndExpand565(b, end);
+
+    // compute the error
+    float3 e = a * a * alpha2_sum + b * b * beta2_sum + 2.0f * (a * b * alphabeta_sum - a * alphax_sum - b * betax_sum);
+
+    //float3 e = blockError3(colors, permutation, a, b);
+
+    return (1.0f / 4.0f) * dot(e, kColorMetricSqr);
+}
+
+__device__ float evalPermutation4(const float3 * colors, const float * weights, float3 color_sum, uint permutation, ushort * start, ushort * end)
+{
+    // Compute endpoints using least squares.
+    float alpha2_sum = 0.0f;
+    float beta2_sum = 0.0f;
+    float alphabeta_sum = 0.0f;
+    float3 alphax_sum = make_float3(0.0f, 0.0f, 0.0f);
+
+    // Compute alpha & beta for this permutation.
+    for (int i = 0; i < 16; i++)
+    {
+        const uint bits = permutation >> (2*i);
+
+        float beta = (bits & 1);
+        if (bits & 2) beta = (1 + beta) / 3.0f;
+        float alpha = 1.0f - beta;
+
+        alpha2_sum += alpha * alpha * weights[i];
+        beta2_sum += beta * beta * weights[i];
+        alphabeta_sum += alpha * beta * weights[i];
+        alphax_sum += alpha * colors[i];
+    }
+
+    float3 betax_sum = color_sum - alphax_sum;
+
+    const float factor = 1.0f / (alpha2_sum * beta2_sum - alphabeta_sum * alphabeta_sum);
+
+    float3 a = (alphax_sum * beta2_sum - betax_sum * alphabeta_sum) * factor;
+    float3 b = (betax_sum * alpha2_sum - alphax_sum * alphabeta_sum) * factor;
+
+    // Round a, b to the closest 5-6-5 color and expand...
+    a = roundAndExpand565(a, start);
+    b = roundAndExpand565(b, end);
+
+    // compute the error
+    float3 e = a * a * alpha2_sum + b * b * beta2_sum + 2.0f * (a * b * alphabeta_sum - a * alphax_sum - b * betax_sum);
+
+    return dot(e, kColorMetricSqr);
+}
+
+/*
+__device__ float evalPermutation3(const float3 * colors, const float * weights, uint permutation, ushort * start, ushort * end)
+{
+    // Compute endpoints using least squares.
+    float alpha2_sum = 0.0f;
+    float beta2_sum = 0.0f;
+    float alphabeta_sum = 0.0f;
+    float3 alphax_sum = make_float3(0.0f, 0.0f, 0.0f);
+
+    // Compute alpha & beta for this permutation.
+    for (int i = 0; i < 16; i++)
+    {
+        const uint bits = permutation >> (2*i);
+
+        float beta = (bits & 1);
+        if (bits & 2) beta = 0.5f;
+        float alpha = 1.0f - beta;
+
+        alpha2_sum += alpha * alpha * weights[i];
+        beta2_sum += beta * beta * weights[i];
+        alphabeta_sum += alpha * beta * weights[i];
+        alphax_sum += alpha * colors[i];
+    }
+
+    float3 betax_sum = color_sum - alphax_sum;
+
+    const float factor = 1.0f / (alpha2_sum * beta2_sum - alphabeta_sum * alphabeta_sum);
+
+    float3 a = (alphax_sum * beta2_sum - betax_sum * alphabeta_sum) * factor;
+    float3 b = (betax_sum * alpha2_sum - alphax_sum * alphabeta_sum) * factor;
+
+    // Round a, b to the closest 5-6-5 color and expand...
+    a = roundAndExpand565(a, start);
+    b = roundAndExpand565(b, end);
+
+    // compute the error
+    float3 e = a * a * alpha2_sum + b * b * beta2_sum + 2.0f * (a * b * alphabeta_sum - a * alphax_sum - b * betax_sum);
+
+    return dot(e, kColorMetricSqr);
+}
+*/
+
+__device__ float evalPermutation4(const float2 * colors, float2 color_sum, uint permutation, ushort * start, ushort * end)
+{
+    // Compute endpoints using least squares.
+    float2 alphax_sum = make_float2(0.0f, 0.0f);
+    uint akku = 0;
+
+    // Compute alpha & beta for this permutation.
+    #pragma unroll
+    for (int i = 0; i < 16; i++)
+    {
+        const uint bits = permutation >> (2*i);
+
+        alphax_sum += alphaTable4[bits & 3] * colors[i];
+        akku += prods4[bits & 3];
+    }
+
+    float alpha2_sum = float(akku >> 16);
+    float beta2_sum = float((akku >> 8) & 0xff);
+    float alphabeta_sum = float(akku & 0xff);
+    float2 betax_sum = 9.0f * color_sum - alphax_sum;
+
+    const float factor = 1.0f / (alpha2_sum * beta2_sum - alphabeta_sum * alphabeta_sum);
+
+    float2 a = (alphax_sum * beta2_sum - betax_sum * alphabeta_sum) * factor;
+    float2 b = (betax_sum * alpha2_sum - alphax_sum * alphabeta_sum) * factor;
+
+    // Round a, b to the closest 5-6 color and expand...
+    a = roundAndExpand56(a, start);
+    b = roundAndExpand56(b, end);
+
+    // compute the error
+    float2 e = a * a * alpha2_sum + b * b * beta2_sum + 2.0f * (a * b * alphabeta_sum - a * alphax_sum - b * betax_sum);
+
+    return (1.0f / 9.0f) * (e.x + e.y);
+}
+
+__device__ float evalPermutation3(const float2 * colors, float2 color_sum, uint permutation, ushort * start, ushort * end)
+{
+    // Compute endpoints using least squares.
+    float2 alphax_sum = make_float2(0.0f, 0.0f);
+    uint akku = 0;
+
+    // Compute alpha & beta for this permutation.
+    #pragma unroll
+    for (int i = 0; i < 16; i++)
+    {
+        const uint bits = permutation >> (2*i);
+
+        alphax_sum += alphaTable3[bits & 3] * colors[i];
+        akku += prods3[bits & 3];
+    }
+
+    float alpha2_sum = float(akku >> 16);
+    float beta2_sum = float((akku >> 8) & 0xff);
+    float alphabeta_sum = float(akku & 0xff);
+    float2 betax_sum = 4.0f * color_sum - alphax_sum;
+
+    const float factor = 1.0f / (alpha2_sum * beta2_sum - alphabeta_sum * alphabeta_sum);
+
+    float2 a = (alphax_sum * beta2_sum - betax_sum * alphabeta_sum) * factor;
+    float2 b = (betax_sum * alpha2_sum - alphax_sum * alphabeta_sum) * factor;
+
+    // Round a, b to the closest 5-6 color and expand...
+    a = roundAndExpand56(a, start);
+    b = roundAndExpand56(b, end);
+
+    // compute the error
+    float2 e = a * a * alpha2_sum + b * b * beta2_sum + 2.0f * (a * b * alphabeta_sum - a * alphax_sum - b * betax_sum);
+
+    return (1.0f / 4.0f) * (e.x + e.y);
+}
+
+__device__ float evalPermutationCTX(const float2 * colors, float2 color_sum, uint permutation, ushort * start, ushort * end)
+{
+    // Compute endpoints using least squares.
+    float2 alphax_sum = make_float2(0.0f, 0.0f);
+    uint akku = 0;
+
+    // Compute alpha & beta for this permutation.
+    #pragma unroll
+    for (int i = 0; i < 16; i++)
+    {
+        const uint bits = permutation >> (2*i);
+
+        alphax_sum += alphaTable4[bits & 3] * colors[i];
+        akku += prods4[bits & 3];
+    }
+
+    float alpha2_sum = float(akku >> 16);
+    float beta2_sum = float((akku >> 8) & 0xff);
+    float alphabeta_sum = float(akku & 0xff);
+    float2 betax_sum = 9.0f * color_sum - alphax_sum;
+
+    const float factor = 1.0f / (alpha2_sum * beta2_sum - alphabeta_sum * alphabeta_sum);
+
+    float2 a = (alphax_sum * beta2_sum - betax_sum * alphabeta_sum) * factor;
+    float2 b = (betax_sum * alpha2_sum - alphax_sum * alphabeta_sum) * factor;
+
+    // Round a, b to the closest 8-8 color and expand...
+    a = roundAndExpand88(a, start);
+    b = roundAndExpand88(b, end);
+
+    // compute the error
+    float2 e = a * a * alpha2_sum + b * b * beta2_sum + 2.0f * (a * b * alphabeta_sum - a * alphax_sum - b * betax_sum);
+
+    return (1.0f / 9.0f) * (e.x + e.y);
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Evaluate all permutations
+////////////////////////////////////////////////////////////////////////////////
+__device__ void evalAllPermutations(const float3 * colors, float3 colorSum, const uint * permutations, ushort & bestStart, ushort & bestEnd, uint & bestPermutation, float * errors)
+{
+    const int idx = threadIdx.x;
+
+    float bestError = FLT_MAX;
+
+    __shared__ uint s_permutations[160];
+
+    for(int i = 0; i < 16; i++)
+    {
+        int pidx = idx + NUM_THREADS * i;
+        if (pidx >= 992) break;
+
+        ushort start, end;
+        uint permutation = permutations[pidx];
+        if (pidx < 160) s_permutations[pidx] = permutation;
+
+        float error = evalPermutation4(colors, colorSum, permutation, &start, &end);
+
+        if (error < bestError)
+        {
+            bestError = error;
+            bestPermutation = permutation;
+            bestStart = start;
+            bestEnd = end;
+        }
+    }
+
+    if (bestStart < bestEnd)
+    {
+        swap(bestEnd, bestStart);
+        bestPermutation ^= 0x55555555;	// Flip indices.
+    }
+
+    for(int i = 0; i < 3; i++)
+    {
+        int pidx = idx + NUM_THREADS * i;
+        if (pidx >= 160) break;
+
+        ushort start, end;
+        uint permutation = s_permutations[pidx];
+        float error = evalPermutation3(colors, colorSum, permutation, &start, &end);
+
+        if (error < bestError)
+        {
+            bestError = error;
+            bestPermutation = permutation;
+            bestStart = start;
+            bestEnd = end;
+
+            if (bestStart > bestEnd)
+            {
+                swap(bestEnd, bestStart);
+                bestPermutation ^= (~bestPermutation >> 1) & 0x55555555;	// Flip indices.
+            }
+        }
+    }
+
+    errors[idx] = bestError;
+}
+
+/*
+__device__ void evalAllPermutations(const float3 * colors, const float * weights, const uint * permutations, ushort & bestStart, ushort & bestEnd, uint & bestPermutation, float * errors)
+{
+	const int idx = threadIdx.x;
+	
+	float bestError = FLT_MAX;
+	
+	__shared__ uint s_permutations[160];
+	
+	for(int i = 0; i < 16; i++)
+	{
+		int pidx = idx + NUM_THREADS * i;
+		if (pidx >= 992) break;
+		
+		ushort start, end;
+		uint permutation = permutations[pidx];
+		if (pidx < 160) s_permutations[pidx] = permutation;
+
+		float error = evalPermutation4(colors, weights, permutation, &start, &end);
+		
+		if (error < bestError)
+		{
+			bestError = error;
+			bestPermutation = permutation;
+			bestStart = start;
+			bestEnd = end;
+		}
+	}
+
+	if (bestStart < bestEnd)
+	{
+		swap(bestEnd, bestStart);
+		bestPermutation ^= 0x55555555;	// Flip indices.
+	}
+
+	for(int i = 0; i < 3; i++)
+	{
+		int pidx = idx + NUM_THREADS * i;
+		if (pidx >= 160) break;
+		
+		ushort start, end;
+		uint permutation = s_permutations[pidx];
+		float error = evalPermutation3(colors, weights, permutation, &start, &end);
+		
+		if (error < bestError)
+		{
+			bestError = error;
+			bestPermutation = permutation;
+			bestStart = start;
+			bestEnd = end;
+			
+			if (bestStart > bestEnd)
+			{
+				swap(bestEnd, bestStart);
+				bestPermutation ^= (~bestPermutation >> 1) & 0x55555555;	// Flip indices.
+			}
+		}
+	}
+
+	errors[idx] = bestError;
+}
+*/
+
+__device__ void evalAllPermutations(const float2 * colors, float2 colorSum, const uint * permutations, ushort & bestStart, ushort & bestEnd, uint & bestPermutation, float * errors)
+{
+    const int idx = threadIdx.x;
+
+    float bestError = FLT_MAX;
+
+    __shared__ uint s_permutations[160];
+
+    for(int i = 0; i < 16; i++)
+    {
+        int pidx = idx + NUM_THREADS * i;
+        if (pidx >= 992) break;
+
+        ushort start, end;
+        uint permutation = permutations[pidx];
+        if (pidx < 160) s_permutations[pidx] = permutation;
+
+        float error = evalPermutation4(colors, colorSum, permutation, &start, &end);
+
+        if (error < bestError)
+        {
+            bestError = error;
+            bestPermutation = permutation;
+            bestStart = start;
+            bestEnd = end;
+        }
+    }
+
+    if (bestStart < bestEnd)
+    {
+        swap(bestEnd, bestStart);
+        bestPermutation ^= 0x55555555;	// Flip indices.
+    }
+
+    for(int i = 0; i < 3; i++)
+    {
+        int pidx = idx + NUM_THREADS * i;
+        if (pidx >= 160) break;
+
+        ushort start, end;
+        uint permutation = s_permutations[pidx];
+        float error = evalPermutation3(colors, colorSum, permutation, &start, &end);
+
+        if (error < bestError)
+        {
+            bestError = error;
+            bestPermutation = permutation;
+            bestStart = start;
+            bestEnd = end;
+
+            if (bestStart > bestEnd)
+            {
+                swap(bestEnd, bestStart);
+                bestPermutation ^= (~bestPermutation >> 1) & 0x55555555;	// Flip indices.
+            }
+        }
+    }
+
+    errors[idx] = bestError;
+}
+
+__device__ void evalLevel4Permutations(const float3 * colors, float3 colorSum, const uint * permutations, ushort & bestStart, ushort & bestEnd, uint & bestPermutation, float * errors)
+{
+    const int idx = threadIdx.x;
+
+    float bestError = FLT_MAX;
+
+    for(int i = 0; i < 16; i++)
+    {
+        int pidx = idx + NUM_THREADS * i;
+        if (pidx >= 992) break;
+
+        ushort start, end;
+        uint permutation = permutations[pidx];
+
+        float error = evalPermutation4(colors, colorSum, permutation, &start, &end);
+
+        if (error < bestError)
+        {
+            bestError = error;
+            bestPermutation = permutation;
+            bestStart = start;
+            bestEnd = end;
+        }
+    }
+
+    if (bestStart < bestEnd)
+    {
+        swap(bestEnd, bestStart);
+        bestPermutation ^= 0x55555555;	// Flip indices.
+    }
+
+    errors[idx] = bestError;
+}
+
+__device__ void evalLevel4Permutations(const float3 * colors, const float * weights, float3 colorSum, const uint * permutations, ushort & bestStart, ushort & bestEnd, uint & bestPermutation, float * errors)
+{
+    const int idx = threadIdx.x;
+
+    float bestError = FLT_MAX;
+
+    for(int i = 0; i < 16; i++)
+    {
+        int pidx = idx + NUM_THREADS * i;
+        if (pidx >= 992) break;
+
+        ushort start, end;
+        uint permutation = permutations[pidx];
+
+        float error = evalPermutation4(colors, weights, colorSum, permutation, &start, &end);
+
+        if (error < bestError)
+        {
+            bestError = error;
+            bestPermutation = permutation;
+            bestStart = start;
+            bestEnd = end;
+        }
+    }
+
+    if (bestStart < bestEnd)
+    {
+        swap(bestEnd, bestStart);
+        bestPermutation ^= 0x55555555;	// Flip indices.
+    }
+
+    errors[idx] = bestError;
+}
+
+__device__ void evalAllPermutationsCTX(const float2 * colors, float2 colorSum, const uint * permutations, ushort & bestStart, ushort & bestEnd, uint & bestPermutation, float * errors)
+{
+    const int idx = threadIdx.x;
+
+    float bestError = FLT_MAX;
+
+    for(int i = 0; i < 16; i++)
+    {
+        int pidx = idx + NUM_THREADS * i;
+        if (pidx >= 704) break;
+
+        ushort start, end;
+        uint permutation = permutations[pidx];
+
+        float error = evalPermutationCTX(colors, colorSum, permutation, &start, &end);
+
+        if (error < bestError)
+        {
+            bestError = error;
+            bestPermutation = permutation;
+            bestStart = start;
+            bestEnd = end;
+        }
+    }
+
+    if (bestStart < bestEnd)
+    {
+        swap(bestEnd, bestStart);
+        bestPermutation ^= 0x55555555;	// Flip indices.
+    }
+
+    errors[idx] = bestError;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Find index with minimum error
+////////////////////////////////////////////////////////////////////////////////
+__device__ int findMinError(float * errors)
+{
+    const int idx = threadIdx.x;
+
+    __shared__ int indices[NUM_THREADS];
+    indices[idx] = idx;
+
+    for(int d = NUM_THREADS/2; d > 32; d >>= 1)
+    {
+        __syncthreads();
+
+        if (idx < d)
+        {
+            float err0 = errors[idx];
+            float err1 = errors[idx + d];
+
+            if (err1 < err0) {
+                errors[idx] = err1;
+                indices[idx] = indices[idx + d];
+            }
+        }
+    }
+
+    __syncthreads();
+
+    // unroll last 6 iterations
+    if (idx < 32)
+    {
+        if (errors[idx + 32] < errors[idx]) {
+            errors[idx] = errors[idx + 32];
+            indices[idx] = indices[idx + 32];
+        }
+        if (errors[idx + 16] < errors[idx]) {
+            errors[idx] = errors[idx + 16];
+            indices[idx] = indices[idx + 16];
+        }
+        if (errors[idx + 8] < errors[idx]) {
+            errors[idx] = errors[idx + 8];
+            indices[idx] = indices[idx + 8];
+        }
+        if (errors[idx + 4] < errors[idx]) {
+            errors[idx] = errors[idx + 4];
+            indices[idx] = indices[idx + 4];
+        }
+        if (errors[idx + 2] < errors[idx]) {
+            errors[idx] = errors[idx + 2];
+            indices[idx] = indices[idx + 2];
+        }
+        if (errors[idx + 1] < errors[idx]) {
+            errors[idx] = errors[idx + 1];
+            indices[idx] = indices[idx + 1];
+        }
+    }
+
+    __syncthreads();
+
+    return indices[0];
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Save DXT block
+////////////////////////////////////////////////////////////////////////////////
+__device__ void saveBlockDXT1(ushort start, ushort end, uint permutation, int xrefs[16], uint2 * result)
+{
+    const int bid = blockIdx.x;
+
+    if (start == end)
+    {
+        permutation = 0;
+    }
+
+    // Reorder permutation.
+    uint indices = 0;
+    for(int i = 0; i < 16; i++)
+    {
+        int ref = xrefs[i];
+        indices |= ((permutation >> (2 * ref)) & 3) << (2 * i);
+    }
+
+    // Write endpoints.
+    result[bid].x = (end << 16) | start;
+
+    // Write palette indices.
+    result[bid].y = indices;
+}
+
+__device__ void saveBlockDXT1_Parallel(uint endpoints, float3 colors[16], int xrefs[16], uint * result)
+{
+    const int tid = threadIdx.x;
+    const int bid = blockIdx.x;
+
+    if (tid < 16)
+    {
+        int3 color = float3ToInt3(colors[xrefs[tid]]);
+
+        ushort endpoint0 = endpoints & 0xFFFF;
+        ushort endpoint1 = endpoints >> 16;
+
+	int3 palette[4];
+	palette[0] = color16ToInt3(endpoint0);
+	palette[1] = color16ToInt3(endpoint1);
+
+        int d0 = colorDistance(palette[0], color);
+        int d1 = colorDistance(palette[1], color);
+
+        uint index;
+        if (endpoint0 > endpoint1) 
+        {
+            palette[2].x = (2 * palette[0].x + palette[1].x) / 3;
+            palette[2].y = (2 * palette[0].y + palette[1].y) / 3;
+            palette[2].z = (2 * palette[0].z + palette[1].z) / 3;
+
+            palette[3].x = (2 * palette[1].x + palette[0].x) / 3;
+            palette[3].y = (2 * palette[1].y + palette[0].y) / 3;
+            palette[3].z = (2 * palette[1].z + palette[0].z) / 3;
+            
+            int d2 = colorDistance(palette[2], color);
+            int d3 = colorDistance(palette[3], color);
+
+            // Compute the index that best fit color.
+            uint b0 = d0 > d3;
+            uint b1 = d1 > d2;
+            uint b2 = d0 > d2;
+            uint b3 = d1 > d3;
+            uint b4 = d2 > d3;
+
+            uint x0 = b1 & b2;
+            uint x1 = b0 & b3;
+            uint x2 = b0 & b4;
+
+            index = (x2 | ((x0 | x1) << 1));
+        }
+        else {
+            palette[2].x = (palette[0].x + palette[1].x) / 2;
+            palette[2].y = (palette[0].y + palette[1].y) / 2;
+            palette[2].z = (palette[0].z + palette[1].z) / 2;
+
+            int d2 = colorDistance(palette[2], color);
+
+            index = 0;
+            if (d1 < d0 && d1 < d2) index = 1;
+            else if (d2 < d0) index = 2;
+        }
+
+        __shared__ uint indices[16];
+
+        indices[tid] = index << (2 * tid);
+        if (tid < 8) indices[tid] |= indices[tid+8];
+        if (tid < 4) indices[tid] |= indices[tid+4];
+        if (tid < 2) indices[tid] |= indices[tid+2];
+        if (tid < 1) indices[tid] |= indices[tid+1];
+
+        if (tid < 2) {
+            result[2 * bid + tid] = tid == 0 ? endpoints : indices[0];
+        }
+    }
+}
+
+__device__ void saveBlockDXT1_Parallel(uint endpoints, uint permutation, int xrefs[16], uint * result)
+{
+    const int tid = threadIdx.x;    
+    const int bid = blockIdx.x;
+
+    if (tid < 16)
+    {
+        // Reorder permutation.
+        uint index = ((permutation >> (2 * xrefs[tid])) & 3) << (2 * tid);
+        __shared__ uint indices[16];
+
+        indices[tid] = index;
+        if (tid < 8) indices[tid] |= indices[tid+8];
+        if (tid < 4) indices[tid] |= indices[tid+4];
+        if (tid < 2) indices[tid] |= indices[tid+2];
+        if (tid < 1) indices[tid] |= indices[tid+1];
+    	
+        if (tid < 2) {
+            result[2 * bid + tid] = tid == 0 ? endpoints : indices[0];
+        }
+    }
+}
+
+
+__device__ void saveBlockCTX1(ushort start, ushort end, uint permutation, int xrefs[16], uint2 * result)
+{
+    saveBlockDXT1(start, end, permutation, xrefs, result);
+}
+
+__device__ void saveSingleColorBlockDXT1(float3 color, uint2 * result)
+{
+    const int bid = blockIdx.x;
+
+    int r = color.x * 255;
+    int g = color.y * 255;
+    int b = color.z * 255;
+
+    ushort color0 = (OMatch5[r][0] << 11) | (OMatch6[g][0] << 5) | OMatch5[b][0];
+    ushort color1 = (OMatch5[r][1] << 11) | (OMatch6[g][1] << 5) | OMatch5[b][1];
+
+    if (color0 < color1)
+    {
+        result[bid].x = (color0 << 16) | color1;
+        result[bid].y = 0xffffffff;
+    }
+    else
+    {
+        result[bid].x = (color1 << 16) | color0;
+        result[bid].y = 0xaaaaaaaa;
+    }
+}
+
+__device__ void saveSingleColorBlockDXT1(float2 color, uint2 * result)
+{
+    const int bid = blockIdx.x;
+
+    int r = color.x * 255;
+    int g = color.y * 255;
+
+    ushort color0 = (OMatch5[r][0] << 11) | (OMatch6[g][0] << 5);
+    ushort color1 = (OMatch5[r][1] << 11) | (OMatch6[g][1] << 5);
+
+    if (color0 < color1)
+    {
+        result[bid].x = (color0 << 16) | color1;
+        result[bid].y = 0xffffffff;
+    }
+    else
+    {
+        result[bid].x = (color1 << 16) | color0;
+        result[bid].y = 0xaaaaaaaa;
+    }
+}
+
+__device__ void saveSingleColorBlockCTX1(float2 color, uint2 * result)
+{
+    const int bid = blockIdx.x;
+
+    int r = color.x * 255;
+    int g = color.y * 255;
+
+    ushort color0 = (r << 8) | (g);
+
+    result[bid].x = (color0 << 16) | color0;
+    result[bid].y = 0x00000000;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Compress color block
+////////////////////////////////////////////////////////////////////////////////
+
+__global__ void compressDXT1(uint firstBlock, uint blockWidth, const uint * permutations, uint2 * result)
+{
+    __shared__ float3 colors[16];
+    __shared__ float3 sums[16];
+    __shared__ int xrefs[16];
+    __shared__ int sameColor;
+
+    loadColorBlockTex(firstBlock, blockWidth, colors, sums, xrefs, &sameColor);
+
+    __syncthreads();
+
+    if (sameColor)
+    {
+        if (threadIdx.x == 0) saveSingleColorBlockDXT1(colors[0], result);
+        return;
+    }
+
+    ushort bestStart, bestEnd;
+    uint bestPermutation;
+
+    __shared__ float errors[NUM_THREADS];
+    evalAllPermutations(colors, sums[0], permutations, bestStart, bestEnd, bestPermutation, errors);
+    
+    // Use a parallel reduction to find minimum error.
+    const int minIdx = findMinError(errors);
+
+    __shared__ uint s_bestEndPoints;
+    __shared__ uint s_bestPermutation;
+
+    // Only write the result of the winner thread.
+    if (threadIdx.x == minIdx)
+    {
+        s_bestEndPoints = (bestEnd << 16) | bestStart;
+        s_bestPermutation = (bestStart != bestEnd) ? bestPermutation : 0;
+    }
+
+    __syncthreads();
+
+    saveBlockDXT1_Parallel(s_bestEndPoints, colors, xrefs, (uint *)result);
+    //saveBlockDXT1_Parallel(s_bestEndPoints, s_bestPermutation, xrefs, (uint *)result);
+}
+
+
+__global__ void compressLevel4DXT1(uint firstBlock, uint blockWidth, const uint * permutations, uint2 * result)
+{
+    __shared__ float3 colors[16];
+    __shared__ float3 sums[16];
+    __shared__ int xrefs[16];
+    __shared__ int sameColor;
+
+    loadColorBlockTex(firstBlock, blockWidth, colors, sums, xrefs, &sameColor);
+
+    __syncthreads();
+
+    if (sameColor)
+    {
+        if (threadIdx.x == 0) saveSingleColorBlockDXT1(colors[0], result);
+        return;
+    }
+
+    ushort bestStart, bestEnd;
+    uint bestPermutation;
+
+    __shared__ float errors[NUM_THREADS];
+
+    evalLevel4Permutations(colors, sums[0], permutations, bestStart, bestEnd, bestPermutation, errors);
+
+    // Use a parallel reduction to find minimum error.
+    const int minIdx = findMinError(errors);
+
+    // Only write the result of the winner thread.
+    if (threadIdx.x == minIdx)
+    {
+        saveBlockDXT1(bestStart, bestEnd, bestPermutation, xrefs, result);
+    }
+}
+
+__global__ void compressWeightedDXT1(uint firstBlock, uint blockWidth, const uint * permutations, uint2 * result)
+{
+    __shared__ float3 colors[16];
+    __shared__ float3 sums[16];
+    __shared__ float weights[16];
+    __shared__ int xrefs[16];
+    __shared__ int sameColor;
+
+    loadColorBlockTex(firstBlock, blockWidth, colors, sums, weights, xrefs, &sameColor);
+
+    __syncthreads();
+
+    if (sameColor)
+    {
+        if (threadIdx.x == 0) saveSingleColorBlockDXT1(colors[0], result);
+        return;
+    }
+
+    ushort bestStart, bestEnd;
+    uint bestPermutation;
+
+    __shared__ float errors[NUM_THREADS];
+
+    evalLevel4Permutations(colors, weights, sums[0], permutations, bestStart, bestEnd, bestPermutation, errors);
+
+    // Use a parallel reduction to find minimum error.
+    int minIdx = findMinError(errors);
+
+    // Only write the result of the winner thread.
+    if (threadIdx.x == minIdx)
+    {
+        saveBlockDXT1(bestStart, bestEnd, bestPermutation, xrefs, result);
+    }
+}
+
+
+__global__ void compressNormalDXT1(const uint * permutations, const uint * image, uint2 * result)
+{
+    __shared__ float2 colors[16];
+    __shared__ float2 sums[16];
+    __shared__ int xrefs[16];
+    __shared__ int sameColor;
+
+    loadColorBlock(image, colors, sums, xrefs, &sameColor);
+
+    __syncthreads();
+
+    if (sameColor)
+    {
+        if (threadIdx.x == 0) saveSingleColorBlockDXT1(colors[0], result);
+        return;
+    }
+
+    ushort bestStart, bestEnd;
+    uint bestPermutation;
+
+    __shared__ float errors[NUM_THREADS];
+
+    evalAllPermutations(colors, sums[0], permutations, bestStart, bestEnd, bestPermutation, errors);
+
+    // Use a parallel reduction to find minimum error.
+    const int minIdx = findMinError(errors);
+
+    // Only write the result of the winner thread.
+    if (threadIdx.x == minIdx)
+    {
+        saveBlockDXT1(bestStart, bestEnd, bestPermutation, xrefs, result);
+    }
+}
+
+__global__ void compressCTX1(const uint * permutations, const uint * image, uint2 * result)
+{
+    __shared__ float2 colors[16];
+    __shared__ float2 sums[16];
+    __shared__ int xrefs[16];
+    __shared__ int sameColor;
+
+    loadColorBlock(image, colors, sums, xrefs, &sameColor);
+
+    __syncthreads();
+
+    if (sameColor)
+    {
+        if (threadIdx.x == 0) saveSingleColorBlockCTX1(colors[0], result);
+        return;
+    }
+
+    ushort bestStart, bestEnd;
+    uint bestPermutation;
+
+    __shared__ float errors[NUM_THREADS];
+
+    evalAllPermutationsCTX(colors, sums[0], permutations, bestStart, bestEnd, bestPermutation, errors);
+
+    // Use a parallel reduction to find minimum error.
+    const int minIdx = findMinError(errors);
+
+    // Only write the result of the winner thread.
+    if (threadIdx.x == minIdx)
+    {
+        saveBlockCTX1(bestStart, bestEnd, bestPermutation, xrefs, result);
+    }
+}
+
+
+/*
+__device__ float computeError(const float weights[16], uchar a0, uchar a1)
+{
+	float palette[6];
+	palette[0] = (6.0f/7.0f * a0 + 1.0f/7.0f * a1);
+	palette[1] = (5.0f/7.0f * a0 + 2.0f/7.0f * a1);
+	palette[2] = (4.0f/7.0f * a0 + 3.0f/7.0f * a1);
+	palette[3] = (3.0f/7.0f * a0 + 4.0f/7.0f * a1);
+	palette[4] = (2.0f/7.0f * a0 + 5.0f/7.0f * a1);
+	palette[5] = (1.0f/7.0f * a0 + 6.0f/7.0f * a1);
+
+	float total = 0.0f;
+
+	for (uint i = 0; i < 16; i++)
+	{
+		float alpha = weights[i];
+
+		float error = a0 - alpha;
+		error = min(error, palette[0] - alpha);
+		error = min(error, palette[1] - alpha);
+		error = min(error, palette[2] - alpha);
+		error = min(error, palette[3] - alpha);
+		error = min(error, palette[4] - alpha);
+		error = min(error, palette[5] - alpha);
+		error = min(error, a1 - alpha);
+		
+		total += error;
+	}
+	
+	return total;
+}
+
+inline __device__ uchar roundAndExpand(float a)
+{
+	return rintf(__saturatef(a) * 255.0f);
+}
+*/
+/*
+__device__ void optimizeAlpha8(const float alphas[16], uchar & a0, uchar & a1)
+{
+	float alpha2_sum = 0;
+	float beta2_sum = 0;
+	float alphabeta_sum = 0;
+	float alphax_sum = 0;
+	float betax_sum = 0;
+
+	for (int i = 0; i < 16; i++)
+	{
+		uint idx = index[i];
+		float alpha;
+		if (idx < 2) alpha = 1.0f - idx;
+		else alpha = (8.0f - idx) / 7.0f;
+		
+		float beta = 1 - alpha;
+
+		alpha2_sum += alpha * alpha;
+		beta2_sum += beta * beta;
+		alphabeta_sum += alpha * beta;
+		alphax_sum += alpha * alphas[i];
+		betax_sum += beta * alphas[i];
+	}
+
+	const float factor = 1.0f / (alpha2_sum * beta2_sum - alphabeta_sum * alphabeta_sum);
+
+	float a = (alphax_sum * beta2_sum - betax_sum * alphabeta_sum) * factor;
+	float b = (betax_sum * alpha2_sum - alphax_sum * alphabeta_sum) * factor;
+
+	a0 = roundAndExpand8(a);
+	a1 = roundAndExpand8(b);
+}
+*/
+/*
+__device__ void compressAlpha(const float alphas[16], uint4 * result)
+{
+	const int tid = threadIdx.x;
+	
+	// Compress alpha block!
+	// Brute force approach:
+	// Try all color pairs: 256*256/2 = 32768, 32768/64 = 512 iterations?
+
+	// Determine min & max alphas
+
+	float A0, A1;
+
+	if (tid < 16)
+	{
+		__shared__ uint s_alphas[16];
+		
+		s_alphas[tid] = alphas[tid];
+		s_alphas[tid] = min(s_alphas[tid], s_alphas[tid^8]);
+		s_alphas[tid] = min(s_alphas[tid], s_alphas[tid^4]);
+		s_alphas[tid] = min(s_alphas[tid], s_alphas[tid^2]);
+		s_alphas[tid] = min(s_alphas[tid], s_alphas[tid^1]);
+		A0 = s_alphas[tid];
+		
+		s_alphas[tid] = alphas[tid];
+		s_alphas[tid] = max(s_alphas[tid], s_alphas[tid^8]);
+		s_alphas[tid] = max(s_alphas[tid], s_alphas[tid^4]);
+		s_alphas[tid] = max(s_alphas[tid], s_alphas[tid^2]);
+		s_alphas[tid] = max(s_alphas[tid], s_alphas[tid^1]);
+		A1 = s_alphas[tid];
+	}
+
+	__syncthreads();
+
+	int minIdx = 0;
+
+	if (A1 - A0 > 8)
+	{
+		float bestError = FLT_MAX;
+
+		// 64 threads -> 8x8
+		// divide [A1-A0] in partitions.
+		// test endpoints 
+		
+		for (int i = 0; i < 128; i++)
+		{
+			uint idx = (i * NUM_THREADS + tid) * 4;
+			uchar a0 = idx & 255;
+			uchar a1 = idx >> 8;
+			
+			float error = computeError(alphas, a0, a1);
+			
+			if (error < bestError)
+			{
+				bestError = error;
+				A0 = a0;
+				A1 = a1;
+			}
+		}
+		
+		__shared__ float errors[NUM_THREADS];
+		errors[tid] = bestError;
+		
+		// Minimize error.
+		minIdx = findMinError(errors);
+
+	}
+
+	if (minIdx == tid)
+	{
+		// @@ Compute indices.
+	
+		// @@ Write alpha block.
+	}
+}
+
+__global__ void compressDXT5(const uint * permutations, const uint * image, uint4 * result)
+{
+	__shared__ float3 colors[16];
+	__shared__ float3 sums[16];
+	__shared__ float weights[16];
+	__shared__ int xrefs[16];
+	
+	loadColorBlock(image, colors, sums, weights, xrefs);
+	
+	__syncthreads();
+
+	compressAlpha(weights, result);	
+
+	ushort bestStart, bestEnd;
+	uint bestPermutation;
+
+	__shared__ float errors[NUM_THREADS];
+	
+	evalLevel4Permutations(colors, weights, sums[0], permutations, bestStart, bestEnd, bestPermutation, errors);
+	
+	// Use a parallel reduction to find minimum error.
+	int minIdx = findMinError(errors);
+	
+	// Only write the result of the winner thread.
+	if (threadIdx.x == minIdx)
+	{
+		saveBlockDXT1(bestStart, bestEnd, bestPermutation, xrefs, (uint2 *)result);
+	}
+}
+*/
+
+/*__device__ void evaluatePalette(uint alpha0, uint alpha1, uint alphas[8])
+{
+	alpha[0] = alpha0;
+	alpha[1] = alpha1;
+	alpha[2] = (6 * alpha[0] + 1 * alpha[1]) / 7;	// bit code 010
+	alpha[3] = (5 * alpha[0] + 2 * alpha[1]) / 7;	// bit code 011
+	alpha[4] = (4 * alpha[0] + 3 * alpha[1]) / 7;	// bit code 100
+	alpha[5] = (3 * alpha[0] + 4 * alpha[1]) / 7;	// bit code 101
+	alpha[6] = (2 * alpha[0] + 5 * alpha[1]) / 7;	// bit code 110
+	alpha[7] = (1 * alpha[0] + 6 * alpha[1]) / 7;	// bit code 111
+}
+
+__device__ uint computeAlphaError(const uint block[16], uint alpha0, uint alpha1, int bestError = INT_MAX)
+{
+	uint8 alphas[8];
+	evaluatePalette(alpha0, alpha1, alphas);
+
+	int totalError = 0;
+
+	for (uint i = 0; i < 16; i++)
+	{
+		uint8 alpha = block[i];
+
+		// @@ It should be possible to do this much faster.
+
+		int minDist = INT_MAX;
+		for (uint p = 0; p < 8; p++)
+		{
+			int dist = alphaDistance(alpha, alphas[p]);
+			minDist = min(dist, minDist);
+		}
+
+
+
+		totalError += minDist;
+
+		if (totalError > bestError)
+		{
+			// early out
+			return totalError;
+		}
+	}
+
+	return totalError;
+}
+
+
+void compressDXT5A(uint alpha[16])
+{
+	// Get min/max alpha.
+	for (uint i = 0; i < 16; i++)
+	{
+		mina = min(mina, alpha[i]);
+		maxa = max(maxa, alpha[i]);
+	}
+
+	dxtBlock->alpha0 = maxa;
+	dxtBlock->alpha1 = mina;
+
+	if (maxa - mina > 8)
+	{
+		int besterror = computeAlphaError(rgba, dxtBlock);
+		int besta0 = maxa;
+		int besta1 = mina;
+
+		// Expand search space a bit.
+		const int alphaExpand = 8;
+		mina = (mina <= alphaExpand) ? 0 : mina - alphaExpand;
+		maxa = (maxa <= 255-alphaExpand) ? 255 : maxa + alphaExpand;
+
+		for (int a0 = mina+9; a0 < maxa; a0++)
+		{
+			for (int a1 = mina; a1 < a0-8; a1++)
+			{
+				nvDebugCheck(a0 - a1 > 8);
+
+				dxtBlock->alpha0 = a0;
+				dxtBlock->alpha1 = a1;
+				int error = computeAlphaError(rgba, dxtBlock, besterror);
+
+				if (error < besterror)
+				{
+					besterror = error;
+					besta0 = a0;
+					besta1 = a1;
+				}
+			}
+		}
+
+		dxtBlock->alpha0 = besta0;
+		dxtBlock->alpha1 = besta1;
+	}
+}
+
+__global__ void compressDXT5n(uint blockNum, uint2 * d_result)
+{
+	uint idx = blockIdx.x * 128 + threadIdx.x;
+
+	if (idx >= blockNum)
+	{
+		return;
+	}
+
+	// @@ Ideally we would load the data to shared mem to achieve coalesced global mem access.
+	// @@ Blocks would require too much shared memory (8k) and limit occupancy.
+
+	// @@ Ideally we should use SIMD processing, multiple threads (4-8) processing the same block.
+	// That simplifies coalescing, and reduces divergence.
+
+	// @@ Experiment with texture. That's probably the most simple approach.
+
+	uint x[16];
+	uint y[16];
+
+
+}
+*/
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Setup kernel
+////////////////////////////////////////////////////////////////////////////////
+
+extern "C" void setupOMatchTables(const void * OMatch5Src, size_t OMatch5Size, const void * OMatch6Src, size_t OMatch6Size)
+{
+    // Init single color lookup contant tables.
+    cudaMemcpyToSymbol(OMatch5, OMatch5Src, OMatch5Size, 0, cudaMemcpyHostToDevice);
+    cudaMemcpyToSymbol(OMatch6, OMatch6Src, OMatch6Size, 0, cudaMemcpyHostToDevice);
+}
+
+extern "C" void setupCompressKernel(const float weights[3])
+{
+    // Set constants.
+    cudaMemcpyToSymbol(kColorMetric, weights, sizeof(float) * 3, 0);
+
+    float weightsSqr[3];
+    weightsSqr[0] = weights[0] * weights[0];
+    weightsSqr[1] = weights[1] * weights[1];
+    weightsSqr[2] = weights[2] * weights[2];
+
+    cudaMemcpyToSymbol(kColorMetricSqr, weightsSqr, sizeof(float) * 3, 0);
+}
+
+extern "C" void bindTextureToArray(cudaArray * d_data)
+{
+    // Setup texture
+    tex.normalized = false;
+    tex.filterMode = cudaFilterModePoint;
+    tex.addressMode[0] = cudaAddressModeClamp;
+    tex.addressMode[1] = cudaAddressModeClamp;
+
+    cudaBindTextureToArray(tex, d_data);
+}
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Launch kernel
+////////////////////////////////////////////////////////////////////////////////
+
+// DXT1 compressors:
+extern "C" void compressKernelDXT1(uint firstBlock, uint blockNum, uint blockWidth, uint * d_result, uint * d_bitmaps)
+{
+    compressDXT1<<<blockNum, NUM_THREADS>>>(firstBlock, blockWidth, d_bitmaps, (uint2 *)d_result);
+}
+
+extern "C" void compressKernelDXT1_Level4(uint firstBlock, uint blockNum, uint blockWidth, uint * d_result, uint * d_bitmaps)
+{
+    compressLevel4DXT1<<<blockNum, NUM_THREADS>>>(firstBlock, blockWidth, d_bitmaps, (uint2 *)d_result);
+}
+
+extern "C" void compressWeightedKernelDXT1(uint firstBlock, uint blockNum, uint blockWidth, uint * d_result, uint * d_bitmaps)
+{
+    compressWeightedDXT1<<<blockNum, NUM_THREADS>>>(firstBlock, blockWidth, d_bitmaps, (uint2 *)d_result);
+}
+
+// @@ DXT1a compressors.
+
+
+// @@ DXT3 compressors:
+extern "C" void compressKernelDXT3(uint firstBlock, uint blockNum, uint blockWidth, uint * d_result, uint * d_bitmaps)
+{
+    //compressDXT3<<<blockNum, NUM_THREADS>>>(firstBlock, blockWidth, d_bitmaps, (uint2 *)d_result);
+}
+
+extern "C" void compressWeightedKernelDXT3(uint firstBlock, uint blockNum, uint blockWidth, uint * d_result, uint * d_bitmaps)
+{
+    //compressWeightedDXT3<<<blockNum, NUM_THREADS>>>(firstBlock, blockWidth, d_bitmaps, (uint2 *)d_result);
+}
+
+
+// @@ DXT5 compressors.
+extern "C" void compressKernelDXT5(uint firstBlock, uint blockNum, uint w, uint * d_result, uint * d_bitmaps)
+{
+    //compressDXT5<<<blockNum, NUM_THREADS>>>(firstBlock, w, d_bitmaps, (uint2 *)d_result);
+}
+
+extern "C" void compressWeightedKernelDXT5(uint firstBlock, uint blockNum, uint w, uint * d_result, uint * d_bitmaps)
+{
+    //compressWeightedDXT5<<<blockNum, NUM_THREADS>>>(firstBlock, w, d_bitmaps, (uint2 *)d_result);
+}
+
+
+
+
+
+/*
+extern "C" void compressNormalKernelDXT1(uint blockNum, uint * d_data, uint * d_result, uint * d_bitmaps)
+{
+    compressNormalDXT1<<<blockNum, NUM_THREADS>>>(d_bitmaps, d_data, (uint2 *)d_result);
+}
+
+extern "C" void compressKernelCTX1(uint blockNum, uint * d_data, uint * d_result, uint * d_bitmaps)
+{
+    compressCTX1<<<blockNum, NUM_THREADS>>>(d_bitmaps, d_data, (uint2 *)d_result);
+}
+*/
+/*
+extern "C" void compressKernelDXT5n(uint blockNum, cudaArray * d_data, uint * d_result)
+{
+//    compressDXT5n<<<blockNum/128, 128>>>(blockNum, (uint2 *)d_result);
+}
+*/

cuda_code/ComputeProductKernel.cu

@@ -0,0 +1,90 @@
+typedef unsigned char uint8_t;
+
+struct __device_builtin__ __align__(_NCS_) uint8n
+{
+    uint8_t _VARNAMES_;
+};
+
+extern "C"
+__global__ void compute_product(
+  const uint8_t* __restrict__ A,
+  const float* __restrict__ B,
+  const char* __restrict__ isEmpty,
+  const int* __restrict__ divStart,
+  const int* __restrict__ divSize,
+  float* __restrict__ V,
+  int* __restrict__ I,
+  int N, int L, int O, int nProbe
+) {
+  const int tid = threadIdx.x; // thread ID
+  const int qid = blockIdx.x; // query ID
+  // const uint8n* A2 = reinterpret_cast<const uint8n*>( const_cast<uint8_t*>(A) )
+  const uint8n* A2 = reinterpret_cast<const uint8n*>(A); // ?
+
+  // Load precomputed distances
+  extern __shared__ volatile float Bsh[];
+#pragma unroll
+  if (tid < 256){
+    for (int i = 0; i < _M_; i++){
+      int bz = i;
+      int by = qid;
+      int bx = tid;
+      Bsh[i * _K_ + tid] = B[(bz * L * _K_) + (by * _K_) + (bx)];
+    }
+  }
+  __syncthreads();
+  // Load A and compute distance
+  int iN = tid;
+  int counter = tid;
+  int start = 0; 
+  int size = 0;
+  int cDiv = -1;
+  bool break_loop = false;
+  while (iN < N){
+    while ( (iN - start) >= size){
+      cDiv ++;
+      if (cDiv >= nProbe){
+        break_loop = true;
+        break;
+      }
+      int residual = iN - start - size;
+      start = divStart[(qid) * nProbe + (cDiv)];
+      iN = start + residual;
+      size =  divSize[(qid) * nProbe + (cDiv)];
+      if (iN >= N){
+        break_loop = true;
+        break;
+      }
+    }
+    if (break_loop)
+      break;
+
+    float sum = 0.f;
+#pragma unroll
+    for (int i = 0; i < _M_ / _NCS_; i++){
+      uint8n Avals = A2[(i * N) + (iN)];
+_CODEBLOCK_
+    }
+    // write to V and I
+    int isCurrentEmpty;
+    isCurrentEmpty = isEmpty[iN];
+
+    /*
+    if (isCurrentEmpty == 0){
+      V[(qid) * O + counter] = sum;
+      I[(qid) * O + counter] = iN;
+    } else {
+      V[(qid) * O + counter] = -999999.f;
+      I[(qid) * O + counter] = -1;
+    }
+    */
+    
+    if (counter < O){
+      V[(qid) * O + counter] = isCurrentEmpty == 0 ? sum : -999999.f;
+      I[(qid) * O + counter] = isCurrentEmpty == 0 ? iN : -1;
+      // atomicAdd(V + (qid) * O + counter, isCurrentEmpty == 0 ? sum : -99999.f);
+    }   
+    iN += _TPB_;
+    counter += _TPB_;
+  }
+}

cuda_code/ConstraintEllipsoidGPU_1.cu

@@ -0,0 +1,103 @@
+// Copyright (c) 2009-2016 The Regents of the University of Michigan
+// This file is part of the HOOMD-blue project, released under the BSD 3-Clause License.
+
+
+// Maintainer: joaander
+
+#include "ConstraintEllipsoidGPU.cuh"
+#include "EvaluatorConstraint.h"
+#include "EvaluatorConstraintEllipsoid.h"
+
+#include <assert.h>
+
+/*! \file ConstraintEllipsoidGPU.cu
+    \brief Defines GPU kernel code for calculating ellipsoid constraint forces. Used by ConstraintEllipsoidGPU.
+*/
+
+//! Kernel for caculating ellipsoid constraint forces on the GPU
+/*! \param d_group_members List of members in the group
+    \param group_size number of members in the group
+    \param N number of particles in system
+    \param d_pos particle positions on device
+    \param P Position of the ellipsoid
+    \param rx radius of the ellipsoid in x direction
+    \param ry radius of the ellipsoid in y direction
+    \param rz radius of the ellipsoid in z direction
+    \param deltaT step size from the Integrator
+*/
+extern "C" __global__
+void gpu_compute_constraint_ellipsoid_constraint_kernel(const unsigned int *d_group_members,
+                                                 unsigned int group_size,
+                                                 const unsigned int N,
+                                                 Scalar4 *d_pos,
+                                                 Scalar3 P,
+                                                 Scalar rx,
+                                                 Scalar ry,
+                                                 Scalar rz)
+    {
+    // start by identifying which particle we are to handle
+    // determine which particle this thread works on
+    int group_idx = blockIdx.x * blockDim.x + threadIdx.x;
+
+    if (group_idx >= group_size)
+        return;
+
+    unsigned int idx = d_group_members[group_idx];
+
+    // read in position, velocity, net force, and mass
+    Scalar4 pos = d_pos[idx];
+
+    // convert to Scalar3's for passing to the evaluators
+    Scalar3 X = make_scalar3(pos.x, pos.y, pos.z);
+
+    // evaluate the constraint position
+    EvaluatorConstraintEllipsoid Ellipsoid(P, rx, ry, rz);
+    Scalar3 C = Ellipsoid.evalClosest(X);
+
+    // apply the constraint
+    d_pos[idx] = make_scalar4(C.x, C.y, C.z, Scalar(0.0));
+    }
+
+
+/*! \param d_group_members List of members in the group
+    \param group_size number of members in the group
+    \param N nunmber of particles
+    \param d_pos particle positions on the device
+    \param P Position of the ellipsoid
+    \param rx radius of the ellipsoid in x direction
+    \param ry radius of the ellipsoid in y direction
+    \param rz radius of the ellipsoid in z direction
+    \param deltaT step size from the Integrator
+    \param block_size Block size to execute on the GPU
+
+    \returns Any error code resulting from the kernel launch
+    \note Always returns cudaSuccess in release builds to avoid the cudaThreadSynchronize()
+*/
+cudaError_t gpu_compute_constraint_ellipsoid_constraint(const unsigned int *d_group_members,
+                                                 unsigned int group_size,
+                                                 const unsigned int N,
+                                                 Scalar4 *d_pos,
+                                                 const Scalar3 P,
+                                                 Scalar rx,
+                                                 Scalar ry,
+                                                 Scalar rz,
+                                                 unsigned int block_size)
+    {
+    assert(d_group_members);
+
+    // setup the grid to run the kernel
+    dim3 grid( group_size / block_size + 1, 1, 1);
+    dim3 threads(block_size, 1, 1);
+
+    // run the kernel
+    gpu_compute_constraint_ellipsoid_constraint_kernel<<< grid, threads>>>(d_group_members,
+                                                                    group_size,
+                                                                    N,
+                                                                    d_pos,
+                                                                    P,
+                                                                    rx,
+                                                                    ry,
+                                                                    rz);
+
+    return cudaSuccess;
+    }

cuda_code/CopySurface.cu

@@ -0,0 +1,52 @@
+/***************************************************************************
+# Copyright (c) 2019, NVIDIA CORPORATION. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#  * Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+#  * Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in the
+#    documentation and/or other materials provided with the distribution.
+#  * Neither the name of NVIDIA CORPORATION nor the names of its
+#    contributors may be used to endorse or promote products derived
+#    from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+# PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+# OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+***************************************************************************/
+#include "CopySurface.h"
+#include <device_launch_parameters.h>
+
+// The CUDA kernel. This sample simply copies the input surface.
+template<class T>
+__global__ void copySurface(cudaSurfaceObject_t input, cudaSurfaceObject_t output, unsigned int width, unsigned int height)
+{
+    unsigned int x = blockIdx.x * blockDim.x + threadIdx.x;
+    unsigned int y = blockIdx.y * blockDim.y + threadIdx.y;
+    if (x < width && y < height)
+    {
+        T data;
+        surf2Dread(&data, input, sizeof(T) * x, y);
+        surf2Dwrite(data, output, sizeof(T) * x, y);
+    }
+}
+
+// A wrapper function that launches the kernel.
+void launchCopySurface(cudaSurfaceObject_t input, cudaSurfaceObject_t output, unsigned int width, unsigned int height, unsigned int format)
+{
+    dim3 dimBlock(16, 16);
+    dim3 dimGrid((width + dimBlock.x - 1) / dimBlock.x, (height + dimBlock.y - 1) / dimBlock.y);
+    if (format == cudaChannelFormatKindFloat) copySurface<float><<<dimGrid, dimBlock>>>(input, output, width, height);
+    else copySurface<int><<<dimGrid, dimBlock>>>(input, output, width, height);
+}

cuda_code/Copy_15.cu

@@ -0,0 +1,225 @@
+#include <ATen/ATen.h>
+#include <ATen/Context.h>
+#include <ATen/Dispatch.h>
+#include <ATen/cuda/CUDAContext.h>
+#include <ATen/cuda/CUDAEvent.h>
+#include <c10/cuda/CUDAStream.h>
+#include <ATen/native/Copy.h>
+#include <ATen/native/TensorIterator.h>
+#include <ATen/native/cuda/Loops.cuh>
+#include <THC/THC.h>
+
+#ifdef __HIP_PLATFORM_HCC__
+#include <hip/hip_version.h>
+#endif
+
+namespace at {
+namespace native {
+
+using namespace at::cuda;
+
+// device-to-device copy, does type conversion
+void copy_device_to_device(TensorIterator& iter, bool non_blocking) {
+  int64_t numel = iter.numel();
+
+  // We can memcpy the memory if both tensors have the same type AND both
+  // tensors are contiguous after dimension coalescing and reordering.
+  bool same_type = iter.dtype(0) == iter.dtype(1);
+  bool same_conj = iter.tensor(0).is_conj() == iter.tensor(1).is_conj();
+  bool memcpy_eligible = same_type && same_conj && iter.is_contiguous();
+
+  Device dst_device = iter.device(0);
+  Device src_device = iter.device(1);
+
+  CUDAGuard device_guard(src_device);
+
+  // We always perform the copy on the source device, using the current stream
+  // on the source device, and we fully synchronize on both src and dst's
+  // current streams for completion of the copy. We have to explicitly do this
+  // for non-contig copies. This mimics the behavior of cross-device
+  // cudaMemcpyAsync on the default stream.
+  CUDAStream copy_stream = getCurrentCUDAStream(src_device.index());
+  if (src_device != dst_device) {
+    // This is a cross-device copy on the src current stream and dst current
+    // stream. We perform a two-way barrier between both devices' streams
+    // before the copy. This ensures that any write-after-write and
+    // write-after-read dependencies on the destination side are handled, so
+    // that no one is operating on the dst memory when we perform the copy.
+    // src waits on dst barrier (src already waits on src)
+    CUDAEvent dst_ready;
+    device_guard.set_device(dst_device);
+    dst_ready.record(getCurrentCUDAStream(dst_device.index()));
+
+    device_guard.set_device(src_device);
+    dst_ready.block(copy_stream);
+  }
+
+  if (memcpy_eligible) {
+    void *dst = iter.data_ptr(0);
+    void *src = iter.data_ptr(1);
+    size_t size = numel * iter.element_size(0);
+    if (src != dst || src_device != dst_device) {
+      // Perform the copy
+      AT_CUDA_CHECK(cudaMemcpyAsync(
+          dst, src, size,
+          cudaMemcpyDeviceToDevice,
+          copy_stream));
+    }
+  } else {
+    auto dtype = iter.dtype(0);
+    if (isQIntType(dtype)) {
+      AT_DISPATCH_QINT_TYPES(dtype, "copy_", [&] {
+        gpu_kernel(iter, [] GPU_LAMBDA(scalar_t x) { return x; });
+      });
+    } else {
+      if (!same_conj && same_type) {
+        AT_DISPATCH_COMPLEX_TYPES(
+            dtype, "copy_conj_", [&] {
+              gpu_kernel(iter, [] GPU_LAMBDA(scalar_t x) { return std::conj(x); });
+            });
+      } else {
+        AT_DISPATCH_ALL_TYPES_AND_COMPLEX_AND3(
+            kHalf, kBool, kBFloat16, dtype, "copy_", [&] {
+              gpu_kernel(iter, [] GPU_LAMBDA(scalar_t x) { return x; });
+            });
+      }
+    }
+  }
+
+  if (src_device != dst_device) {
+    // dst waits on src barrier (dst already waits on dst). We cannot
+    // operate on dst's copy until the copy is complete.
+
+    // Still on src_device, record stream event
+    CUDAEvent src_ready;
+    src_ready.record(copy_stream);
+
+    device_guard.set_device(dst_device);
+    src_ready.block(getCurrentCUDAStream(dst_device.index()));
+  }
+
+  AT_CUDA_CHECK(cudaGetLastError());
+}
+
+static bool copy_requires_temporaries(TensorIterator& iter, bool p2p_enabled) {
+  Device dst_device = iter.device(0);
+  Device src_device = iter.device(1);
+
+  if (dst_device == src_device) {
+    // We never require temporaries for copies on the same GPU.
+    TORCH_INTERNAL_ASSERT(dst_device.is_cuda() && src_device.is_cuda());
+    return false;
+  }
+
+  bool same_dtype = iter.dtype(0) == iter.dtype(1);
+  if (same_dtype && iter.is_contiguous()) {
+    // Contiguous same-dtype copies can always use cudaMemcpyAsync
+    return false;
+  } else if (dst_device.is_cuda() && src_device.is_cuda()) {
+    // Copies between GPUs can use the copy kernel if P2P is supported
+    return !p2p_enabled;
+  } else {
+    // The remaining cases require temporaries. For example, this includes
+    // non-contiguous copies between CPU and GPU.
+    return true;
+  }
+}
+
+static bool maybe_enable_p2p_access(Device dst_device, Device src_device) {
+  if (dst_device.is_cpu() || src_device.is_cpu()) {
+    return false;
+  }
+  return THCState_getPeerToPeerAccess(
+        globalContext().getTHCState(), src_device.index(), dst_device.index());
+}
+
+static void copy_kernel_cuda(TensorIterator& iter, bool non_blocking) {
+  AT_ASSERT(iter.ntensors() == 2);
+
+  Device dst_device = iter.device(0);
+  Device src_device = iter.device(1);
+
+  // Enable p2p access between devices. (No-op if it involves the CPU)
+  bool p2p_enabled = maybe_enable_p2p_access(dst_device, src_device);
+
+  if (copy_requires_temporaries(iter, p2p_enabled)) {
+    // NB: this involves recursive calls to copy. Be careful that those copies
+    // don't require temporaries or you will cause an infinite recursion!
+    auto& dst = iter.tensor(0);
+    Tensor dst_contig;
+    Tensor src_contig;
+
+    // Type conversions are performed on the CPU for CPU-GPU copies and on
+    // the src device for GPU-GPU copies.
+    if (iter.device_type(0) == kCUDA) {
+      dst_contig = dst.is_contiguous() ? dst : at::empty_like(dst, LEGACY_CONTIGUOUS_MEMORY_FORMAT);
+      src_contig = iter.tensor(1).to(iter.dtype(0)).expand_as(dst).contiguous();
+    } else {
+      bool same_type = iter.dtype(0) == iter.dtype(1);
+      dst_contig = (dst.is_contiguous() && same_type) ? dst : at::empty_like(dst, iter.dtype(1), LEGACY_CONTIGUOUS_MEMORY_FORMAT);
+      src_contig = iter.tensor(1).expand_as(dst).contiguous();
+    }
+
+    // propagate the correct conjugate bit
+    dst_contig._set_conj(dst.is_conj());
+    src_contig._set_conj(iter.tensor(1).is_conj());
+
+    // perform a same-dtype copy on contiguous tensors
+    TORCH_INTERNAL_ASSERT(dst_contig.sizes().equals(src_contig.sizes()));
+    TORCH_INTERNAL_ASSERT(dst_contig.scalar_type() == src_contig.scalar_type());
+    dst_contig.copy_(src_contig, non_blocking);
+
+    // if necessary, copy back into dst
+    if (!dst_contig.is_same(dst)) {
+      TORCH_INTERNAL_ASSERT(dst_contig.device() == dst.device());
+      dst.copy_(dst_contig, non_blocking);
+    }
+    return;
+  }
+
+  // Copy on GPU (or between GPUs)
+  if (dst_device.is_cuda() && src_device.is_cuda()) {
+    copy_device_to_device(iter, non_blocking);
+    return;
+  }
+
+  // Copy between CPU and GPU
+  cuda::OptionalCUDAGuard device_guard;
+  cudaMemcpyKind kind;
+  if (dst_device.is_cuda() && src_device.is_cpu()) {
+    device_guard.set_device(dst_device);
+    kind = cudaMemcpyHostToDevice;
+  } else if (dst_device.is_cpu() && src_device.is_cuda()) {
+    device_guard.set_device(src_device);
+    kind = cudaMemcpyDeviceToHost;
+  } else {
+    TORCH_INTERNAL_ASSERT(false, "unsupported devices in GPU copy_()");
+  }
+
+  void* dst = iter.data_ptr(0);
+  void* src = iter.data_ptr(1);
+  int64_t nbytes = iter.numel() * iter.element_size(0);
+  CUDAStream stream = getCurrentCUDAStream();
+
+  if (non_blocking) {
+    AT_CUDA_CHECK(cudaMemcpyAsync(dst, src, nbytes, kind, stream));
+    void* ptr = (dst_device == kCPU ? dst : src);
+    AT_CUDA_CHECK(THCCachingHostAllocator_recordEvent(ptr, stream));
+  } else {
+#if HIP_VERSION >= 301
+    AT_CUDA_CHECK(hipMemcpyWithStream(dst, src, nbytes, kind, stream));
+#else
+    AT_CUDA_CHECK(cudaMemcpyAsync(dst, src, nbytes, kind, stream));
+    AT_CUDA_CHECK(cudaStreamSynchronize(stream));
+#endif
+  }
+
+  if (iter.tensor(0).is_conj() != iter.tensor(1).is_conj()) {
+     iter.tensor(0).conj_physical_();
+  }
+}
+
+REGISTER_DISPATCH(copy_stub, &copy_kernel_cuda);
+
+} // namespace native
+} // namespace at

cuda_code/CudaAllocator_2.cu

@@ -0,0 +1,343 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//============================================================================
+
+#include <cstdlib>
+#include <mutex>
+#include <vtkm/cont/Logging.h>
+#include <vtkm/cont/RuntimeDeviceInformation.h>
+#include <vtkm/cont/cuda/ErrorCuda.h>
+#include <vtkm/cont/cuda/internal/CudaAllocator.h>
+#include <vtkm/cont/cuda/internal/DeviceAdapterTagCuda.h>
+#include <vtkm/cont/cuda/internal/RuntimeDeviceConfigurationCuda.h>
+#define NO_VTKM_MANAGED_MEMORY "NO_VTKM_MANAGED_MEMORY"
+
+#include <mutex>
+#include <vector>
+
+VTKM_THIRDPARTY_PRE_INCLUDE
+#include <cuda_runtime.h>
+VTKM_THIRDPARTY_POST_INCLUDE
+
+// These static vars are in an anon namespace to work around MSVC linker issues.
+namespace
+{
+#if CUDART_VERSION >= 8000
+// Has CudaAllocator::Initialize been called by any thread?
+static std::once_flag IsInitialized;
+#endif
+
+// Holds how VTK-m currently allocates memory.
+// When VTK-m is initialized we set this based on the hardware support ( HardwareSupportsManagedMemory ).
+// The user can explicitly disable managed memory through an enviornment variable
+// or by calling a function on the CudaAllocator.
+// Likewise managed memory can be re-enabled by calling a function on CudaAllocator
+// if and only if the underlying hardware supports pageable managed memory
+static bool ManagedMemoryEnabled = false;
+
+// True if concurrent pagable managed memory is supported by the machines hardware.
+static bool HardwareSupportsManagedMemory = false;
+
+// Avoid overhead of cudaMemAdvise and cudaMemPrefetchAsync for small buffers.
+// This value should be > 0 or else these functions will error out.
+static std::size_t Threshold = 1 << 20;
+}
+
+namespace vtkm
+{
+namespace cont
+{
+namespace cuda
+{
+namespace internal
+{
+
+bool CudaAllocator::UsingManagedMemory()
+{
+  CudaAllocator::Initialize();
+  return ManagedMemoryEnabled;
+}
+
+void CudaAllocator::ForceManagedMemoryOff()
+{
+  if (HardwareSupportsManagedMemory)
+  {
+    ManagedMemoryEnabled = false;
+    VTKM_LOG_F(vtkm::cont::LogLevel::Info, "CudaAllocator disabling managed memory");
+  }
+  else
+  {
+    VTKM_LOG_F(
+      vtkm::cont::LogLevel::Warn,
+      "CudaAllocator trying to disable managed memory on hardware that doesn't support it");
+  }
+}
+
+void CudaAllocator::ForceManagedMemoryOn()
+{
+  if (HardwareSupportsManagedMemory)
+  {
+    ManagedMemoryEnabled = true;
+    VTKM_LOG_F(vtkm::cont::LogLevel::Info, "CudaAllocator enabling managed memory");
+  }
+  else
+  {
+    VTKM_LOG_F(vtkm::cont::LogLevel::Warn,
+               "CudaAllocator trying to enable managed memory on hardware that doesn't support it");
+  }
+}
+
+bool CudaAllocator::IsDevicePointer(const void* ptr)
+{
+  CudaAllocator::Initialize();
+  if (!ptr)
+  {
+    return false;
+  }
+
+  cudaPointerAttributes attr;
+  cudaError_t err = cudaPointerGetAttributes(&attr, ptr);
+  // This function will return invalid value if the pointer is unknown to the
+  // cuda runtime. Manually catch this value since it's not really an error.
+  if (err == cudaErrorInvalidValue)
+  {
+    cudaGetLastError(); // Clear the error so we don't raise it later...
+    return false;
+  }
+  VTKM_CUDA_CALL(err /*= cudaPointerGetAttributes(&attr, ptr)*/);
+  return attr.devicePointer == ptr;
+}
+
+bool CudaAllocator::IsManagedPointer(const void* ptr)
+{
+  if (!ptr || !ManagedMemoryEnabled)
+  {
+    return false;
+  }
+
+  cudaPointerAttributes attr;
+  cudaError_t err = cudaPointerGetAttributes(&attr, ptr);
+  // This function will return invalid value if the pointer is unknown to the
+  // cuda runtime. Manually catch this value since it's not really an error.
+  if (err == cudaErrorInvalidValue)
+  {
+    cudaGetLastError(); // Clear the error so we don't raise it later...
+    return false;
+  }
+  VTKM_CUDA_CALL(err /*= cudaPointerGetAttributes(&attr, ptr)*/);
+#if CUDART_VERSION < 10000 // isManaged deprecated in CUDA 10.
+  return attr.isManaged != 0;
+#else // attr.type doesn't exist before CUDA 10
+  return attr.type == cudaMemoryTypeManaged;
+#endif
+}
+
+void* CudaAllocator::Allocate(std::size_t numBytes)
+{
+  CudaAllocator::Initialize();
+  // When numBytes is zero cudaMallocManaged returns an error and the behavior
+  // of cudaMalloc is not documented. Just return nullptr.
+  if (numBytes == 0)
+  {
+    return nullptr;
+  }
+
+  void* ptr = nullptr;
+  if (ManagedMemoryEnabled)
+  {
+    VTKM_CUDA_CALL(cudaMallocManaged(&ptr, numBytes));
+  }
+  else
+  {
+    VTKM_CUDA_CALL(cudaMalloc(&ptr, numBytes));
+  }
+
+  {
+    VTKM_LOG_F(vtkm::cont::LogLevel::MemExec,
+               "Allocated CUDA array of %s at %p.",
+               vtkm::cont::GetSizeString(numBytes).c_str(),
+               ptr);
+  }
+
+  return ptr;
+}
+
+void* CudaAllocator::AllocateUnManaged(std::size_t numBytes)
+{
+  void* ptr = nullptr;
+  VTKM_CUDA_CALL(cudaMalloc(&ptr, numBytes));
+  {
+    VTKM_LOG_F(vtkm::cont::LogLevel::MemExec,
+               "Allocated CUDA array of %s at %p.",
+               vtkm::cont::GetSizeString(numBytes).c_str(),
+               ptr);
+  }
+  return ptr;
+}
+
+void CudaAllocator::Free(void* ptr)
+{
+  VTKM_LOG_F(vtkm::cont::LogLevel::MemExec, "Freeing CUDA allocation at %p.", ptr);
+  VTKM_CUDA_CALL(cudaFree(ptr));
+}
+
+void CudaAllocator::FreeDeferred(void* ptr, std::size_t numBytes)
+{
+  static std::mutex deferredMutex;
+  static std::vector<void*> deferredPointers;
+  static std::size_t deferredSize = 0;
+  constexpr std::size_t bufferLimit = 2 << 24; //16MB buffer
+
+  {
+    VTKM_LOG_F(vtkm::cont::LogLevel::MemExec,
+               "Deferring free of CUDA allocation at %p of %s.",
+               ptr,
+               vtkm::cont::GetSizeString(numBytes).c_str());
+  }
+
+  std::vector<void*> toFree;
+  // critical section
+  {
+    std::lock_guard<std::mutex> lock(deferredMutex);
+    deferredPointers.push_back(ptr);
+    deferredSize += numBytes;
+    if (deferredSize >= bufferLimit)
+    {
+      toFree.swap(deferredPointers);
+      deferredSize = 0;
+    }
+  }
+
+  for (auto&& p : toFree)
+  {
+    VTKM_LOG_F(vtkm::cont::LogLevel::MemExec, "Freeing deferred CUDA allocation at %p.", p);
+    VTKM_CUDA_CALL(cudaFree(p));
+  }
+}
+
+void CudaAllocator::PrepareForControl(const void* ptr, std::size_t numBytes)
+{
+  if (IsManagedPointer(ptr) && numBytes >= Threshold)
+  {
+#if CUDART_VERSION >= 8000
+    // TODO these hints need to be benchmarked and adjusted once we start
+    // sharing the pointers between cont/exec
+    VTKM_CUDA_CALL(cudaMemAdvise(ptr, numBytes, cudaMemAdviseSetAccessedBy, cudaCpuDeviceId));
+    VTKM_CUDA_CALL(cudaMemPrefetchAsync(ptr, numBytes, cudaCpuDeviceId, cudaStreamPerThread));
+#endif // CUDA >= 8.0
+  }
+}
+
+void CudaAllocator::PrepareForInput(const void* ptr, std::size_t numBytes)
+{
+  if (IsManagedPointer(ptr) && numBytes >= Threshold)
+  {
+#if CUDART_VERSION >= 8000
+    vtkm::Id dev;
+    vtkm::cont::RuntimeDeviceInformation()
+      .GetRuntimeConfiguration(vtkm::cont::DeviceAdapterTagCuda())
+      .GetDeviceInstance(dev);
+    // VTKM_CUDA_CALL(cudaMemAdvise(ptr, numBytes, cudaMemAdviseSetPreferredLocation, dev));
+    // VTKM_CUDA_CALL(cudaMemAdvise(ptr, numBytes, cudaMemAdviseSetReadMostly, dev));
+    VTKM_CUDA_CALL(cudaMemAdvise(ptr, numBytes, cudaMemAdviseSetAccessedBy, dev));
+    VTKM_CUDA_CALL(cudaMemPrefetchAsync(ptr, numBytes, dev, cudaStreamPerThread));
+#endif // CUDA >= 8.0
+  }
+}
+
+void CudaAllocator::PrepareForOutput(const void* ptr, std::size_t numBytes)
+{
+  if (IsManagedPointer(ptr) && numBytes >= Threshold)
+  {
+#if CUDART_VERSION >= 8000
+    vtkm::Id dev;
+    vtkm::cont::RuntimeDeviceInformation()
+      .GetRuntimeConfiguration(vtkm::cont::DeviceAdapterTagCuda())
+      .GetDeviceInstance(dev);
+    // VTKM_CUDA_CALL(cudaMemAdvise(ptr, numBytes, cudaMemAdviseSetPreferredLocation, dev));
+    // VTKM_CUDA_CALL(cudaMemAdvise(ptr, numBytes, cudaMemAdviseUnsetReadMostly, dev));
+    VTKM_CUDA_CALL(cudaMemAdvise(ptr, numBytes, cudaMemAdviseSetAccessedBy, dev));
+    VTKM_CUDA_CALL(cudaMemPrefetchAsync(ptr, numBytes, dev, cudaStreamPerThread));
+#endif // CUDA >= 8.0
+  }
+}
+
+void CudaAllocator::PrepareForInPlace(const void* ptr, std::size_t numBytes)
+{
+  if (IsManagedPointer(ptr) && numBytes >= Threshold)
+  {
+#if CUDART_VERSION >= 8000
+    vtkm::Id dev;
+    vtkm::cont::RuntimeDeviceInformation()
+      .GetRuntimeConfiguration(vtkm::cont::DeviceAdapterTagCuda())
+      .GetDeviceInstance(dev);
+    // VTKM_CUDA_CALL(cudaMemAdvise(ptr, numBytes, cudaMemAdviseSetPreferredLocation, dev));
+    // VTKM_CUDA_CALL(cudaMemAdvise(ptr, numBytes, cudaMemAdviseUnsetReadMostly, dev));
+    VTKM_CUDA_CALL(cudaMemAdvise(ptr, numBytes, cudaMemAdviseSetAccessedBy, dev));
+    VTKM_CUDA_CALL(cudaMemPrefetchAsync(ptr, numBytes, dev, cudaStreamPerThread));
+#endif // CUDA >= 8.0
+  }
+}
+
+void CudaAllocator::Initialize()
+{
+#if CUDART_VERSION >= 8000
+  std::call_once(IsInitialized, []() {
+    auto cudaDeviceConfig = dynamic_cast<
+      vtkm::cont::internal::RuntimeDeviceConfiguration<vtkm::cont::DeviceAdapterTagCuda>&>(
+      vtkm::cont::RuntimeDeviceInformation{}.GetRuntimeConfiguration(
+        vtkm::cont::DeviceAdapterTagCuda()));
+    vtkm::Id numDevices;
+    cudaDeviceConfig.GetMaxDevices(numDevices);
+
+    if (numDevices == 0)
+    {
+      return;
+    }
+
+    // Check all devices, use the feature set supported by all
+    bool managedMemorySupported = true;
+    std::vector<cudaDeviceProp> cudaProp;
+    cudaDeviceConfig.GetCudaDeviceProp(cudaProp);
+    for (int i = 0; i < numDevices && managedMemorySupported; ++i)
+    {
+      // We check for concurrentManagedAccess, as devices with only the
+      // managedAccess property have extra synchronization requirements.
+      managedMemorySupported = managedMemorySupported && cudaProp[i].concurrentManagedAccess;
+    }
+
+    HardwareSupportsManagedMemory = managedMemorySupported;
+    ManagedMemoryEnabled = managedMemorySupported;
+
+    VTKM_LOG_F(vtkm::cont::LogLevel::Info,
+               "CudaAllocator hardware %s managed memory",
+               HardwareSupportsManagedMemory ? "supports" : "doesn't support");
+
+// Check if users want to disable managed memory
+#pragma warning(push)
+// getenv is not thread safe on windows but since it's inside a call_once block so
+// it's fine to suppress the warning here.
+#pragma warning(disable : 4996)
+    const char* buf = std::getenv(NO_VTKM_MANAGED_MEMORY);
+#pragma warning(pop)
+    if (managedMemorySupported && buf != nullptr)
+    { //only makes sense to disable managed memory if the hardware supports it
+      //in the first place
+      ManagedMemoryEnabled = false;
+      VTKM_LOG_F(
+        vtkm::cont::LogLevel::Info,
+        "CudaAllocator disabling managed memory due to NO_VTKM_MANAGED_MEMORY env variable");
+    }
+  });
+#endif
+}
+}
+}
+}
+} // end namespace vtkm::cont::cuda::internal

cuda_code/CudaKernel.cu

@@ -0,0 +1,12 @@
+typedef struct KernelData
+{
+    float a;
+    float b;
+    float result;
+} KernelData;
+
+__global__ void vectorAddition(KernelData* data)
+{
+    int index = blockIdx.x * blockDim.x + threadIdx.x;
+    data[index].result = data[index].a + data[index].b;
+}

cuda_code/CudaKernel_11.cu

@@ -0,0 +1,105 @@
+#include<cuda.h>
+#include<iostream>
+#include "CudaKernel.h"
+
+using namespace std;
+
+#define CudaSafeCall( err ) __cudaSafeCall( err, __FILE__, __LINE__ )
+#define CudaCheckError()    __cudaCheckError( __FILE__, __LINE__ )
+#define checkCudaErrors(err) __checkCudaErrors (err, __FILE__, __LINE__)
+
+
+texture <float,2,cudaReadModeElementType> tex1;
+
+static cudaArray *cuArray = NULL;
+
+//Kernel for x direction sobel
+__global__ void implement_x_sobel(float* output,int width,int height,int widthStep)
+{
+    int x = blockIdx.x * blockDim.x + threadIdx.x;
+    int y = blockIdx.y * blockDim.y + threadIdx.y;
+
+    //Make sure that thread is inside image bounds
+    if(x<width && y<height)
+    {
+        float output_value = (-1*tex2D(tex1,x-1,y-1)) + (0*tex2D(tex1,x,y-1)) + (1*tex2D(tex1,x+1,y-1))
+                           + (-2*tex2D(tex1,x-1,y))   + (0*tex2D(tex1,x,y))   + (2*tex2D(tex1,x+1,y))
+                           + (-1*tex2D(tex1,x-1,y+1)) + (0*tex2D(tex1,x,y+1)) + (1*tex2D(tex1,x+1,y+1));
+
+        output[y*widthStep+x]=output_value;
+    }
+
+}
+
+
+inline void __checkCudaErrors( cudaError err, const char *file, const int line )
+{
+    if( cudaSuccess != err) {
+        fprintf(stderr, "%s(%i) : CUDA Runtime API error %d: %s.\n",
+            file, line, (int)err, cudaGetErrorString( err ) );
+        exit(-1);
+    }
+}   
+
+//Host Code
+inline void __cudaSafeCall( cudaError err, const char *file, const int line )
+{
+#ifdef CUDA_ERROR_CHECK
+    if ( cudaSuccess != err )
+    {
+        printf("cudaSafeCall() failed at %s:%i : %s\n",
+            file, line, cudaGetErrorString( err ) );
+        exit( -1 );
+    }    
+#endif
+
+    return;
+}
+inline void __cudaCheckError( const char *file, const int line )
+{
+#ifdef CUDA_ERROR_CHECK
+    cudaError err = cudaGetLastError();
+    if ( cudaSuccess != err )
+    {
+        printf("cudaCheckError() failed at %s:%i : %s\n",
+            file, line, cudaGetErrorString( err ) );
+        exit( -1 );
+    }
+#endif
+
+    return;
+}
+
+void kernelcall(float* input,float* output,int width,int height,int widthStep)
+{
+    cudaChannelFormatDesc channelDesc = cudaCreateChannelDesc<float>();
+
+    CudaSafeCall(cudaMallocArray(&cuArray,&channelDesc,width,height));
+
+    //Never use 1D memory copy if host and device pointers have different widthStep.
+    // You don't know the width step of CUDA array, so its better to use cudaMemcpy2D...
+    cudaMemcpy2DToArray(cuArray,0,0,input,widthStep,width * sizeof(float),height,cudaMemcpyHostToDevice);
+
+    cudaBindTextureToArray(tex1,cuArray,channelDesc);
+
+    float * D_output_x;
+    CudaSafeCall(cudaMalloc(&D_output_x,widthStep*height)); 
+
+    dim3 blocksize(16,16);
+    dim3 gridsize;
+    gridsize.x=(width+blocksize.x-1)/blocksize.x;
+    gridsize.y=(height+blocksize.y-1)/blocksize.y;
+
+    implement_x_sobel<<<gridsize,blocksize>>>(D_output_x,width,height,widthStep/sizeof(float));
+
+    cudaThreadSynchronize();
+    CudaCheckError();
+
+    //Don't forget to unbind the texture
+    cudaUnbindTexture(tex1);
+
+    CudaSafeCall(cudaMemcpy(output,D_output_x,height*widthStep,cudaMemcpyDeviceToHost));
+
+    cudaFree(D_output_x);
+    cudaFreeArray(cuArray);
+}

cuda_code/CudnnMaxPool_2.cu

@@ -0,0 +1,210 @@
+#include "gpu_runtime.h"
+
+int CuDNN_DLGpuMax_Pooling2d(const DLArrayHandle input,const size_t kernel_H, const size_t kernel_W, DLArrayHandle output, const size_t padding, const size_t stride, DLStreamHandle stream_handle = NULL, ProfilerHandle p = NULL){
+    // create handle
+    // CUDNN_CALL(cudnnCreate(&cudnn));
+    int dev_id = (input->ctx).device_id;
+    cudnn_init(dev_id, stream_handle);
+    
+    // input
+    size_t input_N = input->shape[0];
+    size_t input_C = input->shape[1];
+    size_t input_H = input->shape[2];
+    size_t input_W = input->shape[3];
+    const float * input_data = (const float*) input->data;
+    
+    //output
+    size_t output_H = output->shape[2];
+    size_t output_W = output->shape[3];
+    float *output_data = (float *) output->data;
+    if(p != NULL){
+        int size_input = 1, size_output = 1;
+        for(int i = 0; i < input -> ndim; i++)
+            size_input *= input -> shape[i];
+        for(int i = 0; i < output -> ndim; i++)
+            size_output *= output -> shape[i];
+        p -> input_memory = 1.0 * (size_input) * sizeof(float) / 1024 / 1024;
+        p -> output_memory = 1.0 * size_output * sizeof(float) / 1024 / 1024;
+        p -> workspace_memory = 0;
+        cudaEvent_t start, stop;
+        cudaEventCreate(&start);
+        cudaEventRecord(start,0);
+        //pooling descriptor
+        cudnnPoolingDescriptor_t maxpool_desc;
+        CUDNN_CALL(cudnnCreatePoolingDescriptor(&maxpool_desc));
+        // std::cout<<"padding = "<<padding<<" stride = "<<stride<<std::endl;
+        // CUDNN_CALL(cudnnSetPooling2dDescriptor(maxpool_desc,CUDNN_POOLING_MAX,
+        //   CUDNN_PROPAGATE_NAN, kernel_H, kernel_W, padding, padding, stride, stride));
+        CUDNN_CALL(cudnnSetPooling2dDescriptor(maxpool_desc,CUDNN_POOLING_MAX_DETERMINISTIC,
+                CUDNN_PROPAGATE_NAN, kernel_H, kernel_W, padding, padding, stride, stride));
+        
+        //input descriptor
+        cudnnTensorDescriptor_t input_desc;
+        CUDNN_CALL(cudnnCreateTensorDescriptor(&input_desc));
+        CUDNN_CALL(cudnnSetTensor4dDescriptor(input_desc, CUDNN_TENSOR_NCHW, CUDNN_DATA_FLOAT, input_N, input_C, input_H, input_W));
+    
+        //output descriptor 
+        cudnnTensorDescriptor_t output_desc;
+        CUDNN_CALL(cudnnCreateTensorDescriptor(&output_desc));
+        CUDNN_CALL(cudnnSetTensor4dDescriptor(output_desc,CUDNN_TENSOR_NCHW, CUDNN_DATA_FLOAT, input_N, input_C, output_H, output_W));
+    
+        float alpha = 1.0f;
+        float beta = 0.0f;
+    
+        CUDNN_CALL(cudnnPoolingForward(cudnn_map[dev_id], maxpool_desc, 
+                                    &alpha, input_desc, input_data, &beta, output_desc, output_data));
+    
+        CUDNN_CALL(cudnnDestroyTensorDescriptor(input_desc));
+        CUDNN_CALL(cudnnDestroyTensorDescriptor(output_desc));
+        CUDNN_CALL(cudnnDestroyPoolingDescriptor(maxpool_desc));    
+
+        float elapsedTime;
+        cudaEventCreate(&stop);
+        cudaEventRecord(stop,0);
+        cudaEventSynchronize(stop);
+        cudaEventElapsedTime(&elapsedTime, start,stop);
+        cudaEventDestroy(start);
+        cudaEventDestroy(stop);
+        p->time = elapsedTime;    
+    }
+    else{
+        //pooling descriptor
+        cudnnPoolingDescriptor_t maxpool_desc;
+        CUDNN_CALL(cudnnCreatePoolingDescriptor(&maxpool_desc));
+        // std::cout<<"padding = "<<padding<<" stride = "<<stride<<std::endl;
+        // CUDNN_CALL(cudnnSetPooling2dDescriptor(maxpool_desc,CUDNN_POOLING_MAX,
+        //   CUDNN_PROPAGATE_NAN, kernel_H, kernel_W, padding, padding, stride, stride));
+        CUDNN_CALL(cudnnSetPooling2dDescriptor(maxpool_desc,CUDNN_POOLING_MAX_DETERMINISTIC,
+                CUDNN_PROPAGATE_NAN, kernel_H, kernel_W, padding, padding, stride, stride));
+        
+        //input descriptor
+        cudnnTensorDescriptor_t input_desc;
+        CUDNN_CALL(cudnnCreateTensorDescriptor(&input_desc));
+        CUDNN_CALL(cudnnSetTensor4dDescriptor(input_desc, CUDNN_TENSOR_NCHW, CUDNN_DATA_FLOAT, input_N, input_C, input_H, input_W));
+    
+        //output descriptor 
+        cudnnTensorDescriptor_t output_desc;
+        CUDNN_CALL(cudnnCreateTensorDescriptor(&output_desc));
+        CUDNN_CALL(cudnnSetTensor4dDescriptor(output_desc,CUDNN_TENSOR_NCHW, CUDNN_DATA_FLOAT, input_N, input_C, output_H, output_W));
+    
+        float alpha = 1.0f;
+        float beta = 0.0f;
+    
+        CUDNN_CALL(cudnnPoolingForward(cudnn_map[dev_id], maxpool_desc, 
+                                    &alpha, input_desc, input_data, &beta, output_desc, output_data));
+    
+        CUDNN_CALL(cudnnDestroyTensorDescriptor(input_desc));
+        CUDNN_CALL(cudnnDestroyTensorDescriptor(output_desc));
+        CUDNN_CALL(cudnnDestroyPoolingDescriptor(maxpool_desc));
+    }
+    return 0;
+  }
+  
+  int CuDNN_DLGpuMax_Pooling2d_gradient(const DLArrayHandle output_Y,const DLArrayHandle gradient_Y,const DLArrayHandle input_X, const size_t kernel_H, const size_t kernel_W, DLArrayHandle gradient_X, const size_t padding, const size_t stride, DLStreamHandle stream_handle = NULL, ProfilerHandle p = NULL){
+    // create handle
+    // CUDNN_CALL(cudnnCreate(&cudnn));
+    int dev_id = (input_X->ctx).device_id;
+    cudnn_init(dev_id, stream_handle);
+      
+    // input
+    size_t input_N = input_X->shape[0];
+    size_t input_C = input_X->shape[1];
+    size_t input_H = input_X->shape[2];
+    size_t input_W = input_X->shape[3];
+    const float * input_data = (const float*) input_X->data;
+    float * gradient_x_data = (float *) gradient_X->data; 
+    //output
+    size_t output_H = output_Y->shape[2];
+    size_t output_W = output_Y->shape[3];
+    const float *output_data = (const float *) output_Y->data;
+    const float *gradient_Y_data = (const float *) gradient_Y -> data;
+    if(p != NULL){
+        int size_input1 = 1, size_input2 = 1, size_input3 = 1, size_output = 1;
+        for(int i = 0; i < output_Y -> ndim; i++)
+            size_input1 *= output_Y -> shape[i];
+        for(int i = 0; i < gradient_Y -> ndim; i++)
+            size_input2 *= gradient_Y -> shape[i];
+        for(int i = 0; i < input_X -> ndim; i++)
+            size_input3 *= input_X -> shape[i];
+        for(int i = 0; i < gradient_X -> ndim; i++)
+            size_output *= gradient_X -> shape[i];
+        p -> input_memory = 1.0 * (size_input1 + size_input2 + size_input3) * sizeof(float) / 1024 / 1024;
+        p -> output_memory = 1.0 * size_output * sizeof(float) / 1024 / 1024;
+        p -> workspace_memory = 0;cudaEvent_t start, stop;
+        cudaEventCreate(&start);
+        cudaEventRecord(start,0);
+
+        //pooling descriptor
+        cudnnPoolingDescriptor_t maxpool_desc;
+        CUDNN_CALL(cudnnCreatePoolingDescriptor(&maxpool_desc));
+        // std::cout<<"padding = "<<padding<<" stride = "<<stride<<std::endl;
+        // CUDNN_CALL(cudnnSetPooling2dDescriptor(maxpool_desc,CUDNN_POOLING_MAX,
+        //           CUDNN_PROPAGATE_NAN, kernel_H, kernel_W, padding, padding, stride, stride));
+        CUDNN_CALL(cudnnSetPooling2dDescriptor(maxpool_desc,CUDNN_POOLING_MAX_DETERMINISTIC,
+        CUDNN_PROPAGATE_NAN, kernel_H, kernel_W, padding, padding, stride, stride));
+    
+        //input descriptor
+        cudnnTensorDescriptor_t input_desc;
+        CUDNN_CALL(cudnnCreateTensorDescriptor(&input_desc));
+        CUDNN_CALL(cudnnSetTensor4dDescriptor(input_desc, CUDNN_TENSOR_NCHW, CUDNN_DATA_FLOAT, input_N, input_C, input_H, input_W));
+    
+        //output descriptor 
+        cudnnTensorDescriptor_t output_desc;
+        CUDNN_CALL(cudnnCreateTensorDescriptor(&output_desc));
+        CUDNN_CALL(cudnnSetTensor4dDescriptor(output_desc,CUDNN_TENSOR_NCHW, CUDNN_DATA_FLOAT, input_N, input_C, output_H, output_W));
+    
+        float alpha = 1.0f;
+        float beta = 0.0f;
+    
+        CUDNN_CALL(cudnnPoolingBackward(cudnn_map[dev_id],  maxpool_desc,
+                                        &alpha, output_desc, output_data,
+                                        output_desc, gradient_Y_data,
+                                        input_desc, input_data,
+                                        &beta, input_desc,gradient_x_data));
+        CUDNN_CALL(cudnnDestroyTensorDescriptor(input_desc));
+        CUDNN_CALL(cudnnDestroyTensorDescriptor(output_desc));
+        CUDNN_CALL(cudnnDestroyPoolingDescriptor(maxpool_desc));    
+        
+        float elapsedTime;
+        cudaEventCreate(&stop);
+        cudaEventRecord(stop,0);
+        cudaEventSynchronize(stop);
+        cudaEventElapsedTime(&elapsedTime, start,stop);
+        cudaEventDestroy(start);
+        cudaEventDestroy(stop);
+        p->time = elapsedTime;    
+    }
+    else{
+        //pooling descriptor
+        cudnnPoolingDescriptor_t maxpool_desc;
+        CUDNN_CALL(cudnnCreatePoolingDescriptor(&maxpool_desc));
+        // std::cout<<"padding = "<<padding<<" stride = "<<stride<<std::endl;
+        // CUDNN_CALL(cudnnSetPooling2dDescriptor(maxpool_desc,CUDNN_POOLING_MAX,
+        //           CUDNN_PROPAGATE_NAN, kernel_H, kernel_W, padding, padding, stride, stride));
+        CUDNN_CALL(cudnnSetPooling2dDescriptor(maxpool_desc,CUDNN_POOLING_MAX_DETERMINISTIC,
+        CUDNN_PROPAGATE_NAN, kernel_H, kernel_W, padding, padding, stride, stride));
+    
+        //input descriptor
+        cudnnTensorDescriptor_t input_desc;
+        CUDNN_CALL(cudnnCreateTensorDescriptor(&input_desc));
+        CUDNN_CALL(cudnnSetTensor4dDescriptor(input_desc, CUDNN_TENSOR_NCHW, CUDNN_DATA_FLOAT, input_N, input_C, input_H, input_W));
+    
+        //output descriptor 
+        cudnnTensorDescriptor_t output_desc;
+        CUDNN_CALL(cudnnCreateTensorDescriptor(&output_desc));
+        CUDNN_CALL(cudnnSetTensor4dDescriptor(output_desc,CUDNN_TENSOR_NCHW, CUDNN_DATA_FLOAT, input_N, input_C, output_H, output_W));
+    
+        float alpha = 1.0f;
+        float beta = 0.0f;
+    
+        CUDNN_CALL(cudnnPoolingBackward(cudnn_map[dev_id],  maxpool_desc,
+                                        &alpha, output_desc, output_data,
+                                        output_desc, gradient_Y_data,
+                                        input_desc, input_data,
+                                        &beta, input_desc,gradient_x_data));
+        CUDNN_CALL(cudnnDestroyTensorDescriptor(input_desc));
+        CUDNN_CALL(cudnnDestroyTensorDescriptor(output_desc));
+        CUDNN_CALL(cudnnDestroyPoolingDescriptor(maxpool_desc));
+    }
+    return 0;
+  }

cuda_code/CustomPi.cu

@@ -0,0 +1,42 @@
+#ifdef __cplusplus
+extern "C" {
+  #endif
+
+  struct point{
+    float x;
+    float y;
+  };
+  
+  
+  __global__ void pi(const struct point* A, int* res, const int nbPoint, const float ray){
+    const int idx = 32*blockDim.x * blockIdx.x + threadIdx.x;
+    if (idx < nbPoint-32*blockDim.x)
+      #pragma unroll 16
+      for (int j = 0; j < 32; j++) {
+	int i = idx + blockDim.x * j;
+	res[i] = (A[i].x*A[i].x + A[i].y*A[i].y <= ray);
+      }
+  }
+
+  
+  struct point2{
+    double x;
+    double y;
+  };
+
+  
+__global__ void pi_double(const struct point2* A, int* res, const int nbPoint, const float ray){
+    const int idx = 32*blockDim.x * blockIdx.x + threadIdx.x;
+    if (idx < nbPoint-32*blockDim.x)
+      if (idx < (int)(nbPoint-32*blockDim.x))
+	#pragma unroll 16
+	for (int j = 0; j < 32; j++) {
+	  int i = idx + blockDim.x * j;
+	  res[i] = (A[i].x*A[i].x + A[i].y*A[i].y <= (double)ray);
+	}
+  }
+  
+  
+  #ifdef __cplusplus
+}
+#endif

cuda_code/DReductor.cu

@@ -0,0 +1,130 @@
+// Zhihua Ban all rights reserved.
+// If you have questions, please contact me at [email protected]
+
+#include "AMatrix.hpp"
+#include <cuda.h>
+#include "common.h"
+
+// dim3(GS)
+// dim3(BS)
+// /*number of layers*/
+template<unsigned int GS, unsigned int BS, unsigned int N, class T>
+__global__ void kernel_reduction(
+  T *odata, T *idata,
+  const unsigned int width,
+  const unsigned int height,
+  const unsigned int steps, 
+  const unsigned int layer /*layer size = steps*height*/
+){
+  __shared__ T smem[BS];
+  const unsigned int tid = threadIdx.x;
+  const unsigned int ty  = blockIdx.x;
+  unsigned int i = 0;
+  unsigned int y = 0;
+  unsigned int x = 0;
+  T sumv = 0;
+
+  // for each layer
+  for (; i < N; i++){
+    sumv = 0;
+    for (y = ty; y < height; y+=GS){
+      for (x = tid; x < width; x+=BS){
+        sumv += idata[y*steps + x];
+      }
+    }
+
+    smem[tid] = sumv;
+    __syncthreads();
+
+    if (BS >= 512){ if (tid < 256) smem[tid] = sumv = sumv + smem[tid + 256]; __syncthreads(); }
+    if (BS >= 256){ if (tid < 128) smem[tid] = sumv = sumv + smem[tid + 128]; __syncthreads(); }
+    if (BS >= 128){ if (tid <  64) smem[tid] = sumv = sumv + smem[tid +  64]; __syncthreads(); }
+    if (BS >=  64){ if (tid <  32) smem[tid] = sumv = sumv + smem[tid +  32]; __syncthreads(); }
+    if (BS >=  32){ if (tid <  16) smem[tid] = sumv = sumv + smem[tid +  16]; __syncthreads(); }
+    if (BS >=  16){ if (tid <   8) smem[tid] = sumv = sumv + smem[tid +   8]; __syncthreads(); }
+    if (BS >=   8){ if (tid <   4) smem[tid] = sumv = sumv + smem[tid +   4]; __syncthreads(); }
+    if (BS >=   4){ if (tid <   2) smem[tid] = sumv = sumv + smem[tid +   2]; __syncthreads(); }
+    if (BS >= 2){ if (tid < 1){ odata[i*GS + ty] = sumv + smem[1]; } }
+    idata += layer;
+  }
+}
+// dim3(N)  /*number of layers*/
+// dim3(BS)  
+template<unsigned int BS, unsigned int N, class T>
+__global__ void kernel_reduction(T* odata, const T* idata){
+
+  __shared__ T smem[BS];
+  T sumv = 0;
+  unsigned int tid = threadIdx.x;
+  unsigned int i = blockIdx.x;
+  smem[tid] = sumv = idata[i*BS + tid];
+  __syncthreads();
+  if (BS >= 512){ if (tid < 256) smem[tid] = sumv = sumv + smem[tid + 256]; __syncthreads(); }
+  if (BS >= 256){ if (tid < 128) smem[tid] = sumv = sumv + smem[tid + 128]; __syncthreads(); }
+  if (BS >= 128){ if (tid <  64) smem[tid] = sumv = sumv + smem[tid +  64]; __syncthreads(); }
+  if (BS >=  64){ if (tid <  32) smem[tid] = sumv = sumv + smem[tid +  32]; __syncthreads(); }
+  if (BS >=  32){ if (tid <  16) smem[tid] = sumv = sumv + smem[tid +  16]; __syncthreads(); }
+  if (BS >=  16){ if (tid <   8) smem[tid] = sumv = sumv + smem[tid +   8]; __syncthreads(); }
+  if (BS >=   8){ if (tid <   4) smem[tid] = sumv = sumv + smem[tid +   4]; __syncthreads(); }
+  if (BS >=   4){ if (tid <   2) smem[tid] = sumv = sumv + smem[tid +   2]; __syncthreads(); }
+  if (BS >= 2){ if (tid < 1) { odata[i] = sumv + smem[1]; } }
+}
+
+// dim3(N)  /*number of layers*/
+// dim3(BS)  
+template<unsigned int BS, unsigned int N, class T>
+__global__ void kernel_reduction_factor(T* odata, const T* idata, const float factor){
+
+  __shared__ T smem[BS];
+  T sumv = 0;
+  unsigned int tid = threadIdx.x;
+  unsigned int i = blockIdx.x;
+  smem[tid] = sumv = idata[i*BS + tid];
+  __syncthreads();
+  if (BS >= 512){ if (tid < 256) smem[tid] = sumv = sumv + smem[tid + 256]; __syncthreads(); }
+  if (BS >= 256){ if (tid < 128) smem[tid] = sumv = sumv + smem[tid + 128]; __syncthreads(); }
+  if (BS >= 128){ if (tid <  64) smem[tid] = sumv = sumv + smem[tid +  64]; __syncthreads(); }
+  if (BS >=  64){ if (tid <  32) smem[tid] = sumv = sumv + smem[tid +  32]; __syncthreads(); }
+  if (BS >=  32){ if (tid <  16) smem[tid] = sumv = sumv + smem[tid +  16]; __syncthreads(); }
+  if (BS >=  16){ if (tid <   8) smem[tid] = sumv = sumv + smem[tid +   8]; __syncthreads(); }
+  if (BS >=   8){ if (tid <   4) smem[tid] = sumv = sumv + smem[tid +   4]; __syncthreads(); }
+  if (BS >=   4){ if (tid <   2) smem[tid] = sumv = sumv + smem[tid +   2]; __syncthreads(); }
+  if (BS >= 2){ if (tid < 1) { odata[i] = (sumv + smem[1])*factor; } }
+}
+
+template<unsigned int GS, unsigned int BS, unsigned int N, class T> void 
+run_sum_(T *odata, T *idata, const unsigned int width, const unsigned int height, const unsigned int steps)
+{
+  if (GS > N){
+    kernel_reduction<GS, BS, N, T> <<<GS, BS>>>(odata + GS, idata, width, height, steps, steps*height);
+    kernel_reduction<GS, N, T> <<<N, GS>>>(odata, odata + GS);
+  }
+  else{
+    cerr << "not support yet." << endl;
+    exit(EXIT_FAILURE);
+  }
+}
+
+template void run_sum_<REDUCTOR_GS__, REDUCTOR_BS__, NN_FEATURES__, float>
+(float *odata, float *idata, const unsigned int width, const unsigned int height, const unsigned int steps);
+template void run_sum_<REDUCTOR_GS__, REDUCTOR_BS__, NN_FEATURES__, int  >
+(int   *odata, int   *idata, const unsigned int width, const unsigned int height, const unsigned int steps);
+
+
+template<unsigned int GS, unsigned int BS, unsigned int N, class T> void
+run_mean_(T *odata, T *idata, const unsigned int width, const unsigned int height, const unsigned int steps)
+{
+  if (GS > N){
+    kernel_reduction<GS, BS, N, T> << <GS, BS >> >(odata + GS, idata, width, height, steps, steps*height);
+    kernel_reduction_factor<GS, N, T> << <N, GS >> >(odata, odata + GS, 1.f/float(width*height));
+  }
+  else{
+    cerr << "not support yet." << endl;
+    exit(EXIT_FAILURE);
+  }
+}
+
+template void run_mean_<REDUCTOR_GS__, REDUCTOR_BS__, NN_FEATURES__, float>
+(float *odata, float *idata, const unsigned int width, const unsigned int height, const unsigned int steps);
+template void run_mean_<REDUCTOR_GS__, REDUCTOR_BS__, NN_FEATURES__, int  >
+(int   *odata, int   *idata, const unsigned int width, const unsigned int height, const unsigned int steps);

cuda_code/DepthmapDenoiseWeightedHuber.cu

@@ -0,0 +1,942 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+//! OpenDTAM Variant of Chambolle & Pock denoising
+//!
+//! The complicated half of the DTAM algorithm's mapping core,
+//! but can be used independently to refine depthmaps.
+//!
+//! Written by Paul Foster for GSoC 2014 OpenDTAM project.
+//! High level algorithm described by Richard Newcombe, Steven J. Lovegrove, and Andrew J. Davison. 
+//! "DTAM: Dense tracking and mapping in real-time."
+//! Which was in turn based on Chambolle & Pock's
+//! "A first-order primal-dual algorithm for convex problems with applications to imaging."
+
+#include <opencv2/core/cuda/common.hpp>//for cudaSafeCall,CV_Assert
+
+#include "DepthmapDenoiseWeightedHuber.cuh"
+
+namespace cv { namespace cuda { namespace device {
+    namespace dtam_denoise{
+
+
+static unsigned int arows;//TODO:make sure this is still reentrant
+
+void loadConstants(uint h_rows, uint, uint , uint ,
+        float* , float* , float* , float* , float* ,
+        float*) {
+
+        arows=h_rows;
+}
+
+cudaStream_t localStream=0;
+
+const int BLOCKX2D=32;
+const int BLOCKY2D=32;
+#define GENERATE_CUDA_FUNC2D(funcName,arglist,notypes)                                     \
+static __global__ void funcName arglist;                                                        \
+void funcName##Caller arglist{                                                           \
+   dim3 dimBlock(BLOCKX2D,BLOCKY2D);                                                                  \
+   dim3 dimGrid((acols  + dimBlock.x - 1) / dimBlock.x,                                  \
+                (arows + dimBlock.y - 1) / dimBlock.y);                                  \
+   funcName<<<dimGrid, dimBlock,0,localStream>>>notypes;                                  \
+   cudaSafeCall( cudaGetLastError() );\
+};static __global__ void funcName arglist
+
+
+#define GENERATE_CUDA_FUNC2DROWS(funcName,arglist,notypes)                                     \
+static __global__ void funcName arglist;                                                        \
+void funcName##Caller arglist{                                                           \
+   dim3 dimBlock(BLOCKX2D,BLOCKY2D);                                                                  \
+   dim3 dimGrid(1,                                  \
+                (arows + dimBlock.y - 1) / dimBlock.y);                                  \
+   funcName<<<dimGrid, dimBlock,0,localStream>>>notypes;                                  \
+   cudaSafeCall( cudaGetLastError() );\
+};static __global__ void funcName arglist
+
+
+static __global__ void computeG1  (float* pp, float* g1p, float* gxp, float* gyp, int cols);
+static __global__ void computeG2  (float* pp, float* g1p, float* gxp, float* gyp, int cols);
+void computeGCaller  (float* pp, float* g1p, float* gxp, float* gyp, int cols){
+//   dim3 dimBlock(BLOCKX2D,BLOCKY2D);
+   dim3 dimBlock(BLOCKX2D,4);
+   dim3 dimGrid(1,
+                (arows + dimBlock.y - 1) / dimBlock.y);
+
+   computeG1<<<dimGrid, dimBlock,0,localStream>>>(pp, g1p, gxp, gyp, cols);
+   cudaDeviceSynchronize();
+   computeG2<<<dimGrid, dimBlock,0,localStream>>>(pp, g1p, gxp, gyp, cols);
+   cudaDeviceSynchronize();
+   
+   cudaSafeCall( cudaGetLastError() );
+};
+
+GENERATE_CUDA_FUNC2DROWS(computeG1,
+                     (float* pp, float* g1p, float* gxp, float* gyp, int cols),
+                     (pp, g1p, gxp, gyp, cols)) {
+    #if __CUDA_ARCH__>300
+//TODO: make compatible with cuda 2.0 and lower (remove shuffles). Probably through texture fetch
+
+//Original pseudocode for this function:
+    // //subscripts u,d,l,r mean up,down,left,right
+    // void computeG(){
+    //     // g0 is the strongest nearby gradient (excluding point defects)
+    //     g0x=fabsf(pr-pl);//|dx|
+    //     g0y=fabsf(pd-pu);//|dy|
+    //     g0=max(g0x,g0y);
+    //     // g1 is the scaled g0 through the g function exp(-alpha*x^beta)
+    //     g1=sqrt(g0); //beta=0.5
+    //     alpha=3.5;
+    //     g1=exp(-alpha*g1);
+    //     //hard to explain this without a picture, but breaks are where both neighboring pixels are near a change
+    //     gx=max(g1r,g1);
+    //     gy=max(g1d,g1);
+    //     gu=gyu;  //upper spring is the lower spring of the pixel above
+    //     gd=gy;   //lower spring
+    //     gr=gx;   //right spring
+    //     gl=gxl;  //left spring is the right spring of the pixel to the left
+    // }
+    const float alpha=3.5f;
+    int x = threadIdx.x;
+    int y = blockIdx.y * blockDim.y + threadIdx.y;
+    int upoff=-(y!=0)*cols;
+    int dnoff=(y<gridDim.y*blockDim.y-1)*cols;
+    //itr0
+    int pt=x+y*cols;
+    float ph,pn,pu,pd,pl,pr;
+    float g0x,g0y,g0,g1,gt,gsav;
+    float tmp;
+    ph=pp[pt];
+    pn=pp[pt+blockDim.x];
+
+    pr=__shfl_down(ph,2);
+    tmp=__shfl_up(pn,30);
+    if(threadIdx.x>=30){
+        pr=tmp;
+    }
+    pl=ph;
+    pu=pp[pt+upoff];
+    pd=pp[pt+dnoff];
+
+
+    // g0 is the strongest nearby gradient (excluding point defects)
+        gt=fabsf(pr-pl);
+        g0x=__shfl_up(gt,1);//?xxxxxx no prior val
+        gsav=__shfl_down(gt,31);//x000000 for next time
+        g0x=threadIdx.x>0?g0x:0.0f;//0xxxxxx
+        g0y=fabsf(pd-pu);
+
+        g0=fmaxf(g0x,g0y);
+    // g1 is the scaled g0 through the g function
+        g1=sqrt(g0);
+        g1=exp(-alpha*g1);
+    //save
+        g1p[pt]=g1;
+
+    x+=32;
+    //itr 1:n-2
+    for(;x<cols-32;x+=32){
+        pt=x+y*cols;
+        ph=pn;
+        pn=pp[pt+blockDim.x];
+        pr=__shfl_down(ph,2);
+        tmp=__shfl_up(pn,30);
+        pr=threadIdx.x>=30?tmp:pr;
+
+        pl=ph;
+        pu=pp[pt+upoff];
+        pd=pp[pt+dnoff];
+
+        // g0 is the strongest nearby gradient (excluding point defects)
+            gt=fabsf(pr-pl);
+            g0x=__shfl_up(gt,1);//?xxxxxx
+            g0x=threadIdx.x>0?g0x:gsav;//xxxxxxx
+            gsav=__shfl_down(gt,31);//x000000 for next time
+            g0y=fabsf(pd-pu);
+
+            g0=fmaxf(g0x,g0y);
+
+        // g1 is the scaled g0 through the g function
+            g1=sqrt(g0);
+            g1=exp(-alpha*g1);
+        //save
+            g1p[pt]=g1;
+    }
+
+    //itr n-1
+    pt=x+y*cols;
+    ph=pn;
+    pr=__shfl_down(ph,2);
+    pl=ph;
+    pu=pp[pt+upoff];
+    pd=pp[pt+dnoff];
+
+    // g0 is the strongest nearby gradient (excluding point defects)
+        gt=fabsf(pr-pl);
+        g0x=__shfl_up(gt,1);//?xxxxxx
+        g0x=threadIdx.x>0?g0x:gsav;//xxxxxxx
+        g0y=fabsf(pd-pu);
+
+        g0=fmaxf(g0x,g0y);
+    // g1 is the scaled g0 through the g function
+        g1=sqrt(g0);
+        g1=exp(-alpha*g1);
+    //save
+        g1p[pt]=g1;
+#endif
+}
+GENERATE_CUDA_FUNC2DROWS(computeG2,
+                     (float* pp, float* g1p, float* gxp, float* gyp, int cols),
+                     (pp, g1p, gxp, gyp, cols)) {
+    #if __CUDA_ARCH__>300
+    int x = threadIdx.x;
+    int y = blockIdx.y * blockDim.y + threadIdx.y;
+    int dnoff=(y<gridDim.y*blockDim.y-1)*cols;
+    //itr0
+    int pt=x+y*cols;
+    float g1h,g1n,g1u,g1d,g1r,g1l,gx,gy;
+    float tmp;
+//part2, find gx,gy
+    x = threadIdx.x;
+    y = blockIdx.y * blockDim.y + threadIdx.y;
+    //itr0
+    pt=x+y*cols;
+
+    g1h=g1p[pt];
+    g1n=g1p[pt+blockDim.x];
+    g1r=__shfl_down(g1h,1);
+    tmp=__shfl_up(g1n,31);
+    if(threadIdx.x>=31){
+        g1r=tmp;
+    }
+    g1l=g1h;
+    g1u=g1h;
+    g1d=g1p[pt+dnoff];
+
+    gx=fmaxf(g1l,g1r);
+    gy=fmaxf(g1u,g1d);
+
+    //save
+        gxp[pt]=gx;
+        gyp[pt]=gy;
+    x+=32;
+    //itr 1:n-2
+    for(;x<cols-32;x+=32){
+        pt=x+y*cols;
+        g1h=g1n;
+        g1n=g1p[pt+blockDim.x];
+        g1r=__shfl_down(g1h,1);
+        tmp=__shfl_up(g1n,31);
+        g1r=threadIdx.x>=31?tmp:g1r;
+
+        g1l=g1h;
+        g1u=g1h;
+        g1d=g1p[pt+dnoff];
+
+        gx=fmaxf(g1l,g1r);
+        gy=fmaxf(g1u,g1d);
+        //save
+            gxp[pt]=gx;
+            gyp[pt]=gy;
+    }
+
+    //itr n-1
+    pt=x+y*cols;
+    g1h=g1n;
+    g1r=__shfl_down(g1h,1);
+    g1l=g1h;
+    g1u=g1h;
+    g1d=g1p[pt+dnoff];
+
+    gx=fmaxf(g1l,g1r);
+    gy=fmaxf(g1u,g1d);
+
+
+    //save
+        gxp[pt]=gx;
+        gyp[pt]=gy;
+#endif
+}
+
+
+//This version is faster, but makes synchronization errors at the lines between parts 1 and 2.
+//Could be fixed by a second pass for part 2 over the stitch lines, but I don't have time to figure that out
+//right now.
+GENERATE_CUDA_FUNC2DROWS(computeGunsafe,
+                     (float* pp, float* g1p, float* gxp, float* gyp, int cols),
+                     (pp, g1p, gxp, gyp, cols)) {
+    #if __CUDA_ARCH__>300
+//TODO: make compatible with cuda 2.0 and lower (remove shuffles). Probably through texture fetch
+//TODO: rerun kernel on lines with y%32==31 or y%32==0 to fix stitch lines
+
+//Original pseudocode for this function:
+    // //subscripts u,d,l,r mean up,down,left,right
+    // void computeG(){
+    //     // g0 is the strongest nearby gradient (excluding point defects)
+    //     g0x=fabsf(pr-pl);//|dx|
+    //     g0y=fabsf(pd-pu);//|dy|
+    //     g0=max(g0x,g0y);
+    //     // g1 is the scaled g0 through the g function exp(-alpha*x^beta)
+    //     g1=sqrt(g0); //beta=0.5
+    //     alpha=3.5;
+    //     g1=exp(-alpha*g1);
+    //     //hard to explain this without a picture, but breaks are where both neighboring pixels are near a change
+    //     gx=max(g1r,g1);
+    //     gy=max(g1d,g1);
+    //     gu=gyu;  //upper spring is the lower spring of the pixel above
+    //     gd=gy;   //lower spring
+    //     gr=gx;   //right spring
+    //     gl=gxl;  //left spring is the right spring of the pixel to the left
+    // }
+    const float alpha=3.5f;
+    int x = threadIdx.x;
+    int y = blockIdx.y * blockDim.y + threadIdx.y;
+    int upoff=-(y!=0)*cols;
+    int dnoff=(y<gridDim.y*blockDim.y-1)*cols;
+    //itr0
+    int pt=x+y*cols;
+    float ph,pn,pu,pd,pl,pr;
+    float g0x,g0y,g0,g1,g1h,g1n,g1u,g1d,g1r,g1l,gx,gy,gt,gsav;
+    float tmp;
+    ph=pp[pt];
+    pn=pp[pt+blockDim.x];
+
+    pr=__shfl_down(ph,2);
+    tmp=__shfl_up(pn,30);
+    if(threadIdx.x>=30){
+        pr=tmp;
+    }
+    pl=ph;
+    pu=pp[pt+upoff];
+    pd=pp[pt+dnoff];
+
+
+    // g0 is the strongest nearby gradient (excluding point defects)
+        gt=fabsf(pr-pl);
+        g0x=__shfl_up(gt,1);//?xxxxxx no prior val
+        gsav=__shfl_down(gt,31);//x000000 for next time
+        g0x=threadIdx.x>0?g0x:0.0f;//0xxxxxx
+        g0y=fabsf(pd-pu);
+
+        g0=fmaxf(g0x,g0y);
+    // g1 is the scaled g0 through the g function
+        g1=sqrt(g0);
+        g1=exp(-alpha*g1);
+    //save
+        g1p[pt]=g1;
+
+    x+=32;
+    //itr 1:n-2
+    for(;x<cols-32;x+=32){
+        pt=x+y*cols;
+        ph=pn;
+        pn=pp[pt+blockDim.x];
+        pr=__shfl_down(ph,2);
+        tmp=__shfl_up(pn,30);
+        pr=threadIdx.x>=30?tmp:pr;
+
+        pl=ph;
+        pu=pp[pt+upoff];
+        pd=pp[pt+dnoff];
+
+        // g0 is the strongest nearby gradient (excluding point defects)
+            gt=fabsf(pr-pl);
+            g0x=__shfl_up(gt,1);//?xxxxxx
+            g0x=threadIdx.x>0?g0x:gsav;//xxxxxxx
+            gsav=__shfl_down(gt,31);//x000000 for next time
+            g0y=fabsf(pd-pu);
+
+            g0=fmaxf(g0x,g0y);
+
+        // g1 is the scaled g0 through the g function
+            g1=sqrt(g0);
+            g1=exp(-alpha*g1);
+        //save
+            g1p[pt]=g1;
+    }
+
+    //itr n-1
+    pt=x+y*cols;
+    ph=pn;
+    pr=__shfl_down(ph,2);
+    pl=ph;
+    pu=pp[pt+upoff];
+    pd=pp[pt+dnoff];
+
+    // g0 is the strongest nearby gradient (excluding point defects)
+        gt=fabsf(pr-pl);
+        g0x=__shfl_up(gt,1);//?xxxxxx
+        g0x=threadIdx.x>0?g0x:gsav;//xxxxxxx
+        g0y=fabsf(pd-pu);
+
+        g0=fmaxf(g0x,g0y);
+    // g1 is the scaled g0 through the g function
+        g1=sqrt(g0);
+        g1=exp(-alpha*g1);
+    //save
+        g1p[pt]=g1;
+
+//part2, find gx,gy
+    x = threadIdx.x;
+    y = blockIdx.y * blockDim.y + threadIdx.y;
+    //itr0
+    pt=x+y*cols;
+
+    g1h=g1p[pt];
+    g1n=g1p[pt+blockDim.x];
+    g1r=__shfl_down(g1h,1);
+    tmp=__shfl_up(g1n,31);
+    if(threadIdx.x>=31){
+        g1r=tmp;
+    }
+    g1l=g1h;
+    g1u=g1h;
+    g1d=g1p[pt+dnoff];
+
+    gx=fmaxf(g1l,g1r);
+    gy=fmaxf(g1u,g1d);
+
+    //save
+        gxp[pt]=gx;
+        gyp[pt]=gy;
+    x+=32;
+    //itr 1:n-2
+    for(;x<cols-32;x+=32){
+        pt=x+y*cols;
+        g1h=g1n;
+        g1n=g1p[pt+blockDim.x];
+        g1r=__shfl_down(g1h,1);
+        tmp=__shfl_up(g1n,31);
+        g1r=threadIdx.x>=31?tmp:g1r;
+
+        g1l=g1h;
+        g1u=g1h;
+        g1d=g1p[pt+dnoff];
+
+        gx=fmaxf(g1l,g1r);
+        gy=fmaxf(g1u,g1d);
+        //save
+            gxp[pt]=gx;
+            gyp[pt]=gy;
+    }
+
+    //itr n-1
+    pt=x+y*cols;
+    g1h=g1n;
+    g1r=__shfl_down(g1h,1);
+    g1l=g1h;
+    g1u=g1h;
+    g1d=g1p[pt+dnoff];
+
+    gx=fmaxf(g1l,g1r);
+    gy=fmaxf(g1u,g1d);
+
+
+    //save
+        gxp[pt]=gx;
+        gyp[pt]=gy;
+#endif
+
+}
+__device__ inline float saturate(float x){
+    //return x;
+    return x/fmaxf(1.0f,fabsf(x));
+}
+// static __global__ void updateQD  (float* gqxpt, float* gqypt, float *dpt, float * apt,
+//                float *gxpt, float *gypt, float sigma_q, float sigma_d, float epsilon,
+//                float theta);//DANGER, no interblock synchronization = weird instability
+static __global__ void updateQ  (float* gqxpt, float* gqypt, float *dpt, float * apt,
+                float *gxpt, float *gypt, int cols, float sigma_q, float sigma_d, float epsilon,
+                float theta);
+static __global__ void updateD  (float* gqxpt, float* gqypt, float *dpt, float * apt,
+                float *gxpt, float *gypt, int cols, float sigma_q, float sigma_d, float epsilon,
+                float theta);
+
+void updateQDCaller(float* gqxpt, float* gqypt, float *dpt, float * apt,
+        float *gxpt, float *gypt, int cols, float sigma_q, float sigma_d, float epsilon,
+        float theta) {
+
+    dim3 dimBlock(BLOCKX2D, BLOCKY2D);
+    dim3 dimGrid(1, (arows + dimBlock.y - 1) / dimBlock.y);
+    CV_Assert(dimGrid.y>0);
+    cudaSafeCall( cudaGetLastError() );
+    updateQ<<<dimGrid, dimBlock,0,localStream>>>( gqxpt, gqypt, dpt, apt,
+            gxpt, gypt, cols, sigma_q, sigma_d, epsilon, theta);
+    cudaSafeCall( cudaGetLastError() );
+    updateD<<<dimGrid, dimBlock,0,localStream>>>( gqxpt, gqypt, dpt, apt,
+            gxpt, gypt, cols, sigma_q, sigma_d, epsilon, theta);
+    cudaSafeCall( cudaGetLastError() );
+};
+
+// static __global__ void updateQD  (float* gqxpt, float* gqypt, float *dpt, float * apt,
+//                 float *gxpt, float *gypt, float sigma_q, float sigma_d, float epsilon,
+//                 float theta) {
+//     //TODO: make compatible with cuda 2.0 and lower (remove shuffles). Probably through texture fetch
+// 
+//     //Original pseudocode for this function:
+// //void updateQD(){
+// //    //shifts are shuffles!
+// //    for (all x in blocks of warpsize;;){
+// //        //qx update
+// //        float dh,dn,qxh,gx,gqx,qyh,gy,gqy;
+// //        //load(dh,dn,gxh,gqx);//load here, next(the block to the right), local constant, old x force(with cached multiply)
+// //        dr=dh<<1;
+// //        tmp=dn>>31;
+// //        if (rt)
+// //            dr=tmp;
+// //        qxh=gqx/gxh;
+// //        qxh = (qxh+sigma_q*gxh*(dr-dh))/(1+sigma_q*epsilon);//basic spring force equation f=k(x-x0)
+// //        gqx = saturate(gxh*qxh);//spring saturates (with cached multiply), saturation force proportional to prob. of not an edge.
+// //        gqxpt[pt]=gqx;
+// //
+// //        //qy update
+// //        s[bpt]=dn;
+// //        if(!btm){
+// //            dd=s[bpt+bdnoff];
+// //        }else{
+// //            dd=dpt[pt+dnoff];
+// //        }
+// //        qyh=gqy/gy;
+// //        qyh=(qyh+sigma_q*gyh*(dd-dh))/(1+sigma_q*epsilon);
+// //        gqy=saturate(gyh*qyh);
+// //        gqypt[pt]=gqy;
+// //
+// //        //dx update
+// //        gqr=gqx;
+// //        gql=gqx>>1;
+// //        if (lf)
+// //            gql=gqsave;
+// //        gqsave=gqx<<31;//save for next iter
+// //        dacc = gqr - gql;//dx part
+// //
+// //        //dy update and d store
+// //        gqd=gqy;
+// //        s[bpt]=gqy;
+// //        if(!top)
+// //            gqu=s[bpt+bupoff];
+// //        else
+// //            gqu=gqxpt[pt + upoff];
+// //        dacc += gqd-gqu; //dy part
+// //        d = (d + sigma_d*(dacc+1/theta*ah))/(1+sigma_d/theta);
+// //        dpt[pt]=d;
+// //    }
+// //}
+//     __shared__ float s[32*BLOCKY2D];
+//     int x = threadIdx.x;
+//     int y = blockIdx.y * blockDim.y + threadIdx.y;
+//     bool rt=x==31;
+//     bool lf=x==0;
+//     bool top=y==0;
+//     bool btm=y==rows-1;
+//     bool btop=threadIdx.y==0;
+//     bool bbtm=threadIdx.y==blockDim.y-1;
+//     int pt, bpt,bdnoff ,dnoff, bupoff, upoff;
+// 
+// 
+//     float tmp,gqsave;
+//     gqsave=0;
+//     bpt = threadIdx.x+threadIdx.y*blockDim.x;
+//     bdnoff=blockDim.x;
+//     dnoff=(!btm)*cols;
+//     bupoff=-blockDim.x;
+//     upoff=-(!top)*cols;
+// 
+//     pt=x+y*cols;
+// 
+//     float dh,dn;
+//     dn=dpt[pt];
+// 
+//     for(;x<cols;x+=32){
+//         float qx,gx,gqx,qy,gy,gqy;
+//         pt=x+y*cols;
+// 
+// 
+//         //qx update
+//         {
+//             float dr;
+//             //load(dh,dn,gxh,gqx);//load here, next(the block to the right), local constant, old x force(with cached multiply)
+// 
+//             //load
+//             {
+//                 dh=dn;
+//                 if(x<cols-32){
+//                     dn=dpt[pt+32];
+// 
+//                 }
+//                 gqx=gqxpt[pt];
+//                 gx=gxpt[pt];
+// //                gx=1.0f;
+// 
+//             }
+// 
+//             dr=__shfl_down(dh,1);
+//             tmp=__shfl_up(dn,31);
+//             if (rt && x<cols-32)
+//                 dr=tmp;
+//             qx = gqx/gx;
+//             qx = (qx+sigma_q*gx*(dr-dh))/(1+sigma_q*epsilon);//basic spring force equation f=k(x-x0)
+//             gqx = saturate(gx*qx);//spring saturates (with cached multiply), saturation force proportional to prob. of not an edge.
+//             //gqxpt[pt]=gqx;
+//         }
+//         dpt[pt] = dh;
+//         //qy update
+//         {
+//             float dd;
+//             //load
+//                     {
+//                         gqy=gqypt[pt];
+//                         gy=gypt[pt];
+// //                        gy=1.0f;
+//                     }
+//             s[bpt]=dh;
+//             __syncthreads();
+//             if(!bbtm){
+//                 dd=s[bpt+bdnoff];
+//             }else{
+//                 dd=dpt[pt+dnoff];
+//             }
+//             qy = gqy/gy;
+//             qy = (qy+sigma_q*gy*(dd-dh))/(1+sigma_q*epsilon);
+//             gqy = saturate(gy*qy);
+//             //gqypt[pt]=gqy;
+//         }
+//         float dacc;
+//         //dx update
+//         {
+//             float gqr,gql;
+//             gqr=gqx;
+//             gql=__shfl_up(gqx,1);
+//             if (lf)
+//                 gql=gqsave;
+//             gqsave=__shfl_down(gqx,31);//save for next iter
+//             dacc = gqr - gql;//dx part
+//         }
+//         float d=dh;
+//         //dy update and d store
+//         {
+//             float a;
+//             //load
+//             {
+//                 a=apt[pt];
+//             }
+//             float gqu,gqd;
+// 
+//             gqd=gqy;
+//             s[bpt]=gqy;
+//             __syncthreads();
+//             if(!btop)
+//                 gqu=s[bpt+bupoff];
+//             else
+//                 gqu=gqypt[pt + upoff];
+//             if(y==0)
+//                 gqu=0.0f;
+//             dacc += gqd-gqu; //dy part
+//             d = ( d + sigma_d*(dacc + a/theta) ) / (1 + sigma_d/theta);
+//             //dpt[pt] = d;
+//         }
+//         __syncthreads();
+//         gqxpt[pt]=gqx;
+//         gqypt[pt]=gqy;
+//         dpt[pt] = d;
+//         __syncthreads();
+//     }
+// }
+
+
+GENERATE_CUDA_FUNC2DROWS(updateQ,
+                (float* gqxpt, float* gqypt, float *dpt, float * apt,
+                float *gxpt, float *gypt, int cols, float sigma_q, float sigma_d, float epsilon,
+                float theta),
+                ( gqxpt, gqypt, dpt, apt,
+                        gxpt, gypt, cols, sigma_q, sigma_d, epsilon, theta)) {
+    //TODO: make compatible with cuda 2.0 and lower (remove shuffles). Probably through texture fetch
+
+    //Original pseudocode for this function:
+//void updateQD(){
+//    //shifts are shuffles!
+//    for (all x in blocks of warpsize;;){
+//        //qx update
+//        float dh,dn,qxh,gx,gqx,qyh,gy,gqy;
+//        //load(dh,dn,gxh,gqx);//load here, next(the block to the right), local constant, old x force(with cached multiply)
+//        dr=dh<<1;
+//        tmp=dn>>31;
+//        if (rt)
+//            dr=tmp;
+//        qxh=gqx/gxh;
+//        qxh = (qxh+sigma_q*gxh*(dr-dh))/(1+sigma_q*epsilon);//basic spring force equation f=k(x-x0)
+//        gqx = saturate(gxh*qxh);//spring saturates (with cached multiply), saturation force proportional to prob. of not an edge.
+//        gqxpt[pt]=gqx;
+//
+//        //qy update
+//        s[bpt]=dn;
+//        if(!btm){
+//            dd=s[bpt+bdnoff];
+//        }else{
+//            dd=dpt[pt+dnoff];
+//        }
+//        qyh=gqy/gy;
+//        qyh=(qyh+sigma_q*gyh*(dd-dh))/(1+sigma_q*epsilon);
+//        gqy=saturate(gyh*qyh);
+//        gqypt[pt]=gqy;
+//
+//        //dx update
+//        gqr=gqx;
+//        gql=gqx>>1;
+//        if (lf)
+//            gql=gqsave;
+//        gqsave=gqx<<31;//save for next iter
+//        dacc = gqr - gql;//dx part
+//
+//        //dy update and d store
+//        gqd=gqy;
+//        s[bpt]=gqy;
+//        if(!top)
+//            gqu=s[bpt+bupoff];
+//        else
+//            gqu=gqxpt[pt + upoff];
+//        dacc += gqd-gqu; //dy part
+//        d = (d + sigma_d*(dacc+1/theta*ah))/(1+sigma_d/theta);
+//        dpt[pt]=d;
+//    }
+//}
+#if __CUDA_ARCH__>300
+    __shared__ float s[32*BLOCKY2D];
+    int x = threadIdx.x;
+    int y = blockIdx.y * blockDim.y + threadIdx.y;
+    bool rt=x==31;
+
+    bool bbtm=threadIdx.y==blockDim.y-1;
+    int pt, bpt,bdnoff ,dnoff;
+    
+    float tmp;
+    bpt = threadIdx.x+threadIdx.y*blockDim.x;
+    bdnoff=blockDim.x;
+    dnoff=(y<gridDim.y*blockDim.y-1)*cols;
+
+    pt=x+y*cols;
+
+    float dh,dn;
+    dn=dpt[pt];
+
+
+    for(;x<cols;x+=32){
+        float qx,gx,gqx,qy,gy,gqy;
+        pt=x+y*cols;
+
+
+        //qx update
+        {
+            float dr;
+            //load(dh,dn,gxh,gqx);//load here, next(the block to the right), local constant, old x force(with cached multiply)
+
+            //load
+            {
+                dh=dn;
+                if(x<cols-32){
+                    dn=dpt[pt+32];
+
+                }
+                gqx=gqxpt[pt];
+                gx=gxpt[pt]+.01f;
+//                gx=1.0f;
+            }
+
+            dr=__shfl_down(dh,1);
+            tmp=__shfl_up(dn,31);
+            if (rt && x<cols-32)
+                dr=tmp;
+            qx = gqx/gx;
+            //qx+=(gx*(dr-dh)-epsilon*qx)*.5f;//simplified step
+            qx = (qx+sigma_q*gx*(dr-dh))/(1+sigma_q*epsilon);//basic spring force equation f=k(x-x0)
+            gqx = saturate(gx*qx);//spring saturates (with cached multiply), saturation force proportional to prob. of not an edge.
+            gqxpt[pt]=gqx;
+        }
+
+        //qy update
+        {
+            float dd;
+            //load
+                    {
+                        gqy=gqypt[pt];
+                        gy=gypt[pt]+.01f;
+//                        gy=1.0f;
+                    }
+            s[bpt]=dh;
+            __syncthreads();
+            if(!bbtm)
+                dd=s[bpt+bdnoff];
+            else
+                dd=dpt[pt+dnoff];
+            __syncthreads();
+            qy = gqy/gy;
+            //qy+=(gy*(dd-dh)-epsilon*qy)*.5f;//simplified step
+            qy = (qy+sigma_q*gy*(dd-dh))/(1+sigma_q*epsilon);
+            gqy = saturate(gy*qy);
+
+            gqypt[pt]=gqy;
+        }
+        //__syncthreads();
+    }
+#endif
+}
+
+GENERATE_CUDA_FUNC2DROWS(updateD,
+                (float* gqxpt, float* gqypt, float *dpt, float * apt,
+                float *gxpt, float *gypt,int cols, float sigma_q, float sigma_d, float epsilon,
+                float theta),
+                ( gqxpt, gqypt, dpt, apt,
+                        gxpt, gypt, cols, sigma_q, sigma_d, epsilon, theta)) {
+    #if __CUDA_ARCH__>300
+    //TODO: make compatible with cuda 2.0 and lower (remove shuffles). Probably through texture fetch
+
+    //Original pseudocode for this function:
+//void updateQD(){
+//    //shifts are shuffles!
+//    for (all x in blocks of warpsize){
+//        //qx update
+//        float dh,dn,qxh,gx,gqx,qyh,gy,gqy;
+//        //load(dh,dn,gxh,gqx);//load here, next(the block to the right), local constant, old x force(with cached multiply)
+//        dr=dh<<1;
+//        tmp=dn>>31;
+//        if (rt)
+//            dr=tmp;
+//        qxh=gqx/gxh;
+//        qxh = (qxh+sigma_q*gxh*(dr-dh))/(1+sigma_q*epsilon);//basic spring force equation f=k(x-x0)
+//        gqx = saturate(gxh*qxh);//spring saturates (with cached multiply), saturation force proportional to prob. of not an edge.
+//        gqxpt[pt]=gqx;
+//
+//        //qy update
+//        s[bpt]=dn;
+//        if(!btm){
+//            dd=s[bpt+bdnoff];
+//        }else{
+//            dd=dpt[pt+dnoff];
+//        }
+//        qyh=gqy/gy;
+//        qyh=(qyh+sigma_q*gyh*(dd-dh))/(1+sigma_q*epsilon);
+//        gqy=saturate(gyh*qyh);
+//        gqypt[pt]=gqy;
+//
+//        //dx update
+//        gqr=gqx;
+//        gql=gqx>>1;
+//        if (lf)
+//            gql=gqsave;
+//        gqsave=gqx<<31;//save for next iter
+//        dacc = gqr - gql;//dx part
+//
+//        //dy update and d store
+//        gqd=gqy;
+//        s[bpt]=gqy;
+//        if(!top)
+//            gqu=s[bpt+bupoff];
+//        else
+//            gqu=gqxpt[pt + upoff];
+//        dacc += gqd-gqu; //dy part
+//        d = (d + sigma_d*(dacc+1/theta*ah))/(1+sigma_d/theta);
+//        dpt[pt]=d;
+//    }
+//}
+    __shared__ float s[32*BLOCKY2D];
+    int x = threadIdx.x;
+    int y = blockIdx.y * blockDim.y + threadIdx.y;
+    bool lf=x==0;
+    bool top=y==0;
+    bool btop=threadIdx.y==0;
+    int pt, bpt, bupoff, upoff;
+
+
+    float gqsave=0;
+    bpt = threadIdx.x+threadIdx.y*blockDim.x;
+
+    bupoff=-blockDim.x;
+    upoff=-(!top)*cols;
+
+    pt=x+y*cols;
+
+    for(;x<cols;x+=32){
+        float gqx,gqy;
+        pt=x+y*cols;
+
+
+        float dacc;
+        //dx update
+        {
+            float gqr,gql;
+            gqr=gqx=gqxpt[pt];
+            gql=__shfl_up(gqx,1);
+            if (lf)
+                gql=gqsave;
+            gqsave=__shfl_down(gqx,31);//save for next iter
+            dacc = gqr - gql;//dx part
+        }
+        //dy update and d store
+        {
+            float a;
+            //load
+            {
+                a=apt[pt];
+            }
+            float gqu,gqd;
+            float d=dpt[pt];
+            gqd=gqy=gqypt[pt];
+            s[bpt]=gqy;
+            __syncthreads();
+            if(!btop)
+                gqu=s[bpt+bupoff];
+            else
+                gqu=gqypt[pt + upoff];
+            if(y==0)
+                gqu=0.0f;
+            dacc += gqd-gqu; //dy part
+            //d += dacc*.5f;//simplified step
+            d = ( d + sigma_d*(dacc + a/theta) ) / (1 + sigma_d/theta);
+
+            dpt[pt] = d;
+        }
+        __syncthreads();//can't figure out why this is needed, but it is to avoid subtle errors in Qy at the ends of the warp
+    }
+#endif
+}
+
+
+}}}}

cuda_code/DepthwiseGEMM_64.cu

@@ -0,0 +1,38 @@
+/********************************************************
+*	Author: Zhao Mingxin
+*	Date:	2018/12/11
+*	Description: CUDA Kernel for DepthwiseGEMM. As GPU is good at
+*	dealing with 32 bits computation and gets performance degradation
+*	when bit-width is longer than 32, so the current DepthwiseGEMM 
+*	version can't give right outputs when fixed point is more than 32 bits.
+*
+*	NOTE:	If you have any issues about this code, please
+*	feedback.
+*	Homepage:	https://jackgittes.github.io
+*********************************************************/
+__global__ void DepthwiseGEMM_64(const long long *A,const long long *B,
+        const int Aheight,const int Awidth,const int Bwidth, 
+                const long long up_bound,const long long low_bound,long long *C)
+{
+	long long Cvalue = 0;
+	long long prod_tmp;
+	int Bheight = Awidth;
+	
+	int chn = blockIdx.z;
+	int row = blockIdx.x * blockDim.x + threadIdx.x;
+	int col = blockIdx.y * blockDim.y + threadIdx.y;
+	
+	for (int e = 0; e < Awidth; ++e){
+		prod_tmp = A[chn * Aheight * Awidth + Aheight * e + row]*B[chn*Bheight*Bwidth + col * Bheight+ e];
+		if(prod_tmp>up_bound)
+			prod_tmp = up_bound;
+		if(prod_tmp<low_bound)
+			prod_tmp = low_bound;
+		Cvalue += prod_tmp;
+		if(Cvalue>up_bound)
+			Cvalue=up_bound;
+		if(Cvalue<low_bound)
+			Cvalue=low_bound;
+	}	
+	C[chn*Aheight*Bwidth + Aheight*col + row] = Cvalue;
+}

cuda_code/DeviceMemory_2.cu

@@ -0,0 +1,650 @@
+#include <cassert>
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <cuda.h>
+#include <cuda_runtime_api.h>
+#include "cudacommon.h"
+#include "OptionParser.h"
+#include "ResultDatabase.h"
+#include "Timer.h"
+#include "support.h"
+
+// Forward declarations for texture memory test and benchmark kernels
+void TestTextureMem(ResultDatabase &resultDB, OptionParser &op, double scalet);
+__global__ void
+readGlobalMemoryCoalesced(float *data, float *output, int size, int repeat);
+__global__ void readGlobalMemoryUnit(float *data, float *output, int size, int repeat);
+__global__ void readLocalMemory(const float *data, float *output, int size, int repeat);
+__global__ void writeGlobalMemoryCoalesced(float *output, int size, int repeat);
+__global__ void writeGlobalMemoryUnit(float *output, int size, int repeat);
+__global__ void writeLocalMemory(float *output, int size, int repeat);
+__device__ int getRand(int seed, int mod);
+__global__ void readTexels(int n, float *d_out, int width);
+__global__ void readTexelsInCache(int n, float *d_out);
+__global__ void readTexelsRandom(int n, float *d_out, int width, int height);
+// Texture to use for the benchmarks
+texture<float4, 2, cudaReadModeElementType> texA;
+
+// ****************************************************************************
+// Function: addBenchmarkSpecOptions
+//
+// Purpose:
+//   Add benchmark specific options parsing.  Note that device memory has no
+//   benchmark specific options, so this is just a stub.
+//
+// Arguments:
+//   op: the options parser / parameter database
+//
+// Returns:  nothing
+//
+// Programmer: Kyle Spafford
+// Creation: December 11, 2009
+//
+// Modifications:
+//
+// ****************************************************************************
+void addBenchmarkSpecOptions(OptionParser &op)
+{
+    ;
+}
+
+// ****************************************************************************
+// Function: runBenchmark
+//
+// Purpose:
+//   This benchmark measures the device memory bandwidth for several areas
+//   of memory including global, shared, and texture memories for several
+//   types of access patterns.
+//
+// Arguments:
+//  resultDB: the benchmark stores its results in this ResultDatabase
+//  op: the options parser / parameter database
+//
+// Returns:  nothing
+//
+// Programmer: Kyle Spafford
+// Creation: September 08, 2009
+//
+// Modifications:
+//   Gabriel Marin, 06/09/2010: Change memory access patterns to eliminate 
+//   data reuse. Add auto-scaling factor.
+//
+// ****************************************************************************
+void RunBenchmark(ResultDatabase &resultDB,
+                  OptionParser &op)
+{
+    int npasses = op.getOptionInt("passes");
+    size_t minGroupSize = 32;
+    size_t maxGroupSize = 512;
+    size_t globalWorkSize = 32768;  // 64 * maxGroupSize = 64 * 512;
+    unsigned int memSize       = 64*1024*1024;  // 64MB buffer
+    const long availMem = findAvailBytes();
+    while (memSize*2 > availMem)
+       memSize >>= 1;   // keep it a power of 2
+    
+    const unsigned int numWordsFloat = memSize / sizeof(float);
+
+    // Initialize host memory
+    float *h_in  = new float[numWordsFloat];
+    float *h_out = new float[numWordsFloat];
+    srand48(8650341L);
+    for (int i = 0; i < numWordsFloat; ++i)
+    {
+        h_in[i] = (float)(drand48()*numWordsFloat);
+    }
+
+    // Allocate some device memory
+    float *d_mem1, *d_mem2;
+    char sizeStr[128];
+
+    cudaMalloc((void**)&d_mem1, sizeof(float)*(numWordsFloat));
+    CHECK_CUDA_ERROR();
+    cudaMalloc((void**)&d_mem2, sizeof(float)*(numWordsFloat));
+    CHECK_CUDA_ERROR();
+
+    cudaEvent_t start, stop;
+    cudaEventCreate(&start);
+    cudaEventCreate(&stop);
+    CHECK_CUDA_ERROR();
+
+    cudaEventRecord(start, 0);
+    readGlobalMemoryCoalesced<<<512, 64>>>
+                  (d_mem1, d_mem2, numWordsFloat, 256);
+    cudaEventRecord(stop, 0);
+    cudaEventSynchronize(stop);
+    CHECK_CUDA_ERROR();
+    float t = 0.0f;
+    cudaEventElapsedTime(&t, start, stop);
+    t /= 1.e3;
+    double scalet = 0.15 / t;
+    
+    const unsigned int maxRepeatsCoal  = 256*scalet;
+    const unsigned int maxRepeatsUnit  = 16*scalet;
+    const unsigned int maxRepeatsLocal = 300*scalet;
+
+    for (int p = 0; p < npasses; p++)
+    {
+        // Run the kernel for each group size
+        cout << "Running benchmarks, pass: " << p << "\n";
+        for (int threads=minGroupSize; threads<=maxGroupSize ; threads*=2)
+        {
+            const unsigned int blocks = globalWorkSize / threads;
+            double bdwth;
+            sprintf (sizeStr, "blockSize:%03d", threads);
+
+            // Test 1
+            cudaEventRecord(start, 0);
+            readGlobalMemoryCoalesced<<<blocks, threads>>>
+                    (d_mem1, d_mem2, numWordsFloat, maxRepeatsCoal);
+            cudaEventRecord(stop, 0);
+            cudaEventSynchronize(stop);
+            CHECK_CUDA_ERROR();
+            t = 0.0f;
+            cudaEventElapsedTime(&t, start, stop);
+            t /= 1.e3;
+            bdwth = ((double) globalWorkSize * maxRepeatsCoal * 16 * sizeof(float)) 
+                   / (t * 1000. * 1000. * 1000.);
+            resultDB.AddResult("readGlobalMemoryCoalesced", sizeStr, "GB/s",
+                    bdwth);
+
+            // Test 2
+            cudaEventRecord(start, 0);
+            readGlobalMemoryUnit<<<blocks, threads>>>
+                    (d_mem1, d_mem2, numWordsFloat, maxRepeatsUnit);
+            cudaEventRecord(stop, 0);
+            cudaEventSynchronize(stop);
+            CHECK_CUDA_ERROR();
+            cudaEventElapsedTime(&t, start, stop);
+            t /= 1.e3;
+            bdwth = ((double) globalWorkSize * maxRepeatsUnit * 16 * sizeof(float)) 
+                   / (t * 1000. * 1000. * 1000.);
+            resultDB.AddResult("readGlobalMemoryUnit", sizeStr, "GB/s", bdwth);
+
+            // Test 3
+            cudaEventRecord(start, 0);
+            readLocalMemory<<<blocks, threads>>>
+                    (d_mem1, d_mem2, numWordsFloat, maxRepeatsLocal);
+            cudaEventRecord(stop, 0);
+            cudaEventSynchronize(stop);
+            CHECK_CUDA_ERROR();
+            cudaEventElapsedTime(&t, start, stop);
+            t /= 1.e3;
+            bdwth = ((double) globalWorkSize * maxRepeatsLocal * 16 * sizeof(float)) 
+                   / (t * 1000. * 1000. * 1000.);
+            resultDB.AddResult("readLocalMemory", sizeStr, "GB/s", bdwth);
+
+            // Test 4
+            cudaEventRecord(start, 0);
+            writeGlobalMemoryCoalesced<<<blocks, threads>>>
+                    (d_mem2, numWordsFloat, maxRepeatsCoal);
+            cudaEventRecord(stop, 0);
+            cudaEventSynchronize(stop);
+            CHECK_CUDA_ERROR();
+            cudaEventElapsedTime(&t, start, stop);
+            t /= 1.e3;
+            bdwth = ((double) globalWorkSize * maxRepeatsCoal * 16 * sizeof(float)) 
+                   / (t * 1000. * 1000. * 1000.);
+            resultDB.AddResult("writeGlobalMemoryCoalesced", sizeStr, "GB/s",
+                    bdwth);
+
+            // Test 5
+            cudaEventRecord(start, 0);
+            writeGlobalMemoryUnit<<<blocks, threads>>>
+                       (d_mem2, numWordsFloat, maxRepeatsUnit);
+            cudaEventRecord(stop, 0);
+            cudaEventSynchronize(stop);
+            CHECK_CUDA_ERROR();
+            cudaEventElapsedTime(&t, start, stop);
+            t /= 1.e3;
+            bdwth = ((double) globalWorkSize * maxRepeatsUnit * 16 * sizeof(float)) 
+                    / (t * 1000. * 1000. * 1000.);
+            resultDB.AddResult("writeGlobalMemoryUnit", sizeStr, "GB/s",
+                    bdwth);
+
+            // Test 6
+            cudaEventRecord(start, 0);
+            writeLocalMemory<<<blocks, threads>>>
+                       (d_mem2, numWordsFloat, maxRepeatsLocal);
+            cudaEventRecord(stop, 0);
+            cudaEventSynchronize(stop);
+            CHECK_CUDA_ERROR();
+            cudaEventElapsedTime(&t, start, stop);
+            t /= 1.e3;
+            bdwth = ((double) globalWorkSize * maxRepeatsLocal * 16 * sizeof(float)) 
+                   / (t * 1000. * 1000. * 1000.);
+            resultDB.AddResult("writeLocalMemory", sizeStr, "GB/s", bdwth);
+        }
+    }
+    cudaFree(d_mem1);
+    cudaFree(d_mem2);
+    delete[] h_in;
+    delete[] h_out;
+    cudaEventDestroy(start);
+    cudaEventDestroy(stop);
+    TestTextureMem(resultDB, op, scalet);
+}
+
+// ****************************************************************************
+// Function: TestTextureMem
+//
+// Purpose:
+//   Measures the bandwidth of texture memory for several access patterns
+//   using a 2D texture including sequential, "random", and repeated access to
+//   texture cache.  Texture memory is often a viable alternative to global
+//   memory, especially when data access patterns prevent good coalescing.
+//
+// Arguments:
+//   resultDB: results from the benchmark are stored to this resultd database
+//   op: the options parser / parameter database
+//   scalet: auto-scaling factor for the number of repetitions
+//
+// Returns:  nothing
+//
+// Programmer: Kyle Spafford
+// Creation: December 11, 2009
+//
+// Modifications:
+//   Gabriel Marin 06/09/2010: add auto-scaling factor
+//
+//   Jeremy Meredith, Tue Nov 23 13:45:54 EST 2010
+//   Change data sizes to be larger, and textures to be 2D to match OpenCL
+//   variant.  Dropped #iterations to compensate.  Had to remove validation
+//   for now, which also matches the current OpenCL variant's behavior.
+//
+// ****************************************************************************
+void TestTextureMem(ResultDatabase &resultDB, OptionParser &op, double scalet)
+{
+    // Number of times to repeat each test
+    const unsigned int passes = op.getOptionInt("passes");
+    // Sizes of textures tested (in kb)
+    const unsigned int nsizes = 5;
+    const unsigned int sizes[] = { 16, 64, 256, 1024, 4096 };
+    // Number of texel accesses by each kernel
+    const unsigned int kernelRepFactor = 1024;
+    // Number of times to repeat each kernel per test
+    const unsigned int iterations = 1*scalet;
+
+    cudaEvent_t start, stop;
+    cudaEventCreate(&start);
+    cudaEventCreate(&stop);
+    CHECK_CUDA_ERROR();
+
+    // make sure our texture behaves like we want....
+    texA.normalized = false;
+    texA.addressMode[0] = cudaAddressModeClamp;
+    texA.addressMode[1] = cudaAddressModeClamp;
+    texA.filterMode = cudaFilterModePoint;
+
+    for (int j = 0; j < nsizes; j++)
+    {
+        cout << "Benchmarking Texture Memory, Test: " << j+1 << " / 5\n";
+        const unsigned int size      = 1024 * sizes[j];
+        const unsigned int numFloat  = size / sizeof(float);
+        const unsigned int numFloat4 = size / sizeof(float4);
+        size_t width, height;
+
+        // Image memory sizes should be power of 2.
+        size_t sizeLog = lround(log2(double(numFloat4)));
+        height = 1 << (sizeLog >> 1);  // height is the smaller size
+        width = numFloat4 / height;
+
+        const dim3 blockSize(16, 8);
+        const dim3 gridSize(width/blockSize.x, height/blockSize.y);
+
+        float *h_in = new float[numFloat];
+        float *h_out = new float[numFloat4];
+        float *d_out;
+        cudaMalloc((void**) &d_out, numFloat4 * sizeof(float));
+        CHECK_CUDA_ERROR();
+
+        // Fill input data with some pattern
+        for (unsigned int i = 0; i < numFloat; i++)
+        {
+            h_in[i] = (float) i;
+            if (i < numFloat4)
+            {
+                h_out[i] = 0.0f;
+            }
+        }
+
+        // Allocate a cuda array
+        cudaArray* cuArray;
+        cudaMallocArray(&cuArray, &texA.channelDesc, width, height);
+        CHECK_CUDA_ERROR();
+
+        // Copy in source data
+        cudaMemcpyToArray(cuArray, 0, 0, h_in, size, cudaMemcpyHostToDevice);
+        CHECK_CUDA_ERROR();
+
+        // Bind texture to the array
+        cudaBindTextureToArray(texA, cuArray);
+        CHECK_CUDA_ERROR();
+
+        for (int p = 0; p < passes; p++)
+        {
+            // Test 1: Repeated Linear Access
+            float t = 0.0f;
+
+            cudaEventRecord(start, 0);
+            // read texels from texture
+            for (int iter = 0; iter < iterations; iter++)
+            {
+                readTexels<<<gridSize, blockSize>>>(kernelRepFactor, d_out,
+                                                    width);
+            }
+            cudaEventRecord(stop, 0);
+            CHECK_CUDA_ERROR();
+            cudaEventSynchronize(stop);
+            CHECK_CUDA_ERROR();
+            cudaEventElapsedTime(&t, start, stop);
+            t /= 1.e3;
+
+            // Calculate speed in GB/s
+            double speed = (double)kernelRepFactor * (double)iterations *
+                    (double)(size/(1000.*1000.*1000.)) / (t);
+
+            char sizeStr[256];
+            sprintf(sizeStr, "% 6dkB", size / 1024);
+            resultDB.AddResult("TextureRepeatedLinearAccess", sizeStr, "GB/sec",
+                    speed);
+
+            // Verify results
+            cudaMemcpy(h_out, d_out, numFloat4*sizeof(float),
+                    cudaMemcpyDeviceToHost);
+
+            // Test 2 Repeated Cache Access
+            cudaEventRecord(start, 0);
+            for (int iter = 0; iter < iterations; iter++)
+            {
+                readTexelsInCache<<<gridSize, blockSize>>>
+                        (kernelRepFactor, d_out);
+            }
+            cudaEventRecord(stop, 0);
+            cudaEventSynchronize(stop);
+            CHECK_CUDA_ERROR();
+            cudaEventElapsedTime(&t, start, stop);
+            t /= 1.e3;
+
+            // Calculate speed in GB/s
+            speed = (double)kernelRepFactor * (double)iterations *
+                    ((double)size/(1000.*1000.*1000.)) / (t);
+
+            sprintf(sizeStr, "% 6dkB", size / 1024);
+            resultDB.AddResult("TextureRepeatedCacheHit", sizeStr, "GB/sec",
+                    speed);
+
+            // Verify results
+            cudaMemcpy(h_out, d_out, numFloat4*sizeof(float),
+                    cudaMemcpyDeviceToHost);
+
+            // Test 3 Repeated "Random" Access
+            cudaEventRecord(start, 0);
+
+            // read texels from texture
+            for (int iter = 0; iter < iterations; iter++)
+            {
+                readTexelsRandom<<<gridSize, blockSize>>>
+                                (kernelRepFactor, d_out, width, height);
+            }
+
+            cudaEventRecord(stop, 0);
+            cudaEventSynchronize(stop);
+            CHECK_CUDA_ERROR();
+            cudaEventElapsedTime(&t, start, stop);
+            t /= 1.e3;
+
+            // Calculate speed in GB/s
+            speed = (double)kernelRepFactor * (double)iterations *
+                    ((double)size/(1000.*1000.*1000.)) / (t);
+
+            sprintf(sizeStr, "% 6dkB", size / 1024);
+            resultDB.AddResult("TextureRepeatedRandomAccess", sizeStr,
+                    "GB/sec", speed);
+        }
+        delete[] h_in;
+        delete[] h_out;
+        cudaFree(d_out);
+        cudaFreeArray(cuArray);
+        cudaUnbindTexture(texA);
+    }
+    cudaEventDestroy(start);
+    cudaEventDestroy(stop);
+}
+
+// Begin benchmark kernels
+__global__ void
+readGlobalMemoryCoalesced(float *data, float *output, int size, int repeat)
+{
+    int gid = threadIdx.x + (blockDim.x * blockIdx.x), j = 0;
+    float sum = 0;
+    int s = gid;
+    for (j=0 ; j<repeat ; ++j)
+    {
+       float a0 = data[(s+0)&(size-1)];
+       float a1 = data[(s+32768)&(size-1)];
+       float a2 = data[(s+65536)&(size-1)];
+       float a3 = data[(s+98304)&(size-1)];
+       float a4 = data[(s+131072)&(size-1)];
+       float a5 = data[(s+163840)&(size-1)];
+       float a6 = data[(s+196608)&(size-1)];
+       float a7 = data[(s+229376)&(size-1)];
+       float a8 = data[(s+262144)&(size-1)];
+       float a9 = data[(s+294912)&(size-1)];
+       float a10 = data[(s+327680)&(size-1)];
+       float a11 = data[(s+360448)&(size-1)];
+       float a12 = data[(s+393216)&(size-1)];
+       float a13 = data[(s+425984)&(size-1)];
+       float a14 = data[(s+458752)&(size-1)];
+       float a15 = data[(s+491520)&(size-1)];
+       sum += a0+a1+a2+a3+a4+a5+a6+a7+a8+a9+a10+a11+a12+a13+a14+a15;
+       s = (s+524288)&(size-1);
+    }
+    output[gid] = sum;
+}
+
+__global__ void
+readGlobalMemoryUnit(float *data, float *output, int size, int repeat)
+{
+    int gid = threadIdx.x + (blockDim.x * blockIdx.x), j = 0;
+    float sum = 0;
+    int s = gid*512;
+    for (j=0 ; j<repeat ; ++j)
+    {
+       float a0 = data[(s+0)&(size-1)];
+       float a1 = data[(s+1)&(size-1)];
+       float a2 = data[(s+2)&(size-1)];
+       float a3 = data[(s+3)&(size-1)];
+       float a4 = data[(s+4)&(size-1)];
+       float a5 = data[(s+5)&(size-1)];
+       float a6 = data[(s+6)&(size-1)];
+       float a7 = data[(s+7)&(size-1)];
+       float a8 = data[(s+8)&(size-1)];
+       float a9 = data[(s+9)&(size-1)];
+       float a10 = data[(s+10)&(size-1)];
+       float a11 = data[(s+11)&(size-1)];
+       float a12 = data[(s+12)&(size-1)];
+       float a13 = data[(s+13)&(size-1)];
+       float a14 = data[(s+14)&(size-1)];
+       float a15 = data[(s+15)&(size-1)];
+       sum += a0+a1+a2+a3+a4+a5+a6+a7+a8+a9+a10+a11+a12+a13+a14+a15;
+       s = (s+16)&(size-1);
+    }
+    output[gid] = sum;
+}
+
+__global__ void
+readLocalMemory(const float *data, float *output, int size, int repeat)
+{
+    int gid = threadIdx.x + (blockDim.x * blockIdx.x), j = 0;
+    float sum = 0;
+    int tid=threadIdx.x, localSize=blockDim.x, grpid=blockIdx.x,
+            litems=2048/localSize, goffset=localSize*grpid+tid*litems;
+    int s = tid;
+    __shared__ float lbuf[2048];
+    for ( ; j<litems && j<(size-goffset) ; ++j)
+       lbuf[tid*litems+j] = data[goffset+j];
+    for (int i=0 ; j<litems ; ++j,++i)
+       lbuf[tid*litems+j] = data[i];
+    __syncthreads();
+    for (j=0 ; j<repeat ; ++j)
+    {
+       float a0 = lbuf[(s+0)&(2047)];
+       float a1 = lbuf[(s+1)&(2047)];
+       float a2 = lbuf[(s+2)&(2047)];
+       float a3 = lbuf[(s+3)&(2047)];
+       float a4 = lbuf[(s+4)&(2047)];
+       float a5 = lbuf[(s+5)&(2047)];
+       float a6 = lbuf[(s+6)&(2047)];
+       float a7 = lbuf[(s+7)&(2047)];
+       float a8 = lbuf[(s+8)&(2047)];
+       float a9 = lbuf[(s+9)&(2047)];
+       float a10 = lbuf[(s+10)&(2047)];
+       float a11 = lbuf[(s+11)&(2047)];
+       float a12 = lbuf[(s+12)&(2047)];
+       float a13 = lbuf[(s+13)&(2047)];
+       float a14 = lbuf[(s+14)&(2047)];
+       float a15 = lbuf[(s+15)&(2047)];
+       sum += a0+a1+a2+a3+a4+a5+a6+a7+a8+a9+a10+a11+a12+a13+a14+a15;
+       s = (s+16)&(2047);
+    }
+    output[gid] = sum;
+}
+
+__global__ void
+writeGlobalMemoryCoalesced(float *output, int size, int repeat)
+{
+    int gid = threadIdx.x + (blockDim.x * blockIdx.x), j = 0;
+    int s = gid;
+    for (j=0 ; j<repeat ; ++j)
+    {
+       output[(s+0)&(size-1)] = gid;
+       output[(s+32768)&(size-1)] = gid;
+       output[(s+65536)&(size-1)] = gid;
+       output[(s+98304)&(size-1)] = gid;
+       output[(s+131072)&(size-1)] = gid;
+       output[(s+163840)&(size-1)] = gid;
+       output[(s+196608)&(size-1)] = gid;
+       output[(s+229376)&(size-1)] = gid;
+       output[(s+262144)&(size-1)] = gid;
+       output[(s+294912)&(size-1)] = gid;
+       output[(s+327680)&(size-1)] = gid;
+       output[(s+360448)&(size-1)] = gid;
+       output[(s+393216)&(size-1)] = gid;
+       output[(s+425984)&(size-1)] = gid;
+       output[(s+458752)&(size-1)] = gid;
+       output[(s+491520)&(size-1)] = gid;
+       s = (s+524288)&(size-1);
+    }
+}
+
+__global__ void
+writeGlobalMemoryUnit(float *output, int size, int repeat)
+{
+    int gid = threadIdx.x + (blockDim.x * blockIdx.x), j = 0;
+    int s = gid*512;
+    for (j=0 ; j<repeat ; ++j)
+    {
+       output[(s+0)&(size-1)] = gid;
+       output[(s+1)&(size-1)] = gid;
+       output[(s+2)&(size-1)] = gid;
+       output[(s+3)&(size-1)] = gid;
+       output[(s+4)&(size-1)] = gid;
+       output[(s+5)&(size-1)] = gid;
+       output[(s+6)&(size-1)] = gid;
+       output[(s+7)&(size-1)] = gid;
+       output[(s+8)&(size-1)] = gid;
+       output[(s+9)&(size-1)] = gid;
+       output[(s+10)&(size-1)] = gid;
+       output[(s+11)&(size-1)] = gid;
+       output[(s+12)&(size-1)] = gid;
+       output[(s+13)&(size-1)] = gid;
+       output[(s+14)&(size-1)] = gid;
+       output[(s+15)&(size-1)] = gid;
+       s = (s+16)&(size-1);
+    }
+}
+
+__global__ void
+writeLocalMemory(float *output, int size, int repeat)
+{
+    int gid = threadIdx.x + (blockDim.x * blockIdx.x), j = 0;
+    int tid=threadIdx.x, localSize=blockDim.x, litems=2048/localSize;
+    int s = tid;
+    __shared__ float lbuf[2048];
+    for (j=0 ; j<repeat ; ++j)
+    {
+       lbuf[(s+0)&(2047)] = gid;
+       lbuf[(s+1)&(2047)] = gid;
+       lbuf[(s+2)&(2047)] = gid;
+       lbuf[(s+3)&(2047)] = gid;
+       lbuf[(s+4)&(2047)] = gid;
+       lbuf[(s+5)&(2047)] = gid;
+       lbuf[(s+6)&(2047)] = gid;
+       lbuf[(s+7)&(2047)] = gid;
+       lbuf[(s+8)&(2047)] = gid;
+       lbuf[(s+9)&(2047)] = gid;
+       lbuf[(s+10)&(2047)] = gid;
+       lbuf[(s+11)&(2047)] = gid;
+       lbuf[(s+12)&(2047)] = gid;
+       lbuf[(s+13)&(2047)] = gid;
+       lbuf[(s+14)&(2047)] = gid;
+       lbuf[(s+15)&(2047)] = gid;
+       s = (s+16)&(2047);
+    }
+    __syncthreads();
+    for (j=0 ; j<litems ; ++j)
+       output[gid] = lbuf[tid];
+}
+
+// Simple Repeated Linear Read from texture memory
+__global__ void readTexels(int n, float *d_out, int width)
+{
+    int idx_x = (blockIdx.x * blockDim.x) + threadIdx.x;
+    int idx_y = (blockIdx.y * blockDim.y) + threadIdx.y;
+    int out_idx = idx_y * gridDim.x + idx_x;
+    float sum = 0.0f;
+    int width_bits = width-1;
+    for (int i = 0; i < n; i++)
+    {
+        float4 v = tex2D(texA, float(idx_x), float(idx_y));
+        idx_x = (idx_x+1) & width_bits;
+        sum += v.x;
+    }
+    d_out[out_idx] = sum;
+}
+
+// Repeated read of only 4kb of texels (should fit in texture cache)
+__global__ void readTexelsInCache(int n, float *d_out)
+{
+    int idx_x = (blockIdx.x * blockDim.x) + threadIdx.x;
+    int idx_y = (blockIdx.y * blockDim.y) + threadIdx.y;
+    int out_idx = idx_y * gridDim.x + idx_x;
+    float sum = 0.0f;
+    for (int i = 0; i < n; i++)
+    {
+        float4 v = tex2D(texA, float(idx_x), float(idx_y));
+        sum += v.x;
+    }
+    d_out[out_idx] = sum;
+}
+
+// Read "random" texels
+__global__ void readTexelsRandom(int n, float *d_out, int width, int height)
+{
+    int idx_x = (blockIdx.x * blockDim.x) + threadIdx.x;
+    int idx_y = (blockIdx.y * blockDim.y) + threadIdx.y;
+    int out_idx = idx_y * gridDim.x + idx_x;
+    float sum = 0.0f;
+    int width_bits = width-1;
+    int height_bits = height-1;
+    for (int i = 0; i < n; i++)
+    {
+        float4 v = tex2D(texA, float(idx_x), float(idx_y));
+        idx_x = (idx_x*3+29)&(width_bits);
+        idx_y = (idx_y*5+11)&(height_bits);
+        sum += v.x;
+    }
+    d_out[out_idx] = sum;
+}
+

cuda_code/Distance_14.cu

@@ -0,0 +1,472 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include <faiss/gpu/GpuResources.h>
+#include <faiss/gpu/utils/DeviceUtils.h>
+#include <faiss/impl/AuxIndexStructures.h>
+#include <faiss/impl/FaissAssert.h>
+#include <faiss/gpu/impl/BroadcastSum.cuh>
+#include <faiss/gpu/impl/Distance.cuh>
+#include <faiss/gpu/impl/DistanceUtils.cuh>
+#include <faiss/gpu/impl/L2Norm.cuh>
+#include <faiss/gpu/impl/L2Select.cuh>
+#include <faiss/gpu/utils/BlockSelectKernel.cuh>
+#include <faiss/gpu/utils/DeviceDefs.cuh>
+#include <faiss/gpu/utils/Limits.cuh>
+#include <faiss/gpu/utils/MatrixMult.cuh>
+
+#include <thrust/device_ptr.h>
+#include <thrust/execution_policy.h>
+#include <thrust/fill.h>
+#include <thrust/for_each.h>
+#include <algorithm>
+#include <memory>
+
+namespace faiss {
+namespace gpu {
+
+template <typename T>
+void runDistance(
+        bool computeL2,
+        GpuResources* res,
+        Tensor<T, 2, true>& centroids,
+        bool centroidsRowMajor,
+        Tensor<float, 1, true>* centroidNorms,
+        Tensor<T, 2, true>& queries,
+        bool queriesRowMajor,
+        int k,
+        Tensor<float, 2, true>& outDistances,
+        Tensor<int, 2, true>& outIndices,
+        bool ignoreOutDistances) {
+    // The # of centroids in `centroids` based on memory layout
+    auto numCentroids = centroids.getSize(centroidsRowMajor ? 0 : 1);
+
+    // The # of queries in `queries` based on memory layout
+    auto numQueries = queries.getSize(queriesRowMajor ? 0 : 1);
+
+    // The dimensions of the vectors to consider
+    auto dim = queries.getSize(queriesRowMajor ? 1 : 0);
+    FAISS_ASSERT(
+            (numQueries == 0 || numCentroids == 0) ||
+            dim == centroids.getSize(centroidsRowMajor ? 1 : 0));
+
+    FAISS_ASSERT(outDistances.getSize(0) == numQueries);
+    FAISS_ASSERT(outIndices.getSize(0) == numQueries);
+    FAISS_ASSERT(outDistances.getSize(1) == k);
+    FAISS_ASSERT(outIndices.getSize(1) == k);
+
+    auto defaultStream = res->getDefaultStreamCurrentDevice();
+
+    // If we're querying against a 0 sized set, just return empty results
+    if (centroids.numElements() == 0) {
+        thrust::fill(
+                thrust::cuda::par.on(defaultStream),
+                outDistances.data(),
+                outDistances.end(),
+                Limits<float>::getMax());
+
+        thrust::fill(
+                thrust::cuda::par.on(defaultStream),
+                outIndices.data(),
+                outIndices.end(),
+                -1);
+
+        return;
+    }
+
+    // L2: If ||c||^2 is not pre-computed, calculate it
+    DeviceTensor<float, 1, true> cNorms;
+    if (computeL2 && !centroidNorms) {
+        cNorms = DeviceTensor<float, 1, true>(
+                res,
+                makeTempAlloc(AllocType::Other, defaultStream),
+                {numCentroids});
+        runL2Norm(centroids, centroidsRowMajor, cNorms, true, defaultStream);
+        centroidNorms = &cNorms;
+    }
+
+    //
+    // Prepare norm vector ||q||^2; ||c||^2 is already pre-computed
+    //
+    DeviceTensor<float, 1, true> queryNorms(
+            res,
+            makeTempAlloc(AllocType::Other, defaultStream),
+            {(int)numQueries});
+
+    // ||q||^2
+    if (computeL2) {
+        runL2Norm(queries, queriesRowMajor, queryNorms, true, defaultStream);
+    }
+
+    // By default, aim to use up to 512 MB of memory for the processing, with
+    // both number of queries and number of centroids being at least 512.
+    int tileRows = 0;
+    int tileCols = 0;
+    chooseTileSize(
+            numQueries,
+            numCentroids,
+            dim,
+            sizeof(T),
+            res->getTempMemoryAvailableCurrentDevice(),
+            tileRows,
+            tileCols);
+
+    int numColTiles = utils::divUp(numCentroids, tileCols);
+
+    // We can have any number of vectors to query against, even less than k, in
+    // which case we'll return -1 for the index
+    FAISS_ASSERT(k <= GPU_MAX_SELECTION_K); // select limitation
+
+    // Temporary output memory space we'll use
+    DeviceTensor<float, 2, true> distanceBuf1(
+            res,
+            makeTempAlloc(AllocType::Other, defaultStream),
+            {tileRows, tileCols});
+    DeviceTensor<float, 2, true> distanceBuf2(
+            res,
+            makeTempAlloc(AllocType::Other, defaultStream),
+            {tileRows, tileCols});
+    DeviceTensor<float, 2, true>* distanceBufs[2] = {
+            &distanceBuf1, &distanceBuf2};
+
+    DeviceTensor<float, 2, true> outDistanceBuf1(
+            res,
+            makeTempAlloc(AllocType::Other, defaultStream),
+            {tileRows, numColTiles * k});
+    DeviceTensor<float, 2, true> outDistanceBuf2(
+            res,
+            makeTempAlloc(AllocType::Other, defaultStream),
+            {tileRows, numColTiles * k});
+    DeviceTensor<float, 2, true>* outDistanceBufs[2] = {
+            &outDistanceBuf1, &outDistanceBuf2};
+
+    DeviceTensor<int, 2, true> outIndexBuf1(
+            res,
+            makeTempAlloc(AllocType::Other, defaultStream),
+            {tileRows, numColTiles * k});
+    DeviceTensor<int, 2, true> outIndexBuf2(
+            res,
+            makeTempAlloc(AllocType::Other, defaultStream),
+            {tileRows, numColTiles * k});
+    DeviceTensor<int, 2, true>* outIndexBufs[2] = {
+            &outIndexBuf1, &outIndexBuf2};
+
+    auto streams = res->getAlternateStreamsCurrentDevice();
+    streamWait(streams, {defaultStream});
+
+    int curStream = 0;
+    bool interrupt = false;
+
+    // Tile over the input queries
+    for (int i = 0; i < numQueries; i += tileRows) {
+        if (interrupt || InterruptCallback::is_interrupted()) {
+            interrupt = true;
+            break;
+        }
+
+        int curQuerySize = std::min(tileRows, numQueries - i);
+
+        auto outDistanceView = outDistances.narrow(0, i, curQuerySize);
+        auto outIndexView = outIndices.narrow(0, i, curQuerySize);
+
+        auto queryView =
+                queries.narrow(queriesRowMajor ? 0 : 1, i, curQuerySize);
+        auto queryNormNiew = queryNorms.narrow(0, i, curQuerySize);
+
+        auto outDistanceBufRowView =
+                outDistanceBufs[curStream]->narrow(0, 0, curQuerySize);
+        auto outIndexBufRowView =
+                outIndexBufs[curStream]->narrow(0, 0, curQuerySize);
+
+        // Tile over the centroids
+        for (int j = 0; j < numCentroids; j += tileCols) {
+            if (InterruptCallback::is_interrupted()) {
+                interrupt = true;
+                break;
+            }
+
+            int curCentroidSize = std::min(tileCols, numCentroids - j);
+            int curColTile = j / tileCols;
+
+            auto centroidsView = sliceCentroids(
+                    centroids, centroidsRowMajor, j, curCentroidSize);
+
+            auto distanceBufView = distanceBufs[curStream]
+                                           ->narrow(0, 0, curQuerySize)
+                                           .narrow(1, 0, curCentroidSize);
+
+            auto outDistanceBufColView =
+                    outDistanceBufRowView.narrow(1, k * curColTile, k);
+            auto outIndexBufColView =
+                    outIndexBufRowView.narrow(1, k * curColTile, k);
+
+            // L2: distance is ||c||^2 - 2qc + ||q||^2, we compute -2qc
+            // IP: just compute qc
+            // (query id x dim) x (centroid id, dim)' = (query id, centroid id)
+            runMatrixMult(
+                    distanceBufView,
+                    false, // not transposed
+                    queryView,
+                    !queriesRowMajor, // transposed MM if col major
+                    centroidsView,
+                    centroidsRowMajor, // transposed MM if row major
+                    computeL2 ? -2.0f : 1.0f,
+                    0.0f,
+                    res->getBlasHandleCurrentDevice(),
+                    streams[curStream]);
+
+            if (computeL2) {
+                // For L2 distance, we use this fused kernel that performs both
+                // adding ||c||^2 to -2qc and k-selection, so we only need two
+                // passes (one write by the gemm, one read here) over the huge
+                // region of output memory
+                //
+                // If we aren't tiling along the number of centroids, we can
+                // perform the output work directly
+                if (tileCols == numCentroids) {
+                    // Write into the final output
+                    runL2SelectMin(
+                            distanceBufView,
+                            *centroidNorms,
+                            outDistanceView,
+                            outIndexView,
+                            k,
+                            streams[curStream]);
+
+                    if (!ignoreOutDistances) {
+                        // expand (query id) to (query id, k) by duplicating
+                        // along rows top-k ||c||^2 - 2qc + ||q||^2 in the form
+                        // (query id, k)
+                        runSumAlongRows(
+                                queryNormNiew,
+                                outDistanceView,
+                                true, // L2 distances should not go below zero
+                                      // due to roundoff error
+                                streams[curStream]);
+                    }
+                } else {
+                    auto centroidNormsView =
+                            centroidNorms->narrow(0, j, curCentroidSize);
+
+                    // Write into our intermediate output
+                    runL2SelectMin(
+                            distanceBufView,
+                            centroidNormsView,
+                            outDistanceBufColView,
+                            outIndexBufColView,
+                            k,
+                            streams[curStream]);
+
+                    if (!ignoreOutDistances) {
+                        // expand (query id) to (query id, k) by duplicating
+                        // along rows top-k ||c||^2 - 2qc + ||q||^2 in the form
+                        // (query id, k)
+                        runSumAlongRows(
+                                queryNormNiew,
+                                outDistanceBufColView,
+                                true, // L2 distances should not go below zero
+                                      // due to roundoff error
+                                streams[curStream]);
+                    }
+                }
+            } else {
+                // For IP, just k-select the output for this tile
+                if (tileCols == numCentroids) {
+                    // Write into the final output
+                    runBlockSelect(
+                            distanceBufView,
+                            outDistanceView,
+                            outIndexView,
+                            true,
+                            k,
+                            streams[curStream]);
+                } else {
+                    // Write into the intermediate output
+                    runBlockSelect(
+                            distanceBufView,
+                            outDistanceBufColView,
+                            outIndexBufColView,
+                            true,
+                            k,
+                            streams[curStream]);
+                }
+            }
+        }
+
+        // As we're finished with processing a full set of centroids, perform
+        // the final k-selection
+        if (tileCols != numCentroids) {
+            // The indices are tile-relative; for each tile of k, we need to add
+            // tileCols to the index
+            runIncrementIndex(
+                    outIndexBufRowView, k, tileCols, streams[curStream]);
+
+            runBlockSelectPair(
+                    outDistanceBufRowView,
+                    outIndexBufRowView,
+                    outDistanceView,
+                    outIndexView,
+                    computeL2 ? false : true,
+                    k,
+                    streams[curStream]);
+        }
+
+        curStream = (curStream + 1) % 2;
+    }
+
+    // Have the desired ordering stream wait on the multi-stream
+    streamWait({defaultStream}, streams);
+
+    if (interrupt) {
+        FAISS_THROW_MSG("interrupted");
+    }
+}
+
+template <typename T>
+void runL2Distance(
+        GpuResources* res,
+        Tensor<T, 2, true>& centroids,
+        bool centroidsRowMajor,
+        Tensor<float, 1, true>* centroidNorms,
+        Tensor<T, 2, true>& queries,
+        bool queriesRowMajor,
+        int k,
+        Tensor<float, 2, true>& outDistances,
+        Tensor<int, 2, true>& outIndices,
+        bool ignoreOutDistances = false) {
+    runDistance<T>(
+            true, // L2
+            res,
+            centroids,
+            centroidsRowMajor,
+            centroidNorms,
+            queries,
+            queriesRowMajor,
+            k,
+            outDistances,
+            outIndices,
+            ignoreOutDistances);
+}
+
+template <typename T>
+void runIPDistance(
+        GpuResources* res,
+        Tensor<T, 2, true>& centroids,
+        bool centroidsRowMajor,
+        Tensor<T, 2, true>& queries,
+        bool queriesRowMajor,
+        int k,
+        Tensor<float, 2, true>& outDistances,
+        Tensor<int, 2, true>& outIndices) {
+    runDistance<T>(
+            false, // IP
+            res,
+            centroids,
+            centroidsRowMajor,
+            nullptr, // no centroid norms provided
+            queries,
+            queriesRowMajor,
+            k,
+            outDistances,
+            outIndices,
+            false);
+}
+
+//
+// Instantiations of the distance templates
+//
+
+void runIPDistance(
+        GpuResources* res,
+        Tensor<float, 2, true>& vectors,
+        bool vectorsRowMajor,
+        Tensor<float, 2, true>& queries,
+        bool queriesRowMajor,
+        int k,
+        Tensor<float, 2, true>& outDistances,
+        Tensor<int, 2, true>& outIndices) {
+    runIPDistance<float>(
+            res,
+            vectors,
+            vectorsRowMajor,
+            queries,
+            queriesRowMajor,
+            k,
+            outDistances,
+            outIndices);
+}
+
+void runIPDistance(
+        GpuResources* res,
+        Tensor<half, 2, true>& vectors,
+        bool vectorsRowMajor,
+        Tensor<half, 2, true>& queries,
+        bool queriesRowMajor,
+        int k,
+        Tensor<float, 2, true>& outDistances,
+        Tensor<int, 2, true>& outIndices) {
+    runIPDistance<half>(
+            res,
+            vectors,
+            vectorsRowMajor,
+            queries,
+            queriesRowMajor,
+            k,
+            outDistances,
+            outIndices);
+}
+
+void runL2Distance(
+        GpuResources* res,
+        Tensor<float, 2, true>& vectors,
+        bool vectorsRowMajor,
+        Tensor<float, 1, true>* vectorNorms,
+        Tensor<float, 2, true>& queries,
+        bool queriesRowMajor,
+        int k,
+        Tensor<float, 2, true>& outDistances,
+        Tensor<int, 2, true>& outIndices,
+        bool ignoreOutDistances) {
+    runL2Distance<float>(
+            res,
+            vectors,
+            vectorsRowMajor,
+            vectorNorms,
+            queries,
+            queriesRowMajor,
+            k,
+            outDistances,
+            outIndices,
+            ignoreOutDistances);
+}
+
+void runL2Distance(
+        GpuResources* res,
+        Tensor<half, 2, true>& vectors,
+        bool vectorsRowMajor,
+        Tensor<float, 1, true>* vectorNorms,
+        Tensor<half, 2, true>& queries,
+        bool queriesRowMajor,
+        int k,
+        Tensor<float, 2, true>& outDistances,
+        Tensor<int, 2, true>& outIndices,
+        bool ignoreOutDistances) {
+    runL2Distance<half>(
+            res,
+            vectors,
+            vectorsRowMajor,
+            vectorNorms,
+            queries,
+            queriesRowMajor,
+            k,
+            outDistances,
+            outIndices,
+            ignoreOutDistances);
+}
+
+} // namespace gpu
+} // namespace faiss

cuda_code/DistributionExponentialKernel.cu

@@ -0,0 +1,37 @@
+#include <ATen/Dispatch.h>
+#include <ATen/ExpandUtils.h>
+#include <ATen/NativeFunctions.h>
+#include <ATen/cuda/CUDAApplyUtils.cuh>
+#include <ATen/AccumulateType.h>
+#include <ATen/CUDAGeneratorImpl.h>
+#include <ATen/native/UnaryOps.h>
+#include <ATen/native/cuda/DistributionTemplates.h>
+
+#include <curand.h>
+#include <curand_kernel.h>
+#include <curand_philox4x32_x.h>
+#include <utility>
+#include <functional>
+
+#include <ATen/native/Distributions.h>
+#include <ATen/native/cuda/Loops.cuh>
+#include <ATen/native/TensorIterator.h>
+
+#include <THC/THCGeneral.h>
+#include <THC/THCDeviceUtils.cuh>
+
+#include <cstdint>
+#include <limits>
+#include <utility>
+#include <type_traits>
+
+namespace at { namespace native {
+
+void exponential_kernel(TensorIteratorBase& iter, double lambda, c10::optional<Generator> gen) {
+  auto generator = get_generator_or_default<CUDAGeneratorImpl>(gen, cuda::detail::getDefaultCUDAGenerator());
+  at::native::templates::cuda::exponential_kernel(iter, lambda, generator);
+}
+
+REGISTER_DISPATCH(exponential_stub, &exponential_kernel);
+
+}} // namespace at::native

cuda_code/DistributionExponentialKernel_1.cu

@@ -0,0 +1,15 @@
+#define TORCH_ASSERT_NO_OPERATORS
+#include <ATen/cuda/CUDAGeneratorImpl.h>
+#include <ATen/native/UnaryOps.h>
+#include <ATen/native/cuda/DistributionTemplates.h>
+
+namespace at { namespace native {
+
+void exponential_kernel(TensorIteratorBase& iter, double lambda, c10::optional<Generator> gen) {
+  auto generator = get_generator_or_default<CUDAGeneratorImpl>(gen, cuda::detail::getDefaultCUDAGenerator());
+  at::native::templates::cuda::exponential_kernel(iter, lambda, generator);
+}
+
+REGISTER_DISPATCH(exponential_stub, &exponential_kernel);
+
+}} // namespace at::native

cuda_code/DnDHgels.cu

@@ -0,0 +1,67 @@
+#include <cuda_runtime_api.h> // cudaMalloc, cudaMemcpy, etc.
+#include <cusolverDn.h>         // cusolverDn
+#include "../../cusolver_utils.h"
+#include <stdio.h>            // printf
+#include <stdlib.h>           // EXIT_FAILURE
+
+int main(void) {
+
+    int m = 3;
+    int n = 3;
+    int nrhs = 3;
+    int lda = n;
+    int ldb = n;
+    int ldx = n;
+    double hA[] = {1, 2, 3, 2, 5, 5, 3, 5, 12};
+    double hB[] = {1, 2, 3, 2, 5, 5, 3, 5, 12};
+    double hX[] = {0, 0, 0, 0, 0, 0, 0, 0, 0};
+
+    double hX_result[] = {1, 0, 0, 0, 1, 0, 0, 0, 1};
+
+    double *dA, *dB, *dX;
+    CUDA_CHECK( cudaMalloc((void**) &dA, m * n * sizeof(double)));
+    CUDA_CHECK( cudaMalloc((void**) &dB, m * nrhs * sizeof(double)));
+    CUDA_CHECK( cudaMalloc((void**) &dX, m * nrhs * sizeof(double)));
+    CUDA_CHECK( cudaMemcpy(dA, hA, m * n  * sizeof(double), cudaMemcpyHostToDevice) );
+    CUDA_CHECK( cudaMemcpy(dB, hB, m * nrhs * sizeof(double), cudaMemcpyHostToDevice) );
+    CUDA_CHECK( cudaMemcpy(dX, hX, m * nrhs * sizeof(double), cudaMemcpyHostToDevice) );
+
+    cusolverDnHandle_t handle = NULL;
+    CUSOLVER_CHECK(cusolverDnCreate(&handle));
+
+    size_t lwork_bytes;
+    CUSOLVER_CHECK(cusolverDnDHgels_bufferSize(handle, m, n, nrhs, NULL, lda, NULL, ldb, NULL, ldx, NULL, &lwork_bytes));
+    //printf("%d\n", lwork_bytes);
+
+    void *dWorkspace;
+    cudaMalloc((void**)&dWorkspace, lwork_bytes);
+
+    int *devInfo;
+    int niter;
+    CUDA_CHECK( cudaMalloc((void**) &devInfo, sizeof(int)));
+    CUSOLVER_CHECK(cusolverDnDHgels(handle, m, n, nrhs, dA, lda, dB, ldb, dX, ldx, dWorkspace, lwork_bytes, &niter, devInfo));
+    int hdevInfo;
+    CUDA_CHECK( cudaMemcpy(&hdevInfo, devInfo, sizeof(int), cudaMemcpyDeviceToHost) );
+    double values[n*nrhs];
+    CUDA_CHECK( cudaMemcpy(values, dX, n * nrhs * sizeof(double), cudaMemcpyDeviceToHost) );
+
+    int correct = (hdevInfo == 0);
+    for (int i = 0; i < n * nrhs; i++) {
+        printf("%f == %f\n", values[i], hX_result[i]);
+        if (fabsf(values[i] - hX_result[i]) > 0.001) {
+            correct = 0;
+            //break;
+        }
+    }
+
+    if (correct == 1) {
+        printf("DnDHgels test PASSED\n");
+    } else {
+        printf("DnDHgels test FAILED\n");
+    }
+
+    CUSOLVER_CHECK(cusolverDnDestroy(handle));
+
+    return EXIT_SUCCESS;
+
+}

cuda_code/DnSXgels.cu

@@ -0,0 +1,67 @@
+#include <cuda_runtime_api.h> // cudaMalloc, cudaMemcpy, etc.
+#include <cusolverDn.h>         // cusolverDn
+#include "../../cusolver_utils.h"
+#include <stdio.h>            // printf
+#include <stdlib.h>           // EXIT_FAILURE
+
+int main(void) {
+
+    int m = 3;
+    int n = 3;
+    int nrhs = 3;
+    int lda = n;
+    int ldb = n;
+    int ldx = n;
+    float hA[] = {1, 2, 3, 2, 5, 5, 3, 5, 12};
+    float hB[] = {1, 2, 3, 2, 5, 5, 3, 5, 12};
+    float hX[] = {0, 0, 0, 0, 0, 0, 0, 0, 0};
+
+    float hX_result[] = {1, 0, 0, 0, 1, 0, 0, 0, 1};
+
+    float *dA, *dB, *dX;
+    CUDA_CHECK( cudaMalloc((void**) &dA, m * n * sizeof(float)));
+    CUDA_CHECK( cudaMalloc((void**) &dB, m * nrhs * sizeof(float)));
+    CUDA_CHECK( cudaMalloc((void**) &dX, m * nrhs * sizeof(float)));
+    CUDA_CHECK( cudaMemcpy(dA, hA, m * n  * sizeof(float), cudaMemcpyHostToDevice) );
+    CUDA_CHECK( cudaMemcpy(dB, hB, m * nrhs * sizeof(float), cudaMemcpyHostToDevice) );
+    CUDA_CHECK( cudaMemcpy(dX, hX, m * nrhs * sizeof(float), cudaMemcpyHostToDevice) );
+
+    cusolverDnHandle_t handle = NULL;
+    CUSOLVER_CHECK(cusolverDnCreate(&handle));
+
+    size_t lwork_bytes;
+    CUSOLVER_CHECK(cusolverDnSXgels_bufferSize(handle, m, n, nrhs, NULL, lda, NULL, ldb, NULL, ldx, NULL, &lwork_bytes));
+    //printf("%d\n", lwork_bytes);
+
+    void *dWorkspace;
+    cudaMalloc((void**)&dWorkspace, lwork_bytes);
+
+    int *devInfo;
+    int niter;
+    CUDA_CHECK( cudaMalloc((void**) &devInfo, sizeof(int)));
+    CUSOLVER_CHECK(cusolverDnSXgels(handle, m, n, nrhs, dA, lda, dB, ldb, dX, ldx, dWorkspace, lwork_bytes, &niter, devInfo));
+    int hdevInfo;
+    CUDA_CHECK( cudaMemcpy(&hdevInfo, devInfo, sizeof(int), cudaMemcpyDeviceToHost) );
+    float values[n*nrhs];
+    CUDA_CHECK( cudaMemcpy(values, dX, n * nrhs * sizeof(float), cudaMemcpyDeviceToHost) );
+
+    int correct = (hdevInfo == 0);
+    for (int i = 0; i < n * nrhs; i++) {
+        printf("%f == %f\n", values[i], hX_result[i]);
+        if (fabsf(values[i] - hX_result[i]) > 0.001) {
+            correct = 0;
+            //break;
+        }
+    }
+
+    if (correct == 1) {
+        printf("DnSXgels test PASSED\n");
+    } else {
+        printf("DnSXgels test FAILED\n");
+    }
+
+    CUSOLVER_CHECK(cusolverDnDestroy(handle));
+
+    return EXIT_SUCCESS;
+
+}