int
main(int argc, char **argv)
{
const char *file = "foo";
const size_t sz = 16384;
char *malloc_buf;
void *mmap_buf;
int fd;
srand(time(NULL));
generate_random_file(file, sz);
fd = open(file, O_RDONLY, 0);
if (fd < 0)
err(1, "open %s", file);
malloc_buf = read_file(fd, sz);
mmap_buf = mmap_file(fd, sz);
close(fd);
unlink(file);
if (memcmp(malloc_buf, mmap_buf, sz) != 0)
return 1;
return 0;
}
static int
test(const char *file, int writep)
{
const size_t sz = 4 * getpagesize();
char *buf;
char *malloc_buf;
int fd;
int ret;
buf = generate_random_file(file, 4, getpagesize(), writep);
fd = open(file, O_RDONLY, 0);
if (fd < 0)
err(1, "open %s", file);
malloc_buf = read_file(fd, sz);
close(fd);
ret = memcmp(buf, malloc_buf, sz);
free(buf);
return ret;
}
void read_and_create(int argc, char **argv)
{
int ri,i,nread;
int tmp1,idealelementsperproc;
void **amatptrs,**xvecptrs;
na = atoi(argv[1]);
nz = atoi(argv[2]);
if(strncmp("random",argv[3],6)){
if(me==0){
fd = fopen(argv[3], "r");
if(fd==NULL)ARMCI_Error("unable to open given file",0);
}
}
else{
if(na==0 || nz==0){
printf("\nERROR:exiting-no input file given and na or nz is 0");
fflush(stdout);
ARMCI_Finalize();
MP_FINALIZE();
return;
}
if(me==0){
generate_random_file(na,nz);
fd = fopen("randominput.dat", "r");
}
}
if(me==0){
if(na==0)
nread = fread(&na, sizeof(na), 1, fd);
if(nz==0)
nread = fread(&nz, sizeof(nz), 1, fd);
printf("\nReading CG input\n");
printf("Number of rows: %d\n", na);
printf("Number of non-zeros: %d\n", nz);
}
armci_msg_bcast(&nz,sizeof(int),0);
armci_msg_bcast(&na,sizeof(int),0);
MP_BARRIER();
amatptrs = (void **)malloc(sizeof(void *)*nproc);
xvecptrs = (void **)malloc(sizeof(void *)*nproc);
if(xvecptrs==NULL || amatptrs==NULL)
ARMCI_Error("xvecptrs amatptrs malloc failed",sizeof(void *)*nproc);
if(ARMCI_Malloc(amatptrs,((me==0)?(sizeof(double)*nz):0)))
ARMCI_Error("amat malloc failed",sizeof(double)*nz);
amat = (double *)amatptrs[0];
if(ARMCI_Malloc(amatptrs,((me==0)?(sizeof(int)*(nz+1)):0)))
ARMCI_Error("icol malloc failed",sizeof(int)*(nz+1));
cidx = (int *)amatptrs[0];
ARMCI_Malloc(xvecptrs,((me==0)?(sizeof(int)*(na+1)):0)); /*+1 for end of last row*/
ridx = (int *)xvecptrs[0];
ARMCI_Malloc(xvecptrs,((me==0)?(sizeof(double)*(na+1)):0));
xvec = (double *)xvecptrs[0];
ARMCI_Malloc(xvecptrs,((me==0)?(sizeof(double)*(na+1)):0));
bvec = (double *)xvecptrs[0];
if(me==0){
for (i = 0; i < na + 1; i++)
xvec[i] = 0.0;
nread = fread(amat, sizeof(double), nz, fd);
nread = fread(ridx, sizeof(int), (na+1), fd);
ridx[na]=nz;
nread = fread(cidx, sizeof(int), (nz+1), fd);
nread = fread(bvec, sizeof(double), (na+1), fd);
/* the c adjustment */
for (i = 0; i < na; i++)
ridx[i] -= 1;
for (i = 0; i < nz; i++)
cidx[i] -= 1;
}
MP_BARRIER();
/*acg_matvecmul(amat,xvec,bvec,ridx,cidx);*/
if(0){
for(i=0;i<nz+1;i++)
printf("\n%d:amat[%d]=%f icol[%d]=%d",me,i,amat[i],i,cidx[i]);
for(i=0;i<na+1;i++)
printf("\n%d:irow[%d]=%d bvec[%d]=%f",me,i,ridx[i],i,bvec[i]);
}
allfirstrow = (int *)malloc(sizeof(int)*nproc);
alllastrow = (int *)malloc(sizeof(int)*nproc);
columnmap = (int *)malloc(sizeof(int)*nproc);
if(!allfirstrow || !alllastrow || !columnmap)
ARMCI_Error("malloc failed allfirstrow ",0);
MP_BARRIER();
/*
* next decide who works on which rows, this will decide the
* distribution of a,d,r,q,x,and ax
*/
/*create the mapping for all vectors, row matrix and column matrix*/
if(me==0){
idealelementsperproc = nz/nproc;
tmp1=0;
for(i=0;i<nproc;i++){
int elementsperproc=0;
allfirstrow[i]=tmp1;
for(ri=tmp1;ri<na;ri++,tmp1++){
elementsperproc+=(ridx[ri+1]-ridx[ri]);
if(elementsperproc>=idealelementsperproc){
if((elementsperproc-idealelementsperproc) >
idealelementsperproc-(elementsperproc-(ridx[ri+1]-ridx[ri]))){
alllastrow[i] = ri-1;
if((ri-1)<0)ARMCI_Error("run on a smaller processor count",0);
/*tmp1--;*/
}
else{
alllastrow[i] = ri;
if(ri<0)ARMCI_Error("run on a smaller processor count",0);
tmp1++;
}
elementsperproc=0;
break;
}
}
}
alllastrow[nproc-1]=na-1;
for(i=0;i<nproc;i++)columnmap[i]=ridx[allfirstrow[i]];
}
armci_msg_bcast(columnmap,nproc*sizeof(int),0);
armci_msg_bcast(allfirstrow,nproc*sizeof(int),0);
armci_msg_bcast(alllastrow,nproc*sizeof(int),0);
myfirstrow = allfirstrow[me];
mylastrow = alllastrow[me];
if(me==0)for(i=0;i<nproc;i++){
printf("\nDISTRIBUTION:first row of process\t%d is %d last row of process\t%d is %d",i,allfirstrow[i],i,alllastrow[i]);
}
/*
for(i=myfirstrow;i<mylastrow;i++){
xvec[i]=0.0;
}
*/
ARMCI_Malloc(xvecptrs,((me==0)?(sizeof(double)*na):0));
rvec = (double *)xvecptrs[0];
ARMCI_Malloc(xvecptrs,((me==0)?(sizeof(double)*na):0));
dvec = (double *)xvecptrs[0];
ARMCI_Malloc(xvecptrs,((me==0)?(sizeof(double)*na):0));
svec = (double *)xvecptrs[0];
ARMCI_Malloc(xvecptrs,((me==0)?(sizeof(double)*na):0));
dmvec = (double *)xvecptrs[0];
ARMCI_Malloc(xvecptrs,((me==0)?(sizeof(double)*na):0));
qvec = (double *)xvecptrs[0];
ARMCI_Malloc(xvecptrs,((me==0)?(sizeof(double)*na):0));
axvec = (double *)xvecptrs[0];
if(me==0)fclose(fd);
/*dont forget to free mallocs*/
free(allfirstrow);
free(alllastrow);
free(columnmap);
}
/* (Note: *LAST_SEED is an output parameter.) */
static svn_error_t *
do_random_combine_test(const char **msg,
svn_boolean_t msg_only,
apr_pool_t *pool,
apr_uint32_t *last_seed)
{
static char msg_buff[256];
apr_uint32_t seed, bytes_range, maxlen;
int i, iterations, dump_files, print_windows;
const char *random_bytes;
/* Initialize parameters and print out the seed in case we dump core
or something. */
init_params(&seed, &maxlen, &iterations, &dump_files, &print_windows,
&random_bytes, &bytes_range, pool);
sprintf(msg_buff,
"random combine delta test, seed = %lu", (unsigned long) seed);
*msg = msg_buff;
if (msg_only)
return SVN_NO_ERROR;
else
printf("SEED: %s\n", msg_buff);
for (i = 0; i < iterations; i++)
{
/* Generate source and target for the delta and its application. */
apr_uint32_t subseed_base = svn_test_rand((*last_seed = seed, &seed));
apr_file_t *source = generate_random_file(maxlen, subseed_base, &seed,
random_bytes, bytes_range,
dump_files, pool);
apr_file_t *middle = generate_random_file(maxlen, subseed_base, &seed,
random_bytes, bytes_range,
dump_files, pool);
apr_file_t *target = generate_random_file(maxlen, subseed_base, &seed,
random_bytes, bytes_range,
dump_files, pool);
apr_file_t *source_copy = copy_tempfile(source, pool);
apr_file_t *middle_copy = copy_tempfile(middle, pool);
apr_file_t *target_regen = open_tempfile(NULL, pool);
svn_txdelta_stream_t *txdelta_stream_A;
svn_txdelta_stream_t *txdelta_stream_B;
svn_txdelta_window_handler_t handler;
svn_stream_t *stream;
void *handler_baton;
/* Set up a four-stage pipeline: create two deltas, combine them
and convert the result to svndiff format, parse that back
into delta format, and apply it to a copy of the source file
to see if we get the same target back. */
apr_pool_t *delta_pool = svn_pool_create(pool);
/* Make stage 4: apply the text delta. */
svn_txdelta_apply(svn_stream_from_aprfile(source_copy, delta_pool),
svn_stream_from_aprfile(target_regen, delta_pool),
NULL, NULL, delta_pool, &handler, &handler_baton);
/* Make stage 3: reparse the text delta. */
stream = svn_txdelta_parse_svndiff(handler, handler_baton, TRUE,
delta_pool);
/* Make stage 2: encode the text delta in svndiff format. */
svn_txdelta_to_svndiff2(&handler, &handler_baton, stream, 1,
delta_pool);
/* Make stage 1: create the text deltas. */
svn_txdelta(&txdelta_stream_A,
svn_stream_from_aprfile(source, delta_pool),
svn_stream_from_aprfile(middle, delta_pool),
delta_pool);
svn_txdelta(&txdelta_stream_B,
svn_stream_from_aprfile(middle_copy, delta_pool),
svn_stream_from_aprfile(target, delta_pool),
delta_pool);
{
svn_txdelta_window_t *window_A;
svn_txdelta_window_t *window_B;
svn_txdelta_window_t *composite;
apr_pool_t *wpool = svn_pool_create(delta_pool);
do
{
SVN_ERR(svn_txdelta_next_window(&window_A, txdelta_stream_A,
wpool));
if (print_windows)
delta_window_print(window_A, "A ", stdout);
SVN_ERR(svn_txdelta_next_window(&window_B, txdelta_stream_B,
wpool));
if (print_windows)
delta_window_print(window_B, "B ", stdout);
if (!window_B)
break;
assert(window_A != NULL || window_B->src_ops == 0);
if (window_B->src_ops == 0)
{
composite = window_B;
composite->sview_len = 0;
}
else
composite = svn_txdelta_compose_windows(window_A, window_B,
wpool);
if (print_windows)
delta_window_print(composite, "AB", stdout);
/* The source view length should not be 0 if there are
source copy ops in the window. */
if (composite
&& composite->sview_len == 0 && composite->src_ops > 0)
return svn_error_create
(SVN_ERR_FS_GENERAL, NULL,
"combined delta window is inconsistent");
SVN_ERR(handler(composite, handler_baton));
svn_pool_clear(wpool);
}
while (composite != NULL);
svn_pool_destroy(wpool);
}
svn_pool_destroy(delta_pool);
SVN_ERR(compare_files(target, target_regen, dump_files));
apr_file_close(source);
apr_file_close(middle);
apr_file_close(target);
apr_file_close(source_copy);
apr_file_close(middle_copy);
apr_file_close(target_regen);
}
return SVN_NO_ERROR;
}
/* Implements svn_test_driver_t. */
static svn_error_t *
random_test(const char **msg,
svn_boolean_t msg_only,
svn_test_opts_t *opts,
apr_pool_t *pool)
{
static char msg_buff[256];
apr_uint32_t seed, bytes_range, maxlen;
int i, iterations, dump_files, print_windows;
const char *random_bytes;
/* Initialize parameters and print out the seed in case we dump core
or something. */
init_params(&seed, &maxlen, &iterations, &dump_files, &print_windows,
&random_bytes, &bytes_range, pool);
sprintf(msg_buff, "random delta test, seed = %lu", (unsigned long) seed);
*msg = msg_buff;
if (msg_only)
return SVN_NO_ERROR;
else
printf("SEED: %s\n", msg_buff);
for (i = 0; i < iterations; i++)
{
/* Generate source and target for the delta and its application. */
apr_uint32_t subseed_base = svn_test_rand(&seed);
apr_file_t *source = generate_random_file(maxlen, subseed_base, &seed,
random_bytes, bytes_range,
dump_files, pool);
apr_file_t *target = generate_random_file(maxlen, subseed_base, &seed,
random_bytes, bytes_range,
dump_files, pool);
apr_file_t *source_copy = copy_tempfile(source, pool);
apr_file_t *target_regen = open_tempfile(NULL, pool);
svn_txdelta_stream_t *txdelta_stream;
svn_txdelta_window_handler_t handler;
svn_stream_t *stream;
void *handler_baton;
/* Set up a four-stage pipeline: create a delta, convert it to
svndiff format, parse it back into delta format, and apply it
to a copy of the source file to see if we get the same target
back. */
apr_pool_t *delta_pool = svn_pool_create(pool);
/* Make stage 4: apply the text delta. */
svn_txdelta_apply(svn_stream_from_aprfile(source_copy, delta_pool),
svn_stream_from_aprfile(target_regen, delta_pool),
NULL, NULL, delta_pool, &handler, &handler_baton);
/* Make stage 3: reparse the text delta. */
stream = svn_txdelta_parse_svndiff(handler, handler_baton, TRUE,
delta_pool);
/* Make stage 2: encode the text delta in svndiff format. */
svn_txdelta_to_svndiff2(&handler, &handler_baton, stream, 1,
delta_pool);
/* Make stage 1: create the text delta. */
svn_txdelta(&txdelta_stream,
svn_stream_from_aprfile(source, delta_pool),
svn_stream_from_aprfile(target, delta_pool),
delta_pool);
SVN_ERR(svn_txdelta_send_txstream(txdelta_stream,
handler,
handler_baton,
delta_pool));
svn_pool_destroy(delta_pool);
SVN_ERR(compare_files(target, target_regen, dump_files));
apr_file_close(source);
apr_file_close(target);
apr_file_close(source_copy);
apr_file_close(target_regen);
}
return SVN_NO_ERROR;
}
/* Implements svn_test_driver_t. */
static svn_error_t *
random_test(apr_pool_t *pool)
{
apr_uint32_t seed, maxlen;
apr_size_t bytes_range;
int i, iterations, dump_files, print_windows;
const char *random_bytes;
/* Initialize parameters and print out the seed in case we dump core
or something. */
init_params(&seed, &maxlen, &iterations, &dump_files, &print_windows,
&random_bytes, &bytes_range, pool);
for (i = 0; i < iterations; i++)
{
/* Generate source and target for the delta and its application. */
apr_uint32_t subseed_base = svn_test_rand(&seed);
apr_file_t *source = generate_random_file(maxlen, subseed_base, &seed,
random_bytes, bytes_range,
dump_files, pool);
apr_file_t *target = generate_random_file(maxlen, subseed_base, &seed,
random_bytes, bytes_range,
dump_files, pool);
apr_file_t *source_copy = copy_tempfile(source, pool);
apr_file_t *target_regen = open_tempfile(NULL, pool);
svn_txdelta_stream_t *txdelta_stream;
svn_txdelta_window_handler_t handler;
svn_stream_t *stream;
void *handler_baton;
/* Set up a four-stage pipeline: create a delta, convert it to
svndiff format, parse it back into delta format, and apply it
to a copy of the source file to see if we get the same target
back. */
apr_pool_t *delta_pool = svn_pool_create(pool);
/* Make stage 4: apply the text delta. */
svn_txdelta_apply(svn_stream_from_aprfile(source_copy, delta_pool),
svn_stream_from_aprfile(target_regen, delta_pool),
NULL, NULL, delta_pool, &handler, &handler_baton);
/* Make stage 3: reparse the text delta. */
stream = svn_txdelta_parse_svndiff(handler, handler_baton, TRUE,
delta_pool);
/* Make stage 2: encode the text delta in svndiff format using
varying compression levels. */
svn_txdelta_to_svndiff3(&handler, &handler_baton, stream, 1, i % 10,
delta_pool);
/* Make stage 1: create the text delta. */
svn_txdelta2(&txdelta_stream,
svn_stream_from_aprfile(source, delta_pool),
svn_stream_from_aprfile(target, delta_pool),
FALSE,
delta_pool);
SVN_ERR(svn_txdelta_send_txstream(txdelta_stream,
handler,
handler_baton,
delta_pool));
svn_pool_destroy(delta_pool);
SVN_ERR(compare_files(target, target_regen, dump_files));
apr_file_close(source);
apr_file_close(target);
apr_file_close(source_copy);
apr_file_close(target_regen);
}
return SVN_NO_ERROR;
}
