src32/0000755005635700000120000000000010332235647011360 5ustar weathnrwheelsrc32/Makefile0000644005635700000120000000363110332202353013007 0ustar weathnrwheel# Makefile for matrix_test #CC=gcc -Wall -mtune=k8 -g -std=gnu99 CC=gcc -Wall -mcpu=pentium3 -march=pentium3 -O2 -std=gnu99 CFLAGS=-lgsl -lgslcblas -lm -lpthread STATIC=-static EEE=matrix_test EEE_STATIC=matrix_test.static matrix_test.static: matrix_test.o transpose.o lu_decomp.o test_utils.o gsl_sort.o memcpy_test.o link_list_test.o get_mem_avail.o ${CC} -O2 ${STATIC} -o ${EEE_STATIC} matrix_test.o transpose.o lu_decomp.o test_utils.o gsl_sort.o memcpy_test.o link_list_test.o get_mem_avail.o ${CFLAGS} make all all: matrix_test.o transpose.o lu_decomp.o test_utils.o gsl_sort.o memcpy_test.o link_list_test.o get_mem_avail.o ${CC} -O2 ${CFLAGS} -o ${EEE} matrix_test.o transpose.o lu_decomp.o test_utils.o gsl_sort.o memcpy_test.o link_list_test.o get_mem_avail.o transpose.o: transpose.h matrix_test.h lu_decomp.h defines.h transpose.c test_utils.h ${CC} -O2 -o transpose.o -c transpose.c lu_decomp.o: lu_decomp.c lu_decomp.h defines.h matrix_test.h test_utils.h ${CC} -O2 -o lu_decomp.o -c lu_decomp.c gsl_sort.o: gsl_source.c gsl_sort.h matrix_test.h test_utils.h ${CC} -O2 -o gsl_sort.o -c gsl_source.c matrix_test.o: matrix_test.c matrix_test.h lu_decomp.h defines.h transpose.h ${CC} -D_DEFINE_32BIT -O2 -o matrix_test.o -c matrix_test.c test_utils.o: defines.h test_utils.h test_utils.c ${CC} -O2 -o test_utils.o -c test_utils.c memcpy_test.o: memcpy_test.h memcpy_test.c ${CC} -O2 -o memcpy_test.o -c memcpy_test.c link_list_test.o: link_list_test.c link_list_test.h test_utils.h matrix_test.h ${CC} -O2 -o link_list_test.o -c link_list_test.c get_mem_avail.o: get_mem_avail.c get_mem_avail.h echo "Creating get_mem_avail.o" ${CC} -O2 -o get_mem_avail.o -c get_mem_avail.c copy: echo "Copying in new src files" cp ../src/*.[ch] . rm -f *.o matrix_test matrix_test.static clean: echo "Cleaning directory, but not copying updated files" rm -f *.o matrix_test matrix_test.static matrix_test.static.* src32/defines.h0000644005635700000120000000413510332224654013145 0ustar weathnrwheel /*************************************************************************** * Copyright (C) 2005 by Norman Weathers 639-2727 ,LO-2003 * * weathnr@hoprlw10 * * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU General Public License as published by * * the Free Software Foundation; either version 2 of the License, or * * (at your option) any later version. * * * * This program is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * * GNU General Public License for more details. * * * * You should have received a copy of the GNU General Public License * * along with this program; if not, write to the * * Free Software Foundation, Inc., * * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * ***************************************************************************/ // DEFINES.H #ifndef _DEFINES_H #define _DEFINES_H // Global includes #include #include #include #include #include #include #include #include #include #include #include #include #include // Defines for Transpose #define DEFAULT_TRANSPOSE_SIZE 10000 // Defines for LU_Decomp #define DELTA 0.00001 #define DEFAULT_MATRIX_LU 7500 // Defines for sort job #define DEFAULT_SORT_ELEMENTS 99999999 // Defines for walking Array test #define DEFAULT_ARRAY_MEM_SIZE 900 #define MAXIMUM_ARRAY_LOOPS 10000 #define MAXIMUM_ARRAY_SECONDS 1200 #define LOCAL_ARRAY_LOOP 30 #endifsrc32/get_mem_avail.c0000644005635700000120000001156610332224654014322 0ustar weathnrwheel// Getting the amount of memory available in a system... #include "get_mem_avail.h" #include "link_list_test.h" long long int available_mem() { FILE * pr_mem; int mem_avail=0; int MULT_FACT = 1; long long int TOTAL_MEM=0; int str_len=0; short FLAG=1; char mem_mult[5]; char buff[BUFF_SIZE]; char * scan_format = "MemTotal: %d %s"; pr_mem = fopen("/proc/meminfo", "r"); if (pr_mem == NULL) { printf("ERROR!!! Failure to open /proc/meminfo\n"); printf("FATAL ERROR!!!\n"); printf("Exitting....\n\n"); exit(EXIT_FAILURE); } while (FLAG) { fgets(buff, BUFF_SIZE, pr_mem); str_len = strlen(buff); // Remove the newline buff[str_len-1] = '\0'; if (strstr(buff, "MemTotal:") != NULL) { //printf("Memtotal FOUND\n"); //printf("%s\n", buff); str_len = strlen(buff); //printf("STRING LENGTH NOW: %d\n", str_len); fflush(NULL); sscanf(buff, scan_format, &mem_avail, &mem_mult); /* if (strstr(mem_mult, KB_STR) != NULL) { MULT_FACT = KB_MULT_FACT; } else { MULT_FACT = MB_MULT_FACT; } */ MULT_FACT = KB_MULT_FACT; TOTAL_MEM =(long long int) mem_avail *(long long int) MULT_FACT; /* printf("Total bytes available is: %lld bytes\n",TOTAL_MEM); printf("MULT_FACT is: %d\n", MULT_FACT); //printf("Found our memory to be: %d %s\n", mem_avail, mem_mult); */ FLAG=0; } } //printf("Got first string from /proc/meminfo: %s\n", buff); if (TOTAL_MEM == 0) { return(-1); } else { return(TOTAL_MEM); } } void determine_sizes(struct memory_sizes_struct * mem_sizes, int per_mem, long long int MB_mem) { // Determine the amount of things we need // Matrix Transpose = (MB * %) / 2 // LU Decomp Total size Matrix = (MB * %) / 7 // GSL Sort Size = (MB * %) / 2.5 // Memcpy = (TOTAL_BYTES * %) / sizeof(memcpy test size struct) // Link List = (TOTAL_BYTES * %)/ sizeof(link list struct) // // Determine the basic case for our needs... // Default percentage is 95 % of available ram used for most tests // The difference is with GSL Sort, we use 75%. // First, transpose matrix elements long long int USEABLE = (float)2.3 * 1024; long long int sized_test=0; int FLAG=0; printf("Automatic Size Determination activated...\n"); printf("Total Executable memory is: %lld MB's\n", MB_mem); //printf("Execution type: %d bit binary\n", EXEC_TYPE); if ((EXEC_TYPE != 64) && (MB_mem > USEABLE) ) { printf("\n\nNOTICE!!!\n"); printf("32 bit Executable: Total Memory Greater than %lld MB's\n", USEABLE); printf("Imposing Memory limit of no greater than: %lld MB useable per process during test\n\n", USEABLE); FLAG=1; } fflush(NULL); //printf("Received from MB_MEM --> %lld MB's\n", MB_mem); sized_test = MB_mem * MB_MULT_FACT * per_mem / 100; //printf("DIAGNOSTIC: sized_test for transpose is: %lld bytes\n", sized_test); if (FLAG && ((sized_test / MB_MULT_FACT) > USEABLE)) { //printf("Lowering test size for transpose test...\n"); //printf("Total Memory for transpose test was: %lld bytes\n", sized_test); sized_test = USEABLE * MB_MULT_FACT; //printf("Now: %lld bytes\n", sized_test); } sized_test = sqrt(sized_test / sizeof(long long int)); mem_sizes->transpose_size = sized_test; // Number of links in list // Next, link_list test size... sized_test = (MB_mem * per_mem / 100); if (FLAG && (sized_test > USEABLE)) { //printf("Lowering test size for link list test...\n"); //printf("Total Memory for link list test was: %lld MBs\n", sized_test); sized_test = USEABLE; //printf("Now: %lld MBs\n", sized_test); } mem_sizes->link_list_size = sized_test; // Number of elements // Now, lu_decomp elements... sized_test = (MB_mem * MB_MULT_FACT * per_mem / 100); if (FLAG && (sized_test / MB_MULT_FACT > USEABLE)) { //printf("Lowering test size for lu_decomp test...\n"); //printf("Total Memory for lu_decomp test was: %lld bytes\n", sized_test); sized_test = USEABLE * MB_MULT_FACT; //printf("Now: %lld bytes\n", sized_test); } sized_test = sqrt(sized_test / sizeof(long long int) / 4); mem_sizes->lu_decomp_size = sized_test; // Number of elements in matrix sized_test = (MB_mem * per_mem / 100); if (FLAG && (sized_test > USEABLE)) { sized_test = USEABLE; } mem_sizes->memcpy_size = sized_test; // GSL Sort... 8 bytes per entry in allocation sized_test = (MB_mem * per_mem / 100); if (FLAG && (sized_test > USEABLE)) { //printf("Lowering test size for GSL Sort test...\n"); //printf("Total Memory for GSL Sort test was: %lld MBs\n", sized_test); sized_test = USEABLE; //printf("Now: %lld MBs\n", sized_test); } sized_test *= 1024 * 1024; sized_test /= 10; // Give a little extra padding mem_sizes->gsl_sort_size = sized_test; } src32/get_mem_avail.h0000644005635700000120000000145610332224654014324 0ustar weathnrwheel /* get_mem_avail.c is used to get the amount of available memory available on the system */ #ifndef _GET_MEM_AVAIL_H #define _GET_MEM_AVAIL_H #include #include #include #include #include #define BUFF_SIZE 1024 #define KB_MULT_FACT 1024 #define MB_MULT_FACT 1024*1024 #define KB_STR "kb" #define DEFAULT_PERCENT 95 extern int EXEC_TYPE; struct memory_sizes_struct { long long int lu_decomp_size; long long int transpose_size; long long int gsl_sort_size; long long int memcpy_size; long long int link_list_size; }; long long int available_mem(); // Returns the bytes of mem in the system void determine_sizes(struct memory_sizes_struct * mem_sizes, int per_mem, long long int MB_mem); // Determine the sizes for our different tests... #endifsrc32/gsl_sort.h0000644005635700000120000000341110332224654013360 0ustar weathnrwheel/*************************************************************************** * Copyright (C) 2005 by Norman Weathers 639-2727 ,LO-2003 * * weathnr@hoprlw10 * * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU General Public License as published by * * the Free Software Foundation; either version 2 of the License, or * * (at your option) any later version. * * * * This program is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * * GNU General Public License for more details. * * * * You should have received a copy of the GNU General Public License * * along with this program; if not, write to the * * Free Software Foundation, Inc., * * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * ***************************************************************************/ #include #include #include #include #include #include #include #include #include #include #include #include extern int DEBUG; extern int INFO; extern int VERVOSE; void gsl_sort_test(long long num_vector_elements); src32/gsl_source.c0000644005635700000120000001362710332224654013676 0ustar weathnrwheel/*************************************************************************** * Copyright (C) 2005 by Norman Weathers 639-2727 ,LO-2003 * * weathnr@hoprlw10 * * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU General Public License as published by * * the Free Software Foundation; either version 2 of the License, or * * (at your option) any later version. * * * * This program is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * * GNU General Public License for more details. * * * * You should have received a copy of the GNU General Public License * * along with this program; if not, write to the * * Free Software Foundation, Inc., * * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * ***************************************************************************/ #include "gsl_sort.h" #include "defines.h" #include "lu_decomp.h" #include "test_utils.h" //#include "matrix_test.h" /* int main (int argc , char ** argv) { printf("running sort job\n"); gsl_sort_test(50000000); exit(EXIT_SUCCESS); } */ void gsl_sort_test(long long num_vector_elements) { printf("\n\nPreparing to run Sort Job (GSL based)\n"); struct timeval tv_start,tv_after_create, tv_end; struct timeval tv_start_verify; struct timezone tz; time_t time_stamp; gettimeofday(&tv_start, &tz); int FLAG=0; const gsl_rng_type * T; gsl_rng * r; long long num_bytes_total; double MB_total; long long num_elements = DEFAULT_SORT_ELEMENTS; long long counter = 0; long long index = 0; int multiplier = 1; // Check to see if we have some defines if (num_vector_elements > 2 ) { if (DEBUG) { printf("Assigning user defined elements for vector\n"); } num_elements = num_vector_elements; } double mu = (double) tv_start.tv_usec; extern unsigned long int gsl_rng_default_seed; gsl_rng_default_seed = (unsigned long int) tv_start.tv_usec; printf("Mu now: %g\n", mu); printf("Random seed now: %ld\n", gsl_rng_default_seed); num_bytes_total = num_elements * sizeof(long long); MB_total = (double) num_bytes_total / ((double) 1024 * (double) 1024); index = num_elements / 20; printf("Total MB's to be processed --> %10.3f\n", MB_total); printf("(Bytes = %lld)\n", num_bytes_total); printf("Total number of elements: %lld\n", num_elements); // Allocate the gsl vectors that will be the point for our excercise. gsl_vector *x0 = gsl_vector_alloc(num_elements); //gsl_vector *answer0 = gsl_vector_alloc(num_elements); gsl_rng_env_setup(); T = gsl_rng_default; r = gsl_rng_alloc (T); long long i=0; printf("Preparing to create random numbers\n"); printf ("Random Number Generator type: %s\n", gsl_rng_name (r)); fflush(NULL); counter = 0; for (i = 0; i < num_elements; i++) { //x0[i] = gsl_rng_uniform(r); // gsl_vector_set (gsl_vector * v, size_t i, double x) // gsl_vector_set(x0, i, gsl_rng_uniform(r)); gsl_vector_set(x0, i, gsl_ran_poisson_pdf(gsl_ran_poisson(r,mu), mu)); counter++; if (counter == index) { printf("Completed %4d %% of sort set assignment\n", multiplier * 5); multiplier++; counter=0; } } /* printf("Testing our vector assignment...\n"); for (i = 0; i < num_elements; i++) { printf("Vector position [%d] --> %g\n", i, gsl_vector_get(x0, i)); } */ gettimeofday(&tv_after_create, &tz); printf("Sorting vector...\n"); fflush(NULL); gsl_sort_vector(x0); //printf("Vector sorted... Output follows\n"); printf("Finished sorting vector...\n"); /* for (i = 0; i < num_elements; i++) { printf("Vector position [%d] --> %g\n", i, gsl_vector_get(x0,i)); } */ /* Function: void gsl_sort_vector (gsl_vector * v) This function sorts the elements of the vector v into ascending numerical order. */ // Time to verify sort... We check each element one at a time until we // are sure that we have everything in the correct order. This is a // very subjective test. printf("Running simplistic verify on sorted vector\n"); gettimeofday(&tv_start_verify, &tz); fflush(NULL); for (i = 0; i < num_elements - 1; i++) { if (gsl_vector_get(x0,i) > gsl_vector_get(x0, i+1)) { FLAG += 1; } } gsl_vector_free(x0); gsl_rng_free(r); gettimeofday(&tv_end, &tz); time(&time_stamp); char * str_ptr_orig = ctime(&time_stamp); printf("\n\n---------------------------------------------------------------\n"); printf("Sort job statistics\n"); printf("Total Time: %14.9f\n", convert_time_difference(tv_start, tv_end)); printf("Time for Create: %14.9f\n", convert_time_difference(tv_start, tv_after_create)); printf("Time for Sort: %14.9f\n", convert_time_difference(tv_after_create, tv_start_verify)); printf("Time for verify: %14.9f\n", convert_time_difference(tv_start_verify, tv_end)); printf("\nSORT TEST: "); if (FLAG) { printf("Run FAILED with %d Failures TIMESTAMP: %s\n", FLAG, str_ptr_orig); } else { printf("Run SUCCEEDED. TIMESTAMP: %s\n", str_ptr_orig); } printf("---------------------------------------------------------------\n"); }src32/link_list_test.c0000644005635700000120000004556610332224654014567 0ustar weathnrwheel/*************************************************************************** * Copyright (C) 2005 by Norman Weathers 639-2727 ,LO-2003 * * weathnr@hoprlw10 * * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU General Public License as published by * * the Free Software Foundation; either version 2 of the License, or * * (at your option) any later version. * * * * This program is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * * GNU General Public License for more details. * * * * You should have received a copy of the GNU General Public License * * along with this program; if not, write to the * * Free Software Foundation, Inc., * * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * ***************************************************************************/ #include "defines.h" #include "link_list_test.h" #include "test_utils.h" #include #include #include void link_list_test (int test_size_MB) { printf("-----------------------------LINK LIST TEST---------------------------\n"); printf("\n"); printf("Starting link list test -- Discontiguous memory testing\n\n"); long long int total_bytes = 0; long long int local_counter = 0; long long int MAX_NUM_LINKS = 0; long long int CURRENT_NUM_LINKS = 0, LINKS=0; long long int TMP_NUM_LINKS = 0; long long int DELTA_LINKS = 0; long long int CURRENT_BYTES=0; long long int TOTAL_NUMBER_ELEMENTS=0; long long int rand_num=0; long long int TOTAL_OPERATIONS = 0; double TOTAL_MBS_OPERATED = (double)test_size_MB / 2; double MBS_TOTAL = (double)test_size_MB / 2.0 * SCAN_LOOP_MAX; double TMP_MBS = 0; long int last = 0; int loops = 0; //time_t curr_time, end_time; time_t tmp_time; int curr_time = -1, end_time = 0; struct timeval tv_start, tv_middle, tv_end; struct timezone tz; struct test_case_struct test_case_data; struct link_list * link_list_test; link_list_test = NULL; MAX_NUM_LINKS = (long long int)test_size_MB * 1024 * 1024 / sizeof(test_case_data); total_bytes = (long long int)test_size_MB * (long long int)1024 * (long long int)1024; CURRENT_NUM_LINKS = MAX_NUM_LINKS / 2; if (VERBOSE||DEBUG||INFO) { printf("VERBOSE -- Test Size: %d MB's\n", test_size_MB); printf("VERBOSE -- MAXIMUM_NUM_LINKS: %lld\n", MAX_NUM_LINKS); printf("VERBOSE -- Total bytes: %lld\n", total_bytes); printf("VERBOSE -- CURRENT_NUM_LINKS: %lld\n", CURRENT_NUM_LINKS); } else { // Print out some general info for the user printf("Largest Test Size: %d MB's\n", test_size_MB); printf("Initial Test Size: %d MB's\n", test_size_MB / 2); } memset(&test_case_data.buff, 1 , BUFF_SIZE); test_case_data.buff[BUFF_SIZE - 1] = '\0'; test_case_data.index = 1; test_case_data.dbl_index = test_case_data.index * LINK_MULT_FACT; if (DEBUG) { printf("DEBUG -- String length for our buffer fill is: %d\n", strlen(test_case_data.buff)); printf("DEBUG -- Total string buffer space: %d\n", strlen(test_case_data.buff) + 1); printf("DEBUG -- Size of test_case_data is: %d\n", (int)sizeof(test_case_data)); } gettimeofday(&tv_start, &tz); curr_time = tv_start.tv_sec; end_time = curr_time + MAX_TIME_SECS; last = (long int) tv_start.tv_sec; srandom((int)tv_start.tv_usec); if(VERBOSE||INFO) { printf("V/I -- Creating first linked list set \n"); } fflush(NULL); while (LINKS < CURRENT_NUM_LINKS) { link_list_test = add_element(link_list_test, test_case_data); test_case_data.index++; test_case_data.dbl_index = test_case_data.index * LINK_MULT_FACT; LINKS++; } TOTAL_OPERATIONS += CURRENT_NUM_LINKS * 10; if(VERBOSE||INFO) { printf("V/I -- Finished creating first linked list set\n"); } long long int FAILED_SCANS=0; fflush(NULL); TOTAL_NUMBER_ELEMENTS = CURRENT_NUM_LINKS; /* printf("DEBUG -- REMOVE ME: curr_time -> %d\n", curr_time); printf("DEBUG -- REMOVE ME: end_time -> %d\n", end_time); */ fflush(NULL); while (loops < MAX_LOOPS && curr_time < end_time && !FAILED_SCANS) { // Run through the loop until either out of time or // out of loops LINKS=0; int loop_tmp=0; if (VERBOSE) { printf("VERBOSE -- Running scan_all_elements test\n"); fflush(NULL); } for (loop_tmp = 0; loop_tmp < SCAN_LOOP_MAX; loop_tmp++) { FAILED_SCANS = scan_all_elements(link_list_test); // Run actual test } // Now, we need to reset the number of LINKS TOTAL_OPERATIONS += CURRENT_NUM_LINKS * SCAN_LOOP_MAX; if (DEBUG) { printf("DEBUG -- Changing number of links\n"); } rand_num = (long long int)random() + MAX_NUM_LINKS; TMP_NUM_LINKS = rand_num % MAX_NUM_LINKS; if ((double)TMP_NUM_LINKS * 0.05 + CURRENT_NUM_LINKS >= MAX_NUM_LINKS) TMP_NUM_LINKS = MAX_NUM_LINKS / 2; // Safety net if (DEBUG) { printf("DVI -- TMP_NUM_LINKS = %lld\n", TMP_NUM_LINKS); } DELTA_LINKS = TMP_NUM_LINKS - CURRENT_NUM_LINKS; if (DELTA_LINKS == -MAX_NUM_LINKS) DELTA_LINKS = DELTA_LINKS / 2; if (llabs(DELTA_LINKS) >= CURRENT_NUM_LINKS && DELTA_LINKS < 0) DELTA_LINKS = DELTA_LINKS / 5; // Now, we figure out which way we need to go... if (DEBUG||VERBOSE||INFO) { printf("DVI -- LINK LIST DELTA = %lld\n", DELTA_LINKS); } fflush(NULL); if (DELTA_LINKS < 0) { // Need to remove some links long long int tmp=0; for(tmp=0; tmp < llabs(DELTA_LINKS);tmp++) { link_list_test = del_element(link_list_test); } long long int tmp2 = count_elements(link_list_test); // Determine the MB's we will work with this time around double MB_work = sizeof(struct link_list) * (double)tmp2 / (1024.0 * 1024.0) * SCAN_LOOP_MAX; //printf("DEBUG -- (SUB) MB Work this time = %g\n", MB_work); TMP_MBS = MB_work; TOTAL_OPERATIONS += 3 * llabs(DELTA_LINKS); if (VERBOSE||INFO) { printf("V/I -- After reduction, number of elements now: %lld\n", tmp2); } test_case_data.index = 1; test_case_data.dbl_index = test_case_data.index * LINK_MULT_FACT; for (tmp = 0; tmp < tmp2; tmp++) { edit_element(link_list_test, tmp); } TOTAL_OPERATIONS += tmp2; } else if (DELTA_LINKS > 0) { // Need to add some links long long tmp = 0; long long current_num = count_elements(link_list_test); test_case_data.index = current_num + 1; for(tmp = 0; tmp < DELTA_LINKS;tmp++) { test_case_data.dbl_index = (double)test_case_data.index * LINK_MULT_FACT; link_list_test = add_element(link_list_test, test_case_data); test_case_data.index++; } TOTAL_OPERATIONS += DELTA_LINKS * 10; long long int tmp2 = count_elements(link_list_test); // Determine the MB's we will work with this time around double MB_work = sizeof(struct link_list) * (double)tmp2 / (1024.0 * 1024.0) * SCAN_LOOP_MAX; //printf("DEBUG -- (ADD) MB Work this time = %g\n", MB_work); TMP_MBS = MB_work; if (VERBOSE||INFO) { printf("V/I -- After increase, number of elements now: %lld\n", count_elements(link_list_test)); } } else { printf("INFORMATION -- No change in test size during this loop\n"); long long int tmp2 = count_elements(link_list_test); // Determine the MB's we will work with this time around double MB_work = sizeof(struct link_list) * (double)tmp2 / (1024.0 * 1024.0) * SCAN_LOOP_MAX; //printf("DEBUG -- (NO_CHANGE) MB Work this time = %g\n", MB_work); TMP_MBS = MB_work; } CURRENT_NUM_LINKS = count_elements(link_list_test); loops++; gettimeofday(&tv_middle, &tz); if((long int)tv_middle.tv_sec - last > 20) { /* printf("Completed: %d loops in %ld seconds\n", loops - 1, (long int)tv_middle.tv_sec - (long int)tv_start.tv_sec); printf("Total number links operated on: %lld\n", TOTAL_NUMBER_ELEMENTS); */ printf("STATUS(DMT): Loops: %4d Interval: %4ld seconds Total Links: %10lld FOPS: %12lld\n", loops - 1, (long int)tv_middle.tv_sec - (long int)tv_start.tv_sec, TOTAL_NUMBER_ELEMENTS, TOTAL_OPERATIONS); last = (long int)tv_middle.tv_sec; fflush(NULL); } TOTAL_NUMBER_ELEMENTS += CURRENT_NUM_LINKS; //gettimeofday(&tv_start, &tz); time(&tmp_time); curr_time = tmp_time; fflush(NULL); MBS_TOTAL += TMP_MBS; } fflush(NULL); // Number of total loops is loops + 1, so go ahead and change it now loops++; TOTAL_NUMBER_ELEMENTS -= CURRENT_NUM_LINKS; // Remove the elements // that we didn't operate on... // Remove the last MBS, as we really didn't do any work with it... MBS_TOTAL -= TMP_MBS / 2.0; // Don't take away all... Not fair // when you consider that we time the creation // of the nodes and we may not get to use them. /* link_list_test = add_element(link_list_test, test_case_data); if (link_list_test == NULL) { printf("ERROR... Didn't return what we wanted to from our add_element\n"); exit(EXIT_FAILURE); } printf("Our link_list_test now has %d elements\n", count_elements(link_list_test)); test_case_data.index = 2; test_case_data.dbl_index = test_case_data.index * LINK_MULT_FACT; link_list_test = add_element(link_list_test, test_case_data); printf("Our link_list_test now has %d elements\n", count_elements(link_list_test)); rmv_all_elements(link_list_test); printf("Our link_list_test has now been emptied\n"); //free(link_list_test); exit(EXIT_SUCCESS); */ if (FAILED_SCANS) { printf("ERROR -- Failed scans during the Link List Test\n"); printf("ERROR -- Total number of Failures: %lld\n", FAILED_SCANS); printf("ERROR -- Total number of loops processed: %d\n", loops); } rmv_all_elements(link_list_test); fflush(NULL); //free(link_list_test); // Don't think I need this, but will try and see gettimeofday(&tv_end, &tz); double time_diff = convert_time_difference(tv_start, tv_end); if(DEBUG) { printf("DVI -- Time Values:\n"); printf("Test started: %ld\n", tv_start.tv_sec); printf("Test Ended: %ld\n", tv_end.tv_sec); printf("LOOPS: %d\n", loops); printf("TIME_DIFF: %g\n", time_diff); } printf("\n\nDMT Totals: \n"); printf("Loops: %d\n", loops); printf("Time: %16.8g seconds\n", time_diff); printf("Elements: %lld\n", TOTAL_NUMBER_ELEMENTS); printf("Total MB's: %16.8g MB's\n", MBS_TOTAL); //printf("Operations: %lld\n\n", TOTAL_OPERATIONS); /* The final output will be calculated by using the following # LOOPS / SECS * TOTAL_ELEMENTS Operated On * (Total Operations) TOTAL_OPERATIONS * TOTAL_NUM_ELEMENTS / SEC */ printf("FINAL SCORE: %16.4f\n", MBS_TOTAL / (double)TOTAL_NUMBER_ELEMENTS / time_diff * (double)TOTAL_OPERATIONS); //printf("****Final score calculated as Total Elements * Link List Element Size / time****\n"); printf("WARNING-- Ignore the scores as they don't tell us much of anything for now!\n"); // Ready to return back to the main program... printf("----------------------------------------------------------------------\n\n"); fflush(NULL); } struct link_list * add_element(struct link_list * list_ptr, struct test_case_struct test_case_data) { struct link_list * ptr = list_ptr; if (list_ptr != NULL) { while (list_ptr->next != NULL) list_ptr = list_ptr->next; // Found our last link, add in our next item list_ptr->next = (struct link_list *) malloc(sizeof(struct link_list)); if (list_ptr->next == NULL) { printf("ERROR!!! Error during malloc in add_element call\n"); printf("ERROR!!! This is a FATAL ERROR! Exitting...\n"); exit(EXIT_FAILURE); } list_ptr = list_ptr->next; // Move up to last link in chain list_ptr->next = NULL; // NULL terminate the chain list_ptr->index = test_case_data.index; // Assign the index list_ptr->dbl_index = test_case_data.index * LINK_MULT_FACT; // Assign dbl index // Copy in the string buffer to make things really FAT... memcpy(list_ptr->str_buff, test_case_data.buff, BUFF_SIZE); if (DEBUG) { printf("DEBUG -- IN add_element: strlen of buff is: %d\n", (int)strlen(list_ptr->str_buff)); } /* printf("Finished in add_element adding new link\n"); printf("Link index is: %lld\n", list_ptr->index); printf("Link dbl_index is: %g\n", list_ptr->dbl_index); printf("Str len of string is: %d\n", strlen(list_ptr->str_buff)); */ return(ptr); } else { list_ptr = (struct link_list *) malloc(sizeof(struct link_list)); list_ptr->next = NULL; list_ptr->index = test_case_data.index; // Assign the index list_ptr->dbl_index = test_case_data.index * LINK_MULT_FACT; // Assign dbl index // Copy in the string buffer to make things really FAT... memcpy(list_ptr->str_buff, test_case_data.buff, BUFF_SIZE); /* printf("Finished in add_element adding new link\n"); printf("Link index is: %lld\n", list_ptr->index); printf("Link dbl_index is: %g\n", list_ptr->dbl_index); printf("Str len of string is: %d\n", strlen(list_ptr->str_buff)); */ return(list_ptr); } } struct link_list * del_element(struct link_list * list_ptr) { struct link_list * tmp_ptr = NULL; tmp_ptr = list_ptr->next; // Point to next link in list free(list_ptr); // Get rid of current link if (DEBUG) { printf("DEBUG -- Just removed one element in del_element call\n"); printf("DEBUG -- Current link count: %lld\n", count_elements(tmp_ptr)); } return(tmp_ptr); // Return next link; } struct link_list * rmv_all_elements(struct link_list * list_ptr) { long long int counter=0; while (list_ptr != NULL){ list_ptr = del_element(list_ptr); counter++; } printf("Removed: %lld elements from link list set\n", counter); return(list_ptr); } void debug_print(struct link_list * list_ptr, long long int index) { struct link_list * tmp_ptr = list_ptr; short PRINT_ALL_FLAG = 0; if (index < 0) { printf("Printing all elements\n"); PRINT_ALL_FLAG = 1; } else { printf("Printing @ index: %lld\n", index); } if (PRINT_ALL_FLAG) { while (tmp_ptr != NULL) { printf("@ INDEX: %lld\n", tmp_ptr->index); printf("DBL INDEX: %g\n", tmp_ptr->dbl_index); printf("LONG STRING:\n%s\n", tmp_ptr->str_buff); tmp_ptr = tmp_ptr->next; } } else { if (index < count_elements(list_ptr)) { while(tmp_ptr->index != index && tmp_ptr->index < index) tmp_ptr=tmp_ptr->next; if (tmp_ptr->index == index) { printf("@INDEX: %lld\n", tmp_ptr->index); printf("DBL INDEX: %g\n", tmp_ptr->dbl_index); printf("LONG STRING: \n%s\n", tmp_ptr->str_buff); } else { printf("Index: %lld not found in link list\n", index); } } else { printf("Index: %lld greater than last index\n", index); } } } long long int count_elements(struct link_list * list_ptr) { long long int list_counter=0; while (list_ptr != NULL) { list_ptr = list_ptr->next; list_counter++; } return(list_counter); } long long int scan_all_elements(struct link_list * list_ptr) { struct link_list * tmp_ptr = list_ptr; long long int num_elements = count_elements(list_ptr); long long int loop_ctr = 0; long long int FAILURES = 0; struct test_case_struct test_case_data; test_case_data.index = 1; test_case_data.dbl_index = 1 * LINK_MULT_FACT; // test_case_data.buff memset(&test_case_data.buff, 1 , BUFF_SIZE); test_case_data.buff[BUFF_SIZE - 1] = '\0'; for(loop_ctr=0; loop_ctr < num_elements; loop_ctr++) { if (test_case_data.index != tmp_ptr->index || test_case_data.dbl_index != tmp_ptr->dbl_index || memcmp(tmp_ptr->str_buff, test_case_data.buff, BUFF_SIZE) != 0) { FAILURES++; if (DEBUG) { printf("DEBUG -- FAILURE IN SCAN_ALL_ELEMENTS:\n"); printf("DEBUG -- FAILURE # %lld\n", FAILURES); printf("DEBUG -- test_case_data.index -> %lld vs tmp_ptr -> %lld\n", test_case_data.index, tmp_ptr->index); printf("DEBUG -- test_case_data.dbl_index -> %g vs tmp_ptr-> %g\n", test_case_data.dbl_index, tmp_ptr->dbl_index); printf("DEBUG -- STRING CMP RESULT: %d\n", memcmp(tmp_ptr->str_buff, test_case_data.buff, BUFF_SIZE)); } } test_case_data.index++; test_case_data.dbl_index=test_case_data.index * LINK_MULT_FACT; if (tmp_ptr->next != NULL) tmp_ptr=tmp_ptr->next; } return(FAILURES); } void edit_element(struct link_list * link_list_test, long long int index) { struct link_list * tmp_ptr = link_list_test; long long int tmp = 0; long long int current_count = count_elements(tmp_ptr); for (tmp = 0; tmp < index; tmp++) tmp_ptr = tmp_ptr->next; tmp_ptr->index = index + 1; tmp_ptr->dbl_index = (double)tmp_ptr->index * LINK_MULT_FACT; if(DEBUG) { printf("DEBUG -- Changed .index to: %lld\n", tmp_ptr->index); printf("DEBUG -- Changed .dbl_index to: %g\n", tmp_ptr->dbl_index); } }src32/link_list_test.h0000644005635700000120000000524310332224654014560 0ustar weathnrwheel/*************************************************************************** * Copyright (C) 2005 by Norman Weathers 639-2727 ,LO-2003 * * weathnr@hoprlw10 * * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU General Public License as published by * * the Free Software Foundation; either version 2 of the License, or * * (at your option) any later version. * * * * This program is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * * GNU General Public License for more details. * * * * You should have received a copy of the GNU General Public License * * along with this program; if not, write to the * * Free Software Foundation, Inc., * * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * ***************************************************************************/ #ifndef _LINK_LIST_TEST_H #define _LINK_LIST_TEST_H // Define our BUFF size to be 64k - 16 bytes for our long long and double #define BUFF_SIZE 65536-16 #define LINK_MULT_FACT 1.0001 //#define MAX_LOOPS 50000 #define MAX_TIME_SECS 300 #define SCAN_LOOP_MAX 10 #define MAX_LOOPS 100 #define LINK_LIST_STRUCT_SIZE 65536 extern int DEBUG; extern int VERBOSE; extern int INFO; struct test_case_struct { long long int index; double dbl_index; char buff[BUFF_SIZE]; }; struct link_list { long long int index; double dbl_index; char str_buff[BUFF_SIZE]; struct link_list *next; }; void link_list_test (int array_test_size); struct link_list * add_element(struct link_list * list_ptr, struct test_case_struct test_case_data); struct link_list * del_element(struct link_list * list_ptr); struct link_list * rmv_all_elements(struct link_list *); void debug_print(struct link_list * list_ptr, long long int index); long long int count_elements(struct link_list * list_ptr); //long long int scan_all_elements(struct link_list * list_ptr, struct test_case_struct test_case_data); long long int scan_all_elements(struct link_list * list_ptr); void edit_element(struct link_list * list_ptr, long long int index); #endif src32/long_array_test.c0000644005635700000120000002551410332224654014723 0ustar weathnrwheel/*************************************************************************** * Copyright (C) 2005 by Norman Weathers 639-2727 ,LO-2003 * * weathnr@hoprlw10 * * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU General Public License as published by * * the Free Software Foundation; either version 2 of the License, or * * (at your option) any later version. * * * * This program is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * * GNU General Public License for more details. * * * * You should have received a copy of the GNU General Public License * * along with this program; if not, write to the * * Free Software Foundation, Inc., * * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * ***************************************************************************/ #include "long_array_test.h" #include "defines.h" #include "test_utils.h" #include "memcpy_test.h" #include void run_long_array_test( int mem_size_MB) { // Run a long series of tests of varying degrees up to the mem_size_MB // that we have been given printf("------------------------------Walking Array Test-----------------------"); printf("\n\nPreparing to start test...\n"); if (DEBUG) { printf("DEBUG -- Currently, test not available\n"); printf("DEBUG -- VAR CHECK\n"); printf("DEBUG -- DEBUG = %d\n", DEBUG); printf("DEBUG -- VERBOSE = %d\n", VERBOSE); printf("DEBUG -- INFO = %d\n", INFO); printf("DEBUG -- mem_size_MB = %d MB's\n", mem_size_MB); } // Determine number of maximum elements long long int MAX_NUM_ELEMENTS = 0; long long int CURRENT_NUM_ELEMENTS = 0; long long int TMP_NUM_ELEMENTS=0; long long int DELTA_ARRAY=0; long long int MAX_BYTES_TEST = 0; long long int total_operations=0; long long int rand_num=0; long long int realloc_errors=0; int array_loop_counter=0, local_counter=0, total_time_secs=0; int ERROR_COUNT=0; test_type * test_array, * tmp_array; test_type base; struct timeval tv_start, tv_middle, tv_end, tv_tmp; struct timezone tz; // Convert mem_size_MB to MAX_BYTES_TEST MAX_BYTES_TEST = (long long int) mem_size_MB * (long long int)1024 * (long long int)1024; MAX_NUM_ELEMENTS = MAX_BYTES_TEST / (long long int)sizeof(test_type); CURRENT_NUM_ELEMENTS = MAX_NUM_ELEMENTS/(long long int) 2; if (VERBOSE||DEBUG||INFO) { printf("DVI -- Total Maximum Number of Bytes: %lld\n", MAX_BYTES_TEST); printf("DVI -- Total Maximum Number of Elements: %lld\n", MAX_NUM_ELEMENTS); printf("DVI -- Starting with: %lld Elements\n", CURRENT_NUM_ELEMENTS); printf("DVI -- Maximum Number of Loops: %d\n", MAXIMUM_ARRAY_LOOPS); printf("DVI -- Maximum Time Test May Run: %d seconds\n", MAXIMUM_ARRAY_SECONDS); } test_array = (test_type *) malloc(sizeof(test_type) * CURRENT_NUM_ELEMENTS); if (test_array == NULL) { perror("Malloc Failed during initialization of long_array_test"); printf("ERROR trying to allocate %lld elements\n", CURRENT_NUM_ELEMENTS); printf("Exitting due to FATAL ERROR!\n"); exit(EXIT_FAILURE); } int memset_area_size = sizeof(base) - sizeof(long long int) - sizeof(double); if (DEBUG||VERBOSE||INFO) { printf("DVI -- Preparing to initialize run...\n"); } for (local_counter = 0; local_counter < CURRENT_NUM_ELEMENTS; local_counter++) { base.lli_entry = (long long int)local_counter; base.dbl_entry = local_counter * MULT_FACT; // MULT_FACT in memcpy_test.h memcpy(&test_array[local_counter], &base, sizeof(test_array[local_counter])); } if (DEBUG||VERBOSE||INFO) { printf("DVI -- Sanity Check after initialization\n"); printf("DVI -- FINAL BASE INT and DOUBLE: %lld , %g\n", base.lli_entry, base.dbl_entry); printf("DVI -- FINAL TEST INT and DOUBLE: %lld , %g\n", test_array[CURRENT_NUM_ELEMENTS-1].lli_entry, test_array[CURRENT_NUM_ELEMENTS-1].dbl_entry); printf("DVI -- Size of test_type: %d\n", (int)sizeof(base)); } gettimeofday(&tv_start, &tz); srandom((int)tv_start.tv_usec); while (array_loop_counter < MAXIMUM_ARRAY_LOOPS && total_time_secs < MAXIMUM_ARRAY_SECONDS && !ERROR_COUNT) { /* Here is where we walk the array, do reallocs and in general just have all kinds of fun. In this while loop, we will track our time and run through a lot of loops. We count each action on the array once through as a loop. */ for (local_counter = 0; local_counter < CURRENT_NUM_ELEMENTS; local_counter++) { base.lli_entry = (long long int)local_counter; base.dbl_entry = local_counter * MULT_FACT; // MULT_FACT in memcpy_test.h if (memcmp(&test_array[local_counter], &base, sizeof(base)) != 0) { printf("Error during long_run_array test LOOP: %d, array_offset: %d\n", array_loop_counter, local_counter); ERROR_COUNT++; printf("BASE: INT: %lld DBL: %g\n", base.lli_entry, base.dbl_entry); printf("TEST: INT: %lld DBL: %g\n", test_array[local_counter].lli_entry, test_array[local_counter].dbl_entry); } } if (DEBUG) { printf("DEBUG -- Finished with internal run, realloc'ing\n"); } rand_num = (long long int)random() + MAX_NUM_ELEMENTS; total_operations += (long long int)3 * CURRENT_NUM_ELEMENTS + 5; TMP_NUM_ELEMENTS = rand_num % MAX_NUM_ELEMENTS; if ((double)TMP_NUM_ELEMENTS * 0.05 + TMP_NUM_ELEMENTS >= MAX_NUM_ELEMENTS) TMP_NUM_ELEMENTS=MAX_NUM_ELEMENTS; DELTA_ARRAY = TMP_NUM_ELEMENTS - CURRENT_NUM_ELEMENTS; if (DELTA_ARRAY == -MAX_NUM_ELEMENTS) { DELTA_ARRAY = DELTA_ARRAY / 2; } if (DELTA_ARRAY == CURRENT_NUM_ELEMENTS) { DELTA_ARRAY = DELTA_ARRAY / 2; } if (DEBUG) { printf("DEBUG -- MY DELTA_ARRAY is: %lld NEW CURRENT IS: %lld\n", DELTA_ARRAY, CURRENT_NUM_ELEMENTS - DELTA_ARRAY); } /* Here, we do our realloc and reset the entire world... We are going to realloc to our new memory settings and then we are going to reset all of the structures for testing */ // if (tmp_array = realloc(test_array, (CURRENT_NUM_ELEMENTS * sizeof(base) + // (DELTA_ARRAY * sizeof(base)))) == NULL) { if (DEBUG) { long long int new_size = 0; printf("DEBUG -- CURRENT SIZE IS: %lld\n", CURRENT_NUM_ELEMENTS * sizeof(base)); printf("DEBUG -- NEW SIZE IS: "); new_size = CURRENT_NUM_ELEMENTS * sizeof(base) + DELTA_ARRAY * sizeof(base); printf("%lld for %lld ELEMENTS\n", new_size, CURRENT_NUM_ELEMENTS + DELTA_ARRAY); } if (test_array = (test_type * )realloc(test_array, CURRENT_NUM_ELEMENTS * sizeof(base) + DELTA_ARRAY * sizeof(base)) == NULL) { printf("FATAL ERROR!!!!\n"); printf("Error during realloc.... Exitting\n\n"); exit(EXIT_FAILURE); } else { test_array = tmp_array; // Move pointer // Update the CURRENT_NUM_ELEMENTS CURRENT_NUM_ELEMENTS += DELTA_ARRAY; } if (DEBUG) { printf("DEBUG -- After realloc reassignment, preparing to memcpy\n"); printf("DEBUG -- CURRENT_NUM_ELEMENTS = %lld\n", CURRENT_NUM_ELEMENTS); } // Update our realloced space for (local_counter = 0; local_counter < CURRENT_NUM_ELEMENTS; local_counter++) { if (DEBUG) { printf("DEBUG -- After realloc, updating new entries in base\n"); printf("DEBUG -- Address of first allocation was: %ld\n", &test_array); printf("DEBUG -- Sizeof test_array[%d] is: %d\n", local_counter, (int) sizeof(test_array[local_counter])); printf("DEBUG -- VALUES FROM test_array[%d] are:\n"); printf("DEBUG -- lli_entry --> %lld\n", test_array[local_counter].lli_entry); printf("DEBUG -- dbl_entry --> %g\n", test_array[local_counter].dbl_entry); } base.lli_entry = (long long int)local_counter; base.dbl_entry = local_counter * MULT_FACT; // MULT_FACT in memcpy_test.h if (DEBUG) { printf("DEBUG -- Preparing memcpy\n"); fflush(NULL); } memcpy(&test_array[local_counter], &base, sizeof(base)); if (DEBUG) { printf("Just finished memcpy to test_array, loop: %d\n", local_counter); } } if (DEBUG) { printf("DEBUG -- After memcpy, preparing for next loop\n"); } total_operations += (long long int)3 * CURRENT_NUM_ELEMENTS + 6; if (0 == array_loop_counter % 500 && array_loop_counter != 0) { printf("Check Output # %8d --> ", array_loop_counter); gettimeofday(&tv_middle, &tz); //printf("Running Total --> %lld Operations / %g seconds =", // total_operations, convert_time_difference(tv_start, tv_middle)); printf("%16.5f Ops/sec | ", (double)total_operations / convert_time_difference(tv_start, tv_middle)); printf("Cummalitive Ops: %20lld | ", total_operations); printf("Cummalitive Secs: %10.5f\n", convert_time_difference(tv_start, tv_middle)); } array_loop_counter++; gettimeofday(&tv_middle, &tz); total_time_secs = ceil(convert_time_difference(tv_start, tv_middle)); } gettimeofday(&tv_end, &tz); printf("Total Operations: %lld \n", total_operations); printf("Total Time: %16.10f\n", convert_time_difference(tv_start, tv_end)); printf("OPS/SEC: %16.6f\n", (double)total_operations / convert_time_difference(tv_start, tv_end)); if (ERROR_COUNT) { printf("Errors during long_array_test... Exitting now\n"); printf("%d ERRORS\n", ERROR_COUNT); exit(EXIT_FAILURE); } //sleep(5); printf("Exitting now\n"); free(test_array); printf("\nFinished walking array test\n"); printf("\n------------------------------------------------------------------\n\n"); exit(1); }src32/long_array_test.h0000644005635700000120000000306510332224654014725 0ustar weathnrwheel/*************************************************************************** * Copyright (C) 2005 by Norman Weathers 639-2727 ,LO-2003 * * weathnr@hoprlw10 * * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU General Public License as published by * * the Free Software Foundation; either version 2 of the License, or * * (at your option) any later version. * * * * This program is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * * GNU General Public License for more details. * * * * You should have received a copy of the GNU General Public License * * along with this program; if not, write to the * * Free Software Foundation, Inc., * * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * ***************************************************************************/ extern int DEBUG; extern int VERBOSE; extern int INFO; extern int errno; #define CHAR_STRING_A "ABCDABCD" #define CHAR_STRING_B "12341234" void run_long_array_test( int mem_size_MB ); src32/lu_decomp.c0000644005635700000120000001702010332224654013467 0ustar weathnrwheel/*************************************************************************** * Copyright (C) 2005 by Norman Weathers 639-2727 ,LO-2003 * * weathnr@hoprlw10 * * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU General Public License as published by * * the Free Software Foundation; either version 2 of the License, or * * (at your option) any later version. * * * * This program is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * * GNU General Public License for more details. * * * * You should have received a copy of the GNU General Public License * * along with this program; if not, write to the * * Free Software Foundation, Inc., * * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * ***************************************************************************/ //#include "matrix_test.h" #include "defines.h" #include "lu_decomp.h" #include "test_utils.h" void LU_Decomp (const int MATRIX_SIZE) { printf("Preparing to run LU_Decomp module...\n"); const gsl_rng_type * T; gsl_rng * r; int i,j,s, n = DEFAULT_MATRIX_LU; //2000 int FAILED_FLAG=0; struct timeval tv_start,tv_end; struct timeval tv_decomp_start, tv_decomp_end; struct timeval tv_solve_end; struct timeval tv_reverse_end; struct timezone tz; time_t time_stamp; long long num_bytes_total=0; double MB_total = 0; gettimeofday(&tv_start, &tz); if (MATRIX_SIZE > 2) { n = MATRIX_SIZE; if (DEBUG||INFO) { printf("INFO -- User supplied matrix size: %d\n",n); } } num_bytes_total = (long long)n * (long long)n * (long long)sizeof(long long); MB_total = (double)num_bytes_total / ((double) 1024 * (double)1024); printf("Simulated array size in memory ~ %g MB\n", MB_total*2); gsl_vector *x0 = gsl_vector_alloc(n); gsl_vector *answer0 = gsl_vector_alloc(n); gsl_vector *answer1 = gsl_vector_alloc(n); gsl_matrix *matrix1 = gsl_matrix_alloc(n, n); gsl_matrix *matrix_bak = gsl_matrix_alloc(n, n); gsl_permutation *p = gsl_permutation_alloc(n); gsl_rng_env_setup(); T = gsl_rng_default; r = gsl_rng_alloc (T); printf("Decomp Matrix Size: [%d , %d]\n", n, n); if (DEBUG||INFO) { printf("INFO -- Creating random elements for vector: x0\n"); } for (i = 0; i < n; i++) { double u = gsl_rng_uniform (r); //printf ("%.5f\n", u); gsl_vector_set(x0,i,u); } if (DEBUG||INFO) { printf("INFO -- Finished creating random elements for vector x0\n"); printf("INFO -- Creating random elements for matrix: [%d, %d]\n",n, n); } for (j=0; j< n; j++) { for(i = 0; i matrix_bak\n"); } gsl_matrix_memcpy(matrix_bak, matrix1); fflush(NULL); // Needed this to be able to get original answers from reverse operation later if (DEBUG||INFO) { printf("INFO -- Finished with matrix backup\n"); printf("INFO -- Checking backup matrix\n"); } for (j=0; j DELTA) { printf("Error: DELTA exceeded... Backup matrix copy failed\n"); printf("matrix[%d,%d] %g <----> matrix_bak[%d,%d] %g\n", i,j,gsl_matrix_get(matrix1,i,j),i,j,gsl_matrix_get(matrix_bak,i,j)); FAILED_FLAG++; } } } if (DEBUG||INFO) { printf("INFO -- Finished backup verification\n"); printf("INFO -- Preparing to run decomp...\n"); } gettimeofday(&tv_decomp_start, &tz); gsl_linalg_LU_decomp(matrix1, p, &s); long long size_of_perm = gsl_permutation_size (p); printf("Number of permutations: %lld\n", size_of_perm); gettimeofday(&tv_decomp_end, &tz); if (DEBUG||INFO) { printf("INFO -- Running LU_solve...\n"); } gsl_linalg_LU_solve(matrix1, p, x0, answer0); gettimeofday(&tv_solve_end, &tz); if (DEBUG||INFO) { printf("INFO -- Decomp finished... Reversing operations to check answers\n"); } gsl_blas_dgemv(CblasNoTrans, 1.0, matrix_bak, answer0, 0.0, answer1); for (i=0; i answer1 %g\n", gsl_vector_get(x0,i),gsl_vector_get(answer1,i)); FAILED_FLAG++; } } gettimeofday(&tv_reverse_end, &tz); time(&time_stamp); char * str_ptr_orig = ctime(&time_stamp); //printf("x=\n"); //gsl_vector_fprintf(stdout, answer0, "%g"); printf("--------------------------------------------\n"); printf("Execution Summary for LU_Decomp\n"); printf("--------------------------------------------\n"); if (FAILED_FLAG) { printf("LU_DECOMP TEST: Run FAILED with %d error(s) TIMESTAMP: %s;\n", FAILED_FLAG, str_ptr_orig); } else { printf("LU_DECOMP TEST: Run SUCCEEDED. TIMESTAMP: %s\n", str_ptr_orig); } if (DEBUG||INFO) { printf("INFO -- Freeing GSL allocated objects\n"); } gsl_vector_free(x0); gsl_vector_free(answer0); gsl_vector_free(answer1); gsl_matrix_free(matrix1); gsl_matrix_free(matrix_bak); gsl_rng_free (r); gsl_permutation_free(p); if (DEBUG||INFO) { printf("INFO -- GSL Free finished\n"); } gettimeofday(&tv_end, &tz); //printf("Time start: %d.%d <---> Time Finished: %d.%d\n", // (int)tv_start.tv_sec, (int)tv_start.tv_usec, // (int)tv_end.tv_sec, (int)tv_end.tv_usec); printf("--------------------------------------------\n\n"); printf("Timing (In Seconds)\n"); printf("Total execution time: %12.6f\n", convert_time_difference(tv_start, tv_end)); printf("Total Decomp Time: %12.6f\n", convert_time_difference(tv_decomp_start, tv_decomp_end)); printf("Total Solve Time: %12.6f\n", convert_time_difference(tv_decomp_end, tv_solve_end)); printf("Total Reverse Solve Time: %12.6f\n", convert_time_difference(tv_decomp_end, tv_reverse_end)); printf("LU Decomp Benchmark Index: %f\n", MB_total / convert_time_difference(tv_decomp_start, tv_decomp_end)); printf("\n--------------------------------------------\n"); fflush(NULL); } src32/lu_decomp.h0000644005635700000120000000320410332224655013474 0ustar weathnrwheel/*************************************************************************** * Copyright (C) 2005 by Norman Weathers 639-2727 ,LO-2003 * * weathnr@hoprlw10 * * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU General Public License as published by * * the Free Software Foundation; either version 2 of the License, or * * (at your option) any later version. * * * * This program is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * * GNU General Public License for more details. * * * * You should have received a copy of the GNU General Public License * * along with this program; if not, write to the * * Free Software Foundation, Inc., * * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * ***************************************************************************/ #ifndef LU_DECOMP_H #define LU_DECOMP_H #include #include #include #include #include extern int DEBUG; extern int INFO; extern int VERVOSE; void LU_Decomp(const int MATRIX_SIZE); #endifsrc32/matrix_test.c0000644005635700000120000003023310332224655014065 0ustar weathnrwheel/*************************************************************************** * Copyright (C) 2005 by Norman Weathers 639-2727 ,LO-2003 * * weathnr@hoprlw10 * * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU General Public License as published by * * the Free Software Foundation; either version 2 of the License, or * * (at your option) any later version. * * * * This program is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * * GNU General Public License for more details. * * * * You should have received a copy of the GNU General Public License * * along with this program; if not, write to the * * Free Software Foundation, Inc., * * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * ***************************************************************************/ #include "defines.h" #include "changes.h" #include "matrix_test.h" #include "lu_decomp.h" #include "transpose.h" #include "gsl_sort.h" #include "test_utils.h" #include "memcpy_test.h" #include "link_list_test.h" #include "get_mem_avail.h" void print_help() { printf("\n\n"); printf("Options are --\n"); printf("----Program Control Options----\n"); printf("-t [num ] Number of threads for processes\n"); printf("-T [size] Transpose matrix size\n"); printf("-L [size] LU Decomp matrix size\n"); printf("-S [size] Sort Vector size (elements)\n"); printf("-l [loops] Number of loops to run memcpy test\n"); printf("-m [size(MB)] Size in MB for memcpy test\n"); printf("-c Run forever\n"); printf("-A [MB_SIZE] Link list size tests up to MB_SIZE\n"); printf("-Z Automatic sizes from avail memory\n"); printf(" -Z option can be overridden by individual command line options\n"); printf("\n----Output Control Options----\n"); printf("-d DEBUG output enabled\n"); printf("-i INFO output enabled\n"); printf("-v VERBOSE output enabled\n"); printf("-h Help output displayed and exit\n"); printf("\n\n\n"); } int main(int argc, char *argv[]) { // Variables used during the program short LOOP_FOREVER=0; short NUM_TEST_THREADS=1; short DETERMINE_AUTO_SIZES = 0; short SET_MATRIX_SIZE=0, SET_LIST_SIZE=0, SET_LUDECOMP_SIZE=0; short SET_MEMCPY_SIZE=0, SET_SORT_SIZE=0; int matrix_size=DEFAULT_TRANSPOSE_SIZE; int ludecomp_size=DEFAULT_MATRIX_LU; int memcpy_loops = DEFAULT_LOOPS; int mb_size_memcpy = DEFAULT_MEMCPY_MB; int array_mem_size = DEFAULT_ARRAY_MEM_SIZE; int tmp=0; long long sort_size=DEFAULT_SORT_ELEMENTS; time_t timeval; struct timeval tv_total_test_start, tv_total_test_end; struct timezone tz; long long int TOTAL_MEM_BYTES=0; int next_option=0; // CL Argument list printf("\n\n\n"); // Prespacer... char * short_options="t:T:L:S:hcdivl:m:A:Z"; struct option long_options[] = { {"threads",1,NULL,'t'}, {"transpose",1,NULL,'T'}, {"ludecomp",1,NULL,'L'}, {"sort",1,NULL,'S'}, {"help",0,NULL,'h'}, {"cont",0,NULL,'c'}, {"debug",0,NULL,'d'}, {"verbose",0,NULL,'v'}, {"info",0,NULL,'i'}, {"loops",1,NULL,'l'}, {"memcpymb",1,NULL,'m'}, {"array",1,NULL,'A'}, {"autofit",0,NULL,'Z'}, {NULL,0,NULL,0} }; // Walk through cl options and set appropriate vars do { next_option = getopt_long(argc, argv, short_options, long_options, NULL); switch(next_option) { case 'c': LOOP_FOREVER = 1; break; case 't': NUM_TEST_THREADS = (short)atoi(optarg); if (NUM_TEST_THREADS < 2) { printf("INFO -- Threaded testing requires at least 2 threads\n"); printf("INFO -- Setting thread count back to 1\n"); printf("INFO -- Thread count of: %hd is not valid\n",NUM_TEST_THREADS); NUM_TEST_THREADS = 1; } else if (NUM_TEST_THREADS > 8) { printf("INFO -- Thread count > 8 is not allowed now\n"); printf("INFO -- Please set thread count from 2 - 8\n"); printf("INFO -- Setting thread count back to 1\n"); printf("INFO -- Thread count of %hd too large\n", NUM_TEST_THREADS); NUM_TEST_THREADS = 1; } break; case 'T': SET_MATRIX_SIZE=1; matrix_size=atoi(optarg); break; case 'L': SET_LUDECOMP_SIZE=1; ludecomp_size = atoi(optarg); break; case 'S': SET_SORT_SIZE=1; sort_size = atoll(optarg); break; case 'd': DEBUG=1; printf("DEBUG -- Debug output enabled\n"); break; case 'i': INFO=1; printf("INFO -- Extra information output enabled\n"); break; case 'v': VERBOSE=1; printf("VERBOSE -- Verbose output enabled\n"); break; case 'l': memcpy_loops = atoi(optarg); //printf("DEBUG -- memcpy_loops = %d\n", memcpy_loops); break; case 'm': SET_MEMCPY_SIZE=1; mb_size_memcpy = atoi(optarg); break; case 'A': SET_LIST_SIZE=1; tmp = atoi(optarg); if (!tmp) { printf("Error in array_mem_size argument\n"); printf("Using default value: %d MB's\n", array_mem_size); array_mem_size=DEFAULT_ARRAY_MEM_SIZE; } else { // Set array_mem_size to tmp array_mem_size = tmp; if (array_mem_size < 1) { printf("Using automatic Defaults for Link List memory size\n"); array_mem_size = DEFAULT_ARRAY_MEM_SIZE; printf("Array Mem size set to default: %d MB's\n", array_mem_size); } } //break; case 'Z': DETERMINE_AUTO_SIZES = 1; break; array_mem_size = tmp; break; case 'h': print_help(); exit(EXIT_SUCCESS); break; case '?': print_help(); exit(EXIT_FAILURE); } } while (next_option != -1); // -------------- End Vars ---------------- // Simple test // printf("Arg Count: %d\n", argc); // if (argc == 2) { // printf("Arg 2 is: %s\n", argv[1]); // array_size = atoi(argv[1]); //} /*printf("Pre-argument defaults (users may override with command line options) --\n"); printf("Matrix_size = %d\n", matrix_size); printf("LUdecomp_size = %d\n", ludecomp_size); fflush(NULL); sleep(1); */ TOTAL_MEM_BYTES = available_mem(); struct memory_sizes_struct mem_sizes; long long int MB_TOTAL = 0; MB_TOTAL = TOTAL_MEM_BYTES / 1024 / 1024; //printf("DEBUG -- REMOVE ME: MB_TOTAL calculated to be: %lld \n", MB_TOTAL); if (DETERMINE_AUTO_SIZES) { // DETERMINE AUTO SIZES, currently hard coded for 48% of available memory // per process... This is AVAILABLE memory, not FREE MEMORY determine_sizes(&mem_sizes, 48, MB_TOTAL); if (DEBUG||VERBOSE||INFO) { printf("The following auto setups created:\n"); printf("Number of transpose elements: %lld\n", mem_sizes.transpose_size); printf("Number of Linked List elements: %lld\n", mem_sizes.link_list_size); printf("Number of lu_decomp matrix elements: %lld\n", mem_sizes.lu_decomp_size); } if (!SET_MATRIX_SIZE) { matrix_size = mem_sizes.transpose_size; } else if (DEBUG||VERBOSE||INFO) { printf("DVI -- Overriding automatic sizes (transpose) from command line argument\n"); } if (!SET_LUDECOMP_SIZE) { ludecomp_size = mem_sizes.lu_decomp_size; } else if (DEBUG||VERBOSE||INFO) { printf("DVI -- Overriding automatic sizes (ludecomp) from command line argument\n"); } if (!SET_LIST_SIZE) { array_mem_size = mem_sizes.link_list_size; } else if (DEBUG||VERBOSE||INFO) { printf("DVI -- Overriding automatic sizes (link list) from command line argument\n"); } if (!SET_MEMCPY_SIZE) { mb_size_memcpy = mem_sizes.memcpy_size; } else if (DEBUG||VERBOSE||INFO) { printf("DVI -- Overriding automatic sizes (memcmp) from command line argument\n"); } if (!SET_SORT_SIZE) { sort_size = mem_sizes.gsl_sort_size; } else if(DEBUG||VERBOSE||INFO) { printf("DVI -- Overriding automatic sizes (gsl sort) form command line argument\n"); } } printf("\n\n\n\n"); printf("Starting NCOMP Benchmark Utility Test\n"); sleep(1); time(&timeval); printf("NCOMP Benchmarks started at:\n"); printf("%s\n", ctime(&timeval)); printf("------------------------------------------------------\n"); //printf("Extra Output Enabled.\n"); printf("Pre Test Diagnostic Output\n"); printf(" -- Printing out runtime environemnt variables\n"); printf(" -- Debug output: %d\n", DEBUG); printf(" -- Verbose output : %d\n", VERBOSE); printf(" -- Information output: %d\n", INFO); printf(" -- Matrix Test Size: %d x %d Elements\n", matrix_size, matrix_size); printf(" -- LU Decomp Size: %d Elements\n", ludecomp_size); printf(" -- Sort Size: %lld Elements\n", sort_size); printf(" -- Link List mem size: %d MB's\n", array_mem_size); printf(" -- mb_size_memcpy: %d MB's\n", mb_size_memcpy); printf(" -- Total Available Memory: %lld Bytes\n", TOTAL_MEM_BYTES); //printf(" -- Number of Threads: %hd Threads\n", NUM_TEST_THREADS); printf(" -- Executable Type: %d bit Executable\n", EXEC_TYPE); printf("------------------------------------------------------\n"); printf("\n\n\nIgnoring thread count for now...\n\n\n"); //printf("Exec Bits: %d\n", EXEC_TYPE); fflush(NULL); sleep(5); // REMOVE THIS //exit(0); // END REMOVE do { if (LOOP_FOREVER) { time(&timeval); printf("Looping Forever.... Loop: %d\n", LOOP_FOREVER); printf("Loop started at: %s\n", ctime(&timeval)); LOOP_FOREVER++; } gettimeofday(&tv_total_test_start, &tz); // Run the memcpy test. memcpy_test(memcpy_loops, mb_size_memcpy); sleep(3); if (array_mem_size) { link_list_test(array_mem_size); } //sleep(3); transpose(matrix_size); //sleep(3); LU_Decomp(ludecomp_size); //sleep(3); gsl_sort_test(sort_size); gettimeofday(&tv_total_test_end, &tz); //printf("Total test timings end: %d.%d\n", // tv_total_test_end.tv_sec,tv_total_test_end.tv_usec); double test_timings_total = convert_time_difference(tv_total_test_start, tv_total_test_end); printf("\n\nTotal Test Execution Time (in seconds): %14.6g\n\n", test_timings_total); } while(LOOP_FOREVER); return EXIT_SUCCESS; } src32/matrix_test.h0000644005635700000120000000305610332224655014075 0ustar weathnrwheel/*************************************************************************** * Copyright (C) 2005 by Norman Weathers 639-2727 ,LO-2003 * * weathnr@hoprlw10 * * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU General Public License as published by * * the Free Software Foundation; either version 2 of the License, or * * (at your option) any later version. * * * * This program is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * * GNU General Public License for more details. * * * * You should have received a copy of the GNU General Public License * * along with this program; if not, write to the * * Free Software Foundation, Inc., * * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * ***************************************************************************/ #ifndef MATRIX_TEST_H #define MATRIX_TEST_H int DEBUG=0; int INFO=0; int VERBOSE=0; #ifdef _DEFINE_32BIT int EXEC_TYPE = 32; #else int EXEC_TYPE = 64; #endif #endif src32/matrix_test_utils.c0000644005635700000120000000257110332224655015311 0ustar weathnrwheel/*************************************************************************** * Copyright (C) 2005 by Norman Weathers 639-2727 ,LO-2003 * * weathnr@hoprlw10 * * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU General Public License as published by * * the Free Software Foundation; either version 2 of the License, or * * (at your option) any later version. * * * * This program is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * * GNU General Public License for more details. * * * * You should have received a copy of the GNU General Public License * * along with this program; if not, write to the * * Free Software Foundation, Inc., * * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * ***************************************************************************/ src32/matrix_test_utils.h0000644005635700000120000000257110332224655015316 0ustar weathnrwheel/*************************************************************************** * Copyright (C) 2005 by Norman Weathers 639-2727 ,LO-2003 * * weathnr@hoprlw10 * * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU General Public License as published by * * the Free Software Foundation; either version 2 of the License, or * * (at your option) any later version. * * * * This program is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * * GNU General Public License for more details. * * * * You should have received a copy of the GNU General Public License * * along with this program; if not, write to the * * Free Software Foundation, Inc., * * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * ***************************************************************************/ src32/memcpy_test.WORKS.c0000644005635700000120000002205010332224655014755 0ustar weathnrwheel/*************************************************************************** * Copyright (C) 2005 by Norman Weathers 639-2727 ,LO-2003 * * weathnr@hoprlw10 * * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU General Public License as published by * * the Free Software Foundation; either version 2 of the License, or * * (at your option) any later version. * * * * This program is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * * GNU General Public License for more details. * * * * You should have received a copy of the GNU General Public License * * along with this program; if not, write to the * * Free Software Foundation, Inc., * * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * ***************************************************************************/ #include "memcpy_test.h" void memcpy_test(int LOOPS, int MB_SIZE) { test_report_t test_report[LOOPS]; int i=0; double avg_test_time=0.0; double avg_MB_Score=0.0; double Low_test_time=-1.0, high_test_time=-1.0; double Low_MB_Score=-1.0, high_MB_Score=-1.0; double diff_time=0.0; long long ELEMENTS=(long long)MB_SIZE * 1024 * 1024 / sizeof(test_type); printf("--------------------------MEMCPY TEST------------------------\n"); printf("\n"); printf("%d loops will be run for MEMCPY test\n", LOOPS); printf("%lld Elements @ %d bytes each will be used\n",ELEMENTS, sizeof(test_type)); printf("Total Requested MB %10.4f\n", (double)ELEMENTS / 1024.0 / 1024.0 * sizeof(test_type)); for (i=0; i< LOOPS; i++) { mem_test_struct(i, MB_SIZE, test_report); //printf("Back from test loop: %d\n", i); } printf("\n----Outputing report data----\n\n"); for (i = 0; i < LOOPS; i++) { diff_time = test_report[i].end_time - test_report[i].start_time; printf("Loop: %4d Test_Time: %16.10g Seconds MB_Score: %16.10g\n", i, diff_time,test_report[i].MB_Score); avg_test_time += diff_time; avg_MB_Score += test_report[i].MB_Score; if (Low_test_time < 0.0 || Low_test_time > diff_time) { Low_test_time = diff_time; } if (Low_MB_Score < 0.0 || Low_MB_Score > test_report[i].MB_Score) Low_MB_Score = test_report[i].MB_Score; if (high_test_time < 0.0 || high_test_time < diff_time) { high_test_time = diff_time; } if (high_MB_Score < test_report[i].MB_Score) high_MB_Score = test_report[i].MB_Score; } printf("\n-----------------------------MEMCPY SCORES--------------------------\n"); printf("AVERAGE TEST TIME (seconds) : %20.12g\n", avg_test_time/LOOPS); printf("AVERAGE MB SCORE : %20.12g\n", avg_MB_Score/LOOPS); printf("Largest time (Seconds) : %20.12g\n", high_test_time); printf("Shortest time (Seconds) : %20.12g\n", Low_test_time); printf("Highest MB Score : %20.12g\n", high_MB_Score); printf("Lowest MB Score : %20.12g\n", Low_MB_Score); printf("End MEMCPY test\n\n"); } /* This is a complex memory test to determine how quickly the computer and OS can do memcpy's of complex structures. (The structures are not that complex, actually) */ void mem_test_struct(int loop, int MB_SIZE, test_report_t test_data[]) { // Here, we will do some very simple things to determine how fast we // are with slightly more complex data... long long int lli_entry1=0; long long RUNTIME_SIZE = ((long long) MB_SIZE * 1024 * 1024) / sizeof(test_type); double dbl_entry1=0.0; double time_diff = 0.0; struct sysinfo system_info; struct timeval tv_start, tv_middle, tv_end; struct timezone tz; volatile test_type testing, testing1; testing.lli_entry = lli_entry1; testing.dbl_entry = dbl_entry1; gettimeofday(&tv_start, &tz); //printf("Filled info into testing structure as follows:\n"); //printf("long long int: %16lld\n", testing.lli_entry); //printf("Double : %16.6g\n", testing.dbl_entry); gettimeofday(&tv_middle, &tz); testing.lli_entry += 1; testing.dbl_entry += 1.1; //printf("After adding ...\n"); //printf("long long int: %16lld\n", testing.lli_entry); //printf("Double : %16.6g\n", testing.dbl_entry); gettimeofday(&tv_end, &tz); //printf("Start time: %ld\n", tv_start.tv_sec); //printf("End time: %ld\n", tv_end.tv_sec); time_diff = diff_time2(tv_end, tv_start); //printf("Middle execute time is: %16.10g seconds\n", diff_time(tv_middle, tv_start)); //printf("Total execute time is: %16.10g seconds\n",time_diff); memcpy(&testing1, &testing, sizeof(test_type)); //printf("Testing1 now has:\n"); //printf("long long: %16lld\n", testing1.lli_entry); //printf("double : %16.10g\n", testing1.dbl_entry); //printf("Size of struct: %d \n", sizeof(testing1)); printf("Running MEMCPY test LOOP: %10d\n", loop); gettimeofday(&tv_start, &tz); long long int i=0; //test_type ** test_array; test_type * test_array; test_array = (test_type *) malloc(RUNTIME_SIZE * sizeof(test_type)); //printf("Copying data from testing to test_array\n"); testing.lli_entry = 0; testing.dbl_entry = testing.lli_entry * MULT_FACT; for (i = 0; i < RUNTIME_SIZE; i++) { memcpy(&test_array[i], &testing, sizeof(test_array[i])); testing.lli_entry += 1; testing.dbl_entry = (double) testing.lli_entry * MULT_FACT; } gettimeofday(&tv_middle, &tz); //printf("Finished copying data ...\n"); //printf("Checking data areas...\n"); long long int FAILURES_INT=0; long long int FAILURES_DBL = 0; double diff_check=0.0; for (i = 0; i < RUNTIME_SIZE; i++) { if (test_array[i].lli_entry != i) { FAILURES_INT++; //printf("Failure during check: "); //printf("i = %lld, lli = %lld, CHECK_DBL = %g, dbl = %g\n", // i, test_array[i].lli_entry, (double) MULT_FACT * (double) i, // test_array[i].dbl_entry); //printf("Difference is: %g\n", // test_array[i].dbl_entry - ((double) MULT_FACT * (double)i)); //exit(1); } diff_check = test_array[i].dbl_entry - ((double) i * MULT_FACT); if (diff_check < 0.0 ) diff_check *= -1.0; if (diff_check > 1e-14) { FAILURES_DBL++; } } //printf("LLI: %lld DBL: %16.10g\n", test_array[RUNTIME_SIZE/3].lli_entry, test_array[RUNTIME_SIZE/3].dbl_entry); //printf("Memory being returned...\n"); gettimeofday(&tv_end, &tz); //printf("Time difference to run mem copies was:%16.10g\n", // diff_time(tv_end, tv_start)); //sleep(1); free(test_array); //printf("Calculated memory speed with simple calculations:\n"); //printf("Total bytes operated on: %lld\n", // sizeof(test_type) * RUNTIME_SIZE * 2); if (FAILURES_DBL) { printf("ERROR!!! There were failures in the double precision calculations!\n"); printf("Total number of failures: %lld\n", FAILURES_DBL); printf("FATAL ERROR ---- FAILED MEMCPY TEST CASE!\n\n"); exit(1); } double bytes_per_sec = ((double) sizeof(test_type) * (double)RUNTIME_SIZE) / diff_time2(tv_middle, tv_start); //printf("%16.5g Bytes / Second \n", bytes_per_sec); //printf("Megabytes / second = %16.10g\n", // (bytes_per_sec / ((double) 1024 * (double) 1024))); //printf("Total time for execution: %16.10g\n", // diff_time(tv_end, tv_start)); test_data[loop].loop_num = loop; test_data[loop].start_time = dbl_time(tv_start); test_data[loop].end_time = dbl_time(tv_middle); test_data[loop].MB_Score = bytes_per_sec / ((double)1024 * (double) 1024); /*printf("Start_time: %g End_time: %g\n", test_data[loop].start_time, test_data[loop].end_time); */ } double diff_time2 (struct timeval tv_end, struct timeval tv_start) { // multiply and subtract the two numbers... double tv_end_time = 0.0; double tv_start_time = 0.0; double difference = 0.0; tv_end_time = (double) tv_end.tv_sec + ((double) tv_end.tv_usec / 1000000.0); //printf("tv_end_time = %16g\n", tv_end_time); tv_start_time = (double) tv_start.tv_sec + ((double) tv_start.tv_usec / 1000000.0); //printf("tv_start_time = %16g\n", tv_start_time); //difference = tv_end_time - tv_start_time; //printf("difference = %16g\n", difference); //return(difference); return(tv_end_time - tv_start_time); } inline double dbl_time(struct timeval tv_val) { return( (double) tv_val.tv_sec + ((double) tv_val.tv_usec / 1000000.0)); }src32/memcpy_test.c0000644005635700000120000002135210332224655014055 0ustar weathnrwheel/*************************************************************************** * Copyright (C) 2005 by Norman Weathers 639-2727 ,LO-2003 * * weathnr@hoprlw10 * * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU General Public License as published by * * the Free Software Foundation; either version 2 of the License, or * * (at your option) any later version. * * * * This program is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * * GNU General Public License for more details. * * * * You should have received a copy of the GNU General Public License * * along with this program; if not, write to the * * Free Software Foundation, Inc., * * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * ***************************************************************************/ #include "memcpy_test.h" void memcpy_test(int LOOPS, int MB_SIZE) { test_report_t test_report[LOOPS]; int i=0, tloop=0; double avg_test_time=0.0; double avg_MB_Score=0.0; double Low_test_time=-1.0, high_test_time=-1.0; double Low_MB_Score=-1.0, high_MB_Score=-1.0; double diff_time=0.0; double gtd_overhead=0.0; struct timeval tv_start, tv_middle, tv_end; struct timezone tz; long long int USEABLE = (float)2.3 * 1024; if ((long long int)MB_SIZE > USEABLE) { MB_SIZE = (int) USEABLE; } long long ELEMENTS=(long long)MB_SIZE * 1024 * 1024 / sizeof(test_type); printf("--------------------------MEMCPY TEST------------------------\n"); printf("\n"); printf("%d loops will be run for MEMCPY test\n", LOOPS); printf("%lld Elements @ %d bytes each will be used\n",ELEMENTS, sizeof(test_type)); printf("Total Requested MB %10.4f\n", (double)ELEMENTS / 1024.0 / 1024.0 * sizeof(test_type)); printf("\n\nDetermining gettimeofday overhead...\n"); fflush(NULL); gettimeofday(&tv_start, &tz); for (tloop = 0; tloop < GTD_LOOP; tloop++) { gettimeofday(&tv_middle, &tz); } gettimeofday(&tv_end, &tz); gtd_overhead = diff_time2(tv_end, tv_start) / (double) GTD_LOOP; printf("gettimeofday overhead ~ %16.12f seconds\n\n", gtd_overhead); fflush(NULL); for (i=0; i< LOOPS; i++) { mem_test_struct(i, MB_SIZE, test_report); //printf("Back from test loop: %d\n", i); } printf("\n----Outputing report data----\n\n"); fflush(NULL); for (i = 0; i < LOOPS; i++) { diff_time = test_report[i].end_time - test_report[i].start_time; printf("Loop: %4d Test_Time: %16.10g Seconds MB_Score: %16.10g\n", i, diff_time,test_report[i].MB_Score); avg_test_time += diff_time; avg_MB_Score += test_report[i].MB_Score; if (Low_test_time < 0.0 || Low_test_time > diff_time) { Low_test_time = diff_time; } if (Low_MB_Score < 0.0 || Low_MB_Score > test_report[i].MB_Score) Low_MB_Score = test_report[i].MB_Score; if (high_test_time < 0.0 || high_test_time < diff_time) { high_test_time = diff_time; } if (high_MB_Score < test_report[i].MB_Score) high_MB_Score = test_report[i].MB_Score; fflush(NULL); } printf("\n-----------------------------MEMCPY SCORES--------------------------\n"); printf("AVERAGE TEST TIME (seconds) : %20.12f\n", avg_test_time/LOOPS); printf("AVERAGE MB SCORE : %20.12f\n", avg_MB_Score/LOOPS); printf("Largest time (Seconds) : %20.12f\n", high_test_time); printf("Shortest time (Seconds) : %20.12f\n", Low_test_time); printf("Highest MB Score : %20.12f\n", high_MB_Score); printf("Lowest MB Score : %20.12f\n", Low_MB_Score); printf("----------------------------------------------------------------------\n"); printf("End MEMCPY test\n\n"); fflush(NULL); } /* This is a complex memory test to determine how quickly the computer and OS can do memcpy's of complex structures. (The structures are not that complex, actually) */ void mem_test_struct(int loop, int MB_SIZE, test_report_t test_data[]) { // Here, we will do some very simple things to determine how fast we // are with slightly more complex data... long long int lli_entry1=0, tloop=0; long long RUNTIME_SIZE = ((long long) MB_SIZE * 1024 * 1024) / sizeof(test_type); double dbl_entry1=0.0; double time_diff = 0.0; double gtd_overhead = 0.0; struct sysinfo system_info; struct timeval tv_start, tv_middle, tv_end; struct timezone tz; volatile test_type testing, testing1; testing.lli_entry = lli_entry1; testing.dbl_entry = dbl_entry1; testing.lli_entry += 1; testing.dbl_entry += 1.1; time_diff = diff_time2(tv_end, tv_start); memcpy(&testing1, &testing, sizeof(test_type)); gettimeofday(&tv_start, &tz); for (tloop = 0; tloop < GTD_LOOP; tloop++) { gettimeofday(&tv_middle, &tz); } gettimeofday(&tv_end, &tz); gtd_overhead = diff_time2(tv_end, tv_start) / (double) GTD_LOOP; printf("Running MEMCPY test LOOP: %10d\n", loop); gettimeofday(&tv_start, &tz); fflush(NULL); long long int i=0; //test_type ** test_array; test_type * test_array; test_array = (test_type *) malloc(RUNTIME_SIZE * sizeof(test_type)); //printf("Copying data from testing to test_array\n"); testing.lli_entry = 0; testing.dbl_entry = testing.lli_entry * MULT_FACT; for (i = 0; i < RUNTIME_SIZE; i++) { memcpy(&test_array[i], &testing, sizeof(test_array[i])); //testing.lli_entry += 1; //testing.dbl_entry = (double) testing.lli_entry * MULT_FACT; } gettimeofday(&tv_middle, &tz); //printf("Finished copying data ...\n"); //printf("Checking data areas...\n"); long long int FAILURES_DBL = 0; double diff_check=0.0; for (i = 0; i < RUNTIME_SIZE; i++) { if (memcmp(&test_array[i], &testing, sizeof(testing) != 0)) FAILURES_DBL++; } //printf("LLI: %lld DBL: %16.10g\n", test_array[RUNTIME_SIZE/3].lli_entry, test_array[RUNTIME_SIZE/3].dbl_entry); //printf("Memory being returned...\n"); gettimeofday(&tv_end, &tz); //printf("Time difference to run mem copies was:%16.10g\n", // diff_time(tv_end, tv_start)); //sleep(1); free(test_array); //printf("Calculated memory speed with simple calculations:\n"); //printf("Total bytes operated on: %lld\n", // sizeof(test_type) * RUNTIME_SIZE * 2); if (FAILURES_DBL) { printf("ERROR!!! There were failures in the double precision calculations!\n"); printf("Total number of failures: %lld\n", FAILURES_DBL); printf("FATAL ERROR ---- FAILED MEMCPY TEST CASE!\n\n"); exit(1); } double bytes_per_sec = (double) 2 * ((double) sizeof(test_type) * (double)RUNTIME_SIZE) / (diff_time2(tv_end, tv_start) - (3.0 * gtd_overhead)); //printf("%16.5g Bytes / Second \n", bytes_per_sec); //printf("Megabytes / second = %16.10g\n", // (bytes_per_sec / ((double) 1024 * (double) 1024))); //printf("Total time for execution: %16.10g\n", // diff_time(tv_end, tv_start)); test_data[loop].loop_num = loop; test_data[loop].start_time = dbl_time(tv_start); test_data[loop].end_time = dbl_time(tv_end); test_data[loop].MB_Score = bytes_per_sec / ((double)1024 * (double) 1024); /*printf("Start_time: %g End_time: %g\n", test_data[loop].start_time, test_data[loop].end_time); */ } double diff_time2 (struct timeval tv_end, struct timeval tv_start) { // multiply and subtract the two numbers... double tv_end_time = 0.0; double tv_start_time = 0.0; double difference = 0.0; tv_end_time = (double) tv_end.tv_sec + ((double) tv_end.tv_usec / 1000000.0); //printf("tv_end_time = %16g\n", tv_end_time); tv_start_time = (double) tv_start.tv_sec + ((double) tv_start.tv_usec / 1000000.0); //printf("tv_start_time = %16g\n", tv_start_time); //difference = tv_end_time - tv_start_time; //printf("difference = %16g\n", difference); //return(difference); return(tv_end_time - tv_start_time); } inline double dbl_time(struct timeval tv_val) { return( (double) tv_val.tv_sec + ((double) tv_val.tv_usec / 1000000.0)); } src32/memcpy_test.h0000644005635700000120000000444410332224655014065 0ustar weathnrwheel/*************************************************************************** * Copyright (C) 2005 by Norman Weathers 639-2727 ,LO-2003 * * weathnr@hoprlw10 * * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU General Public License as published by * * the Free Software Foundation; either version 2 of the License, or * * (at your option) any later version. * * * * This program is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * * GNU General Public License for more details. * * * * You should have received a copy of the GNU General Public License * * along with this program; if not, write to the * * Free Software Foundation, Inc., * * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * ***************************************************************************/ #ifndef MEMCPY_TEST_H #define MEMCPY_TEST_H #include #include #include #include #include #include // Global Defines #define DEFAULT_RUN 35000 #define DEFAULT_MEMCPY_MB 512 #define DEFAULT_LOOPS 31 #define MULT_FACT 1.001 #define GTD_LOOP 1000 #define TEST_MEMCPY_STRUCT_SIZE 4096 // Global variable declerations typedef struct test_struct { long long int lli_entry; double dbl_entry; // Filler area char fill[TEST_MEMCPY_STRUCT_SIZE-16]; } test_type; typedef struct test_report_struct { int loop_num; double start_time; double end_time; long long num_bytes; double MB_Score; } test_report_t; void memcpy_test(int LOOPS, int MB_SIZE); double diff_time2(struct timeval tv_end, struct timeval tv_start); void mem_test_struct(int loop, int MB_SIZE, test_report_t test_data[]); inline double dbl_time(struct timeval tv_val); #endif src32/mini_driver.c0000644005635700000120000000035310332224655014031 0ustar weathnrwheel#include "defines.h" #include "link_list_test.h" int DEBUG; int VERBOSE; int INFO; int main(int argc, char ** argv) { printf("Running mini-main for link-list test\n"); DEBUG = 1; INFO = 1; VERBOSE = 1; link_list_test(2); } src32/test_utils.c0000644005635700000120000000454610332224655013731 0ustar weathnrwheel/*************************************************************************** * Copyright (C) 2005 by Norman Weathers 639-2727 ,LO-2003 * * weathnr@hoprlw10 * * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU General Public License as published by * * the Free Software Foundation; either version 2 of the License, or * * (at your option) any later version. * * * * This program is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * * GNU General Public License for more details. * * * * You should have received a copy of the GNU General Public License * * along with this program; if not, write to the * * Free Software Foundation, Inc., * * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * ***************************************************************************/ #include "defines.h" #include "test_utils.h" double convert_time_difference(struct timeval tv1, struct timeval tv2) { // Take two timeval structs like those in gettimeofday and // return the difference between these two times. int time_sec_1, time_sec_2, time_usec_1, time_usec_2; int diff_time_sec=0, diff_time_usec=0; time_sec_1 = (int)tv1.tv_sec; time_sec_2 = (int)tv2.tv_sec; time_usec_1 = (int)tv1.tv_usec; time_usec_2 = (int)tv2.tv_usec; diff_time_sec = time_sec_2 - time_sec_1; diff_time_usec = time_usec_2 - time_usec_1; /* If our usec difference is less than 0, we need to take 1 full second away from diff_time_sec and add it back to the usecs */ if (diff_time_usec < 0) { diff_time_sec--; diff_time_usec += 1000000; } double total_time = (double)diff_time_sec + ((double)diff_time_usec/(double)1000000); //printf("OUTPUT FROM convert_time_difference... %g\n", total_time); return total_time; } src32/test_utils.h0000644005635700000120000000311210332224655013722 0ustar weathnrwheel/*************************************************************************** * Copyright (C) 2005 by Norman Weathers 639-2727 ,LO-2003 * * weathnr@hoprlw10 * * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU General Public License as published by * * the Free Software Foundation; either version 2 of the License, or * * (at your option) any later version. * * * * This program is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * * GNU General Public License for more details. * * * * You should have received a copy of the GNU General Public License * * along with this program; if not, write to the * * Free Software Foundation, Inc., * * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * ***************************************************************************/ #ifndef _TEST_UTILS_H #define _TEST_UTILS_H #include #include #include #include double convert_time_difference(struct timeval tv1, struct timeval tv2); #endifsrc32/transpose.c0000644005635700000120000002310710332224655013542 0ustar weathnrwheel/*************************************************************************** * Copyright (C) 2005 by Norman Weathers 639-2727 ,LO-2003 * * weathnr@hoprlw10 * * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU General Public License as published by * * the Free Software Foundation; either version 2 of the License, or * * (at your option) any later version. * * * * This program is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * * GNU General Public License for more details. * * * * You should have received a copy of the GNU General Public License * * along with this program; if not, write to the * * Free Software Foundation, Inc., * * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * ***************************************************************************/ //#include "matrix_test.h" #include "defines.h" #include "transpose.h" #include "lu_decomp.h" #include "test_utils.h" void transpose(int matrix_size) { int array_size=DEFAULT_TRANSPOSE_SIZE; long long **array_2D=NULL; //long long * temp_array=NULL; long long temp_location=0; long long num_bytes_total=0; double MB_total = 0; short FLAG=0; time_t time_stamp; struct timeval tv_matrix_test_start; struct timeval tv_transpose_end; struct timeval tv_matrix_create_end; struct timeval tv_matrix_verify_end; struct timezone tz; if (matrix_size > 2) { array_size = matrix_size; } else { printf("Invalid matrix size specified... Using defaults: %d\n", array_size); } printf("-------------------------------------------------\n"); printf("Starting matrix array operation: Transposition\n\n"); printf("-------------------------------------------------\n"); gettimeofday(&tv_matrix_test_start, &tz); if (DEBUG||INFO) { printf("INFO -- Array size will be: %d x %d elements\n", array_size, array_size); } // Use long long as our array if (DEBUG||INFO) { printf("INFO -- Size of a long long int: %d\n", (int)sizeof(temp_location)); } num_bytes_total = (long long)array_size * (long long)array_size * (long long)sizeof(array_2D); MB_total = (double)num_bytes_total / ((double) 1024 * (double)1024); printf("Total number of bytes that will be used in the matrix:\n"); printf("%lld Bytes ( %10.3f MBs )\n", num_bytes_total, MB_total); array_2D = malloc(array_size * sizeof(long long)); if (array_2D == NULL) { fprintf(stderr, "ERROR!!! Malloc of pointers failed\n"); exit(EXIT_FAILURE); } if (DEBUG) { printf("DEBUG -- Allocation of memory for array pointers succeeded!\n"); } // Time to create our inner array using the loop over our array pointers. fflush(NULL); int i=0; for (i=0; i< array_size; i++) { array_2D[i] = malloc(array_size * sizeof(long long)); if (array_2D[i] == NULL) { fprintf(stderr,"ERROR!!! Allocation of memory for array position %d failed\n", i); fprintf(stderr,"Fatal Error... Usually out of memory. Exitting.\n"); exit(EXIT_FAILURE); } } if (DEBUG) { printf("DEBUG -- Successful allocation of all array elements\n"); } if (DEBUG||INFO) { printf("INFO -- Zeroing out all of the array information\n"); } int j = 0; for (j = 0; j < array_size; j++) { for (i = 0; i < array_size; i++) { array_2D[j][i] = 0; } if ( j % 500 == 0 && VERBOSE) { printf("Completed zeroing at array indices[%d][%d]\n",j,i); } } printf("Completed zeroing all matrix elements.\n"); printf("Filling row 0 with even elements\n"); fflush(NULL); for (i = 0; i < array_size; i++) { array_2D[0][i] = i*2; if (i % 500 == 0 && VERBOSE) { printf("Completed filling row 0 to position: %d\n", i); } } printf("Filling column 0 with odd elements (Excluding 0,0)\n"); for (i = 0; i < array_size; i++) { if (i == 0) { array_2D[i][0] = 0; } else { array_2D[i][0] = (i*2)-1; // Creating odd elements } if (i % 500 == 0 && VERBOSE) { printf("Completed filling column 0 to position: %d\n", i); fflush(NULL); } } fflush(NULL); printf("Generating matrices elements (internal)\n"); for (j=1; j < array_size; j++) { for (i=1; i < array_size; i++) { // Assign array_2D[j][i] now array_2D[j][i] = array_2D[0][i] + array_2D[j][0]; } if (j % 500 == 0 && VERBOSE) { printf("Finished filling in row: %d\n", j); fflush(NULL); } } fflush(NULL); gettimeofday(&tv_matrix_create_end, &tz); if (DEBUG||INFO) { printf("DEBUG -- Preparing to transpose...\n"); printf("DEBUG -- Doing this the inefficient way (on purpose)\n"); printf("DEBUG -- Creating array of %d elements for transpose\n", array_size); } /* temp_array=malloc(array_size * sizeof(temp_array)); if (temp_array == NULL) { printf("Error!!! Malloc failed for temporary array. Exitting!\n"); exit(EXIT_FAILURE); } */ fflush(NULL); if (DEBUG||INFO) { printf("INFO -- Preparing to copy and transpose\n"); } int subx=0; for (i = 0; i < array_size; i++) { for(subx = 0; subx < array_size; subx++) { temp_location = array_2D[i][subx]; array_2D[i][subx] = array_2D[subx][i]; array_2D[subx][i] = temp_location; // Cheap, cheesy brute force way of doing it... } if (i % 500 == 0 && VERBOSE) { printf("Finished transpose at element column: %d\n", i); fflush(NULL); } } gettimeofday(&tv_transpose_end, &tz); printf("Finished with transposition, running verification\n"); for (j = 0; j < array_size; j++) { for (i = 0; i < array_size; i++) { if (array_2D[j][i] != array_2D[j][0] + array_2D[0][i]) { printf("ERROR!!! Element at [%d][%d] (j,i) does not match additive\n", j,i); printf("(%lld + %lld != %lld (From array: %lld)\n", array_2D[j][0],array_2D[0][i], array_2D[j][0] + array_2D[0][i] , array_2D[j][i]); FLAG++; } } if (j % 500 == 0 && VERBOSE) { printf("Finished verification at: [%d][%d]\n", j,i); fflush(NULL); } } fflush(NULL); gettimeofday(&tv_matrix_verify_end, &tz); //printf("tv_matrix_test_start time: %d.%d\n",tv_matrix_test_start.tv_sec, tv_matrix_test_start.tv_usec); //printf("tv_matrix_create_end time: %d.%d\n",tv_matrix_create_end.tv_sec, tv_matrix_create_end.tv_usec); //printf("tv_transpose_end time: %d.%d\n",tv_transpose_end.tv_sec, // tv_transpose_end.tv_usec); //printf("tv_matrix_verify_end time: %d.%d\n",tv_matrix_verify_end.tv_sec, tv_matrix_verify_end.tv_usec); double matrix_create_secs = convert_time_difference(tv_matrix_test_start, tv_matrix_create_end); double matrix_trans_secs = convert_time_difference(tv_matrix_create_end, tv_transpose_end); double matrix_verify_secs = convert_time_difference(tv_transpose_end, tv_matrix_verify_end); double matrix_transpose_test_total = convert_time_difference(tv_matrix_test_start, tv_matrix_verify_end); printf("-------------------------------------------------\n\n"); printf("Total Transpose Time (with verify): %14.4f\n", matrix_transpose_test_total); printf("Matrix Creation Time: %14.4f\n", matrix_create_secs); printf("Matrix Transpose Time: %14.4f\n", matrix_trans_secs); printf("Matrix Verify Time: %14.4f\n", matrix_verify_secs); printf("Transpose Benchmark Index: %14.4f\n", MB_total / matrix_transpose_test_total); printf("\n\n"); printf("-------------------------------------------------\n"); time(&time_stamp); char * str_ptr_orig = ctime(&time_stamp); if (FLAG) { printf("TRANSPOSE TEST: Run FAILED with %hd failures. TIMESTAMP: %s", FLAG, str_ptr_orig); } else { printf("TRANSPOSE TEST: Run SUCCEEDED. TIMESTAMP: %s", str_ptr_orig); } /* if (DEBUG) { printf("Freeing temp_array\n"); } free(temp_array); */ if (DEBUG) { printf("DEBUG -- Freeing array memory (1st level)\n"); } for (i = 0; i < array_size; i++) { //if (DEBUG) { // printf("DEBUG -- Deleting array_2D[%d]\n", i); //} free(array_2D[i]); } if (DEBUG) { printf("DEBUG -- Freeing array pointer memory...\n"); } free(array_2D); fflush(NULL); //printf("\n\nCalling LU_Decomp routines\n"); // Add a variable here to pass user supplied matrix size to LU_Decomp // program. If we pass anything less than 3, we will use the default // matrix size. } src32/transpose.h0000644005635700000120000000320510332224655013544 0ustar weathnrwheel #ifndef TRANSPOSE_H #define TRANSPOSE_H /*************************************************************************** * Copyright (C) 2005 by Norman Weathers 639-2727 ,LO-2003 * * weathnr@hoprlw10 * * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU General Public License as published by * * the Free Software Foundation; either version 2 of the License, or * * (at your option) any later version. * * * * This program is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * * GNU General Public License for more details. * * * * You should have received a copy of the GNU General Public License * * along with this program; if not, write to the * * Free Software Foundation, Inc., * * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * ***************************************************************************/ #include #include #include #include #include #include extern int DEBUG; extern int INFO; extern int VERBOSE; void transpose(int matrix_size); #endif src32/Makefile.orig0000644005635700000120000000246510321560362013757 0ustar weathnrwheel# Makefile for matrix_test CC=gcc -march=pentium3 -m32 CFLAGS=-lgsl -lgslcblas -lm -lpthread STATIC=-static EEE=matrix_test EEE_STATIC=matrix_test.static matrix_test.static: matrix_test.o transpose.o lu_decomp.o test_utils.o gsl_sort.o memcpy_test.o ${CC} -O2 ${STATIC} -o ${EEE_STATIC} matrix_test.o transpose.o lu_decomp.o test_utils.o gsl_sort.o memcpy_test.o ${CFLAGS} make all all: matrix_test.o transpose.o lu_decomp.o test_utils.o gsl_sort.o memcpy_test.o ${CC} -O2 ${CFLAGS} -o ${EEE} matrix_test.o transpose.o lu_decomp.o test_utils.o gsl_sort.o memcpy_test.o transpose.o: transpose.h matrix_test.h lu_decomp.h defines.h transpose.c test_utils.h ${CC} -O2 -o transpose.o -c transpose.c lu_decomp.o: lu_decomp.c lu_decomp.h defines.h matrix_test.h test_utils.h ${CC} -O2 -o lu_decomp.o -c lu_decomp.c gsl_sort.o: gsl_source.c gsl_sort.h matrix_test.h test_utils.h ${CC} -O2 -o gsl_sort.o -c gsl_source.c matrix_test.o: matrix_test.c matrix_test.h lu_decomp.h defines.h transpose.h ${CC} -O2 -o matrix_test.o -c matrix_test.c test_utils.o: defines.h test_utils.h test_utils.c ${CC} -O2 -o test_utils.o -c test_utils.c memcpy_test.o: memcpy_test.h memcpy_test.c ${CC} -O2 -o memcpy_test.o -c memcpy_test.c clean: echo "Copying in new src files" cp ../src/*.[ch] . rm -f *.o matrix_test matrix_test.static src32/changes.h0000644005635700000120000000366610332224654013150 0ustar weathnrwheel/*************************************************************************** * Copyright (C) 2005 by Norman Weathers 639-2727 ,LO-2003 * * weathnr@hoprlw10 * * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU General Public License as published by * * the Free Software Foundation; either version 2 of the License, or * * (at your option) any later version. * * * * This program is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * * GNU General Public License for more details. * * * * You should have received a copy of the GNU General Public License * * along with this program; if not, write to the * * Free Software Foundation, Inc., * * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * ***************************************************************************/ /* 20051102 -- Added safeguards to protect the 32 bit executable from segfaulting in case of nodes having > 2 GB of Total Memory. This program will not allow auto types > 2.3 GB. This only will protect during auto configuration of the executable. 20051025 -- Started to put the disk writer/reader portion of the link list test together. This will write out some portion of the link list to some location and allow it to be read back in and then compared to memory. This will hopefully stress the DMA channels, memory, CPU, and a little bit of the disk as well. */