/*************************
** LoadNumArrayWithRand **
**************************
** Load up an array with random longs.
*/
private static void LoadNumArrayWithRand(int[,] array, /* Pointer to arrays */
int arraysize,
int numarrays) /* # of elements in array */
{
int i; /* Used for index */
/*
** Initialize the random number generator
*/
ByteMark.randnum(13);
/*
** Load up first array with randoms
*/
for (i = 0; i < arraysize; i++)
{
array[0, i] = ByteMark.randnum(0);
}
/*
** Now, if there's more than one array to load, copy the
** first into each of the others.
*/
while (--numarrays > 0)
{
for (int j = 0; j < arraysize; j++, i++)
{
array[numarrays, j] = array[0, j];
}
}
return;
}
/*************************
** LoadNumArrayWithRand **
**************************
** Load up an array with random longs.
*/
private static void LoadNumArrayWithRand(int[][] array, /* Pointer to arrays */
int arraysize,
int numarrays) /* # of elements in array */
{
int i; /* Used for index */
/*
** Initialize the random number generator
*/
ByteMark.randnum(13);
/*
** Load up first array with randoms
*/
for (i = 0; i < arraysize; i++)
{
array[0][i] = ByteMark.randnum(0);
}
/*
** Now, if there's more than one array to load, copy the
** first into each of the others.
*/
for (i = 1; i < numarrays; i++)
{
// the old code didn't do a memcpy, so I'm not doing
// an Array.Copy()
for (int j = 0; j < arraysize; j++)
{
array[i][j] = array[0][j];
}
}
return;
}
/********************
** LoadStringArray **
*********************
** Initialize the string array with random strings of
** varying sizes.
** Returns the pointer to the offset pointer array.
** Note that since we're creating a number of arrays, this
** routine builds one array, then copies it into the others.
*/
private static void LoadStringArray(string[][] array, /* String array */
int arraysize, /* Size of array */
int numarrays) /* # of arrays */
{
/*
** Initialize random number generator.
*/
ByteMark.randnum(13);
/*
** Load up the first array with randoms
*/
int i;
for (i = 0; i < arraysize; i++)
{
int length;
length = 4 + ByteMark.abs_randwc(76);
array[0][i] = "";
/*
** Fill up the string with random bytes.
*/
StringBuilder builder = new StringBuilder(length);
int add;
for (add = 0; add < length; add++)
{
char myChar = (char)(ByteMark.abs_randwc(96) + 32);
builder.Append(myChar);
}
array[0][i] = builder.ToString();
}
/*
** We now have initialized a single full array. If there
** is more than one array, copy the original into the
** others.
*/
int k;
for (k = 1; k < numarrays; k++)
{
for (i = 0; i < arraysize; i++)
{
array[k][i] = array[0][i];
}
}
}
/***************
** LoadAssign **
****************
** The array given by arraybase is loaded with positive random
** numbers. Elements in the array are capped at 5,000,000.
*/
private static void LoadAssign(int[,] arraybase)
{
short i, j;
/*
** Reset random number generator so things repeat.
*/
ByteMark.randnum(13);
for (i = 0; i < global.ASSIGNROWS; i++)
for (j = 0; j < global.ASSIGNROWS; j++)
arraybase[i, j] = ByteMark.abs_randwc(5000000);
return;
}
private static void build_problem(double[][] a, int n, double[] b)
{
int i, j, k, k1;
double rcon;
ByteMark.randnum(13);
for (i = 0; i < n; i++)
{
b[i] = (double)(ByteMark.abs_randwc(100) + 1);
for (j = 0; j < n; j++)
{
if (i == j)
{
a[i][j] = (double)(ByteMark.abs_randwc(1000) + 1);
}
else
{
a[i][j] = (double)0.0;
}
}
}
for (i = 0; i < 8 * n; i++)
{
k = ByteMark.abs_randwc(n);
k1 = ByteMark.abs_randwc(n);
if (k != k1)
{
if (k < k1)
{
rcon = 1.0;
}
else
{
rcon = -1.0;
}
for (j = 0; j < n; j++)
{
a[k][j] += a[k1][j] * rcon;
}
b[k] += b[k1] * rcon;
}
}
}
double DoNNET(NNetStruct locnnetstruct)
{
// string errorcontext = "CPU:NNET";
// int systemerror = 0;
long accumtime = 0;
double iterations = 0.0;
/*
** Init random number generator.
** NOTE: It is important that the random number generator
** be re-initialized for every pass through this test.
** The NNET algorithm uses the random number generator
** to initialize the net. Results are sensitive to
** the initial neural net state.
*/
ByteMark.randnum(3);
/*
** Read in the input and output patterns. We'll do this
** only once here at the beginning. These values don't
** change once loaded.
*/
read_data_file();
/*
** See if we need to perform self adjustment loop.
*/
if (locnnetstruct.adjust == 0)
{
/*
** Do self-adjustment. This involves initializing the
** # of loops and increasing the loop count until we
** get a number of loops that we can use.
*/
for (locnnetstruct.loops = 1;
locnnetstruct.loops < MAXNNETLOOPS;
locnnetstruct.loops++)
{
ByteMark.randnum(3);
if (DoNNetIteration(locnnetstruct.loops) > global.min_ticks)
{
break;
}
}
}
/*
** All's well if we get here. Do the test.
*/
accumtime = 0L;
iterations = (double)0.0;
do
{
ByteMark.randnum(3); /* Gotta do this for Neural Net */
accumtime += DoNNetIteration(locnnetstruct.loops);
iterations += (double)locnnetstruct.loops;
} while (ByteMark.TicksToSecs(accumtime) < locnnetstruct.request_secs);
/*
** Clean up, calculate results, and go home. Be sure to
** show that we don't have to rerun adjustment code.
*/
locnnetstruct.iterspersec = iterations / ByteMark.TicksToFracSecs(accumtime);
if (locnnetstruct.adjust == 0)
{
locnnetstruct.adjust = 1;
}
return(locnnetstruct.iterspersec);
}
public override double Run()
{
int i;
char[] Z = new char[global.KEYLEN];
char[] DK = new char[global.KEYLEN];
char[] userkey = new char[8];
long accumtime;
double iterations;
byte[] plain1; /* First plaintext buffer */
byte[] crypt1; /* Encryption buffer */
byte[] plain2; /* Second plaintext buffer */
/*
** Re-init random-number generator.
*/
ByteMark.randnum(3);
/*
** Build an encryption/decryption key
*/
for (i = 0; i < 8; i++)
{
userkey[i] = (char)(ByteMark.abs_randwc(60000) & 0xFFFF);
}
for (i = 0; i < global.KEYLEN; i++)
{
Z[i] = (char)0;
}
/*
** Compute encryption/decryption subkeys
*/
en_key_idea(userkey, Z);
de_key_idea(Z, DK);
/*
** Allocate memory for buffers. We'll make 3, called plain1,
** crypt1, and plain2. It works like this:
** plain1 >>encrypt>> crypt1 >>decrypt>> plain2.
** So, plain1 and plain2 should match.
** Also, fill up plain1 with sample text.
*/
plain1 = new byte[this.arraysize];
crypt1 = new byte[this.arraysize];
plain2 = new byte[this.arraysize];
/*
** Note that we build the "plaintext" by simply loading
** the array up with random numbers.
*/
for (i = 0; i < this.arraysize; i++)
{
plain1[i] = (byte)(ByteMark.abs_randwc(255) & 0xFF);
}
/*
** See if we need to perform self adjustment loop.
*/
if (this.adjust == 0)
{
/*
** Do self-adjustment. This involves initializing the
** # of loops and increasing the loop count until we
** get a number of loops that we can use.
*/
for (this.loops = 100;
this.loops < global.MAXIDEALOOPS;
this.loops += 10)
{
if (DoIDEAIteration(plain1, crypt1, plain2,
this.arraysize,
this.loops,
Z, DK) > global.min_ticks)
{
break;
}
}
}
/*
** All's well if we get here. Do the test.
*/
accumtime = 0;
iterations = (double)0.0;
do
{
accumtime += DoIDEAIteration(plain1, crypt1, plain2,
this.arraysize,
this.loops, Z, DK);
iterations += (double)this.loops;
} while (ByteMark.TicksToSecs(accumtime) < this.request_secs);
/*
** Clean up, calculate results, and go home. Be sure to
** show that we don't have to rerun adjustment code.
*/
if (this.adjust == 0)
{
this.adjust = 1;
}
return(iterations / ByteMark.TicksToFracSecs(accumtime));
}
