Merge pull request #36 from TimmyLiu/develop

enable rect read/write for gemm in client (good performance when lda, ldb and ldc is bigger than m, n and k); Also bug fixes of hemm and symm hanging and ssyr2k crashing when using the tuning kdb files

Author: Kent Knox

src/client/clfunc_common.hpp

@@ -313,6 +313,7 @@ class clblasFunc
     virtual void reset_gpu_write_buffer() = 0;
 	virtual void read_gpu_buffer() = 0;
 	virtual void roundtrip_func() = 0;
+	virtual void roundtrip_func_rect() {}
 	virtual void allochostptr_roundtrip_func() {}
 	virtual void usehostptr_roundtrip_func() {}
 	virtual void copyhostptr_roundtrip_func() {}

src/client/clfunc_xgemm.hpp

@@ -454,6 +454,103 @@ class xGemm : public clblasFunc
 		clWaitForEvents(1, &event_);
 	timer.Stop(timer_id);
 	}
+	void roundtrip_func_rect()
+	{
+	timer.Start(timer_id);
+		cl_int err;
+		//rect
+		size_t a_buffer_origin[3] = {0,0,0}; 
+		size_t a_host_origin[3] = {0,0,0};
+		size_t a_region[3] = {buffer_.m_*sizeof(T),buffer_.k_,1};
+		size_t a_buffer_row_pitch=0*sizeof(T);//lda
+		size_t a_buffer_slice_pitch=0;
+		size_t a_host_row_pitch=buffer_.lda_*sizeof(T);
+		size_t a_host_slice_pitch=0;
+
+		size_t b_buffer_origin[3] = {0,0,0}; 
+		size_t b_host_origin[3] = {0,0,0};
+		size_t b_region[3] = {buffer_.k_*sizeof(T),buffer_.n_,1};
+		size_t b_buffer_row_pitch=0*sizeof(T);//ldb
+		size_t b_buffer_slice_pitch=0;
+		size_t b_host_row_pitch=buffer_.ldb_*sizeof(T);
+		size_t b_host_slice_pitch=0;
+
+		size_t c_buffer_origin[3] = {0,0,0}; 
+		size_t c_host_origin[3] = {0,0,0};
+		size_t c_region[3] = {buffer_.m_*sizeof(T),buffer_.n_,1};
+		size_t c_buffer_row_pitch=0*sizeof(T);//ldc
+		size_t c_buffer_slice_pitch=0;
+		size_t c_host_row_pitch=buffer_.ldc_*sizeof(T);
+		size_t c_host_slice_pitch=0;
+
+        buffer_.buf_a_ = clCreateBuffer(ctx_, CL_MEM_READ_ONLY,
+                                       (buffer_.k_*buffer_.m_ +
+                                           buffer_.offA_) * sizeof(T),
+                                       NULL, &err);
+
+        buffer_.buf_b_ = clCreateBuffer(ctx_, CL_MEM_READ_ONLY,
+                                        (buffer_.k_ * buffer_.n_ +
+                                            buffer_.offB_) * sizeof(T),
+                                        NULL, &err);
+
+        buffer_.buf_c_ = clCreateBuffer(ctx_, CL_MEM_READ_WRITE,
+                                        (buffer_.m_ * buffer_.n_ +
+                                            buffer_.offC_) * sizeof(T),
+                                        NULL, &err);
+        /*
+		err = clEnqueueWriteBuffer(queue_, buffer_.buf_a_, CL_TRUE,
+                                   buffer_.offA_ * sizeof(T),
+                                   buffer_.lda_ * buffer_.a_num_vectors_ *
+                                       sizeof(T),
+                                   buffer_.a_, 0, NULL, NULL);
+		
+        err = clEnqueueWriteBuffer(queue_, buffer_.buf_b_, CL_TRUE,
+                                   buffer_.offB_ * sizeof(T),
+                                   buffer_.ldb_ * buffer_.b_num_vectors_ *
+                                       sizeof(T),
+                                   buffer_.b_, 0, NULL, NULL);
+
+        err = clEnqueueWriteBuffer(queue_, buffer_.buf_c_, CL_TRUE,
+                                   buffer_.offC_ * sizeof(T),
+                                   buffer_.ldc_ * buffer_.c_num_vectors_ *
+                                   sizeof(T),
+                                   buffer_.c_, 0, NULL, NULL);*/
+        err = clEnqueueWriteBufferRect(queue_, buffer_.buf_a_, CL_TRUE, a_buffer_origin, a_host_origin, a_region, a_buffer_row_pitch,
+										a_buffer_slice_pitch, a_host_row_pitch, a_host_slice_pitch, buffer_.a_, 0, NULL, NULL);
+        err = clEnqueueWriteBufferRect(queue_, buffer_.buf_b_, CL_TRUE, b_buffer_origin, b_host_origin, b_region, b_buffer_row_pitch,
+										b_buffer_slice_pitch, b_host_row_pitch, b_host_slice_pitch, buffer_.b_, 0, NULL, NULL);
+        err = clEnqueueWriteBufferRect(queue_, buffer_.buf_c_, CL_TRUE, c_buffer_origin, c_host_origin, c_region, c_buffer_row_pitch,
+										c_buffer_slice_pitch, c_host_row_pitch, c_host_slice_pitch, buffer_.c_, 0, NULL, NULL);
+
+		if(buffer_.trans_a_==clblasNoTrans)
+		{
+			buffer_.lda_=buffer_.m_;
+		}
+		else
+		{
+			buffer_.lda_=buffer_.k_;
+		}
+		if(buffer_.trans_b_==clblasNoTrans)
+		{
+			buffer_.ldb_=buffer_.k_;
+		}
+		else
+		{
+			buffer_.ldb_=buffer_.n_;
+		}
+		buffer_.ldc_=buffer_.m_;
+		xGemm_Function(false);
+		/*
+		err = clEnqueueReadBuffer(queue_, buffer_.buf_c_, CL_TRUE,
+			                      buffer_.offC_ * sizeof(T), buffer_.ldc_ * buffer_.c_num_vectors_ *
+                                       sizeof(T),
+								  buffer_.c_, 0, NULL, &event_);
+		*/
+		err = ::clEnqueueReadBufferRect(queue_, buffer_.buf_c_, CL_TRUE, c_buffer_origin, c_host_origin, c_region, c_buffer_row_pitch,
+										c_buffer_slice_pitch, c_host_row_pitch, c_host_slice_pitch, buffer_.c_, 0, NULL, &event_);
+		clWaitForEvents(1, &event_);
+	timer.Stop(timer_id);
+	}	
 	void allochostptr_roundtrip_func()
 	{
 	timer.Start(timer_id);
@@ -528,12 +625,7 @@ class xGemm : public clblasFunc
                                         (buffer_.ldc_ * buffer_.c_num_vectors_ +
                                             buffer_.offC_) * sizeof(T),
                                         buffer_.c_, &err);
-		xGemm_Function(false);
-		err = clEnqueueReadBuffer(queue_, buffer_.buf_c_, CL_TRUE,
-			                      buffer_.offC_ * sizeof(T), buffer_.ldc_ * buffer_.c_num_vectors_ *
-                                       sizeof(T),
-								  buffer_.c_, 0, NULL, &event_);
-		clWaitForEvents(1, &event_);
+		xGemm_Function(true);
 	timer.Stop(timer_id);
 	}
 	void copyhostptr_roundtrip_func()
@@ -554,7 +646,12 @@ class xGemm : public clblasFunc
                                         (buffer_.ldc_ * buffer_.c_num_vectors_ +
                                             buffer_.offC_) * sizeof(T),
                                         buffer_.c_, &err);
-		xGemm_Function(true);
+		xGemm_Function(false);
+		err = clEnqueueReadBuffer(queue_, buffer_.buf_c_, CL_TRUE,
+			                      buffer_.offC_ * sizeof(T), buffer_.ldc_ * buffer_.c_num_vectors_ *
+                                       sizeof(T),
+								  buffer_.c_, 0, NULL, &event_);
+		clWaitForEvents(1, &event_);
 	timer.Stop(timer_id);
 	}
 	void usepersismem_roundtrip_func()

src/client/client.cpp

@@ -102,7 +102,7 @@ int main(int argc, char *argv[])
     ( "diag", po::value<int>( &diag_option )->default_value(0), "0 = unit diagonal, 1 = non unit diagonal. only used with [list of function families]" ) // xtrsm xtrmm
     ( "profile,p", po::value<cl_uint>( &profileCount )->default_value(20), "Time and report the kernel speed (default: profiling off)" )
 	( "roundtrip", po::value<std::string>( &roundtrip )->default_value("noroundtrip"),"including the time of OpenCL memory allocation and transportation; options:roundtrip, noroundtrip(default)")
-	( "memalloc", po::value<std::string>( &memalloc )->default_value("default"),"setting the memory allocation flags for OpenCL; would not take effect if roundtrip time is not measured; options:default(default),alloc_host_ptr,use_host_ptr,copy_host_ptr,use_persistent_mem_amd")
+	( "memalloc", po::value<std::string>( &memalloc )->default_value("default"),"setting the memory allocation flags for OpenCL; would not take effect if roundtrip time is not measured; options:default(default),alloc_host_ptr,use_host_ptr,copy_host_ptr,use_persistent_mem_amd,rect_mem")
     ;
 
   po::variables_map vm;
@@ -534,6 +534,10 @@ int main(int argc, char *argv[])
 	{
 		my_function->usepersismem_roundtrip_func();
 	}
+	else if (memalloc=="rect_mem")
+	{
+		my_function->roundtrip_func_rect();
+	}
 	//my_function->reset_gpu_write_buffer();
 	my_function->releaseGPUBuffer_deleteCPUBuffer();
   }

src/library/blas/generic/solution_seq_make.c

@@ -1435,9 +1435,12 @@ getStepGranulation(SolutionStep *step)
             }
         }
 
-        status = getGranularityInfo(&step->device, mempat->name,
-                                    step->args.dtype, step->extraFlags,
-                                    (int)MNK, dims, &step->pgran, &time);
+		if( step->funcID != CLBLAS_GEMM2 )
+		{
+			status = getGranularityInfo(&step->device, mempat->name,
+										step->args.dtype, step->extraFlags,
+										(int)MNK, dims, &step->pgran, &time);
+		}
         /*
          * Disable blocking for implementations dealing with cache reads
          * from the global memory

src/library/blas/gens/syrxk.c

@@ -21,6 +21,7 @@
 
 #include <string.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <assert.h>
 
 #include <clBLAS.h>
@@ -1219,10 +1220,11 @@ genUpdateGenericDiagTile(
     // type of the vectorized coordinates
     Kstring vctype;
     Kstring constOffs, constShifts, constMasks;
-    unsigned int i, j, nops;
+    unsigned int i, j, nops,size;
     unsigned int maxFetches = 0;
     const char *yname, *xname;
     const char *ldcName;
+	char hexadec[2];
 
     batch = createStmtBatch();
     if (batch == NULL) {
@@ -1253,6 +1255,14 @@ genUpdateGenericDiagTile(
     tifl = (isUpper) ? TILE_ITER_BACKWARD_ROWS :
                        TILE_ITER_BACKWARD_COLS;
     iterInit(&iter, &tileTempC, 1, tifl);
+	nops = 0;
+	while (!iterIsEnd(&iter)) {
+		nops++;
+		size = nops / nrCols;
+		iterIterate(&iter);
+	}
+
+	iterInit(&iter, &tileTempC, 1, tifl);
 
     initTmpResTile(&tileTempC, gset, true);
 
@@ -1316,7 +1326,7 @@ genUpdateGenericDiagTile(
     maxFetches = umin(maxFetches, i);
 
     // declare vectorized coordinates
-    declareDiagUpresIndexedVars(ctx, vctype.buf, "cc", tempRows);
+    declareDiagUpresIndexedVars(ctx, vctype.buf, "cc", size);
 
     /*
      * real y coordinate, offset mask and
@@ -1326,8 +1336,8 @@ genUpdateGenericDiagTile(
                      "unsigned int mask;\n"
                      "int hit;\n");
     if (withBeta) {
-        declareDiagUpresIndexedVars(ctx, typeName, "alphaNew", tempRows);
-        declareDiagUpresIndexedVars(ctx, typeName, "betaNew", tempRows);
+        declareDiagUpresIndexedVars(ctx, typeName, "alphaNew", size);
+        declareDiagUpresIndexedVars(ctx, typeName, "betaNew", size);
     }
 
     // declare tile
@@ -1443,7 +1453,9 @@ genUpdateGenericDiagTile(
             ksprintf(&kstr, "cc%u", i);
         }
         else {
-            ksprintf(&kstr, "cc%u.s%u", i, iter.col);
+			snprintf(hexadec, sizeof(char)*2, "%x", iter.col);
+			//itoa(iter.col, hexadec, 16);
+            ksprintf(&kstr, "cc%u.s%s", i, hexadec);
         }
 
         // prepare multipliers and fetch