From 69f2911e04ffb1b19eef1fafb8c040af271f656e Mon Sep 17 00:00:00 2001 From: Tor Aamodt Date: Thu, 15 Jul 2010 18:09:46 -0800 Subject: creating branch for adding support for CUDA 3.x and Fermi [git-p4: depot-paths = "//depot/gpgpu_sim_research/fermi/distribution/": change = 6829] --- benchmarks/CUDA/STO/main.cu | 867 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 867 insertions(+) create mode 100644 benchmarks/CUDA/STO/main.cu (limited to 'benchmarks/CUDA/STO/main.cu') diff --git a/benchmarks/CUDA/STO/main.cu b/benchmarks/CUDA/STO/main.cu new file mode 100644 index 0000000..31a234d --- /dev/null +++ b/benchmarks/CUDA/STO/main.cu @@ -0,0 +1,867 @@ +/*========================================================================== + M A I N + +* Copyright (c) 2008, NetSysLab at the University of British Columbia +* 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 the University 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 NetSysLab ``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 NetSysLab 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. + +DESCRIPTION + Main entry. + + +==========================================================================*/ + +/*========================================================================== + + INCLUDES + +==========================================================================*/ +// system +#include +#include +#include + +// project +#include +#include +#include + + +/*========================================================================== + + DATA DECLARATIONS + +==========================================================================*/ + +/*-------------------------------------------------------------------------- + TYPE DEFINITIONS +--------------------------------------------------------------------------*/ + +/*-------------------------------------------------------------------------- + FUNCTION PROTOTYPES +--------------------------------------------------------------------------*/ + + +/*-------------------------------------------------------------------------- + CONSTANTS +--------------------------------------------------------------------------*/ + +/*-------------------------------------------------------------------------- + GLOBAL VARIABLES +--------------------------------------------------------------------------*/ + + +/*-------------------------------------------------------------------------- + MACROS +--------------------------------------------------------------------------*/ + +/*========================================================================== + + FUNCTIONS + +==========================================================================*/ + +/*-------------------------------------------------------------------------- + GLOBAL FUNCTIONS +--------------------------------------------------------------------------*/ + +/*=========================================================================== + +FUNCTION SG_PRINT_TIME_BREAKDOWN + +DESCRIPTION + Prints out the given time breakdown parameter + +DEPENDENCIES + None + +RETURN VALUE + None + +===========================================================================*/ +static void print_gpu_time_breakdown( sg_time_breakdown_type* time_breakdown, + float input_buffer_alloc_time, + float gpu_init_time ) { + + printf("\n== GPU Timing ==\n"); + printf("GPU init : %f\n", gpu_init_time); + printf("Host input buffer alloc : %f\n", input_buffer_alloc_time); + printf("-----\n"); + printf("Host output buffer alloc : %f\n", + time_breakdown->host_output_buffer_alloc_time); + printf("GPU memory alloc : %f\n", time_breakdown->device_mem_alloc_time); + printf("Data copy in : %f\n", time_breakdown->copy_in_time); + printf("Kernel execution : %f\n", time_breakdown->exec_time); + printf("Data copy out : %f\n", time_breakdown->copy_out_time); + printf("Last hasing stage : %f\n", time_breakdown->last_stage_time); + +} + +#ifdef FEATURE_RUN_OVERLAP_TEST +/*=========================================================================== + +FUNCTION run_md5_overlap_test + +DESCRIPTION + run the test + +DEPENDENCIES + None + +RETURN VALUE + None + +===========================================================================*/ +void run_md5_overlap_test( ) { + + //**** Variables ****// + float host_input_buffer_alloc_time, gpu_init_time; + sg_time_breakdown_type gpu_time_breakdown; + unsigned char* sc_output; + unsigned char* sg_output; + unsigned char* buffer; + unsigned int timer; + int sg_output_size; + int sc_output_size; + + + printf( "MD5 Overlap Test\n\n" ); + + //**** create the timer ****// + timer = 0; + CUT_SAFE_CALL( cutCreateTimer( &timer)); + + + + //** GPU initialization timing **// + CUT_SAFE_CALL(cutResetTimer(timer)); + CUT_SAFE_CALL(cutStartTimer(timer)); + + /* GPU device initialization */ + sg_init(); + + /* stop the timer */ + CUT_SAFE_CALL(cutStopTimer(timer)); + gpu_init_time = cutGetTimerValue(timer); + + + + //**** Host input buffer allocation timing ****// + CUT_SAFE_CALL(cutResetTimer(timer)); + CUT_SAFE_CALL(cutStartTimer(timer)); + + /* allocate test buffer */ + buffer = (unsigned char*) sg_malloc(TEST_MEM_SIZE_OVERLAP); + + /* stop the timer */ + CUT_SAFE_CALL(cutStopTimer(timer)); + host_input_buffer_alloc_time = cutGetTimerValue(timer); + + + + //**** initialize test buffer with random data ****// + for( unsigned int i = 0; i < TEST_MEM_SIZE_OVERLAP; ++i) { + buffer[i] = i; + } + + + + /***************/ + /***** GPU *****/ + /***************/ + + //** MD5 timing **// + CUT_SAFE_CALL(cutResetTimer(timer)); + CUT_SAFE_CALL(cutStartTimer(timer)); + + /* run GPU version */ + sg_md5_overlap(buffer, TEST_MEM_SIZE_OVERLAP, CHUNK_SIZE, OFFSET, + &sg_output, &sg_output_size, &gpu_time_breakdown); + + /* stop the timer */ + CUT_SAFE_CALL(cutStopTimer(timer)); + print_gpu_time_breakdown( &gpu_time_breakdown, + host_input_buffer_alloc_time, + gpu_init_time ); + printf( "GPU Proc. Time (gpu init and input alloc are not included): %f \n", + cutGetTimerValue(timer)); + + + + + /***************/ + /***** CPU *****/ + /***************/ + //**** start timer for cpu ****// + CUT_SAFE_CALL( cutResetTimer( timer ) ); + CUT_SAFE_CALL( cutStartTimer( timer ) ); + + + //**** run CPU version ****// + sc_md5_overlap(buffer, TEST_MEM_SIZE_OVERLAP, CHUNK_SIZE, OFFSET, + &sc_output, &sc_output_size); + + + //**** stop the timer ****// + CUT_SAFE_CALL( cutStopTimer( timer)); + printf( "CPU Processing time(ms): %f \n", cutGetTimerValue( timer)); + + + if(sc_output_size != sg_output_size){ + printf( "\nGPU and CPU didn't converse to the same output size:\n"); + printf( "\nGPU output size: %d\n", sg_output_size); + printf( "\nCPU output size: %d\n", sc_output_size); + } else { + printf( "\nOutput size: %d\n", sc_output_size); + } + + + //**** check if the results are equivalent ****// + CUTBoolean res = cutCompareub( sg_output, + sc_output, + sg_output_size); + + + //**** print the results ****// + printf( "Test %s\n", (1 == res) ? "PASSED" : "FAILED"); + printf("CPU GPU\n"); + for ( int i = sc_output_size - 4; i < sc_output_size; i++) { + printf("%X %X\n",sc_output[i], sg_output[i]); + } + + + sg_free(buffer); + //sg_free(sg_output); + cudaFreeHost(sg_output ); + free(sc_output); + +} + +/*=========================================================================== + +FUNCTION run_sha1_overlap_test + +DESCRIPTION + run the test + +DEPENDENCIES + None + +RETURN VALUE + None + +===========================================================================*/ +void run_sha1_overlap_test( ) { + + //**** Variables ****// + float host_input_buffer_alloc_time, gpu_init_time; + sg_time_breakdown_type gpu_time_breakdown; + unsigned char* sc_output; + unsigned char* sg_output; + unsigned char* buffer; + unsigned int timer; + int sg_output_size; + int sc_output_size; + + + printf( "SHA1 Overlap Test\n\n" ); + + //**** create the timer ****// + timer = 0; + CUT_SAFE_CALL( cutCreateTimer( &timer)); + + + + //** GPU initialization timing **// + CUT_SAFE_CALL(cutResetTimer(timer)); + CUT_SAFE_CALL(cutStartTimer(timer)); + + /* GPU device initialization */ + sg_init(); + + /* stop the timer */ + CUT_SAFE_CALL(cutStopTimer(timer)); + gpu_init_time = cutGetTimerValue(timer); + + + + //**** Host input buffer allocation timing ****// + CUT_SAFE_CALL(cutResetTimer(timer)); + CUT_SAFE_CALL(cutStartTimer(timer)); + + /* allocate test buffer */ + buffer = (unsigned char*) sg_malloc(TEST_MEM_SIZE_OVERLAP); + + /* stop the timer */ + CUT_SAFE_CALL(cutStopTimer(timer)); + host_input_buffer_alloc_time = cutGetTimerValue(timer); + + + + //**** initialize test buffer with random data ****// + for( unsigned int i = 0; i < TEST_MEM_SIZE_OVERLAP; ++i) { + buffer[i] = i; + } + + + + /***************/ + /***** GPU *****/ + /***************/ + + //** SHA1 timing **// + CUT_SAFE_CALL(cutResetTimer(timer)); + CUT_SAFE_CALL(cutStartTimer(timer)); + + /* run GPU version */ + sg_sha1_overlap(buffer, TEST_MEM_SIZE_OVERLAP, CHUNK_SIZE, OFFSET, + &sg_output, &sg_output_size, &gpu_time_breakdown); + + /* stop the timer */ + CUT_SAFE_CALL(cutStopTimer(timer)); + print_gpu_time_breakdown( &gpu_time_breakdown, + host_input_buffer_alloc_time, + gpu_init_time ); + printf( "GPU Proc. Time (gpu init and input alloc are not included): %f \n", + cutGetTimerValue(timer)); + + + + + /***************/ + /***** CPU *****/ + /***************/ + //**** start timer for cpu ****// + CUT_SAFE_CALL( cutResetTimer( timer ) ); + CUT_SAFE_CALL( cutStartTimer( timer ) ); + + + //**** run CPU version ****// + sc_sha1_overlap(buffer, TEST_MEM_SIZE_OVERLAP, CHUNK_SIZE, OFFSET, + &sc_output, &sc_output_size); + + + //**** stop the timer ****// + CUT_SAFE_CALL( cutStopTimer( timer)); + printf( "CPU Processing time(ms): %f \n", cutGetTimerValue( timer)); + + + if(sc_output_size != sg_output_size){ + printf( "\nGPU and CPU didn't converse to the same output size:\n"); + printf( "\nGPU output size: %d\n", sg_output_size); + printf( "\nCPU output size: %d\n", sc_output_size); + } else { + printf( "\nOutput size: %d\n", sc_output_size); + } + + + //**** check if the results are equivalent ****// + CUTBoolean res = cutCompareub( sg_output, + sc_output, + sg_output_size); + + + //**** print the results ****// + printf( "Test %s\n", (1 == res) ? "PASSED" : "FAILED"); + printf("CPU GPU\n"); + for ( int i = sc_output_size - 4; i < sc_output_size; i++) { + printf("%X %X\n",sc_output[i], sg_output[i]); + } + + + sg_free(buffer); + //sg_free(sg_output); + cudaFreeHost(sg_output ); + free(sc_output); + +} + +#else /* FEATURE_RUN_OVERLAP_TEST */ + + +/*=========================================================================== + +FUNCTION run_md5_test + +DESCRIPTION + run the test + +DEPENDENCIES + None + +RETURN VALUE + None + +===========================================================================*/ +void run_md5_test( ) { + + //**** Variables ****// + unsigned char *sc_output, *sc_single_output; + unsigned char *sg_output; + unsigned char *buffer; + unsigned int timer; + int sg_output_size; + int sc_output_size; + float host_input_buffer_alloc_time, gpu_init_time; + sg_time_breakdown_type gpu_time_breakdown; + + printf( "MD5 Test\n\n" ); + + //**** create the timer ****// + timer = 0; + CUT_SAFE_CALL( cutCreateTimer( &timer)); + + + //** GPU initialization timing **// + CUT_SAFE_CALL(cutResetTimer(timer)); + CUT_SAFE_CALL(cutStartTimer(timer)); + + /* GPU device initialization */ + sg_init(); + + /* stop the timer */ + CUT_SAFE_CALL(cutStopTimer(timer)); + gpu_init_time = cutGetTimerValue(timer); + + + //**** Host input buffer allocation timing ****// + CUT_SAFE_CALL(cutResetTimer(timer)); + CUT_SAFE_CALL(cutStartTimer(timer)); + + /* allocate test buffer */ + buffer = (unsigned char*) sg_malloc(TEST_MEM_SIZE); + + /* stop the timer */ + CUT_SAFE_CALL(cutStopTimer(timer)); + host_input_buffer_alloc_time = cutGetTimerValue(timer); + + + + //**** initialize test buffer with random data ****// + for( unsigned int i = 0; i < TEST_MEM_SIZE; ++i) { + buffer[i] = i; + } + + + + /***************/ + /***** GPU *****/ + /***************/ + + + //** MD5 timing **// + CUT_SAFE_CALL(cutResetTimer(timer)); + CUT_SAFE_CALL(cutStartTimer(timer)); + + /* run GPU version */ + sg_md5(buffer, TEST_MEM_SIZE, &sg_output, &sg_output_size, + &gpu_time_breakdown); + + /* stop the timer */ + CUT_SAFE_CALL(cutStopTimer(timer)); + print_gpu_time_breakdown( &gpu_time_breakdown, + host_input_buffer_alloc_time, + gpu_init_time ); + printf( "GPU Proc. Time (gpu init and input alloc are not included): %f \n", + cutGetTimerValue(timer)); + + + /***************/ + /***** CPU *****/ + /***************/ + //**** start timer for cpu ****// + CUT_SAFE_CALL( cutResetTimer( timer ) ); + CUT_SAFE_CALL( cutStartTimer( timer ) ); + + //**** run CPU version ****// + sc_md5(buffer, TEST_MEM_SIZE, &sc_output, &sc_output_size); + + //**** stop the timer ****// + CUT_SAFE_CALL( cutStopTimer( timer)); + printf( "CPU Processing time(ms): %f \n", cutGetTimerValue( timer)); + + /*****************************/ + /***** CPU Single Thread *****/ + /*****************************/ + //**** start timer for single thread cpu ****// + CUT_SAFE_CALL( cutResetTimer( timer ) ); + CUT_SAFE_CALL( cutStartTimer( timer ) ); + + //**** run Single Thread CPU version ****// + sc_md5_standard(buffer, TEST_MEM_SIZE, &sc_single_output); + + //**** stop the timer ****// + CUT_SAFE_CALL( cutStopTimer( timer)); + printf( "CPU Single Thread Processing time(ms): %f \n", + cutGetTimerValue( timer)); + + + if(sc_output_size != sg_output_size){ + printf( "\nGPU and CPU didn't converse to the same output size:\n"); + printf( "\nGPU output size: %d\n", sg_output_size); + printf( "\nCPU output size: %d\n", sc_output_size); + } else { + printf( "\nOutput size: %d\n", sc_output_size); + } + + + //**** check if the results are equivalent ****// + CUTBoolean res = cutCompareub( sg_output, + sc_output, + sg_output_size); + + + //**** print the results ****// + printf( "Test %s\n", (1 == res) ? "PASSED" : "FAILED"); + printf("CPU GPU\n"); + for ( int i = sc_output_size - 4; i < sc_output_size; i++) { + printf("%X %X\n",sc_output[i], sg_output[i]); + } + + + + sg_free(buffer); + free(sg_output); /* We dont need to free this using sg_free, it will always be + allocated using malloc. will try to come up with a + cleaner way to make things more clear. */ + free(sc_output); + +} + +/*=========================================================================== + +FUNCTION run_sha1_test + +DESCRIPTION + run the sha1 test + +DEPENDENCIES + None + +RETURN VALUE + None + +===========================================================================*/ +void run_sha1_test( ) { + + //**** Variables ****// + unsigned char *sc_output, *sc_single_output; + unsigned char *sg_output; + unsigned char *buffer; + unsigned int timer; + int sg_output_size; + int sc_output_size; + float host_input_buffer_alloc_time, gpu_init_time; + sg_time_breakdown_type gpu_time_breakdown; + + printf( "SHA1 Test\n\n" ); + + //**** create the timer ****// + timer = 0; + CUT_SAFE_CALL( cutCreateTimer( &timer)); + + //** GPU initialization timing **// + CUT_SAFE_CALL(cutResetTimer(timer)); + CUT_SAFE_CALL(cutStartTimer(timer)); + + /* GPU device initialization */ + sg_init(); + + /* stop the timer */ + CUT_SAFE_CALL(cutStopTimer(timer)); + gpu_init_time = cutGetTimerValue(timer); + + + //**** Host input buffer allocation timing ****// + CUT_SAFE_CALL(cutResetTimer(timer)); + CUT_SAFE_CALL(cutStartTimer(timer)); + + /* allocate test buffer */ + buffer = (unsigned char*) sg_malloc(TEST_MEM_SIZE); + + /* stop the timer */ + CUT_SAFE_CALL(cutStopTimer(timer)); + host_input_buffer_alloc_time = cutGetTimerValue(timer); + + + + //**** initialize test buffer with random data ****// + for( unsigned int i = 0; i < TEST_MEM_SIZE; ++i) { + buffer[i] = i; + } + + + + /***************/ + /***** GPU *****/ + /***************/ + + + //** SHA1 timing **// + CUT_SAFE_CALL(cutResetTimer(timer)); + CUT_SAFE_CALL(cutStartTimer(timer)); + + /* run GPU version */ + sg_sha1(buffer, TEST_MEM_SIZE, &sg_output, &sg_output_size, + &gpu_time_breakdown); + + /* stop the timer */ + CUT_SAFE_CALL(cutStopTimer(timer)); + print_gpu_time_breakdown( &gpu_time_breakdown, + host_input_buffer_alloc_time, + gpu_init_time ); + printf( "GPU Proc. Time (gpu init and input alloc are not included): %f \n", + cutGetTimerValue(timer)); + + + /***************/ + /***** CPU *****/ + /***************/ + //**** start timer for cpu ****// + CUT_SAFE_CALL( cutResetTimer( timer ) ); + CUT_SAFE_CALL( cutStartTimer( timer ) ); + + //**** run CPU version ****// + sc_sha1(buffer, TEST_MEM_SIZE, &sc_output, &sc_output_size); + + //**** stop the timer ****// + CUT_SAFE_CALL( cutStopTimer( timer)); + printf( "CPU Processing time(ms): %f \n", cutGetTimerValue( timer)); + + /*****************************/ + /***** CPU Single Thread *****/ + /*****************************/ + //**** start timer for single thread cpu ****// + CUT_SAFE_CALL( cutResetTimer( timer ) ); + CUT_SAFE_CALL( cutStartTimer( timer ) ); + + //**** run Single Thread CPU version ****// + sc_sha1_standard(buffer, TEST_MEM_SIZE, &sc_single_output); + + //**** stop the timer ****// + CUT_SAFE_CALL( cutStopTimer( timer)); + printf( "CPU Single Thread Processing time(ms): %f \n", + cutGetTimerValue( timer)); + + + if(sc_output_size != sg_output_size){ + printf( "\nGPU and CPU didn't converse to the same output size:\n"); + printf( "\nGPU output size: %d\n", sg_output_size); + printf( "\nCPU output size: %d\n", sc_output_size); + } else { + printf( "\nOutput size: %d\n", sc_output_size); + } + + + //**** check if the results are equivalent ****// + CUTBoolean res = cutCompareub( sg_output, + sc_output, + sg_output_size); + + + //**** print the results ****// + printf( "Test %s\n", (1 == res) ? "PASSED" : "FAILED"); + printf("CPU GPU\n"); + for ( int i = sc_output_size - 4; i < sc_output_size; i++) { + printf("%X %X\n",sc_output[i], sg_output[i]); + } + + + + sg_free(buffer); + free(sg_output); /* We dont need to free this using sg_free, it will always be + allocated using malloc. will try to come up with a + cleaner way to make things more clear. */ + free(sc_output); + +} +/* void run_sha1_test( ) { */ + +/* //\**** Variables ****\// */ +/* unsigned int timer = 0; */ +/* unsigned char* buffer; */ +/* unsigned char* sg_output; */ +/* int sg_output_size; */ +/* unsigned char *sc_output, *sc_single_output; */ +/* int sc_output_size; */ + + +/* printf( "SHA1 Test\n\n" ); */ + + +/* //\**** host memory management ****\// */ +/* // allocate test buffer */ +/* buffer = (unsigned char*) sg_malloc(TEST_MEM_SIZE); */ + + +/* //\**** initialize test buffer with random data ****\// */ +/* for( unsigned int i = 0; i < TEST_MEM_SIZE; ++i) { */ +/* buffer[i] = i; */ +/* } */ + +/* //\**** create the timer ****\// */ +/* timer = 0; */ +/* CUT_SAFE_CALL( cutCreateTimer( &timer)); */ + + +/* /\***************\/ */ +/* /\***** GPU *****\/ */ +/* /\***************\/ */ +/* //\**** start timer for GPU timing ****\// */ +/* CUT_SAFE_CALL( cutResetTimer(timer) ); */ +/* CUT_SAFE_CALL( cutStartTimer( timer)); */ + + +/* //\**** run GPU version ****\// */ +/* sg_sha1(buffer, TEST_MEM_SIZE, &sg_output, &sg_output_size); */ + + +/* //\**** stop the timer ****\// */ +/* CUT_SAFE_CALL( cutStopTimer( timer)); */ + + +/* //\**** print results ****\// */ +/* printf( "GPU Processing time(ms): %f \n", cutGetTimerValue( timer)); */ + + +/* /\***************\/ */ +/* /\***** CPU *****\/ */ +/* /\***************\/ */ +/* //\**** start timer for cpu ****\// */ +/* CUT_SAFE_CALL( cutResetTimer( timer ) ); */ +/* CUT_SAFE_CALL( cutStartTimer( timer ) ); */ + + +/* //\**** run CPU version ****\// */ +/* sc_sha1(buffer, TEST_MEM_SIZE, &sc_output, &sc_output_size); */ + + +/* //\**** stop the timer ****\// */ +/* CUT_SAFE_CALL( cutStopTimer( timer)); */ +/* printf( "CPU Processing time(ms): %f \n", cutGetTimerValue( timer)); */ + + +/* /\*****************************\/ */ +/* /\***** CPU Single Thread *****\/ */ +/* /\*****************************\/ */ +/* //\**** start timer for single thread cpu ****\// */ +/* CUT_SAFE_CALL( cutResetTimer( timer ) ); */ +/* CUT_SAFE_CALL( cutStartTimer( timer ) ); */ + +/* //\**** run CPU version ****\// */ +/* sc_sha1_standard(buffer, TEST_MEM_SIZE, &sc_single_output); */ + +/* //\**** stop the timer ****\// */ +/* CUT_SAFE_CALL( cutStopTimer( timer)); */ +/* printf( "CPU Single Thread Processing time(ms): %f \n", */ +/* cutGetTimerValue( timer)); */ + + +/* if(sc_output_size != sg_output_size){ */ +/* printf( "\nGPU and CPU didn't converse to the same output size:\n"); */ +/* printf( "\nGPU output size: %d\n", sg_output_size); */ +/* printf( "\nCPU output size: %d\n", sc_output_size); */ +/* } else { */ +/* printf( "\nOutput size: %d\n", sc_output_size); */ +/* } */ + + +/* //\**** check if the results are equivalent ****\// */ +/* CUTBoolean res = cutCompareub( sg_output, */ +/* sc_output, */ +/* sg_output_size); */ + + +/* //\**** print the results ****\// */ +/* printf( "Test %s\n", (1 == res) ? "PASSED" : "FAILED"); */ +/* printf("CPU GPU\n"); */ +/* for ( int i = sc_output_size - 4; i < sc_output_size; i++) { */ +/* printf("%X %X\n",sc_output[i], sg_output[i]); */ +/* } */ + + +/* sg_free(buffer); */ +/* free(sg_output); /\* We dont need to free this using sg_free, it will always be */ +/* allocated using malloc. I will try to come up with a */ +/* cleaner way to make things more clear. *\/ */ +/* free(sc_output); */ + +/* } */ +#endif /* FEATURE_RUN_OVERLAP_TEST */ + + + +/*-------------------------------------------------------------------------- + GLOBAL FUNCTIONS +--------------------------------------------------------------------------*/ +/*=========================================================================== + +FUNCTION main + +DESCRIPTION + main entry of the program + +DEPENDENCIES + None + +RETURN VALUE + None + +===========================================================================*/ +int main( int argc, char** argv) { + +#ifdef FEATURE_SHARED_MEMORY + printf("Shared Memory Enabled\n"); +#endif + + +#ifdef FEATURE_PINNED_MODE + printf("Pinned Memory Enabled\n"); +#endif + + +#ifdef FEATURE_REDUCED_HASH_SIZE + printf("Reduced Hash Size Enabled\n"); +#endif + +#ifdef FEATURE_RUN_OVERLAP_TEST +#ifdef FEATURE_RUN_SHA1 + printf("Running SHA1 Overlap Test..\n"); + run_sha1_overlap_test( ); +#else + printf("Running MD5 Overlap Test..\n"); + run_md5_overlap_test( ); +#endif // FEATURE_RUN_SHA1 +#else +#ifdef FEATURE_RUN_SHA1 + printf("Running SHA1 Non-Overlap Test..\n"); + run_sha1_test( ); +#else + printf("Running MD5 Non-Overlap Test..\n"); + run_md5_test( ); +#endif // FEATURE_RUN_SHA1 +#endif // FEATURE_RUN_OVERLAP_TEST + +} + -- cgit v1.3