static void
init_drop(int seed, double d)
{
int ndrop = (int)(d * sizeof(drop_priv));
int dropped;
unsigned int rand_ceil = RANDOM_END - (RANDOM_END % DROP_ARRAY_SIZE);
unsigned int r;
memset(drop_priv, 0, sizeof(drop_priv));
srand48(seed);
for (dropped = 0; dropped < ndrop; dropped ++) {
/* Keep picking numbers until we get one in range and
* that has not already been picked.
*/
while( (r = (mrand48() & 0x7fffffff)) > rand_ceil &&
drop_priv[r % DROP_ARRAY_SIZE]);
drop_priv[r % DROP_ARRAY_SIZE] = 1;
}
printf("# dropping %d of %d frames\n", ndrop, DROP_ARRAY_SIZE);
}
static char *
makeDiskDescriptorFile(const char *fileName,
uint64_t capacity,
uint32_t cid)
{
static const char ddfTemplate[] =
"# Disk DescriptorFile\n"
"version=1\n"
"encoding=\"UTF-8\"\n"
"CID=%08x\n"
"parentCID=ffffffff\n"
"createType=\"streamOptimized\"\n"
"\n"
"# Extent description\n"
"RW %llu SPARSE \"%s\"\n"
"\n"
"# The Disk Data Base\n"
"#DDB\n"
"\n"
"ddb.longContentID = \"%08x%08x%08x%08x\"\n"
"ddb.toolsVersion = \"2147483647\"\n" /* OpenSource Tools version. */
"ddb.virtualHWVersion = \"4\"\n" /* This field is obsolete, used by ESX3.x and older only. */
"ddb.geometry.cylinders = \"%u\"\n"
"ddb.geometry.heads = \"255\"\n" /* 255/63 is good for anything bigger than 4GB. */
"ddb.geometry.sectors = \"63\"\n"
"ddb.adapterType = \"lsilogic\"\n";
char *ret;
unsigned int cylinders;
if (capacity > 65535 * 255 * 63) {
cylinders = 65535;
} else {
cylinders = CEILING(capacity, 255 * 63);
}
if (asprintf(&ret, ddfTemplate, cid, (long long int)capacity, fileName, (uint32_t)mrand48(), (uint32_t)mrand48(), (uint32_t)mrand48(), cid, cylinders) == -1) {
return NULL;
}
return ret;
}
static float zgaussian(void) /* return one Gaussian random deviate */
{
unsigned int U, sgn, i, j;
float x, y;
while (1) {
U = (unsigned int)mrand48() ;
i = U & 0x0000007F; /* 7 bit to choose the step */
sgn = U & 0x00000080; /* 1 bit for the sign */
j = U>>8; /* 24 bit for the x-value */
x = j*wtab[i]; if( j < ktab[i] ) break;
if( i < 127 ){
float y0, y1;
y0 = ytab[i];
y1 = ytab[i+1];
y = y1+(y0-y1)*drand48();
} else {
x = PARAM_R - log(1.0-drand48())/PARAM_R;
y = exp(-PARAM_R*(x-0.5*PARAM_R))*drand48();
}
if( y < expf(-0.5f*x*x) ) break;
}
#if 0
{static FILE *fp=NULL ; /** for debugging **/
if( fp == NULL ){
fp = fopen("zzz.1D","w") ;
fprintf(fp,"# x U i j\n") ;
}
fprintf(fp,"%f %u %u %u\n",(sgn ? x : -x),U,i,j) ;
}
#endif
return (sgn ? x : -x) ;
}
int
main (void)
{
static unsigned short data[7] = { 1, 2, 3, 4, 5, 6, 7 };
printf ("one %X\n", mrand48 ());
printf ("two %X\n", mrand48 ());
printf ("three %X\n", mrand48 ());
lcong48 (data);
printf ("after lcong48:\n");
printf ("one %X\n", mrand48 ());
printf ("two %X\n", mrand48 ());
printf ("three %X\n", mrand48 ());
return 0;
}
/*
* magic - Returns the next magic number.
*/
u_int32_t
magic()
{
return (u_int32_t) mrand48();
}
int
main (void)
{
time_t t = time (NULL);
int i, ret = 0;
double d;
long int l;
struct drand48_data data;
unsigned short int buf[3];
srand48 ((long int) t);
for (i = 0; i < 50; i++)
if ((d = drand48 ()) < 0.0 || d >= 1.0)
{
printf ("drand48 %d %g\n", i, d);
ret = 1;
}
srand48_r ((long int) t, &data);
for (i = 0; i < 50; i++)
if (drand48_r (&data, &d) != 0 || d < 0.0 || d >= 1.0)
{
printf ("drand48_r %d %g\n", i, d);
ret = 1;
}
buf[2] = (t & 0xffff0000) >> 16; buf[1] = (t & 0xffff); buf[0] = 0x330e;
for (i = 0; i < 50; i++)
if ((d = erand48 (buf)) < 0.0 || d >= 1.0)
{
printf ("erand48 %d %g\n", i, d);
ret = 1;
}
buf[2] = (t & 0xffff0000) >> 16; buf[1] = (t & 0xffff); buf[0] = 0x330e;
for (i = 0; i < 50; i++)
if (erand48_r (buf, &data, &d) != 0 || d < 0.0 || d >= 1.0)
{
printf ("erand48_r %d %g\n", i, d);
ret = 1;
}
srand48 ((long int) t);
for (i = 0; i < 50; i++)
if ((l = lrand48 ()) < 0 || l > INT32_MAX)
{
printf ("lrand48 %d %ld\n", i, l);
ret = 1;
}
srand48_r ((long int) t, &data);
for (i = 0; i < 50; i++)
if (lrand48_r (&data, &l) != 0 || l < 0 || l > INT32_MAX)
{
printf ("lrand48_r %d %ld\n", i, l);
ret = 1;
}
buf[2] = (t & 0xffff0000) >> 16; buf[1] = (t & 0xffff); buf[0] = 0x330e;
for (i = 0; i < 50; i++)
if ((l = nrand48 (buf)) < 0 || l > INT32_MAX)
{
printf ("nrand48 %d %ld\n", i, l);
ret = 1;
}
buf[2] = (t & 0xffff0000) >> 16; buf[1] = (t & 0xffff); buf[0] = 0x330e;
for (i = 0; i < 50; i++)
if (nrand48_r (buf, &data, &l) != 0 || l < 0 || l > INT32_MAX)
{
printf ("nrand48_r %d %ld\n", i, l);
ret = 1;
}
srand48 ((long int) t);
for (i = 0; i < 50; i++)
if ((l = mrand48 ()) < INT32_MIN || l > INT32_MAX)
{
printf ("mrand48 %d %ld\n", i, l);
ret = 1;
}
srand48_r ((long int) t, &data);
for (i = 0; i < 50; i++)
if (mrand48_r (&data, &l) != 0 || l < INT32_MIN || l > INT32_MAX)
{
printf ("mrand48_r %d %ld\n", i, l);
ret = 1;
}
buf[2] = (t & 0xffff0000) >> 16; buf[1] = (t & 0xffff); buf[0] = 0x330e;
for (i = 0; i < 50; i++)
if ((l = jrand48 (buf)) < INT32_MIN || l > INT32_MAX)
{
printf ("jrand48 %d %ld\n", i, l);
ret = 1;
}
buf[2] = (t & 0xffff0000) >> 16; buf[1] = (t & 0xffff); buf[0] = 0x330e;
for (i = 0; i < 50; i++)
if (jrand48_r (buf, &data, &l) != 0 || l < INT32_MIN || l > INT32_MAX)
{
printf ("jrand48_r %d %ld\n", i, l);
ret = 1;
}
return ret;
}
static int
do_test (void)
{
unsigned short int xs[3] = { 0x0001, 0x0012, 0x0123 };
unsigned short int lxs[7];
unsigned short int *xsp;
int result = 0;
long int l;
double d;
double e;
/* Test srand48. */
srand48 (0x98765432);
/* Get the values of the internal Xi array. */
xsp = seed48 (xs);
if (xsp[0] != 0x330e || xsp[1] != 0x5432 || xsp[2] != 0x9876)
{
puts ("srand48(0x98765432) didn't set correct value");
printf (" expected: { %04hx, %04hx, %04hx }\n", 0x330e, 0x5432, 0x9876);
printf (" seen: { %04hx, %04hx, %04hx }\n", xsp[0], xsp[1], xsp[2]);
result = 1;
}
/* Put the values back. */
memcpy (xs, xsp, sizeof (xs));
(void) seed48 (xs);
/* See whether the correct values are installed. */
l = lrand48 ();
if (l != 0x2fed1413l)
{
printf ("lrand48() in line %d failed: expected %lx, seen %lx\n",
__LINE__ - 4, 0x2fed1413l, l);
result = 1;
}
l = mrand48 ();
if (l != -0x5d73effdl)
{
printf ("mrand48() in line %d failed: expected %lx, seen %lx\n",
__LINE__ - 4, -0x5d73effdl, l);
result = 1;
}
l = lrand48 ();
if (l != 0x585fcfb7l)
{
printf ("lrand48() in line %d failed: expected %lx, seen %lx\n",
__LINE__ - 4, 0x585fcfb7l, l);
result = 1;
}
l = mrand48 ();
if (l != -0x61770b8cl)
{
printf ("mrand48() in line %d failed: expected %lx, seen %lx\n",
__LINE__ - 4, -0x61770b8cl, l);
result = 1;
}
/* Test seed48. The previous call should have install the values in
the initialization of `xs' above. */
xs[0] = 0x1234;
xs[1] = 0x5678;
xs[2] = 0x9012;
xsp = seed48 (xs);
if (xsp[0] != 0x62f2 || xsp[1] != 0xf474 || xsp[2] != 0x9e88)
{
puts ("seed48() did not install the values correctly");
printf (" expected: { %04hx, %04hx, %04hx }\n", 0x62f2, 0xf474, 0x9e88);
printf (" seen: { %04hx, %04hx, %04hx }\n", xsp[0], xsp[1], xsp[2]);
result = 1;
}
/* Test lrand48 and mrand48. We continue from the seed established
above. */
l = lrand48 ();
if (l != 0x017e48b5l)
{
printf ("lrand48() in line %d failed: expected %lx, seen %lx\n",
__LINE__ - 4, 0x017e48b5l, l);
result = 1;
}
l = mrand48 ();
if (l != -0x1485e05dl)
{
printf ("mrand48() in line %d failed: expected %lx, seen %lx\n",
__LINE__ - 4, -0x1485e05dl, l);
result = 1;
}
l = lrand48 ();
if (l != 0x6b6a3f95l)
{
printf ("lrand48() in line %d failed: expected %lx, seen %lx\n",
__LINE__ - 4, 0x6b6a3f95l, l);
result = 1;
}
l = mrand48 ();
if (l != 0x175c0d6fl)
{
printf ("mrand48() in line %d failed: expected %lx, seen %lx\n",
__LINE__ - 4, 0x175c0d6fl, l);
result = 1;
}
/* Test lcong48. */
lxs[0] = 0x4567;
lxs[1] = 0x6789;
lxs[2] = 0x8901;
lxs[3] = 0x0123;
lxs[4] = 0x2345;
lxs[5] = 0x1111;
lxs[6] = 0x2222;
lcong48 (lxs);
/* See whether the correct values are installed. */
l = lrand48 ();
if (l != 0x6df63d66l)
{
printf ("lrand48() in line %d failed: expected %lx, seen %lx\n",
__LINE__ - 4, 0x6df63d66l, l);
result = 1;
}
l = mrand48 ();
if (l != 0x2f92c8e1l)
{
printf ("mrand48() in line %d failed: expected %lx, seen %lx\n",
__LINE__ - 4, 0x2f92c8e1l, l);
result = 1;
}
l = lrand48 ();
if (l != 0x3b4869ffl)
{
printf ("lrand48() in line %d failed: expected %lx, seen %lx\n",
__LINE__ - 4, 0x3b4869ffl, l);
result = 1;
}
l = mrand48 ();
if (l != 0x5cd4cc3el)
{
printf ("mrand48() in line %d failed: expected %lx, seen %lx\n",
__LINE__ - 4, 0x5cd4cc3el, l);
result = 1;
}
/* Check whether srand48() restores the A and C parameters. */
srand48 (0x98765432);
/* See whether the correct values are installed. */
l = lrand48 ();
if (l != 0x2fed1413l)
{
printf ("lrand48() in line %d failed: expected %lx, seen %lx\n",
__LINE__ - 4, 0x2fed1413l, l);
result = 1;
}
l = mrand48 ();
if (l != -0x5d73effdl)
{
printf ("mrand48() in line %d failed: expected %lx, seen %lx\n",
__LINE__ - 4, -0x5d73effdl, l);
result = 1;
}
l = lrand48 ();
if (l != 0x585fcfb7l)
{
printf ("lrand48() in line %d failed: expected %lx, seen %lx\n",
__LINE__ - 4, 0x585fcfb7l, l);
result = 1;
}
l = mrand48 ();
if (l != -0x61770b8cl)
{
printf ("mrand48() in line %d failed: expected %lx, seen %lx\n",
__LINE__ - 4, -0x61770b8cl, l);
result = 1;
}
/* And again to see whether seed48() does the same. */
lcong48 (lxs);
/* See whether lxs wasn't modified. */
l = lrand48 ();
if (l != 0x6df63d66l)
{
printf ("lrand48() in line %d failed: expected %lx, seen %lx\n",
__LINE__ - 4, 0x6df63d66l, l);
result = 1;
}
/* Test seed48. The previous call should have install the values in
the initialization of `xs' above. */
xs[0] = 0x1234;
xs[1] = 0x5678;
xs[2] = 0x9012;
xsp = seed48 (xs);
if (xsp[0] != 0x0637 || xsp[1] != 0x7acd || xsp[2] != 0xdbec)
{
puts ("seed48() did not install the values correctly");
printf (" expected: { %04hx, %04hx, %04hx }\n", 0x0637, 0x7acd, 0xdbec);
printf (" seen: { %04hx, %04hx, %04hx }\n", xsp[0], xsp[1], xsp[2]);
result = 1;
}
/* Test lrand48 and mrand48. We continue from the seed established
above. */
l = lrand48 ();
if (l != 0x017e48b5l)
{
printf ("lrand48() in line %d failed: expected %lx, seen %lx\n",
__LINE__ - 4, 0x017e48b5l, l);
result = 1;
}
l = mrand48 ();
if (l != -0x1485e05dl)
{
printf ("mrand48() in line %d failed: expected %lx, seen %lx\n",
__LINE__ - 4, -0x1485e05dl, l);
result = 1;
}
l = lrand48 ();
if (l != 0x6b6a3f95l)
{
printf ("lrand48() in line %d failed: expected %lx, seen %lx\n",
__LINE__ - 4, 0x6b6a3f95l, l);
result = 1;
}
l = mrand48 ();
if (l != 0x175c0d6fl)
{
printf ("mrand48() in line %d failed: expected %lx, seen %lx\n",
__LINE__ - 4, 0x175c0d6fl, l);
result = 1;
}
/* Test drand48. */
d = drand48 ();
if (d != 0.0908832261858485424)
{
printf ("drand48() in line %d failed: expected %.*g, seen %.*g\n",
__LINE__ - 4, DECIMAL_DIG, 0.0908832261858485424,
DECIMAL_DIG, d);
result = 1;
}
d = drand48 ();
if (d != 0.943149381730059133133)
{
printf ("drand48() in line %d failed: expected %.*g, seen %.*g\n",
__LINE__ - 4, DECIMAL_DIG, 0.943149381730059133133,
DECIMAL_DIG, d);
result = 1;
}
/* Now the functions which get the Xis passed. */
xs[0] = 0x3849;
xs[1] = 0x5061;
xs[2] = 0x7283;
l = nrand48 (xs);
if (l != 0x1efe61a1l)
{
printf ("nrand48() in line %d failed: expected %lx, seen %lx\n",
__LINE__ - 4, 0x1efe61a1l, l);
result = 1;
}
l = jrand48 (xs);
if (l != -0xa973860l)
{
printf ("jrand48() in line %d failed: expected %lx, seen %lx\n",
__LINE__ - 4, -0xa973860l, l);
result = 1;
}
l = nrand48 (xs);
if (l != 0x2a5e57fel)
{
printf ("nrand48() in line %d failed: expected %lx, seen %lx\n",
__LINE__ - 4, 0x2a5e57fel, l);
result = 1;
}
l = jrand48 (xs);
if (l != 0x71a779a8l)
{
printf ("jrand48() in line %d failed: expected %lx, seen %lx\n",
__LINE__ - 4, 0x71a779a8l, l);
result = 1;
}
/* Test whether the global A and C are used. */
lcong48 (lxs);
l = nrand48 (xs);
if (l != 0x32beee9fl)
{
printf ("nrand48() in line %d failed: expected %lx, seen %lx\n",
__LINE__ - 4, 0x32beee9fl, l);
result = 1;
}
l = jrand48 (xs);
if (l != 0x7bddf3bal)
{
printf ("jrand48() in line %d failed: expected %lx, seen %lx\n",
__LINE__ - 4, 0x7bddf3bal, l);
result = 1;
}
l = nrand48 (xs);
if (l != 0x85bdf28l)
{
printf ("nrand48() in line %d failed: expected %lx, seen %lx\n",
__LINE__ - 4, 0x85bdf28l, l);
result = 1;
}
l = jrand48 (xs);
if (l != 0x7b433e47l)
{
printf ("jrand48() in line %d failed: expected %lx, seen %lx\n",
__LINE__ - 4, 0x7b433e47l, l);
result = 1;
}
/* Test erand48. Also compare with the drand48 results. */
(void) seed48 (xs);
d = drand48 ();
e = erand48 (xs);
if (d != e)
{
printf ("\
drand48() and erand48 in lines %d and %d produce different results\n",
__LINE__ - 6, __LINE__ - 5);
printf (" drand48() = %g, erand48() = %g\n", d, e);
result = 1;
}
else if (e != 0.640650904452755298735)
{
printf ("erand48() in line %d failed: expected %.*g, seen %.*g\n",
__LINE__ - 4, DECIMAL_DIG, 0.640650904452755298735,
DECIMAL_DIG, e);
result = 1;
}
d = drand48 ();
e = erand48 (xs);
if (d != e)
{
printf ("\
drand48() and erand48 in lines %d and %d produce different results\n",
__LINE__ - 6, __LINE__ - 5);
printf (" drand48() = %g, erand48() = %g\n", d, e);
result = 1;
}
else if (e != 0.115372323508150742555)
{
printf ("erand48() in line %d failed: expected %.*g, seen %.*g\n",
__LINE__ - 4, DECIMAL_DIG, 0.0115372323508150742555,
DECIMAL_DIG, e);
result = 1;
}
return result;
}
BOOL
PALAPI
PAL_Random(
IN BOOL bStrong,
IN OUT LPVOID lpBuffer,
IN DWORD dwLength)
{
int rand_des = -1;
BOOL bRet = FALSE;
DWORD i;
char buf;
long num = 0;
static BOOL sMissingDevRandom;
static BOOL sMissingDevURandom;
static BOOL sInitializedMRand;
PERF_ENTRY(PAL_Random);
ENTRY("PAL_Random(bStrong=%d, lpBuffer=%p, dwLength=%d)\n",
bStrong, lpBuffer, dwLength);
i = 0;
if (bStrong == TRUE && i < dwLength && !sMissingDevRandom)
{
// request non-blocking access to avoid hangs if the /dev/random is exhausted
// or just simply broken
if ((rand_des = PAL__open(RANDOM_DEVICE_NAME, O_RDONLY | O_NONBLOCK)) == -1)
{
if (errno == ENOENT)
{
sMissingDevRandom = TRUE;
}
else
{
ASSERT("PAL__open() failed, errno:%d (%s)\n", errno, strerror(errno));
}
// Back off and try /dev/urandom.
}
else
{
for( ; i < dwLength; i++)
{
if (read(rand_des, &buf, 1) < 1)
{
// the /dev/random pool has been exhausted. Fall back
// to /dev/urandom for the remainder of the buffer.
break;
}
*(((BYTE*)lpBuffer) + i) ^= buf;
}
close(rand_des);
}
}
if (i < dwLength && !sMissingDevURandom)
{
if ((rand_des = PAL__open(URANDOM_DEVICE_NAME, O_RDONLY)) == -1)
{
if (errno == ENOENT)
{
sMissingDevURandom = TRUE;
}
else
{
ASSERT("PAL__open() failed, errno:%d (%s)\n", errno, strerror(errno));
}
// Back off and try mrand48.
}
else
{
for( ; i < dwLength; i++)
{
if (read(rand_des, &buf, 1) < 1)
{
// Fall back to srand48 for the remainder of the buffer.
break;
}
*(((BYTE*)lpBuffer) + i) ^= buf;
}
close(rand_des);
}
}
if (!sInitializedMRand)
{
srand48(time(NULL));
sInitializedMRand = TRUE;
}
// always xor srand48 over the whole buffer to get some randomness
// in case /dev/random is not really random
for(i = 0; i < dwLength; i++)
{
if (i % sizeof(long) == 0) {
num = mrand48();
}
*(((BYTE*)lpBuffer) + i) ^= num;
num >>= 8;
}
bRet = TRUE;
LOGEXIT("PAL_Random returns %d\n", bRet);
PERF_EXIT(PAL_Random);
return bRet;
}
static inline long
random ()
{
return mrand48 ();
}
// START FUNC DECL
int
udf_deg2(
char *TM_tbl, /* member table */
char *TM_TC_lb, /* I8 */
char *TM_TC_cnt, /* I4 */
char *TD1_tbl, /* first degree connections */
char *TD1_fk_TM, /* I4 */
char *TC_tbl, /* connections */
char *TC_mid, /* I4 */
char *TD2_tbl, /* second degree connections */
char *TD2_mid /* I4 */
)
// STOP FUNC DECL
{
int status = 0;
int *deg2 = NULL;
int n_deg2 = 0;
int *alt_deg2 = NULL, *xloc = NULL;
unsigned int a, b;
int n_alt_deg2;
int block_size, nT;
char *TM_TC_lb_X = NULL;
size_t TM_TC_lb_nX = 0;
char *TM_TC_cnt_X = NULL;
size_t TM_TC_cnt_nX = 0;
char *TC_mid_X = NULL;
size_t TC_mid_nX = 0;
char *TD2_mid_X = NULL;
size_t TD2_mid_nX = 0;
char *TD1_fk_TM_X = NULL;
size_t TD1_fk_TM_nX = 0;
int TM_tbl_id = -1;
TBL_REC_TYPE TM_tbl_rec;
long long nR_TM;
int TC_tbl_id = -1;
TBL_REC_TYPE TC_tbl_rec;
long long nR_TC;
int TD1_tbl_id = -1;
TBL_REC_TYPE TD1_tbl_rec;
long long nR_TD1;
int TD2_tbl_id = -1;
TBL_REC_TYPE TD2_tbl_rec;
long long nR_TD2;
int nn_fld_id = -1;
FLD_REC_TYPE nn_fld_rec;
int TM_TC_lb_fld_id = -1;
FLD_REC_TYPE TM_TC_lb_fld_rec;
int TM_TC_cnt_fld_id = -1;
FLD_REC_TYPE TM_TC_cnt_fld_rec;
int TC_mid_fld_id = -1;
FLD_REC_TYPE TC_mid_fld_rec;
int TD1_fk_TM_fld_id = -1;
FLD_REC_TYPE TD1_fk_TM_fld_rec;
int TD2_mid_fld_id = -1;
FLD_REC_TYPE TD2_mid_fld_rec;
if ( ( TM_tbl == NULL ) || ( *TM_tbl == '\0' ) ) {
go_BYE(-1);
}
if ( ( TC_tbl == NULL ) || ( *TC_tbl == '\0' ) ) {
go_BYE(-1);
}
if ( ( TD1_tbl == NULL ) || ( *TD1_tbl == '\0' ) ) {
go_BYE(-1);
}
if ( ( TD2_tbl == NULL ) || ( *TD2_tbl == '\0' ) ) {
go_BYE(-1);
}
if ( strcmp(TD2_tbl, TM_tbl) == 0 ) {
go_BYE(-1);
}
if ( strcmp(TD2_tbl, TC_tbl) == 0 ) {
go_BYE(-1);
}
if ( strcmp(TD2_tbl, TD1_tbl) == 0 ) {
go_BYE(-1);
}
status = is_tbl(TM_tbl, &TM_tbl_id, &TM_tbl_rec);
cBYE(status);
if ( TM_tbl_id < 0 ) {
go_BYE(-1);
}
nR_TM = TM_tbl_rec.nR;
status = is_fld(NULL, TM_tbl_id, TM_TC_lb, &TM_TC_lb_fld_id,
&TM_TC_lb_fld_rec, &nn_fld_id, &nn_fld_rec);
if ( TM_TC_lb_fld_id < 0 ) {
go_BYE(-1);
}
if ( nn_fld_id >= 0 ) {
go_BYE(-1);
}
if ( TM_TC_lb_fld_rec.fldtype != I8 ) {
go_BYE(-1);
}
status = get_data(TM_TC_lb_fld_rec, &TM_TC_lb_X, &TM_TC_lb_nX, 0);
long long *TM_TC_lb_I8 = (long long *)TM_TC_lb_X;
status = is_fld(NULL, TM_tbl_id, TM_TC_cnt, &TM_TC_cnt_fld_id,
&TM_TC_cnt_fld_rec, &nn_fld_id, &nn_fld_rec);
if ( TM_TC_cnt_fld_id < 0 ) {
go_BYE(-1);
}
if ( nn_fld_id >= 0 ) {
go_BYE(-1);
}
if ( TM_TC_cnt_fld_rec.fldtype != I4 ) {
go_BYE(-1);
}
status = get_data(TM_TC_cnt_fld_rec, &TM_TC_cnt_X, &TM_TC_cnt_nX, 0);
int *TM_TC_cnt_I4 = (int *)TM_TC_cnt_X;
/*----------------------------------------------------------------*/
status = is_tbl(TC_tbl, &TC_tbl_id, &TC_tbl_rec);
cBYE(status);
if ( TC_tbl_id < 0 ) {
go_BYE(-1);
}
nR_TC = TC_tbl_rec.nR;
status = is_fld(NULL, TC_tbl_id, TC_mid, &TC_mid_fld_id,
&TC_mid_fld_rec, &nn_fld_id, &nn_fld_rec);
if ( TC_mid_fld_id < 0 ) {
go_BYE(-1);
}
if ( nn_fld_id >= 0 ) {
go_BYE(-1);
}
if ( TC_mid_fld_rec.fldtype != I4 ) {
go_BYE(-1);
}
status = get_data(TC_mid_fld_rec, &TC_mid_X, &TC_mid_nX, 0);
int *TC_mid_I4 = (int *)TC_mid_X;
/*----------------------------------------------------------------*/
status = is_tbl(TD1_tbl, &TD1_tbl_id, &TD1_tbl_rec);
cBYE(status);
if ( TD1_tbl_id < 0 ) {
go_BYE(-1);
}
nR_TD1 = TD1_tbl_rec.nR;
status = is_fld(NULL, TD1_tbl_id, TD1_fk_TM, &TD1_fk_TM_fld_id,
&TD1_fk_TM_fld_rec, &nn_fld_id, &nn_fld_rec);
if ( TD1_fk_TM_fld_id < 0 ) {
go_BYE(-1);
}
if ( nn_fld_id >= 0 ) {
go_BYE(-1);
}
if ( TD1_fk_TM_fld_rec.fldtype != I4 ) {
go_BYE(-1);
}
status = get_data(TD1_fk_TM_fld_rec, &TD1_fk_TM_X, &TD1_fk_TM_nX, 0);
int *TD1_fk_TM_I4 = (int *)TD1_fk_TM_X;
/*----------------------------------------------------------------*/
// Set up data structures for each thread
#define MAX_NUM_SECOND_DEGREE 32*1048576
deg2 = malloc(MAX_NUM_SECOND_DEGREE * sizeof(int));
return_if_malloc_failed(deg2);
int *bak_deg2 = deg2;
//--------------------------------------------------
unsigned long long t0 = get_time_usec();
for ( int i = 0; i < nR_TD1; i++ ) {
int TM_idx = TD1_fk_TM_I4[i];
long long TC_idx = TM_TC_lb_I8[TM_idx];
int TC_cnt = TM_TC_cnt_I4[TM_idx];
// TODO P1 TO BE FIXED: realloc needed
if ( n_deg2 + TC_cnt > MAX_NUM_SECOND_DEGREE ) {
continue;
}
memcpy(deg2, TC_mid_I4 + TC_idx, ((sizeof(int) * TC_cnt)));
deg2 += TC_cnt;
n_deg2 += TC_cnt;
}
// fprintf(stderr, "Need to process %d people \n", cnt);
unsigned long long t1 = get_time_usec();
deg2 = bak_deg2;
if ( n_deg2 > 2*1048576 ) { // TODO P2 Document this choice
n_alt_deg2 = max(1024, (n_deg2 * 2));
n_alt_deg2 = prime_geq(n_alt_deg2);
alt_deg2 = malloc(n_alt_deg2 * sizeof(int));
return_if_malloc_failed(alt_deg2);
xloc = malloc(n_deg2 * sizeof(int));
return_if_malloc_failed(xloc);
unsigned long long seed = get_time_usec();
srand48(seed);
a = (unsigned long long)mrand48();
a = prime_geq(a);
b = (unsigned long long)mrand48();
b = prime_geq(b);
nT = g_num_cores;
//-------------------------------------
block_size = n_deg2 / nT;
#pragma omp parallel for
for ( int tid = 0; tid < nT; tid++ ) {
int lb = tid * block_size;
int ub = lb + block_size;
if ( tid == (nT-1) ) {
ub = n_deg2;
}
for ( int i = lb; i < ub; i++ ) {
xloc[i] = ( ( deg2[i] * a ) + b ) % n_alt_deg2;
}
}
//-------------------------------------
block_size = n_alt_deg2 / nT;
#pragma omp parallel for
for ( int tid = 0; tid < nT; tid++ ) {
int lb = tid * block_size;
int ub = lb + block_size;
if ( tid == (nT-1) ) {
ub = n_alt_deg2;
}
for ( int i = lb; i < ub; i++ ) {
alt_deg2[i] = -1; // indicates unused
}
}
//-------------------------------------
// sequential loop
for ( int i = 0; i < n_deg2; i++ ) {
int loc = xloc[i];
int val = deg2[i];
if ( alt_deg2[loc] == -1 ) {
alt_deg2[loc] = val;
}
else if ( alt_deg2[loc] == val ) {
// nothing to do
}
else { // sequential search for new spot
bool found = false;
for ( int j = loc; j < n_alt_deg2; j++ ) {
if ( alt_deg2[j] == -1 ) {
alt_deg2[j] = val;
found = true;
break;
}
else if ( alt_deg2[j] == val ) {
found = true;
break;
}
}
if ( found == false ) {
for ( int j = 0; j < loc; j++ ) {
if ( alt_deg2[j] == -1 ) {
alt_deg2[j] = val;
found = true;
break;
}
else if ( alt_deg2[j] == val ) {
found = true;
break;
}
}
if ( found == false ) {
go_BYE(-1);
}
}
}
}
//-------------------------------------
block_size = n_deg2 / nT;
#pragma omp parallel for
for ( int tid = 0; tid < nT; tid++ ) {
int lb = tid * block_size;
int ub = lb + block_size;
if ( tid == (nT-1) ) {
ub = n_deg2;
}
for ( int i = lb; i < ub; i++ ) {
deg2[i] = -1; // indicates unused
}
}
//-------------------------------------
nR_TD2 = 0;
for ( int i = 0; i < n_alt_deg2; i++ ) {
int val = alt_deg2[i];
if ( val < 0 ) {
continue;
}
deg2[nR_TD2++] = val;
}
}
else {
#ifdef IPP
ippsSortAscend_32s_I(deg2, n_deg2);
#else
qsort_asc_I4 (deg2, n_deg2, sizeof(int), NULL);
#endif
unsigned long long t2 = get_time_usec();
/* Remove duplicates */
nR_TD2 = 1; /* first guy always gets in */
for ( int oldidx = 1; oldidx < n_deg2; oldidx++ ) {
if ( deg2[oldidx] != deg2[oldidx-1] ) {
deg2[nR_TD2++] = deg2[oldidx];
}
}
}
unsigned long long t3 = get_time_usec();
/* Write output to file */
FLD_TYPE fldtype = I4;
int fldsz = -1;
size_t filesz = 0;
int ddir_id = -1;
int fileno = -1;
status = get_fld_sz(fldtype, &fldsz);
cBYE(status);
filesz = fldsz * nR_TD2;
status = mk_temp_file(filesz, &ddir_id, &fileno);
cBYE(status);
status = q_mmap(ddir_id, fileno, &TD2_mid_X, &TD2_mid_nX, true);
cBYE(status);
memcpy(TD2_mid_X, deg2, fldsz * nR_TD2);
rs_munmap(TD2_mid_X, TD2_mid_nX);
unsigned long long t4 = get_time_usec();
/*--------------------------------------------*/
char strbuf[32];
sprintf(strbuf, "%lld", nR_TD2);
status = add_tbl(TD2_tbl, strbuf, &TD2_tbl_id, &TD2_tbl_rec);
cBYE(status);
zero_fld_rec(&TD2_mid_fld_rec);
TD2_mid_fld_rec.fldtype = I4;
status = add_fld(TD2_tbl_id, TD2_mid, ddir_id, fileno,
&TD2_mid_fld_id, &TD2_mid_fld_rec);
cBYE(status);
/*
fprintf(stderr, "t1 = %llu \n", t1 - t0);
fprintf(stderr, "t2 = %llu \n", t2 - t1);
fprintf(stderr, "t3 = %llu \n", t3 - t2);
fprintf(stderr, "t4 = %llu \n", t4 - t3);
*/
BYE:
rs_munmap(TM_TC_lb_X, TM_TC_lb_nX);
rs_munmap(TM_TC_cnt_X, TM_TC_cnt_nX);
rs_munmap(TC_mid_X, TC_mid_nX);
rs_munmap(TD1_fk_TM_X, TD1_fk_TM_nX);
rs_munmap(TD2_mid_X, TD2_mid_nX);
free_if_non_null(deg2);
free_if_non_null(alt_deg2);
free_if_non_null(xloc);
return(status);
}
int f_rand(int argc, const int *argt, void **args)
{
int i;
if (argc < 2)
return E_ARG_LO;
if (argc > 2)
return E_ARG_HI;
switch (argt[0]) {
case CELL_TYPE:
{
CELL *res = args[0];
CELL *arg1 = args[1];
CELL *arg2 = args[2];
for (i = 0; i < columns; i++) {
unsigned long x = (unsigned long)mrand48();
int lo = arg1[i];
int hi = arg2[i];
if (lo > hi) {
int tmp = lo;
lo = hi;
hi = tmp;
}
res[i] = (lo == hi) ? lo : lo + x % (unsigned long)(hi - lo);
}
return 0;
}
case FCELL_TYPE:
{
FCELL *res = args[0];
FCELL *arg1 = args[1];
FCELL *arg2 = args[2];
for (i = 0; i < columns; i++) {
double x = drand48();
FCELL lo = arg1[i];
FCELL hi = arg2[i];
if (lo > hi) {
FCELL tmp = lo;
lo = hi;
hi = tmp;
}
res[i] = (FCELL) (lo + x * (hi - lo));
}
return 0;
}
case DCELL_TYPE:
{
DCELL *res = args[0];
DCELL *arg1 = args[1];
DCELL *arg2 = args[2];
for (i = 0; i < columns; i++) {
double x = drand48();
DCELL lo = arg1[i];
DCELL hi = arg2[i];
if (lo > hi) {
DCELL tmp = lo;
lo = hi;
hi = tmp;
}
res[i] = lo + x * (hi - lo);
}
return 0;
}
default:
return E_INV_TYPE;
}
}
// START FUNC DECL
int
mk_hashes_I2(
short *scalars,
int num_scalars,
short **ptr_hashes,
unsigned int *ptr_n,
unsigned int *ptr_a,
unsigned int *ptr_b
)
// STOP FUNC DECL
{
int status = 0;
short *hashes = NULL;
unsigned char *used = NULL;
unsigned int n, a, b;
*ptr_n = *ptr_a = *ptr_b = 0; *ptr_hashes = NULL;
if ( ( num_scalars < 1 ) || ( num_scalars > MAX_NUM_SCALARS ) ){ go_BYE(-1);}
n = prime_geq(num_scalars * num_scalars);
if ( n <= 1 ) { go_BYE(-1); }
hashes = malloc(n * sizeof(short));
return_if_malloc_failed(hashes);
used = malloc(n * sizeof(unsigned char));
return_if_malloc_failed(used);
srand48(get_time_usec());
for ( int iter = 0; ; iter++ ) {
// initializations
a = (unsigned int)mrand48();
a = prime_geq(a);
b = (unsigned int)mrand48();
b = prime_geq(b);
bool is_collision = false;
assign_const_I2( hashes, n, 0);
assign_const_I1((char *)used, n, 0);
//-------------------------------------
for ( int i = 0; i < num_scalars; i++ ) {
unsigned long long val = scalars[i];
unsigned long long ltemp = ( ( a * val ) + b ) % n;
unsigned short loc = (unsigned short)ltemp;
if ( used[loc] == 0 ) {
used[loc] = 1;
hashes[loc] = scalars[i];
}
else {
is_collision = true;
break;
}
}
if ( is_collision == false ) { break; }
}
int chk_cnt = 0;
for ( int i = 0; i < n; i++ ) {
if ( used[i] == 1 ) { chk_cnt++; }
if ( ( used[i] == 0 ) && ( hashes[i] != 0 ) ) { go_BYE(-1); }
}
if ( chk_cnt != num_scalars ) { go_BYE(-1); }
//---------------------------------------
*ptr_hashes = hashes;
*ptr_a = a;
*ptr_b = b;
*ptr_n = n;
BYE:
free_if_non_null(used);
return(status);
}
void test01 ( void )
/******************************************************************************/
/*
Purpose:
TEST01 tests MRAND48 + SRAND48.
Licensing:
This code is distributed under the GNU LGPL license.
Modified:
18 August 2008
Author:
John Burkardt
*/
{
int i;
long int seed;
long int value;
printf ( "\n" );
printf ( "TEST01\n" );
printf ( " MRAND48 returns signed long integers in [-2^31,+2^31].\n" );
printf ( " SRAND48 is used to initialize the seed (but only 32 bits).\n" );
seed = 123456789L;
printf ( "\n" );
printf ( " The initial seed is %d\n", seed );
printf ( "\n" );
srand48 ( seed );
for ( i = 1; i <= 10; i++ )
{
value = mrand48 ( );
printf ( " %6d %12d\n", i, value );
}
seed = 987654321L;
printf ( "\n" );
printf ( " The initial seed is %d\n", seed );
printf ( "\n" );
srand48 ( seed );
for ( i = 1; i <= 10; i++ )
{
value = mrand48 ( );
printf ( " %6d %12d\n", i, value );
}
seed = 123456789L;
printf ( "\n" );
printf ( " The initial seed is %d\n", seed );
printf ( "\n" );
srand48 ( seed );
for ( i = 1; i <= 10; i++ )
{
value = mrand48 ( );
printf ( " %6d %12d\n", i, value );
}
return;
}
void test02 ( void )
/******************************************************************************/
/*
Purpose:
TEST02 tests MRAND48 + SEED48.
Licensing:
This code is distributed under the GNU LGPL license.
Modified:
18 August 2008
Author:
John Burkardt
*/
{
int i;
int modulus = 65536;
long long int seed;
unsigned short int seedvec[3];
long int value;
printf ( "\n" );
printf ( "TEST02\n" );
printf ( " MRAND48 returns signed long integers in [-2^31,+2^31].\n" );
printf ( " SEED48 is used to initialize the seed (all 48 bits).\n" );
seed = 123456789LL;
seedvec[0] = seed % modulus;
seed = seed / modulus;
seedvec[1] = seed % modulus;
seed = seed / modulus;
seedvec[2] = seed % modulus;
seed = seed / modulus;
printf ( "\n" );
printf ( " The initial seed is %d\n", seed );
printf ( " The seed vector is %d, %d, %d\n", seedvec[0], seedvec[1], seedvec[2] );
printf ( "\n" );
seed48 ( seedvec );
for ( i = 1; i <= 10; i++ )
{
value = mrand48 ( );
printf ( " %6d %12d\n", i, value );
}
seed = 987654321LL;
seedvec[0] = seed % modulus;
seed = seed / modulus;
seedvec[1] = seed % modulus;
seed = seed / modulus;
seedvec[2] = seed % modulus;
seed = seed / modulus;
printf ( "\n" );
printf ( " The initial seed is %d\n", seed );
printf ( " The seed vector is %d, %d, %d\n", seedvec[0], seedvec[1], seedvec[2] );
printf ( "\n" );
seed48 ( seedvec );
for ( i = 1; i <= 10; i++ )
{
value = mrand48 ( );
printf ( " %6d %12d\n", i, value );
}
seed = 123456789LL;
seedvec[0] = seed % modulus;
seed = seed / modulus;
seedvec[1] = seed % modulus;
seed = seed / modulus;
seedvec[2] = seed % modulus;
seed = seed / modulus;
printf ( "\n" );
printf ( " The initial seed is %d\n", seed );
printf ( " The seed vector is %d, %d, %d\n", seedvec[0], seedvec[1], seedvec[2] );
printf ( "\n" );
seed48 ( seedvec );
for ( i = 1; i <= 10; i++ )
{
value = mrand48 ( );
printf ( " %6d %12d\n", i, value );
}
return;
}
}
#endif
static uint32_t kafka_hash(const char *keydata, size_t keylen) {
uint32_t hash = 5381;
for (; keylen > 0; keylen--)
hash = ((hash << 5) + hash) + keydata[keylen - 1];
return hash;
}
/* 31 bit -> 4 byte -> 8 byte hex string + null byte */
#define KAFKA_RANDOM_KEY_SIZE 9
#define KAFKA_RANDOM_KEY_BUFFER \
(char[KAFKA_RANDOM_KEY_SIZE]) { "" }
static char *kafka_random_key(char buffer[static KAFKA_RANDOM_KEY_SIZE]) {
ssnprintf(buffer, KAFKA_RANDOM_KEY_SIZE, "%08lX", (unsigned long)mrand48());
return buffer;
}
static int32_t kafka_partition(const rd_kafka_topic_t *rkt, const void *keydata,
size_t keylen, int32_t partition_cnt, void *p,
void *m) {
uint32_t key = kafka_hash(keydata, keylen);
uint32_t target = key % partition_cnt;
int32_t i = partition_cnt;
while (--i > 0 && !rd_kafka_topic_partition_available(rkt, target)) {
target = (target + 1) % partition_cnt;
}
return target;
}
