From 6ea9939e0610a809f6f47d13ec68df00d1ca0afc Mon Sep 17 00:00:00 2001 From: Joshua Bakita Date: Fri, 16 Oct 2020 16:55:14 -0400 Subject: Move the DIS benchmarks up a directory and update hardcoded paths Note that this repo does not attempt to keep a copy of the original DIS benchmark distributions. UNC real-time has another repo for that. --- dis/Field/DISstressmarkRNG.h | 190 +++++++++ dis/Field/field.c | 153 +++++++ dis/Makefile | 38 ++ dis/Matrix/ver1/DISstressmarkRNG.h | 190 +++++++++ dis/Matrix/ver1/matrix.c | 600 +++++++++++++++++++++++++++ dis/Matrix/ver2/DISstressmarkRNG.h | 190 +++++++++ dis/Matrix/ver2/matrix.c | 594 ++++++++++++++++++++++++++ dis/Neighborhood/DISstressmarkRNG.h | 190 +++++++++ dis/Neighborhood/neighborhood.c | 103 +++++ dis/Neighborhood/utili.h | 363 ++++++++++++++++ dis/Pointer/DISstressmarkRNG.h | 190 +++++++++ dis/Pointer/pointer.c | 159 +++++++ dis/Transitive/DISstressmarkRNG.h | 190 +++++++++ dis/Transitive/transitive.c | 131 ++++++ dis/Update/DISstressmarkRNG.h | 190 +++++++++ dis/Update/update.c | 138 ++++++ dis/WSS_DOCS.md | 83 ++++ dis/clean.sh | 1 + dis/gen_input.py | 113 +++++ dis/inputs/Field/in1 | 179 ++++++++ dis/inputs/Field/in2 | 179 ++++++++ dis/inputs/Field/in3 | 45 ++ dis/inputs/Field/in4 | 90 ++++ dis/inputs/Field/in5 | 198 +++++++++ dis/inputs/Field/in6 | 201 +++++++++ dis/inputs/Field/in7 | 197 +++++++++ dis/inputs/Matrix/in1 | 1 + dis/inputs/Matrix/in2 | 3 + dis/inputs/Matrix/in3 | 1 + dis/inputs/Matrix/in4 | 1 + dis/inputs/Matrix/in5 | 1 + dis/inputs/Matrix/in6 | 1 + dis/inputs/Matrix/in7 | 1 + dis/inputs/Neighborhood/in1 | 2 + dis/inputs/Neighborhood/in2 | 2 + dis/inputs/Neighborhood/in3 | 2 + dis/inputs/Neighborhood/in4 | 2 + dis/inputs/Neighborhood/in5 | 2 + dis/inputs/Pointer/in1 | 13 + dis/inputs/Pointer/in10 | 12 + dis/inputs/Pointer/in2 | 8 + dis/inputs/Pointer/in3 | 5 + dis/inputs/Pointer/in4 | 12 + dis/inputs/Pointer/in5 | 8 + dis/inputs/Pointer/in6 | 12 + dis/inputs/Pointer/in7 | 12 + dis/inputs/Pointer/in8 | 12 + dis/inputs/Pointer/in9 | 12 + dis/inputs/Transitive/in1 | 1 + dis/inputs/Transitive/in2 | 1 + dis/inputs/Transitive/in3 | 1 + dis/inputs/Transitive/in4 | 1 + dis/inputs/Transitive/in5 | 1 + dis/inputs/Transitive/in6 | 1 + dis/inputs/Transitive/in7 | 1 + dis/inputs/Transitive/in8 | 1 + dis/inputs/Update/in1 | 1 + dis/inputs/Update/in2 | 1 + dis/inputs/Update/in3 | 1 + dis/inputs/Update/in4 | 1 + dis/inputs/Update/in5 | 1 + dis/inputs/Update/in6 | 1 + dis/inputs/Update/in7 | 1 + dis/inputs/Update/in8 | 1 + dis/inputs/WSSS | 12 + dis/inputs/WSSS_maxstride4mb | 16 + dis/inputs/caches | 7 + dis/inputs/caches_maxstride2ways | 11 + dis/inputs/random_walk/in1 | 1 + dis/original/Field/DISstressmarkRNG.h | 190 --------- dis/original/Field/field.c | 153 ------- dis/original/Makefile | 38 -- dis/original/Matrix/ver1/DISstressmarkRNG.h | 190 --------- dis/original/Matrix/ver1/matrix.c | 600 --------------------------- dis/original/Matrix/ver2/DISstressmarkRNG.h | 190 --------- dis/original/Matrix/ver2/matrix.c | 594 -------------------------- dis/original/Neighborhood/DISstressmarkRNG.h | 190 --------- dis/original/Neighborhood/neighborhood.c | 103 ----- dis/original/Neighborhood/utili.h | 363 ---------------- dis/original/Pointer/DISstressmarkRNG.h | 190 --------- dis/original/Pointer/pointer.c | 159 ------- dis/original/Transitive/DISstressmarkRNG.h | 190 --------- dis/original/Transitive/transitive.c | 131 ------ dis/original/Update/DISstressmarkRNG.h | 190 --------- dis/original/Update/update.c | 138 ------ dis/original/WSS_DOCS.md | 83 ---- dis/original/clean.sh | 1 - dis/original/gen_input.py | 113 ----- dis/original/inputs/Field/in1 | 179 -------- dis/original/inputs/Field/in2 | 179 -------- dis/original/inputs/Field/in3 | 45 -- dis/original/inputs/Field/in4 | 90 ---- dis/original/inputs/Field/in5 | 198 --------- dis/original/inputs/Field/in6 | 201 --------- dis/original/inputs/Field/in7 | 197 --------- dis/original/inputs/Matrix/in1 | 1 - dis/original/inputs/Matrix/in2 | 3 - dis/original/inputs/Matrix/in3 | 1 - dis/original/inputs/Matrix/in4 | 1 - dis/original/inputs/Matrix/in5 | 1 - dis/original/inputs/Matrix/in6 | 1 - dis/original/inputs/Matrix/in7 | 1 - dis/original/inputs/Neighborhood/in1 | 2 - dis/original/inputs/Neighborhood/in2 | 2 - dis/original/inputs/Neighborhood/in3 | 2 - dis/original/inputs/Neighborhood/in4 | 2 - dis/original/inputs/Neighborhood/in5 | 2 - dis/original/inputs/Pointer/in1 | 13 - dis/original/inputs/Pointer/in10 | 12 - dis/original/inputs/Pointer/in2 | 8 - dis/original/inputs/Pointer/in3 | 5 - dis/original/inputs/Pointer/in4 | 12 - dis/original/inputs/Pointer/in5 | 8 - dis/original/inputs/Pointer/in6 | 12 - dis/original/inputs/Pointer/in7 | 12 - dis/original/inputs/Pointer/in8 | 12 - dis/original/inputs/Pointer/in9 | 12 - dis/original/inputs/Transitive/in1 | 1 - dis/original/inputs/Transitive/in2 | 1 - dis/original/inputs/Transitive/in3 | 1 - dis/original/inputs/Transitive/in4 | 1 - dis/original/inputs/Transitive/in5 | 1 - dis/original/inputs/Transitive/in6 | 1 - dis/original/inputs/Transitive/in7 | 1 - dis/original/inputs/Transitive/in8 | 1 - dis/original/inputs/Update/in1 | 1 - dis/original/inputs/Update/in2 | 1 - dis/original/inputs/Update/in3 | 1 - dis/original/inputs/Update/in4 | 1 - dis/original/inputs/Update/in5 | 1 - dis/original/inputs/Update/in6 | 1 - dis/original/inputs/Update/in7 | 1 - dis/original/inputs/Update/in8 | 1 - dis/original/inputs/WSSS | 12 - dis/original/inputs/WSSS_maxstride4mb | 16 - dis/original/inputs/caches | 7 - dis/original/inputs/caches_maxstride2ways | 11 - dis/original/inputs/random_walk/in1 | 1 - dis/original/postproc.sh | 3 - dis/original/random_walk.c | 550 ------------------------ dis/original/runDIS1.sh | 2 - dis/original/runDIS2.sh | 2 - dis/original/runDIS4.sh | 5 - dis/original/run_dis.sh | 81 ---- dis/original/setup_mem_and_global.sh | 13 - dis/original/summarize.py | 71 ---- dis/postproc.sh | 3 + dis/random_walk.c | 550 ++++++++++++++++++++++++ dis/runDIS1.sh | 2 + dis/runDIS2.sh | 2 + dis/runDIS4.sh | 5 + dis/run_dis.sh | 81 ++++ dis/setup_mem_and_global.sh | 13 + dis/summarize.py | 71 ++++ 154 files changed, 5810 insertions(+), 5810 deletions(-) create mode 100644 dis/Field/DISstressmarkRNG.h create mode 100644 dis/Field/field.c create mode 100755 dis/Makefile create mode 100755 dis/Matrix/ver1/DISstressmarkRNG.h create mode 100755 dis/Matrix/ver1/matrix.c create mode 100755 dis/Matrix/ver2/DISstressmarkRNG.h create mode 100755 dis/Matrix/ver2/matrix.c create mode 100644 dis/Neighborhood/DISstressmarkRNG.h create mode 100644 dis/Neighborhood/neighborhood.c create mode 100644 dis/Neighborhood/utili.h create mode 100644 dis/Pointer/DISstressmarkRNG.h create mode 100644 dis/Pointer/pointer.c create mode 100644 dis/Transitive/DISstressmarkRNG.h create mode 100644 dis/Transitive/transitive.c create mode 100644 dis/Update/DISstressmarkRNG.h create mode 100644 dis/Update/update.c create mode 100644 dis/WSS_DOCS.md create mode 100755 dis/clean.sh create mode 100755 dis/gen_input.py create mode 100644 dis/inputs/Field/in1 create mode 100644 dis/inputs/Field/in2 create mode 100644 dis/inputs/Field/in3 create mode 100644 dis/inputs/Field/in4 create mode 100644 dis/inputs/Field/in5 create mode 100644 dis/inputs/Field/in6 create mode 100644 dis/inputs/Field/in7 create mode 100644 dis/inputs/Matrix/in1 create mode 100644 dis/inputs/Matrix/in2 create mode 100644 dis/inputs/Matrix/in3 create mode 100644 dis/inputs/Matrix/in4 create mode 100644 dis/inputs/Matrix/in5 create mode 100644 dis/inputs/Matrix/in6 create mode 100644 dis/inputs/Matrix/in7 create mode 100644 dis/inputs/Neighborhood/in1 create mode 100644 dis/inputs/Neighborhood/in2 create mode 100644 dis/inputs/Neighborhood/in3 create mode 100644 dis/inputs/Neighborhood/in4 create mode 100644 dis/inputs/Neighborhood/in5 create mode 100644 dis/inputs/Pointer/in1 create mode 100644 dis/inputs/Pointer/in10 create mode 100644 dis/inputs/Pointer/in2 create mode 100644 dis/inputs/Pointer/in3 create mode 100644 dis/inputs/Pointer/in4 create mode 100644 dis/inputs/Pointer/in5 create mode 100644 dis/inputs/Pointer/in6 create mode 100644 dis/inputs/Pointer/in7 create mode 100644 dis/inputs/Pointer/in8 create mode 100644 dis/inputs/Pointer/in9 create mode 100644 dis/inputs/Transitive/in1 create mode 100644 dis/inputs/Transitive/in2 create mode 100644 dis/inputs/Transitive/in3 create mode 100644 dis/inputs/Transitive/in4 create mode 100644 dis/inputs/Transitive/in5 create mode 100644 dis/inputs/Transitive/in6 create mode 100644 dis/inputs/Transitive/in7 create mode 100644 dis/inputs/Transitive/in8 create mode 100644 dis/inputs/Update/in1 create mode 100644 dis/inputs/Update/in2 create mode 100644 dis/inputs/Update/in3 create mode 100644 dis/inputs/Update/in4 create mode 100644 dis/inputs/Update/in5 create mode 100644 dis/inputs/Update/in6 create mode 100644 dis/inputs/Update/in7 create mode 100644 dis/inputs/Update/in8 create mode 100644 dis/inputs/WSSS create mode 100644 dis/inputs/WSSS_maxstride4mb create mode 100644 dis/inputs/caches create mode 100644 dis/inputs/caches_maxstride2ways create mode 100644 dis/inputs/random_walk/in1 delete mode 100644 dis/original/Field/DISstressmarkRNG.h delete mode 100644 dis/original/Field/field.c delete mode 100755 dis/original/Makefile delete mode 100755 dis/original/Matrix/ver1/DISstressmarkRNG.h delete mode 100755 dis/original/Matrix/ver1/matrix.c delete mode 100755 dis/original/Matrix/ver2/DISstressmarkRNG.h delete mode 100755 dis/original/Matrix/ver2/matrix.c delete mode 100644 dis/original/Neighborhood/DISstressmarkRNG.h delete mode 100644 dis/original/Neighborhood/neighborhood.c delete mode 100644 dis/original/Neighborhood/utili.h delete mode 100644 dis/original/Pointer/DISstressmarkRNG.h delete mode 100644 dis/original/Pointer/pointer.c delete mode 100644 dis/original/Transitive/DISstressmarkRNG.h delete mode 100644 dis/original/Transitive/transitive.c delete mode 100644 dis/original/Update/DISstressmarkRNG.h delete mode 100644 dis/original/Update/update.c delete mode 100644 dis/original/WSS_DOCS.md delete mode 100755 dis/original/clean.sh delete mode 100755 dis/original/gen_input.py delete mode 100644 dis/original/inputs/Field/in1 delete mode 100644 dis/original/inputs/Field/in2 delete mode 100644 dis/original/inputs/Field/in3 delete mode 100644 dis/original/inputs/Field/in4 delete mode 100644 dis/original/inputs/Field/in5 delete mode 100644 dis/original/inputs/Field/in6 delete mode 100644 dis/original/inputs/Field/in7 delete mode 100644 dis/original/inputs/Matrix/in1 delete mode 100644 dis/original/inputs/Matrix/in2 delete mode 100644 dis/original/inputs/Matrix/in3 delete mode 100644 dis/original/inputs/Matrix/in4 delete mode 100644 dis/original/inputs/Matrix/in5 delete mode 100644 dis/original/inputs/Matrix/in6 delete mode 100644 dis/original/inputs/Matrix/in7 delete mode 100644 dis/original/inputs/Neighborhood/in1 delete mode 100644 dis/original/inputs/Neighborhood/in2 delete mode 100644 dis/original/inputs/Neighborhood/in3 delete mode 100644 dis/original/inputs/Neighborhood/in4 delete mode 100644 dis/original/inputs/Neighborhood/in5 delete mode 100644 dis/original/inputs/Pointer/in1 delete mode 100644 dis/original/inputs/Pointer/in10 delete mode 100644 dis/original/inputs/Pointer/in2 delete mode 100644 dis/original/inputs/Pointer/in3 delete mode 100644 dis/original/inputs/Pointer/in4 delete mode 100644 dis/original/inputs/Pointer/in5 delete mode 100644 dis/original/inputs/Pointer/in6 delete mode 100644 dis/original/inputs/Pointer/in7 delete mode 100644 dis/original/inputs/Pointer/in8 delete mode 100644 dis/original/inputs/Pointer/in9 delete mode 100644 dis/original/inputs/Transitive/in1 delete mode 100644 dis/original/inputs/Transitive/in2 delete mode 100644 dis/original/inputs/Transitive/in3 delete mode 100644 dis/original/inputs/Transitive/in4 delete mode 100644 dis/original/inputs/Transitive/in5 delete mode 100644 dis/original/inputs/Transitive/in6 delete mode 100644 dis/original/inputs/Transitive/in7 delete mode 100644 dis/original/inputs/Transitive/in8 delete mode 100644 dis/original/inputs/Update/in1 delete mode 100644 dis/original/inputs/Update/in2 delete mode 100644 dis/original/inputs/Update/in3 delete mode 100644 dis/original/inputs/Update/in4 delete mode 100644 dis/original/inputs/Update/in5 delete mode 100644 dis/original/inputs/Update/in6 delete mode 100644 dis/original/inputs/Update/in7 delete mode 100644 dis/original/inputs/Update/in8 delete mode 100644 dis/original/inputs/WSSS delete mode 100644 dis/original/inputs/WSSS_maxstride4mb delete mode 100644 dis/original/inputs/caches delete mode 100644 dis/original/inputs/caches_maxstride2ways delete mode 100644 dis/original/inputs/random_walk/in1 delete mode 100755 dis/original/postproc.sh delete mode 100644 dis/original/random_walk.c delete mode 100755 dis/original/runDIS1.sh delete mode 100755 dis/original/runDIS2.sh delete mode 100755 dis/original/runDIS4.sh delete mode 100755 dis/original/run_dis.sh delete mode 100755 dis/original/setup_mem_and_global.sh delete mode 100755 dis/original/summarize.py create mode 100755 dis/postproc.sh create mode 100644 dis/random_walk.c create mode 100755 dis/runDIS1.sh create mode 100755 dis/runDIS2.sh create mode 100755 dis/runDIS4.sh create mode 100755 dis/run_dis.sh create mode 100755 dis/setup_mem_and_global.sh create mode 100755 dis/summarize.py diff --git a/dis/Field/DISstressmarkRNG.h b/dis/Field/DISstressmarkRNG.h new file mode 100644 index 0000000..4aa2620 --- /dev/null +++ b/dis/Field/DISstressmarkRNG.h @@ -0,0 +1,190 @@ +#include + +#define IA 16807 +#define IM 2147483647 +#define AM (1.0/IM) +#define IQ 127773 +#define IR 2836 +#define NTAB 32 +#define NDIV (1+(IM-1)/NTAB) +#define EPS 1.2e-7 +#define RNMX (1.0-EPS) + +static long iy=0; +static long iv[NTAB]; +static long iseed; + +int ABS(int x){ + if (x>= 0) return x; + else + return (-x); +} + +int sign(int x){ + if (x >= 0) return 1; + else + return (-1); +} + +int MAX(int x, int y){ + if (x>= y) return x; + else + return y; +} + +int MIN(int x, int y){ + if (x<= y) return x; + else + return y; +} + +void randInit(long idum) +{ + long j; + long k; + + assert (idum <= 0); + assert (iy == 0); + + iseed = idum; + if (-(iseed)<1){ + iseed = 1; + } + else { + iseed = -(iseed); + } + for (j=NTAB+7; j>=0; j--){ + k = (iseed)/IQ; + iseed = IA*(iseed-k*IQ)-IR*k; + if (iseed < 0){ + iseed += IM; + } + if (j < NTAB){ + iv[j] = iseed; + } + } + iy = iv[0]; +} + +float randNum() +{ + long j; + long k; + float temp; + + assert (iy != 0); + + k = (iseed)/IQ; + iseed = IA*(iseed-k*IQ)-IR*k; + + if (iseed < 0){ + iseed += IM; + } + j = iy/NDIV; + iy = iv[j]; + iv[j] = iseed; + + temp = AM * iy; + + if (temp > RNMX){ + return RNMX; + } + else { + return temp; + } +} + + +float randomFloat(float lowest_float, float highest_float) +{ + float value; + float range; + +assert (lowest_float < highest_float); + +range = highest_float - lowest_float; +value = randNum()*(highest_float - lowest_float) + lowest_float; +assert(value >= lowest_float); +assert(value <= highest_float); + +return value; + +} + +float randomNonZeroFloat(float lowest_float, float highest_float, float epsilon) +{ + + double range; + float value; + + + assert (lowest_float < 0); + assert (highest_float > 0); + assert (epsilon > 0); + assert ((epsilon < -lowest_float) && (epsilon < highest_float)); + + range = highest_float - lowest_float; + value = (randNum() * range)+lowest_float; + + if (ABS(value) < epsilon) + { + if (value > 0) value = value + epsilon; + else if (value < 0) value = value - epsilon; + + } + + assert (value >= lowest_float); + assert (value <= highest_float); + + return value; +} + +unsigned int randomUInt(int lowest_uint, int highest_uint) +{ + float range; + unsigned int value; + float temp; + + range =(float)(highest_uint - lowest_uint + 1); + temp = randNum(); + value =(unsigned int)( floor(temp * range) + lowest_uint); + + assert (value >= lowest_uint); + assert (value <= highest_uint); + + return value; +} + +unsigned int randomNonZeroUInt(int lowest_uint, int highest_uint) +{ + float range; + unsigned int value; + float temp; + + range =(float)(highest_uint - lowest_uint + 1); + value = 0; + while(value == 0){ + temp = randNum(); + + value =(unsigned int)( floor(temp * range) + lowest_uint); + } + + assert (value >= lowest_uint); + assert (value <= highest_uint); + + return value; +} + +int randInt(int lowest_uint, int highest_uint) +{ + float range; + int value; + + range = highest_uint - lowest_uint + 1; + value = (int)(floor(randNum() * range) + lowest_uint); + + assert (value >= lowest_uint); + assert (value <= highest_uint); + + return value; +} diff --git a/dis/Field/field.c b/dis/Field/field.c new file mode 100644 index 0000000..8565e8c --- /dev/null +++ b/dis/Field/field.c @@ -0,0 +1,153 @@ +/* + * Sample code for the DIS Field Stressmark + * + * This source code is the completely correct source code based on + * the example codes provided by Atlantic Aerospace Division, Titan + * Systems Corporation, 2000. + * + * If you just compile and generate the executables from this source + * code, this code would be enough. However, if you wish to get a complete + * understanding of this stressmark, it is strongly suggested that you + * read the Benchmark Analysis and Specifications Document Version 1.0 + * before going on since the detailed comments are given in this documents. + * the comments are not repeated here. + */ + +#include +#include +#include +#include +#include "DISstressmarkRNG.h" +#include "extra.h" + + +#define MIN_FIELD_SIZE 16 +#define MAX_FIELD_SIZE (16777216*4) // This has been quadrupled from original +#define MIN_SEED -2147483647 +#define MAX_SEED -1 +#define MIN_MOD_OFFSET 0 +#define MAX_MOD_OFFSET 65535 +#define MIN_TOKENS 1 +#define MAX_TOKENS 256 +#define MIN_TOKEN_LENGTH 1 +#define MAX_TOKEN_LENGTH 8 +#define MIN_TOKEN_VALUE 0 +#define MAX_TOKEN_VALUE 255 +#define MAX_SUBFIELDS 256 + +/* + * main() + */ + +int main(int argc, char** argv){ + SET_UP + unsigned char *field; + unsigned int f; + int seed; + int mod_offset; + unsigned int n; + + time_t startTime; + + struct tokenS{ + unsigned char delimiter[MAX_TOKEN_LENGTH]; + unsigned char length; + struct statisticS{ + unsigned int count; + unsigned char min; + unsigned char sum; + }stat[MAX_SUBFIELDS]; + unsigned char subfields; + }token[MAX_TOKENS]; + + unsigned int l; + + assert(fscanf(stdin, "%d %d %d %d", &f, &seed, &mod_offset, &n) == 4); + + assert((f >= MIN_FIELD_SIZE) && (f <= MAX_FIELD_SIZE)); + assert((seed >= MIN_SEED) && (seed <= MAX_SEED)); + assert((mod_offset >= MIN_MOD_OFFSET) && (mod_offset <= MAX_MOD_OFFSET)); + assert((n >= MIN_TOKENS) && (n <= MAX_TOKENS)); + for (l=0; l= MIN_TOKEN_VALUE) && (x <= MAX_TOKEN_VALUE)); + token[l].delimiter[index] = (unsigned char )x; + index++; + assert(fscanf(stdin,"%x", &x) == 1); + } + assert((index >= MIN_TOKEN_LENGTH) && (index <= MAX_TOKEN_LENGTH)); + token[l].length = index; + } + + if ((field = (unsigned char*)malloc(f*sizeof(unsigned char))) == NULL) + return (-1); + + randInit(seed); + for (l =0; l field[index]) + token[l].stat[token[l].subfields].min = field[index]; + } + index++; + } + token[l].subfields++; + STOP_LOOP + } + + startTime = time(NULL) - startTime; + + for (l = 0; l< n; l++){ + unsigned int ll; + fprintf(stdout, "%d subfields for token %d \n", token[l].subfields, l); + for ( ll =0; ll + +#define IA 16807 +#define IM 2147483647 +#define AM (1.0/IM) +#define IQ 127773 +#define IR 2836 +#define NTAB 32 +#define NDIV (1+(IM-1)/NTAB) +#define EPS 1.2e-7 +#define RNMX (1.0-EPS) + +static long iy=0; +static long iv[NTAB]; +static long iseed; + +int ABS(int x){ + if (x>= 0) return x; + else + return (-x); +} + +int sign(int x){ + if (x >= 0) return 1; + else + return (-1); +} + +int MAX(int x, int y){ + if (x>= y) return x; + else + return y; +} + +int MIN(int x, int y){ + if (x<= y) return x; + else + return y; +} + +void randInit(long idum) +{ + long j; + long k; + + assert (idum <= 0); + assert (iy == 0); + + iseed = idum; + if (-(iseed)<1){ + iseed = 1; + } + else { + iseed = -(iseed); + } + for (j=NTAB+7; j>=0; j--){ + k = (iseed)/IQ; + iseed = IA*(iseed-k*IQ)-IR*k; + if (iseed < 0){ + iseed += IM; + } + if (j < NTAB){ + iv[j] = iseed; + } + } + iy = iv[0]; +} + +float randNum() +{ + long j; + long k; + float temp; + + assert (iy != 0); + + k = (iseed)/IQ; + iseed = IA*(iseed-k*IQ)-IR*k; + + if (iseed < 0){ + iseed += IM; + } + j = iy/NDIV; + iy = iv[j]; + iv[j] = iseed; + + temp = AM * iy; + + if (temp > RNMX){ + return RNMX; + } + else { + return temp; + } +} + + +float randomFloat(float lowest_float, float highest_float) +{ + float value; + float range; + +assert (lowest_float < highest_float); + +range = highest_float - lowest_float; +value = randNum()*(highest_float - lowest_float) + lowest_float; +assert(value >= lowest_float); +assert(value <= highest_float); + +return value; + +} + +float randomNonZeroFloat(float lowest_float, float highest_float, float epsilon) +{ + + double range; + float value; + + + assert (lowest_float < 0); + assert (highest_float > 0); + assert (epsilon > 0); + assert ((epsilon < -lowest_float) && (epsilon < highest_float)); + + range = highest_float - lowest_float; + value = (randNum() * range)+lowest_float; + + if (ABS(value) < epsilon) + { + if (value > 0) value = value + epsilon; + else if (value < 0) value = value - epsilon; + + } + + assert (value >= lowest_float); + assert (value <= highest_float); + + return value; +} + +unsigned int randomUInt(int lowest_uint, int highest_uint) +{ + float range; + unsigned int value; + float temp; + + range =(float)(highest_uint - lowest_uint + 1); + temp = randNum(); + value =(unsigned int)( floor(temp * range) + lowest_uint); + + assert (value >= lowest_uint); + assert (value <= highest_uint); + + return value; +} + +unsigned int randomNonZeroUInt(int lowest_uint, int highest_uint) +{ + float range; + unsigned int value; + float temp; + + range =(float)(highest_uint - lowest_uint + 1); + value = 0; + while(value == 0){ + temp = randNum(); + + value =(unsigned int)( floor(temp * range) + lowest_uint); + } + + assert (value >= lowest_uint); + assert (value <= highest_uint); + + return value; +} + +int randInt(int lowest_uint, int highest_uint) +{ + float range; + int value; + + range = highest_uint - lowest_uint + 1; + value = (int)(floor(randNum() * range) + lowest_uint); + + assert (value >= lowest_uint); + assert (value <= highest_uint); + + return value; +} diff --git a/dis/Matrix/ver1/matrix.c b/dis/Matrix/ver1/matrix.c new file mode 100755 index 0000000..518a638 --- /dev/null +++ b/dis/Matrix/ver1/matrix.c @@ -0,0 +1,600 @@ +/* + * Sample code for the DIS Matrix Stressmark + * + * This source code is the completely correct source code based on + * the example codes provided by Atlantic Aerospace Division, Titan + * Systems Corporation, 2000. + * + * If you just compile and generate the executables from this source + * code, this code would be enough. However, if you wish to get a complete + * understanding of this stressmark, it is strongly suggested that you + * read the Benchmark Analysis and Specifications Document Version 1.0 + * before going on since the detailed comments are given in this documents. + * the comments are not repeated here. + */ + +/* + * The Sparse Matrix Storage is implemented by Compact Row Storage Scheme + * In the code, the data is first generated by randomNonzeroFloat() + * the data is first stored in a full-space matrix with size of dim*dim + * then the data is transfered to the Compact Row Matrix, + * the data value is kept in *value, + * the columns corresponding to the value are stored in *col_ind, + * the start element of each row is stored in *row_start. + */ + +/* + * Please note: + * the total number of data is numberNonzero +dim + * among which, NumberNonzero because this is symmetric matrix + * dim because the diagonal elements + */ + +#include +#include +#include +#include +#include +#include "DISstressmarkRNG.h" + +#define MIN_SEED -2147483647 +#define MAX_SEED -1 +#define MIN_DIM 1 +#define MAX_DIM 32768 +#define MAX_ITERATIONS 65536 +#define MIN_TOLERANCE 0.000007 +#define MAX_TOLERANCE 0.5 +#define MIN_NUMBER -3.4e10/dim +#define MAX_NUMBER 3.4e10/dim +#define EPSI 1.0e-10 +#define MIN_DIG_NUMBER 1.0e-10 +#define MAX_DIG_NUMBER 3.4e10 + +/* + * External variable, dimension + */ + +static int dim; + +/* + * matrix * vector + */ + +double *matrixMulvector(double *value, + int *col_ind, + int *row_start, + double *vector) +{ + int l, ll; + double *out; + double sum; + int tmp_rs, tmp_re; + + out = (double *)malloc(dim*sizeof(double)); + + for (l=0; l + */ +double *valueMulvector(double value, double *vector){ + + int l; + double *vect; + int lll; + double sum; + + vect = (double *) malloc(dim * sizeof(double )); + + for (l=0; l errorTolerance)){ + + /* + * alpha = (transpose(vectorR) * vectorR) / + * (transpose(vectorP) * (matrixA * vectorP) + */ + temp1 = matrixMulvector(value, col_ind, row_start, vectorP); + temp3 = transpose(vectorR); + temp4 = transpose(vectorP); + temp5 = vectorMul(temp4, temp1); + temp6 = vectorMul(temp3, vectorR); + alpha = temp6/temp5; + + /* + * nextVectorR = vectorR - alpha*(matrixA * vectorP) + */ + + temp7 = valueMulvector(alpha, temp1); + temp8 = vectorSub(vectorR, temp7); + nextVectorR = equalVector(temp8); + + /* + * beta = (transpose(nextVectorR) * nextVectorR) / + * (transpose(vectorR) * vectorR) + */ + temp9 = transpose(nextVectorR); + temp10 = vectorMul(temp9, nextVectorR); + temp11 = transpose(vectorR); + temp12 = vectorMul(temp11, vectorR); + beta = temp10/temp12; + + /* + * vectorX = vectorX + alpha * vectorP + */ + temp13 = valueMulvector(alpha, vectorP); + vectorX = vectorAdd(vectorX,temp13); + + /* + *vectorP = nextVectorR + beta*vectorP + */ + temp14 = valueMulvector(beta, vectorP); + temp17 = vectorAdd(nextVectorR, temp14); + + for (ll=0; ll MIN_SEED) && (seed < MAX_SEED)); + assert((dim > MIN_DIM) && (dim < MAX_DIM)); + assert((numberNonzero > dim) && (numberNonzero < dim*dim)); + assert((maxIterations > 0) && (maxIterations < MAX_ITERATIONS)); + assert((errorTolerance > MIN_TOLERANCE) && (errorTolerance < MAX_TOLERANCE)); + + matrixA = (double *)malloc(dim*dim*sizeof(double )); + vectorB = (double *)malloc(dim*sizeof(double)); + vectorX = (double *)malloc(dim*sizeof(double)); + + value = (double *)malloc((numberNonzero+dim)*sizeof(double)); + col_ind = (int *)malloc((numberNonzero+dim)*sizeof(int)); + row_start = (int *)malloc((dim+1)*sizeof(int)); + + randInit(seed); + + initMatrix(matrixA, dim, numberNonzero); + + create_CRS(matrixA, value, col_ind, row_start, dim, numberNonzero); + + initVector(vectorB, dim); + zeroVector(vectorX, dim); + printf(" after init\n"); + + beginTime = time(NULL); + + actualError = 0; + actualIteration = 0; + + biConjugateGradient(value, col_ind, row_start, vectorB, vectorX, errorTolerance, + maxIterations, + &actualError, &actualIteration, dim); + + + + endTime = time(NULL) - beginTime; + + + + sum = 0; + for (k=1; k + +#define IA 16807 +#define IM 2147483647 +#define AM (1.0/IM) +#define IQ 127773 +#define IR 2836 +#define NTAB 32 +#define NDIV (1+(IM-1)/NTAB) +#define EPS 1.2e-7 +#define RNMX (1.0-EPS) + +static long iy=0; +static long iv[NTAB]; +static long iseed; + +int ABS(int x){ + if (x>= 0) return x; + else + return (-x); +} + +int sign(int x){ + if (x >= 0) return 1; + else + return (-1); +} + +int MAX(int x, int y){ + if (x>= y) return x; + else + return y; +} + +int MIN(int x, int y){ + if (x<= y) return x; + else + return y; +} + +void randInit(long idum) +{ + long j; + long k; + + assert (idum <= 0); + assert (iy == 0); + + iseed = idum; + if (-(iseed)<1){ + iseed = 1; + } + else { + iseed = -(iseed); + } + for (j=NTAB+7; j>=0; j--){ + k = (iseed)/IQ; + iseed = IA*(iseed-k*IQ)-IR*k; + if (iseed < 0){ + iseed += IM; + } + if (j < NTAB){ + iv[j] = iseed; + } + } + iy = iv[0]; +} + +float randNum() +{ + long j; + long k; + float temp; + + assert (iy != 0); + + k = (iseed)/IQ; + iseed = IA*(iseed-k*IQ)-IR*k; + + if (iseed < 0){ + iseed += IM; + } + j = iy/NDIV; + iy = iv[j]; + iv[j] = iseed; + + temp = AM * iy; + + if (temp > RNMX){ + return RNMX; + } + else { + return temp; + } +} + + +float randomFloat(float lowest_float, float highest_float) +{ + float value; + float range; + +assert (lowest_float < highest_float); + +range = highest_float - lowest_float; +value = randNum()*(highest_float - lowest_float) + lowest_float; +assert(value >= lowest_float); +assert(value <= highest_float); + +return value; + +} + +float randomNonZeroFloat(float lowest_float, float highest_float, float epsilon) +{ + + double range; + float value; + + + assert (lowest_float < 0); + assert (highest_float > 0); + assert (epsilon > 0); + assert ((epsilon < -lowest_float) && (epsilon < highest_float)); + + range = highest_float - lowest_float; + value = (randNum() * range)+lowest_float; + + if (ABS(value) < epsilon) + { + if (value > 0) value = value + epsilon; + else if (value < 0) value = value - epsilon; + + } + + assert (value >= lowest_float); + assert (value <= highest_float); + + return value; +} + +unsigned int randomUInt(int lowest_uint, int highest_uint) +{ + float range; + unsigned int value; + float temp; + + range =(float)(highest_uint - lowest_uint + 1); + temp = randNum(); + value =(unsigned int)( floor(temp * range) + lowest_uint); + + assert (value >= lowest_uint); + assert (value <= highest_uint); + + return value; +} + +unsigned int randomNonZeroUInt(int lowest_uint, int highest_uint) +{ + float range; + unsigned int value; + float temp; + + range =(float)(highest_uint - lowest_uint + 1); + value = 0; + while(value == 0){ + temp = randNum(); + + value =(unsigned int)( floor(temp * range) + lowest_uint); + } + + assert (value >= lowest_uint); + assert (value <= highest_uint); + + return value; +} + +int randInt(int lowest_uint, int highest_uint) +{ + float range; + int value; + + range = highest_uint - lowest_uint + 1; + value = (int)(floor(randNum() * range) + lowest_uint); + + assert (value >= lowest_uint); + assert (value <= highest_uint); + + return value; +} diff --git a/dis/Matrix/ver2/matrix.c b/dis/Matrix/ver2/matrix.c new file mode 100755 index 0000000..957d7c5 --- /dev/null +++ b/dis/Matrix/ver2/matrix.c @@ -0,0 +1,594 @@ +/* Please note: + * This code is the optimized version of the first version of Matrix + * Stressmark. It uses less temporary vectors and vsariables, thus reduce + * memory allocation/deallocation overhead. the simulation is faster + */ +/* + * Sample code for the DIS Matrix Stressmark + * + * This source code is the completely correct source code based on + * the example codes provided by Atlantic Aerospace Division, Titan + * Systems Corporation, 2000. + * + * If you just compile and generate the executables from this source + * code, this code would be enough. However, if you wish to get a complete + * understanding of this stressmark, it is strongly suggested that you + * read the Benchmark Analysis and Specifications Document Version 1.0 + * before going on since the detailed comments are given in this documents. + * the comments are not repeated here. + */ + +/* + * The Sparse Matrix Storage is implemented by Compact Row Storage Scheme + * In the code, the data is first generated by randomNonzeroFloat() + * the data is first stored in a full-space matrix with size of dim*dim + * then the data is transfered to the Compact Row Matrix, + * the data value is kept in *value, + * the columns corresponding to the value are stored in *col_ind, + * the start element of each row is stored in *row_start. + */ + +/* + * Please note: + * the total number of data is numberNonzero +dim + * among which, NumberNonzero because this is symmetric matrix + * dim because the diagonal elements + */ + +#include +#include +#include +#include +#include +#include "DISstressmarkRNG.h" +#include "extra.h" + +#define MIN_SEED -2147483647 +#define MAX_SEED -1 +#define MIN_DIM 1 +#define MAX_DIM 32768 +#define MAX_ITERATIONS 65536 +#define MIN_TOLERANCE 0.000007 +#define MAX_TOLERANCE 0.5 +#define MIN_NUMBER -3.4e10/dim +#define MAX_NUMBER 3.4e10/dim +#define EPSI 1.0e-10 +#define MIN_DIG_NUMBER 1.0e-10 +#define MAX_DIG_NUMBER 3.4e10 + +/* + * External variable, dimension + */ + +static int dim; +int argc; +char** argv; + +/* + * matrix * vector + */ + +void matrixMulvector(double *value, + int *col_ind, + int *row_start, + double *vector, + double *out) +{ + int l, ll; + double sum; + int tmp_rs, tmp_re; + + for (l=0; l + */ +void valueMulvector(double value, double *vector, double *vect){ + + int l; + int lll, i; + double tmp; + + for (l=0; l errorTolerance)){ + START_LOOP + + /* + * alpha = (transpose(vectorR) * vectorR) / + * (transpose(vectorP) * (matrixA * vectorP) + */ + + matrixMulvector(value, col_ind, row_start, vectorP, tmpVector1); + transpose(vectorR, tmpVector2); + transpose(vectorP, tmpVector3); + tmpValue1 = vectorMul(tmpVector3, tmpVector1); + tmpValue2 = vectorMul(tmpVector2, vectorR); + alpha = tmpValue2/tmpValue1; + + /* + * nextVectorR = vectorR - alpha*(matrixA * vectorP) + */ + + valueMulvector(alpha, tmpVector1, tmpVector2); + vectorSub(vectorR, tmpVector2, tmpVector1); + equalVector(tmpVector1, nextVectorR); + + /* + * beta = (transpose(nextVectorR) * nextVectorR) / + * (transpose(vectorR) * vectorR) + */ + + transpose(nextVectorR, tmpVector3); + tmpValue1 = vectorMul(tmpVector3, nextVectorR); + transpose(vectorR, tmpVector2); + tmpValue2 = vectorMul(tmpVector2, vectorR); + beta = tmpValue1/tmpValue2; + + /* + * vectorX = vectorX + alpha * vectorP + */ + valueMulvector(alpha, vectorP, tmpVector1); + vectorAdd(vectorX,tmpVector1, vectorX); + + /* + *vectorP = nextVectorR + beta*vectorP + */ + valueMulvector(beta, vectorP, tmpVector1); + vectorAdd(nextVectorR, tmpVector1, tmpVector1); + + for (ll=0; ll MIN_SEED) && (seed < MAX_SEED)); + assert((dim > MIN_DIM) && (dim < MAX_DIM)); + assert((numberNonzero > dim) && (numberNonzero < dim*dim)); + assert((maxIterations > 0) && (maxIterations < MAX_ITERATIONS)); + assert((errorTolerance > MIN_TOLERANCE) && (errorTolerance < MAX_TOLERANCE)); + + matrixA = (double *)malloc(dim*dim*sizeof(double )); + vectorB = (double *)malloc(dim*sizeof(double)); + vectorX = (double *)malloc(dim*sizeof(double)); + + value = (double *)malloc((numberNonzero+dim)*sizeof(double)); + col_ind = (int *)malloc((numberNonzero+dim)*sizeof(int)); + row_start = (int *)malloc((dim+1)*sizeof(int)); + + randInit(seed); + + initMatrix(matrixA, dim, numberNonzero); + + create_CRS(matrixA, value, col_ind, row_start, dim, numberNonzero); + + initVector(vectorB, dim); + zeroVector(vectorX, dim); + printf(" after init\n"); + + beginTime = time(NULL); + + actualError = 0; + actualIteration = 0; + + biConjugateGradient(value, col_ind, row_start, vectorB, vectorX, errorTolerance, + maxIterations, + &actualError, &actualIteration, dim); + + + + endTime = time(NULL) - beginTime; + + + + sum = 0; + for (k=1; k + +#define IA 16807 +#define IM 2147483647 +#define AM (1.0/IM) +#define IQ 127773 +#define IR 2836 +#define NTAB 32 +#define NDIV (1+(IM-1)/NTAB) +#define EPS 1.2e-7 +#define RNMX (1.0-EPS) + +static long iy=0; +static long iv[NTAB]; +static long iseed; + +int ABS(int x){ + if (x>= 0) return x; + else + return (-x); +} + +int sign(int x){ + if (x >= 0) return 1; + else + return (-1); +} + +int MAX(int x, int y){ + if (x>= y) return x; + else + return y; +} + +int MIN(int x, int y){ + if (x<= y) return x; + else + return y; +} + +void randInit(long idum) +{ + long j; + long k; + + assert (idum <= 0); + assert (iy == 0); + + iseed = idum; + if (-(iseed)<1){ + iseed = 1; + } + else { + iseed = -(iseed); + } + for (j=NTAB+7; j>=0; j--){ + k = (iseed)/IQ; + iseed = IA*(iseed-k*IQ)-IR*k; + if (iseed < 0){ + iseed += IM; + } + if (j < NTAB){ + iv[j] = iseed; + } + } + iy = iv[0]; +} + +float randNum() +{ + long j; + long k; + float temp; + + assert (iy != 0); + + k = (iseed)/IQ; + iseed = IA*(iseed-k*IQ)-IR*k; + + if (iseed < 0){ + iseed += IM; + } + j = iy/NDIV; + iy = iv[j]; + iv[j] = iseed; + + temp = AM * iy; + + if (temp > RNMX){ + return RNMX; + } + else { + return temp; + } +} + + +float randomFloat(float lowest_float, float highest_float) +{ + float value; + float range; + +assert (lowest_float < highest_float); + +range = highest_float - lowest_float; +value = randNum()*(highest_float - lowest_float) + lowest_float; +assert(value >= lowest_float); +assert(value <= highest_float); + +return value; + +} + +float randomNonZeroFloat(float lowest_float, float highest_float, float epsilon) +{ + + double range; + float value; + + + assert (lowest_float < 0); + assert (highest_float > 0); + assert (epsilon > 0); + assert ((epsilon < -lowest_float) && (epsilon < highest_float)); + + range = highest_float - lowest_float; + value = (randNum() * range)+lowest_float; + + if (ABS(value) < epsilon) + { + if (value > 0) value = value + epsilon; + else if (value < 0) value = value - epsilon; + + } + + assert (value >= lowest_float); + assert (value <= highest_float); + + return value; +} + +unsigned int randomUInt(int lowest_uint, int highest_uint) +{ + float range; + unsigned int value; + float temp; + + range =(float)(highest_uint - lowest_uint + 1); + temp = randNum(); + value =(unsigned int)( floor(temp * range) + lowest_uint); + + assert (value >= lowest_uint); + assert (value <= highest_uint); + + return value; +} + +unsigned int randomNonZeroUInt(int lowest_uint, int highest_uint) +{ + float range; + unsigned int value; + float temp; + + range =(float)(highest_uint - lowest_uint + 1); + value = 0; + while(value == 0){ + temp = randNum(); + + value =(unsigned int)( floor(temp * range) + lowest_uint); + } + + assert (value >= lowest_uint); + assert (value <= highest_uint); + + return value; +} + +int randInt(int lowest_uint, int highest_uint) +{ + float range; + int value; + + range = highest_uint - lowest_uint + 1; + value = (int)(floor(randNum() * range) + lowest_uint); + + assert (value >= lowest_uint); + assert (value <= highest_uint); + + return value; +} diff --git a/dis/Neighborhood/neighborhood.c b/dis/Neighborhood/neighborhood.c new file mode 100644 index 0000000..1736d38 --- /dev/null +++ b/dis/Neighborhood/neighborhood.c @@ -0,0 +1,103 @@ +/* + * Sample code for the DIS Neighborhood Stressmark + * + * This source code is the completely correct source code based on + * the example codes provided by Atlantic Aerospace Division, Titan + * Systems Corporation, 2000. + * + * If you just compile and generate the executables from this source + * code, this code would be enough. However, if you wish to get a complete + * understanding of this stressmark, it is strongly suggested that you + * read the Benchmark Analysis and Specifications Document Version 1.0 + * before going on since the detailed comments are given in this documents. + * the comments are not repeated here. + */ + +#include +#include +#include +#include +#include "DISstressmarkRNG.h" +#include "utili.h" +#include "extra.h" + +/* + * main() + */ +int main(int argc, char** argv) +{ + long int seed; + int dimension; + int numberLines; + int minThickness; + int maxThickness; + int distanceShort; + int distanceLong; + int bitDepth; + int maxPixel; + Pixel *image; + Neighborhood values; + + time_t beginTime; + time_t endTime; + SET_UP + + assert(fscanf(stdin, "%ld %d %d %d %d %d %d %d", + &seed, &bitDepth, &dimension, &numberLines, + &minThickness, &maxThickness, + &distanceShort, &distanceLong) == 8); + + assert((seed >= MIN_SEED) && (seed <= MAX_SEED)); + assert((dimension > 0) && (dimension <= MAX_DIMENSION)); + assert((numberLines > 0) && (numberLines <= MAX_NUMBER_LINES)); + assert((minThickness > 0) && (minThickness < dimension)); + assert((maxThickness >= minThickness) && (maxThickness < dimension)); + assert((distanceShort > 0) && (distanceShort < dimension)); + assert((distanceLong > 0) && (distanceLong < dimension)); + assert((bitDepth >= MIN_BIT_DEPTH) && (bitDepth <= MAX_BIT_DEPTH)); + + randInit(seed); + maxPixel = (1 << bitDepth) - 1; + image = createImage(dimension, maxPixel, numberLines, + minThickness, maxThickness); + assert (image != NULL); + + beginTime = time(NULL); + START_LOOP + neighborhoodCalculation(image, dimension, + distanceShort, distanceLong, &values, maxPixel); + STOP_LOOP + endTime = time(NULL); + WRITE_TO_FILE + +// printf(" end time is %d\n", endTime); + + fprintf(stdout, "%9.4e %9.4e %9.4e %9.4e %9.4e %9.4e %9.4e %9.4e", + values.distShort.deg0.entropy, + values.distShort.deg0.energy, + values.distShort.deg45.entropy, + values.distShort.deg45.energy, + values.distShort.deg90.entropy, + values.distShort.deg90.energy, + values.distShort.deg135.entropy, + values.distShort.deg135.energy); + + fprintf(stdout,"%9.4e %9.4e %9.4e %9.4e %9.4e %9.4e %9.4e %9.4e", + values.distLong.deg0.entropy, + values.distLong.deg0.energy,values.distShort.deg45.entropy, + values.distLong.deg45.energy, + values.distLong.deg90.entropy, + values.distLong.deg90.energy, + values.distLong.deg135.entropy, + values.distLong.deg135.energy); + + fprintf(stderr, "time for neghborhood stressmark = %f\n", + difftime(endTime, beginTime)); + + free((Pixel *)image); + return (SUCCESS); + } + + + + diff --git a/dis/Neighborhood/utili.h b/dis/Neighborhood/utili.h new file mode 100644 index 0000000..2a8e2a0 --- /dev/null +++ b/dis/Neighborhood/utili.h @@ -0,0 +1,363 @@ +/* + * Sample code for the DIS Pointer Stressmark + * + * This source code is the completely correct source code based on + * the example codes provided by Atlantic Aerospace Division, Titan + * Systems Corporation, 2000. + * + * If you just compile and generate the executables from this source + * code, this code would be enough. However, if you wish to get a complete + * understanding of this stressmark, it is strongly suggested that you + * read the Benchmark Analysis and Specifications Document Version 1.0 + * before going on since the detailed comments are given in this documents. + * the comments are not repeated here. + */ + +#include + +#define TRUE 1 +#define FALSE !TRUE +#define SUCCESS TRUE +#define ERROR FLASE + +#define MIN_PIXEL 0 +#define MAX_DIMENSION 32768 +#define MIN_SEED -2147483647 +#define MAX_SEED -1 +#define MAX_NUMBER_LINES 65536 +#define MIN_BIT_DEPTH 7 +#define MAX_BIT_DEPTH 15 + +typedef struct { + int column; + int row; +}Coord; + +/* + * Neighborhood structure consists of the GLCM descriptors entropy and + * energy for each of 2 distance and 4 angels + */ +typedef struct { + float entropy; + float energy; +}Descriptors; + +typedef struct { + Descriptors deg0; + Descriptors deg45; + Descriptors deg90; + Descriptors deg135; +}Angeles; + +typedef struct { + Angeles distShort; + Angeles distLong; +}Neighborhood; + +typedef short int Pixel; /* short int;*/ + + +void drawLineSegment(Pixel *image, + Coord startPoint, + Coord endPoint, + int startValue, + int endValue, + int thickness, + int dimension) + { + int changeColumn, changeRow; + int delta; + int column, row; + float value, valueDelta; + int t; + + changeColumn = endPoint.column - startPoint.column; + changeRow = endPoint.row - startPoint.row; + + assert((changeRow != 0) || (changeColumn != 0)); + + column = startPoint.column; + row = startPoint.row; + value = startValue; + + if (ABS(changeColumn) > ABS(changeRow)){ + valueDelta = ((float) endValue - startValue)/ + ((float) ABS(changeColumn)); + delta = 2*ABS(row) - ABS(column); + for (column = startPoint.column; + column == endPoint.column+sign(changeColumn); + column += sign(changeColumn)){ + for (t = MAX(0, row-thickness/2); + t < MIN(dimension, row+thickness - thickness/2); + t++) + image[t*dimension + column] = (int)value; + value += valueDelta; + if (delta >= 0){ + row += sign(changeRow); + delta -= 2*ABS(changeColumn); + } + column += sign(changeColumn); + delta += 2*ABS(changeRow); + } + } + else { + valueDelta = ((float) endValue - startValue)/ + ((float) ABS(changeRow)); + delta = 2* ABS(column) - ABS(row); + for (row = startPoint.row; + row == endPoint.row + sign(changeRow); + row += sign(changeRow)){ + for (t = MAX(0, column-thickness/2); + t < MIN(dimension, row + thickness - thickness/2); + t++) + image[row*dimension + t] = (int)value; + if (delta >= 0){ + column += sign(changeColumn); + delta -= 2*ABS(changeRow); + } + row += sign(changeRow); + delta += 2*ABS(changeColumn); + } + } + return; + } + + + +Pixel *createImage (int dimension, + Pixel maxPixel, + int numberLines, + int minThickness, + int maxThickness) + { + Pixel *image; + int i; + + Coord startPoint; + Coord endPoint; + int thickness; + int startValue; + int endValue; + + image = (Pixel *)malloc(sizeof(Pixel) * dimension * dimension); + assert (image != NULL); + for (i=0; i= 0) && (binIndex < numBins)); + sumHist[binIndex] += 1; + binIndex = value0 - value1 + maxPixel - MIN_PIXEL; + + assert((binIndex >= 0) && (binIndex < numBins)); + + diffHist[binIndex] += 1; + totalNumPixels += 1; + + } + + value0RowOffset += dimension; + value1RowOffset += dimension; + + } + + + if (totalNumPixels > 0){ + int index; + double energySum; + double energyDifference; + double entropyValue; + double sumNormalized; + double diffNormalized; + double scale; + + energySum = (double) 0; + energyDifference = (double) 0; + entropyValue = (double) 0; + scale = 1.e0/totalNumPixels; + for (index = 0; index 0){ + sumNormalized = (double) sumHist[index]*scale; + entropyValue = entropyValue - sumNormalized * + log((double)sumNormalized); + energySum = energySum + sumNormalized * sumNormalized ; + } + if (diffHist[index] > 0){ + diffNormalized = (double)diffHist[index]*scale; + entropyValue = entropyValue - diffNormalized * log(diffNormalized); + energyDifference = energyDifference + + diffNormalized * diffNormalized; + } + } + *energy = energySum * energyDifference; + *entropy = entropyValue; + } + return; + } + + +void neighborhoodCalculation + (Pixel *image, + int dimension, + int distanceShort, + int distanceLong, + Neighborhood *neighborhood, + Pixel maxPixel) + { + int *sumHist, *diffHist; + int numBins; + + numBins = (2 * (maxPixel - MIN_PIXEL + 1) -1); + sumHist = (int *) malloc(numBins * sizeof(int)); + assert (sumHist != NULL); + diffHist = (int *)malloc(numBins * sizeof(int)); + assert(diffHist != NULL); + + printf(" before short calc deg0\n"); + calcEntropyEnergy(sumHist, diffHist, image, numBins, + distanceShort, 0, + &(neighborhood->distShort.deg0.entropy), + &(neighborhood->distShort.deg0.energy), dimension, + maxPixel); + + calcEntropyEnergy(sumHist, diffHist, image, numBins, + distanceShort, distanceShort, + &(neighborhood->distShort.deg45.entropy), + &(neighborhood->distShort.deg45.energy), dimension, + maxPixel); + + calcEntropyEnergy(sumHist, diffHist, image, numBins, + 0, distanceShort, + &(neighborhood->distShort.deg90.entropy), + &(neighborhood->distShort.deg90.energy), dimension, + maxPixel); + + calcEntropyEnergy(sumHist, diffHist, image, numBins, + -distanceShort, distanceShort, + &(neighborhood->distShort.deg135.entropy), + &(neighborhood->distShort.deg135.energy), dimension, + maxPixel); + + calcEntropyEnergy(sumHist, diffHist, image, numBins, + distanceLong, 0, + &(neighborhood->distLong.deg0.entropy), + &(neighborhood->distLong.deg0.energy), dimension, + maxPixel); + + calcEntropyEnergy(sumHist, diffHist, image, numBins, + distanceLong, distanceLong, + &(neighborhood->distLong.deg45.entropy), + &(neighborhood->distLong.deg45.energy), dimension, + maxPixel); + + calcEntropyEnergy(sumHist, diffHist, image, numBins, + 0, distanceLong, + &(neighborhood->distLong.deg90.entropy), + &(neighborhood->distLong.deg90.energy), dimension, + maxPixel); + + calcEntropyEnergy(sumHist, diffHist, image, numBins, + -distanceLong, distanceLong, + &(neighborhood->distLong.deg135.entropy), + &(neighborhood->distLong.deg135.energy), dimension, + maxPixel); + + free(sumHist); + free(diffHist); + + return; + } + diff --git a/dis/Pointer/DISstressmarkRNG.h b/dis/Pointer/DISstressmarkRNG.h new file mode 100644 index 0000000..4aa2620 --- /dev/null +++ b/dis/Pointer/DISstressmarkRNG.h @@ -0,0 +1,190 @@ +#include + +#define IA 16807 +#define IM 2147483647 +#define AM (1.0/IM) +#define IQ 127773 +#define IR 2836 +#define NTAB 32 +#define NDIV (1+(IM-1)/NTAB) +#define EPS 1.2e-7 +#define RNMX (1.0-EPS) + +static long iy=0; +static long iv[NTAB]; +static long iseed; + +int ABS(int x){ + if (x>= 0) return x; + else + return (-x); +} + +int sign(int x){ + if (x >= 0) return 1; + else + return (-1); +} + +int MAX(int x, int y){ + if (x>= y) return x; + else + return y; +} + +int MIN(int x, int y){ + if (x<= y) return x; + else + return y; +} + +void randInit(long idum) +{ + long j; + long k; + + assert (idum <= 0); + assert (iy == 0); + + iseed = idum; + if (-(iseed)<1){ + iseed = 1; + } + else { + iseed = -(iseed); + } + for (j=NTAB+7; j>=0; j--){ + k = (iseed)/IQ; + iseed = IA*(iseed-k*IQ)-IR*k; + if (iseed < 0){ + iseed += IM; + } + if (j < NTAB){ + iv[j] = iseed; + } + } + iy = iv[0]; +} + +float randNum() +{ + long j; + long k; + float temp; + + assert (iy != 0); + + k = (iseed)/IQ; + iseed = IA*(iseed-k*IQ)-IR*k; + + if (iseed < 0){ + iseed += IM; + } + j = iy/NDIV; + iy = iv[j]; + iv[j] = iseed; + + temp = AM * iy; + + if (temp > RNMX){ + return RNMX; + } + else { + return temp; + } +} + + +float randomFloat(float lowest_float, float highest_float) +{ + float value; + float range; + +assert (lowest_float < highest_float); + +range = highest_float - lowest_float; +value = randNum()*(highest_float - lowest_float) + lowest_float; +assert(value >= lowest_float); +assert(value <= highest_float); + +return value; + +} + +float randomNonZeroFloat(float lowest_float, float highest_float, float epsilon) +{ + + double range; + float value; + + + assert (lowest_float < 0); + assert (highest_float > 0); + assert (epsilon > 0); + assert ((epsilon < -lowest_float) && (epsilon < highest_float)); + + range = highest_float - lowest_float; + value = (randNum() * range)+lowest_float; + + if (ABS(value) < epsilon) + { + if (value > 0) value = value + epsilon; + else if (value < 0) value = value - epsilon; + + } + + assert (value >= lowest_float); + assert (value <= highest_float); + + return value; +} + +unsigned int randomUInt(int lowest_uint, int highest_uint) +{ + float range; + unsigned int value; + float temp; + + range =(float)(highest_uint - lowest_uint + 1); + temp = randNum(); + value =(unsigned int)( floor(temp * range) + lowest_uint); + + assert (value >= lowest_uint); + assert (value <= highest_uint); + + return value; +} + +unsigned int randomNonZeroUInt(int lowest_uint, int highest_uint) +{ + float range; + unsigned int value; + float temp; + + range =(float)(highest_uint - lowest_uint + 1); + value = 0; + while(value == 0){ + temp = randNum(); + + value =(unsigned int)( floor(temp * range) + lowest_uint); + } + + assert (value >= lowest_uint); + assert (value <= highest_uint); + + return value; +} + +int randInt(int lowest_uint, int highest_uint) +{ + float range; + int value; + + range = highest_uint - lowest_uint + 1; + value = (int)(floor(randNum() * range) + lowest_uint); + + assert (value >= lowest_uint); + assert (value <= highest_uint); + + return value; +} diff --git a/dis/Pointer/pointer.c b/dis/Pointer/pointer.c new file mode 100644 index 0000000..5671697 --- /dev/null +++ b/dis/Pointer/pointer.c @@ -0,0 +1,159 @@ +/* + * Sample code for the DIS Pointer Stressmark + * + * This source code is the completely correct source code based on + * the example codes provided by Atlantic Aerospace Division, Titan + * Systems Corporation, 2000. + * + * If you just compile and generate the executables from this source + * code, this code would be enough. However, if you wish to get a complete + * understanding of this stressmark, it is strongly suggested that you + * read the Benchmark Analysis and Specifications Document Version 1.0 + * before going on since the detailed comments are given in this documents. + * the comments are not repeated here. + */ +#include +#include +#include +#include +#include "DISstressmarkRNG.h" +#include "extra.h" + +#define MIN_FIELD_SIZE 16 +#define MAX_FIELD_SIZE (16777216*4) // Modifed from original +#define MIN_WINDOW_SIZE 1 +#define MAX_WINDOW_SIZE 15 +#define MIN_HOP_LIMIT 1 + +#define MAX_HOP_LIMIT 4294967295U + +#define MIN_SEED -2147483647 +#define MAX_SEED -1 +#define MIN_THREADS 1 +#define MAX_THREADS 256 + +/* + * main() + */ +int main(int argc, char** argv){ + + unsigned int *field; + unsigned int f; + unsigned short int w; + unsigned int maxhops; + int seed; + unsigned int n; + + clock_t startTime; + + struct threadS{ + unsigned int initial; + unsigned int minStop; + unsigned int maxStop; + unsigned int hops; + }*thread; + + unsigned int l; + SET_UP + + assert(fscanf(stdin, "%lu %u %lu %ld %u", + &f, &l, &maxhops, &seed, &n) == 5); + + assert ((f >= MIN_FIELD_SIZE) && (f <= MAX_FIELD_SIZE)); + w = (unsigned int) l; + assert ((w >= MIN_WINDOW_SIZE) && (w <= MAX_WINDOW_SIZE)); + assert (w % 2 == 1); + assert (f > w); + assert ((maxhops >= MIN_HOP_LIMIT) && (maxhops <= MAX_HOP_LIMIT)); + assert ((seed >= MIN_SEED) && (seed <= MAX_SEED)); + + assert ((n >= MIN_THREADS) && (n <= MAX_THREADS)); + if ((thread = (struct threadS *)malloc(n*sizeof(struct threadS))) == NULL) + return (-1); + + for (l=0; l= 0) && (thread[l].initial < f)); + assert ((thread[l].minStop >= 0) && (thread[l].minStop < f)); + assert ((thread[l].maxStop >= 0) && (thread[l].maxStop < f)); + } + + if ((field = (unsigned int *)malloc(f*sizeof(int))) == NULL) + return (-1); + + randInit(seed); + for (l=0; l= minStop) && + (index < maxStop)))){ + + unsigned int ll, lll; + unsigned int max, min; + unsigned int partition; + unsigned int high; + + partition = field[index]; + max = MAX_FIELD_SIZE; + min = 0; + high = 0; + + for (ll=0; ll max) high++; + else if (x > min){ /* start else* */ + partition = x; + balance = 0; + for (lll=ll+1; lll partition) balance++; + }/* end for loop */ + + if (balance+high == w/2) break; + else if (balance+high > w/2){ + min = partition; + }/* end if */ + else { + max = partition; + high++; + }/* end else */ + } + if (min == max) break; + } /* end else* */ + index = (partition+hops)%(f-w); + hops++; + }/* end loop ll */ + thread[l].hops = hops; + STOP_LOOP +} /* end while */ + + startTime = time(NULL) - startTime; + + for (l=0; l + +#define IA 16807 +#define IM 2147483647 +#define AM (1.0/IM) +#define IQ 127773 +#define IR 2836 +#define NTAB 32 +#define NDIV (1+(IM-1)/NTAB) +#define EPS 1.2e-7 +#define RNMX (1.0-EPS) + +static long iy=0; +static long iv[NTAB]; +static long iseed; + +int ABS(int x){ + if (x>= 0) return x; + else + return (-x); +} + +int sign(int x){ + if (x >= 0) return 1; + else + return (-1); +} + +int MAX(int x, int y){ + if (x>= y) return x; + else + return y; +} + +int MIN(int x, int y){ + if (x<= y) return x; + else + return y; +} + +void randInit(long idum) +{ + long j; + long k; + + assert (idum <= 0); + assert (iy == 0); + + iseed = idum; + if (-(iseed)<1){ + iseed = 1; + } + else { + iseed = -(iseed); + } + for (j=NTAB+7; j>=0; j--){ + k = (iseed)/IQ; + iseed = IA*(iseed-k*IQ)-IR*k; + if (iseed < 0){ + iseed += IM; + } + if (j < NTAB){ + iv[j] = iseed; + } + } + iy = iv[0]; +} + +float randNum() +{ + long j; + long k; + float temp; + + assert (iy != 0); + + k = (iseed)/IQ; + iseed = IA*(iseed-k*IQ)-IR*k; + + if (iseed < 0){ + iseed += IM; + } + j = iy/NDIV; + iy = iv[j]; + iv[j] = iseed; + + temp = AM * iy; + + if (temp > RNMX){ + return RNMX; + } + else { + return temp; + } +} + + +float randomFloat(float lowest_float, float highest_float) +{ + float value; + float range; + +assert (lowest_float < highest_float); + +range = highest_float - lowest_float; +value = randNum()*(highest_float - lowest_float) + lowest_float; +assert(value >= lowest_float); +assert(value <= highest_float); + +return value; + +} + +float randomNonZeroFloat(float lowest_float, float highest_float, float epsilon) +{ + + double range; + float value; + + + assert (lowest_float < 0); + assert (highest_float > 0); + assert (epsilon > 0); + assert ((epsilon < -lowest_float) && (epsilon < highest_float)); + + range = highest_float - lowest_float; + value = (randNum() * range)+lowest_float; + + if (ABS(value) < epsilon) + { + if (value > 0) value = value + epsilon; + else if (value < 0) value = value - epsilon; + + } + + assert (value >= lowest_float); + assert (value <= highest_float); + + return value; +} + +unsigned int randomUInt(int lowest_uint, int highest_uint) +{ + float range; + unsigned int value; + float temp; + + range =(float)(highest_uint - lowest_uint + 1); + temp = randNum(); + value =(unsigned int)( floor(temp * range) + lowest_uint); + + assert (value >= lowest_uint); + assert (value <= highest_uint); + + return value; +} + +unsigned int randomNonZeroUInt(int lowest_uint, int highest_uint) +{ + float range; + unsigned int value; + float temp; + + range =(float)(highest_uint - lowest_uint + 1); + value = 0; + while(value == 0){ + temp = randNum(); + + value =(unsigned int)( floor(temp * range) + lowest_uint); + } + + assert (value >= lowest_uint); + assert (value <= highest_uint); + + return value; +} + +int randInt(int lowest_uint, int highest_uint) +{ + float range; + int value; + + range = highest_uint - lowest_uint + 1; + value = (int)(floor(randNum() * range) + lowest_uint); + + assert (value >= lowest_uint); + assert (value <= highest_uint); + + return value; +} diff --git a/dis/Transitive/transitive.c b/dis/Transitive/transitive.c new file mode 100644 index 0000000..5fa52e8 --- /dev/null +++ b/dis/Transitive/transitive.c @@ -0,0 +1,131 @@ +/* + * Sample code for the DIS Transitive Stressmark + * + * This source code is the completely correct source code based on + * the example codes provided by Atlantic Aerospace Division, Titan + * Systems Corporation, 2000. + * + * If you just compile and generate the executables from this source + * code, this code would be enough. However, if you wish to get a complete + * understanding of this stressmark, it is strongly suggested that you + * read the Benchmark Analysis and Specifications Document Version 1.0 + * before going on since the detailed comments are given in this documents. + * the comments are not repeated here. + * + * CHANGELOG: + * Joshua Bakita, 05/30/2020: Fixed out-of-bounds randInt call + */ + +#include +#include +#include +#include +#include "DISstressmarkRNG.h" +#include "extra.h" + +#define MIN_VERTICES 8 +#define MAX_VERTICES 16384 +#define MIN_EDGES 0 +#define MAX_EDGES 268435456 +#define MIN_SEED -2147483647 +#define MAX_SEED -1 +#define NO_PATH 2147483647 + +#define MIN_EDGS 0 +#define MAX_EDGE 255 + +/* + * main() + */ + +int main(int argc, char** argv){ + unsigned int *din, *dout; + unsigned int n; + unsigned int m; + unsigned int i, j, k; + int seed; + + time_t startTime; + unsigned int sum; + + fscanf(stdin,"%d %d %d", &n, &m, &seed); + + assert((n >= MIN_VERTICES) && (n <= MAX_VERTICES)); + assert((m >= MIN_EDGES) && (m <= MAX_EDGES)); + assert (m <= n*n); + assert ((seed >= MIN_SEED) && (seed <= MAX_SEED)); + + if ((din = (unsigned int *)malloc(n*n*sizeof(unsigned int))) == NULL) + return (-1); + if ((dout = (unsigned int *)malloc(n*n*sizeof(unsigned int))) == NULL) + return (-1); + + for (i=0; i + +#define IA 16807 +#define IM 2147483647 +#define AM (1.0/IM) +#define IQ 127773 +#define IR 2836 +#define NTAB 32 +#define NDIV (1+(IM-1)/NTAB) +#define EPS 1.2e-7 +#define RNMX (1.0-EPS) + +static long iy=0; +static long iv[NTAB]; +static long iseed; + +int ABS(int x){ + if (x>= 0) return x; + else + return (-x); +} + +int sign(int x){ + if (x >= 0) return 1; + else + return (-1); +} + +int MAX(int x, int y){ + if (x>= y) return x; + else + return y; +} + +int MIN(int x, int y){ + if (x<= y) return x; + else + return y; +} + +void randInit(long idum) +{ + long j; + long k; + + assert (idum <= 0); + assert (iy == 0); + + iseed = idum; + if (-(iseed)<1){ + iseed = 1; + } + else { + iseed = -(iseed); + } + for (j=NTAB+7; j>=0; j--){ + k = (iseed)/IQ; + iseed = IA*(iseed-k*IQ)-IR*k; + if (iseed < 0){ + iseed += IM; + } + if (j < NTAB){ + iv[j] = iseed; + } + } + iy = iv[0]; +} + +float randNum() +{ + long j; + long k; + float temp; + + assert (iy != 0); + + k = (iseed)/IQ; + iseed = IA*(iseed-k*IQ)-IR*k; + + if (iseed < 0){ + iseed += IM; + } + j = iy/NDIV; + iy = iv[j]; + iv[j] = iseed; + + temp = AM * iy; + + if (temp > RNMX){ + return RNMX; + } + else { + return temp; + } +} + + +float randomFloat(float lowest_float, float highest_float) +{ + float value; + float range; + +assert (lowest_float < highest_float); + +range = highest_float - lowest_float; +value = randNum()*(highest_float - lowest_float) + lowest_float; +assert(value >= lowest_float); +assert(value <= highest_float); + +return value; + +} + +float randomNonZeroFloat(float lowest_float, float highest_float, float epsilon) +{ + + double range; + float value; + + + assert (lowest_float < 0); + assert (highest_float > 0); + assert (epsilon > 0); + assert ((epsilon < -lowest_float) && (epsilon < highest_float)); + + range = highest_float - lowest_float; + value = (randNum() * range)+lowest_float; + + if (ABS(value) < epsilon) + { + if (value > 0) value = value + epsilon; + else if (value < 0) value = value - epsilon; + + } + + assert (value >= lowest_float); + assert (value <= highest_float); + + return value; +} + +unsigned int randomUInt(int lowest_uint, int highest_uint) +{ + float range; + unsigned int value; + float temp; + + range =(float)(highest_uint - lowest_uint + 1); + temp = randNum(); + value =(unsigned int)( floor(temp * range) + lowest_uint); + + assert (value >= lowest_uint); + assert (value <= highest_uint); + + return value; +} + +unsigned int randomNonZeroUInt(int lowest_uint, int highest_uint) +{ + float range; + unsigned int value; + float temp; + + range =(float)(highest_uint - lowest_uint + 1); + value = 0; + while(value == 0){ + temp = randNum(); + + value =(unsigned int)( floor(temp * range) + lowest_uint); + } + + assert (value >= lowest_uint); + assert (value <= highest_uint); + + return value; +} + +int randInt(int lowest_uint, int highest_uint) +{ + float range; + int value; + + range = highest_uint - lowest_uint + 1; + value = (int)(floor(randNum() * range) + lowest_uint); + + assert (value >= lowest_uint); + assert (value <= highest_uint); + + return value; +} diff --git a/dis/Update/update.c b/dis/Update/update.c new file mode 100644 index 0000000..1fd8197 --- /dev/null +++ b/dis/Update/update.c @@ -0,0 +1,138 @@ +/* + * Sample code for the DIS Update Stressmark + * + * This source code is the completely correct source code based on + * the example codes provided by Atlantic Aerospace Division, Titan + * Systems Corporation, 2000. + * + * If you just compile and generate the executables from this source + * code, this code would be enough. However, if you wish to get a complete + * understanding of this stressmark, it is strongly suggested that you + * read the Benchmark Analysis and Specifications Document Version 1.0 + * before going on since the detailed comments are given in this documents. + * the comments are not repeated here. + */ + +#include +#include +#include +#include +#include "DISstressmarkRNG.h" +#include "extra.h" + +#define MIN_FIELD_SIZE 16 + +#define MAX_FIELD_SIZE 16777216 + +#define MIN_WINDOW_SIZE 1 + +#define MAX_WINDOW_SIZE 15 + +#define MIN_HOP_LIMIT 1 + +#define MAX_HOP_LIMIT 4294967295U + +#define MIN_SEED -2147483647 + +#define MAX_SEED -1 + +/* + *main() + */ + +int main(int argc, char** argv){ + + unsigned int *field; + unsigned int f; + unsigned int index; + unsigned short int w; + unsigned int maxhops; + int seed; + time_t startTime; + unsigned int initial; + unsigned int minStop; + unsigned int maxStop; + unsigned int hops; + unsigned int l; + + assert(fscanf(stdin, "%u %u %u %d %u %u %u", + &f, &l, &maxhops, &seed, &initial, &minStop, &maxStop) == 7); + + assert((f >= MIN_FIELD_SIZE) && (f <= MAX_FIELD_SIZE)); + w = (unsigned int )l; + assert((w >= MIN_WINDOW_SIZE) && (w <= MAX_WINDOW_SIZE)); + assert(w%2 == 1); + assert(f > w); + assert((maxhops >= MIN_HOP_LIMIT) && (maxhops <= MAX_HOP_LIMIT)); + assert((seed >= MIN_SEED) && (seed <= MAX_SEED)); + assert((initial >= 0) && (initial < f)); + assert((minStop >= 0) && (minStop < f)); + assert((maxStop >= 0) && (maxStop < f)); + + if ((field = (unsigned int *)malloc(f*sizeof(int))) == NULL) + return (-1); + + randInit(seed); + for (l=0; l= minStop) && + (index < maxStop)))){ + int sum; + + unsigned int ll, lll; + unsigned int max, min; + unsigned int partition; + unsigned int high; + if (hops % 100 == 0) {START_LOOP} // These loops are too quick to sample individually + max = MAX_FIELD_SIZE; + min = 0; + high = 0; + sum = 0; + + for (ll=0; ll max) high++; + else if (x >min){ /* start else* */ + partition = x; + balance = 0; + for (lll=ll+1; lll partition) balance++; + } + if (balance+high == w/2) break; + else if (balance+high>w/2){ + min = partition; + }/* end if */ + else{ + max = partition; + high++; + } /* end else */ + } + if (min == max) break; + }/* end else* */ + field[index] = sum % (f-w); + index = (partition+hops)%(f-w); + hops++; + if (hops % 100 == 0) {STOP_LOOP} // These loops are too quick to sample individually + }/* end for loop */ + + startTime = time(NULL) - startTime; + + fprintf(stdout, "%u hops\n", hops); + fprintf(stderr, "total time = %u seconds.\n", (unsigned int)startTime); + free(field); + WRITE_TO_FILE + return(1); +} diff --git a/dis/WSS_DOCS.md b/dis/WSS_DOCS.md new file mode 100644 index 0000000..da5e066 --- /dev/null +++ b/dis/WSS_DOCS.md @@ -0,0 +1,83 @@ +# Documentation Mapping DIS Stressmark Parameters to WSS + +## Field +1 allocation in main() +f = 1st input param + +sizeof(unsigned char) * f + +## Matrix +6 allocations in main(), 7 allocations in biConjugateGradient() + +*Allocations in main()* +dim = 2nd input param +numberNonzero = 3nd input param + +sizeof(double) * (dim^2+3dim+numberNonzero) + sizeof(int) * (2dim+1+numberNonzero) + +*Allocations in biConjugateGradient()* +sizeof(double) * 7dim + +## Neighborhood +1 allocation in createImage, 2 allocations in neighborhoodCalculation + +*Allocations in createImage()* +dimension = 3rd input param + +sizeof(short int) * dimension^2 + +*Allocations in neighborhoodCalculation()* +bitDepth = 2nd param + +sizeof(int) * (2^(bitDepth + 1) - 1) + +## Pointer +n = 5th input param +f = 1st input param + +sizeof(unsigned int) * 4n + sizeof(int) * f + +## Transitive +n = 1st input param + +sizeof(unsigned int) * 2n^2 + +## Update +f = 1st input param + +sizeof(int) * f + +## Testplan +*Problem!* Larger WSS = more computations +Use testcase #1 for non-specified parameters +Below math computed for x86_64 +- Test WSS at powers of 2: 16 KiB, 32, 64, 128, 256, 512, 1MiB, 2, 4, 8, 16, 32 +- For each WSS, measure cache allocation of 0, 1, 2, 4, 8, 16 + +### Field +Just vary first param + +f = WSS + +### Matrix +0.3 - 16% number nonzero +- Fixed at 8% +Just vary dim (matrix size) + +sizeof(double) * (dim^2+10dim+numberNonzero) + sizeof(int) * (2dim+1+numberNonzero) = WSS + + +### Neighborhood +8 or 15 bit depth +- Fix at 12? +Just vary dim (image size) + +### Pointer +10 for n +Just vary f + +### Transitive +Just vary n + +### Update +Just vary f diff --git a/dis/clean.sh b/dis/clean.sh new file mode 100755 index 0000000..7c58295 --- /dev/null +++ b/dis/clean.sh @@ -0,0 +1 @@ +tail -n +2 $1 | tr "-" " " | sed "s/L3:0=0000;1=0000;2=0000;3=0000/0/" | sed "s/L3:0=0000;1=0000;2=0000;3=0001/1/" | sed "s/L3:0=0000;1=0000;2=0000;3=0003/2/" | sed "s/L3:0=0000;1=0000;2=0000;3=0007/3/" | sed "s/L3:0=0000;1=0000;2=0000;3=000f/4/" | sed "s/L3:0=0000;1=0000;2=0000;3=003f/6/" | sed "s/L3:0=0000;1=0000;2=0000;3=00ff/8/" | sed "s/L3:0=0000;1=0000;2=0000;3=03ff/10/" | sed "s/L3:0=0000;1=0000;2=0000;3=0fff/12/" | sed "s/L3:0=0000;1=0000;2=0000;3=3fff/14/" | sed "s/L3:0=0000;1=0000;2=0000;3=ffff/16/" > $1.clean diff --git a/dis/gen_input.py b/dis/gen_input.py new file mode 100755 index 0000000..c7821b0 --- /dev/null +++ b/dis/gen_input.py @@ -0,0 +1,113 @@ +#!/usr/bin/python3 +##### +# Copyright 2020 Joshua Bakita +# +# This program generates input data for the DIS benchmark suite on stdout +# given a requested working set size. +##### + + +from ctypes import sizeof, c_double, c_int, c_short +from math import sqrt, floor +import sys # For argv and stderr + +USAGE = """Usage: {}