/** Prepare a set of buffers for use with an accumulate operation. The
* returned set of buffers is guaranteed to be in private space and scaled.
* Copies will be made if needed, the result should be completed by finish.
*
* @param[in] buf Original set of buffers.
* @param[in] count Number of entries in the buffer list.
* @param[in] size The size of the buffers (all are of the same size).
* @param[in] datatype The type of the buffer.
* @param[in] scale Scaling constant to apply to each buffer.
* @return Pointer to the new buffer or buf
*/
void ARMCII_Buf_acc_scale(void *buf_in, void *buf_out, int size, int datatype, void *scale) {
int j, nelem;
int type_size = -1;
MPI_Datatype type;
switch (datatype) {
case ARMCI_ACC_INT:
MPI_Type_size(MPI_INT, &type_size);
type = MPI_INT;
nelem= size/type_size;
{
int *src_i = (int*) buf_in;
int *scl_i = (int*) buf_out;
const int s = *((int*) scale);
for (j = 0; j < nelem; j++)
scl_i[j] = src_i[j]*s;
}
break;
case ARMCI_ACC_LNG:
MPI_Type_size(MPI_LONG, &type_size);
type = MPI_LONG;
nelem= size/type_size;
{
long *src_l = (long*) buf_in;
long *scl_l = (long*) buf_out;
const long s = *((long*) scale);
for (j = 0; j < nelem; j++)
scl_l[j] = src_l[j]*s;
}
break;
case ARMCI_ACC_FLT:
MPI_Type_size(MPI_FLOAT, &type_size);
type = MPI_FLOAT;
nelem= size/type_size;
{
float *src_f = (float*) buf_in;
float *scl_f = (float*) buf_out;
const float s = *((float*) scale);
for (j = 0; j < nelem; j++)
scl_f[j] = src_f[j]*s;
}
break;
case ARMCI_ACC_DBL:
MPI_Type_size(MPI_DOUBLE, &type_size);
type = MPI_DOUBLE;
nelem= size/type_size;
{
double *src_d = (double*) buf_in;
double *scl_d = (double*) buf_out;
const double s = *((double*) scale);
for (j = 0; j < nelem; j++)
scl_d[j] = src_d[j]*s;
}
break;
case ARMCI_ACC_CPL:
MPI_Type_size(MPI_FLOAT, &type_size);
type = MPI_FLOAT;
nelem= size/type_size;
{
float *src_fc = (float*) buf_in;
float *scl_fc = (float*) buf_out;
const float s_r = ((float*)scale)[0];
const float s_c = ((float*)scale)[1];
for (j = 0; j < nelem; j += 2) {
// Complex multiplication: (a + bi)*(c + di)
const float src_fc_j = src_fc[j];
const float src_fc_j_1 = src_fc[j+1];
/*
scl_fc[j] = src_fc[j]*s_r - src_fc[j+1]*s_c;
scl_fc[j+1] = src_fc[j+1]*s_r + src_fc[j]*s_c;
*/
scl_fc[j] = src_fc_j*s_r - src_fc_j_1*s_c;
scl_fc[j+1] = src_fc_j_1*s_r + src_fc_j*s_c;
}
}
break;
case ARMCI_ACC_DCP:
MPI_Type_size(MPI_DOUBLE, &type_size);
type = MPI_DOUBLE;
nelem= size/type_size;
{
double *src_dc = (double*) buf_in;
double *scl_dc = (double*) buf_out;
const double s_r = ((double*)scale)[0];
const double s_c = ((double*)scale)[1];
for (j = 0; j < nelem; j += 2) {
// Complex multiplication: (a + bi)*(c + di)
const double src_dc_j = src_dc[j];
const double src_dc_j_1 = src_dc[j+1];
/*
scl_dc[j] = src_dc[j]*s_r - src_dc[j+1]*s_c;
scl_dc[j+1] = src_dc[j+1]*s_r + src_dc[j]*s_c;
*/
scl_dc[j] = src_dc_j*s_r - src_dc_j_1*s_c;
scl_dc[j+1] = src_dc_j_1*s_r + src_dc_j*s_c;
}
}
break;
default:
ARMCII_Error("unknown data type (%d)", datatype);
}
ARMCII_Assert_msg(size % type_size == 0,
"Transfer size is not a multiple of the datatype size");
}
/* blockindexed_contig_test()
*
* Tests behavior with a blockindexed that can be converted to a
* contig easily. This is specifically for coverage.
*
* Returns the number of errors encountered.
*/
int blockindexed_contig_test(void)
{
int buf[4] = { 7, -1, -2, -3 };
int err, errs = 0;
int i, count = 1;
int disp = 0;
MPI_Datatype newtype;
int size, int_size;
MPI_Aint extent;
err = MPI_Type_create_indexed_block(count, 1, &disp, MPI_INT, &newtype);
if (err != MPI_SUCCESS) {
if (verbose) {
fprintf(stderr, "error creating struct type in blockindexed_contig_test()\n");
}
errs++;
}
MPI_Type_size(MPI_INT, &int_size);
err = MPI_Type_size(newtype, &size);
if (err != MPI_SUCCESS) {
if (verbose) {
fprintf(stderr, "error obtaining type size in blockindexed_contig_test()\n");
}
errs++;
}
if (size != int_size) {
if (verbose) {
fprintf(stderr, "error: size != int_size in blockindexed_contig_test()\n");
}
errs++;
}
err = MPI_Type_extent(newtype, &extent);
if (err != MPI_SUCCESS) {
if (verbose) {
fprintf(stderr, "error obtaining type extent in blockindexed_contig_test()\n");
}
errs++;
}
if (extent != int_size) {
if (verbose) {
fprintf(stderr, "error: extent != int_size in blockindexed_contig_test()\n");
}
errs++;
}
MPI_Type_commit(&newtype);
err = pack_and_unpack((char *) buf, 1, newtype, 4 * sizeof(int));
if (err != 0) {
if (verbose) {
fprintf(stderr, "error packing/unpacking in blockindexed_contig_test()\n");
}
errs += err;
}
for (i = 0; i < 4; i++) {
int goodval;
switch (i) {
case 0:
goodval = 7;
break;
default:
goodval = 0; /* pack_and_unpack() zeros before unpack */
break;
}
if (buf[i] != goodval) {
errs++;
if (verbose)
fprintf(stderr, "buf[%d] = %d; should be %d\n", i, buf[i], goodval);
}
}
MPI_Type_free(&newtype);
return errs;
}
int main(int argc, char *argv[])
{
int i, j, nerrors=0, total_errors=0;
int rank, size;
int bpos;
MPI_Datatype darray;
MPI_Status status;
MPI_File mpi_fh;
/* Define array distribution
A 2x2 block size works with ROMIO, a 3x3 block size breaks it. */
int distrib[2] = { MPI_DISTRIBUTE_CYCLIC, MPI_DISTRIBUTE_CYCLIC };
int bsize[2] = { NBLOCK, NBLOCK };
int gsize[2] = { NSIDE, NSIDE };
int psize[2] = { NPROC, NPROC };
double data[NSIDE*NSIDE];
double *ldata, *pdata;
int tsize, nelem;
MPI_File dfile;
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &size);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
/* Set up type */
CHECK(MPI_Type_create_darray(size, rank, 2, gsize, distrib,
bsize, psize, MPI_ORDER_FORTRAN, MPI_DOUBLE, &darray));
CHECK(MPI_Type_commit(&darray));
CHECK(MPI_Type_size(darray, &tsize));
nelem = tsize / sizeof(double);
for(i = 0; i < (NSIDE*NSIDE); i++) data[i] = i;
if (rank == 0) {
CHECK(MPI_File_open(MPI_COMM_SELF, argv[1],
MPI_MODE_CREATE|MPI_MODE_WRONLY, MPI_INFO_NULL, &dfile));
CHECK(MPI_File_write(dfile, data, NSIDE*NSIDE, MPI_DOUBLE, &status));
CHECK(MPI_File_close(&dfile));
}
MPI_Barrier(MPI_COMM_WORLD);
/* Allocate buffer */
ldata = (double *)malloc(tsize);
pdata = (double *)malloc(tsize);
/* Use Pack to pull out array */
bpos = 0;
CHECK(MPI_Pack(data, 1, darray, pdata, tsize, &bpos, MPI_COMM_WORLD));
MPI_Barrier(MPI_COMM_WORLD);
/* Read in array from file. */
CHECK(MPI_File_open(MPI_COMM_WORLD, argv[1], MPI_MODE_RDONLY, MPI_INFO_NULL, &mpi_fh));
CHECK(MPI_File_set_view(mpi_fh, 0, MPI_DOUBLE, darray, "native", MPI_INFO_NULL));
CHECK(MPI_File_read_all(mpi_fh, ldata, nelem, MPI_DOUBLE, &status));
CHECK(MPI_File_close(&mpi_fh));
for(i = 0; i < size; i++) {
#ifdef VERBOSE
MPI_Barrier(MPI_COMM_WORLD);
if(rank == i) {
printf("=== Rank %i === (%i elements) \nPacked: ", rank, nelem);
for(j = 0; j < nelem; j++) {
printf("%4.1f ", pdata[j]);
fflush(stdout);
}
printf("\nRead: ");
for(j = 0; j < nelem; j++) {
printf("%4.1f ", ldata[j]);
fflush(stdout);
}
printf("\n\n");
fflush(stdout);
}
#endif
if(rank == i) {
for (j=0; j< nelem; j++) {
if (pdata[j] != ldata[j]) {
fprintf(stderr, "rank %d at index %d: packbuf %4.1f filebuf %4.1f\n",
rank, j, pdata[j], ldata[j]);
nerrors++;
}
}
}
}
MPI_Allreduce(&nerrors, &total_errors, 1, MPI_INT, MPI_SUM, MPI_COMM_WORLD);
if (rank == 0 && total_errors == 0)
printf(" No Errors\n");
free(ldata);
free(pdata);
MPI_Type_free(&darray);
MPI_Finalize();
exit(total_errors);
}
void ADIOI_NFS_WriteStrided(ADIO_File fd, void *buf, int count,
MPI_Datatype datatype, int file_ptr_type,
ADIO_Offset offset, ADIO_Status *status, int
*error_code)
{
/* offset is in units of etype relative to the filetype. */
ADIOI_Flatlist_node *flat_buf, *flat_file;
int i, j, k, err=-1, bwr_size, fwr_size=0, st_index=0;
int bufsize, num, size, sum, n_etypes_in_filetype, size_in_filetype;
int n_filetypes, etype_in_filetype;
ADIO_Offset abs_off_in_filetype=0;
int filetype_size, etype_size, buftype_size, req_len;
MPI_Aint filetype_extent, buftype_extent;
int buf_count, buftype_is_contig, filetype_is_contig;
ADIO_Offset userbuf_off;
ADIO_Offset off, req_off, disp, end_offset, writebuf_off, start_off;
char *writebuf, *value;
int flag, st_fwr_size, st_n_filetypes, writebuf_len, write_sz;
int new_bwr_size, new_fwr_size, err_flag=0, info_flag, max_bufsize;
#ifndef PRINT_ERR_MSG
static char myname[] = "ADIOI_NFS_WRITESTRIDED";
#endif
ADIOI_Datatype_iscontig(datatype, &buftype_is_contig);
ADIOI_Datatype_iscontig(fd->filetype, &filetype_is_contig);
MPI_Type_size(fd->filetype, &filetype_size);
MPI_Type_extent(fd->filetype, &filetype_extent);
MPI_Type_size(datatype, &buftype_size);
MPI_Type_extent(datatype, &buftype_extent);
etype_size = fd->etype_size;
bufsize = buftype_size * count;
/* get max_bufsize from the info object. */
value = (char *) ADIOI_Malloc((MPI_MAX_INFO_VAL+1)*sizeof(char));
MPI_Info_get(fd->info, "ind_wr_buffer_size", MPI_MAX_INFO_VAL, value,
&info_flag);
max_bufsize = atoi(value);
ADIOI_Free(value);
if (!buftype_is_contig && filetype_is_contig) {
/* noncontiguous in memory, contiguous in file. */
ADIOI_Flatten_datatype(datatype);
flat_buf = ADIOI_Flatlist;
while (flat_buf->type != datatype) flat_buf = flat_buf->next;
off = (file_ptr_type == ADIO_INDIVIDUAL) ? fd->fp_ind :
fd->disp + etype_size * offset;
start_off = off;
end_offset = off + bufsize - 1;
writebuf_off = off;
writebuf = (char *) ADIOI_Malloc(max_bufsize);
writebuf_len = (int) (ADIOI_MIN(max_bufsize,end_offset-writebuf_off+1));
/* if atomicity is true, lock the region to be accessed */
if (fd->atomicity)
ADIOI_WRITE_LOCK(fd, start_off, SEEK_SET, end_offset-start_off+1);
for (j=0; j<count; j++)
for (i=0; i<flat_buf->count; i++) {
userbuf_off = j*buftype_extent + flat_buf->indices[i];
req_off = off;
req_len = flat_buf->blocklens[i];
ADIOI_BUFFERED_WRITE_WITHOUT_READ
off += flat_buf->blocklens[i];
}
/* write the buffer out finally */
lseek(fd->fd_sys, writebuf_off, SEEK_SET);
if (!(fd->atomicity)) ADIOI_WRITE_LOCK(fd, writebuf_off, SEEK_SET, writebuf_len);
err = write(fd->fd_sys, writebuf, writebuf_len);
if (!(fd->atomicity)) ADIOI_UNLOCK(fd, writebuf_off, SEEK_SET, writebuf_len);
if (err == -1) err_flag = 1;
if (fd->atomicity)
ADIOI_UNLOCK(fd, start_off, SEEK_SET, end_offset-start_off+1);
ADIOI_Free(writebuf); /* malloced in the buffered_write macro */
if (file_ptr_type == ADIO_INDIVIDUAL) fd->fp_ind = off;
#ifdef PRINT_ERR_MSG
*error_code = (err_flag) ? MPI_ERR_UNKNOWN : MPI_SUCCESS;
#else
if (err_flag) {
*error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ADIO_ERROR,
myname, "I/O Error", "%s", strerror(errno));
ADIOI_Error(fd, *error_code, myname);
}
else *error_code = MPI_SUCCESS;
#endif
}
else { /* noncontiguous in file */
/* filetype already flattened in ADIO_Open */
flat_file = ADIOI_Flatlist;
while (flat_file->type != fd->filetype) flat_file = flat_file->next;
disp = fd->disp;
if (file_ptr_type == ADIO_INDIVIDUAL) {
offset = fd->fp_ind; /* in bytes */
n_filetypes = -1;
flag = 0;
while (!flag) {
n_filetypes++;
for (i=0; i<flat_file->count; i++) {
if (disp + flat_file->indices[i] +
(ADIO_Offset) n_filetypes*filetype_extent + flat_file->blocklens[i]
>= offset) {
st_index = i;
fwr_size = (int) (disp + flat_file->indices[i] +
(ADIO_Offset) n_filetypes*filetype_extent
+ flat_file->blocklens[i] - offset);
flag = 1;
break;
}
}
}
}
else {
n_etypes_in_filetype = filetype_size/etype_size;
n_filetypes = (int) (offset / n_etypes_in_filetype);
etype_in_filetype = (int) (offset % n_etypes_in_filetype);
size_in_filetype = etype_in_filetype * etype_size;
sum = 0;
for (i=0; i<flat_file->count; i++) {
sum += flat_file->blocklens[i];
if (sum > size_in_filetype) {
st_index = i;
fwr_size = sum - size_in_filetype;
abs_off_in_filetype = flat_file->indices[i] +
size_in_filetype - (sum - flat_file->blocklens[i]);
break;
}
}
/* abs. offset in bytes in the file */
offset = disp + (ADIO_Offset) n_filetypes*filetype_extent + abs_off_in_filetype;
}
start_off = offset;
/* Calculate end_offset, the last byte-offset that will be accessed.
e.g., if start_offset=0 and 100 bytes to be write, end_offset=99*/
st_fwr_size = fwr_size;
st_n_filetypes = n_filetypes;
i = 0;
j = st_index;
off = offset;
fwr_size = ADIOI_MIN(st_fwr_size, bufsize);
while (i < bufsize) {
i += fwr_size;
end_offset = off + fwr_size - 1;
if (j < (flat_file->count - 1)) j++;
else {
j = 0;
n_filetypes++;
}
off = disp + flat_file->indices[j] + (ADIO_Offset) n_filetypes*filetype_extent;
fwr_size = ADIOI_MIN(flat_file->blocklens[j], bufsize-i);
}
/* if atomicity is true, lock the region to be accessed */
if (fd->atomicity)
ADIOI_WRITE_LOCK(fd, start_off, SEEK_SET, end_offset-start_off+1);
/* initial read for the read-modify-write */
writebuf_off = offset;
writebuf = (char *) ADIOI_Malloc(max_bufsize);
writebuf_len = (int)(ADIOI_MIN(max_bufsize,end_offset-writebuf_off+1));
if (!(fd->atomicity)) ADIOI_WRITE_LOCK(fd, writebuf_off, SEEK_SET, writebuf_len);
lseek(fd->fd_sys, writebuf_off, SEEK_SET);
err = read(fd->fd_sys, writebuf, writebuf_len);
if (err == -1) {
FPRINTF(stderr, "ADIOI_NFS_WriteStrided: ROMIO tries to optimize this access by doing a read-modify-write, but is unable to read the file. Please give the file read permission and open it with MPI_MODE_RDWR.\n");
MPI_Abort(MPI_COMM_WORLD, 1);
}
if (buftype_is_contig && !filetype_is_contig) {
/* contiguous in memory, noncontiguous in file. should be the most
common case. */
i = 0;
j = st_index;
off = offset;
n_filetypes = st_n_filetypes;
fwr_size = ADIOI_MIN(st_fwr_size, bufsize);
while (i < bufsize) {
if (fwr_size) {
/* TYPE_UB and TYPE_LB can result in
fwr_size = 0. save system call in such cases */
/* lseek(fd->fd_sys, off, SEEK_SET);
err = write(fd->fd_sys, ((char *) buf) + i, fwr_size);*/
req_off = off;
req_len = fwr_size;
userbuf_off = i;
ADIOI_BUFFERED_WRITE
}
i += fwr_size;
if (off + fwr_size < disp + flat_file->indices[j] +
flat_file->blocklens[j] + (ADIO_Offset) n_filetypes*filetype_extent)
off += fwr_size;
/* did not reach end of contiguous block in filetype.
no more I/O needed. off is incremented by fwr_size. */
else {
if (j < (flat_file->count - 1)) j++;
else {
j = 0;
n_filetypes++;
}
off = disp + flat_file->indices[j] +
(ADIO_Offset) n_filetypes*filetype_extent;
fwr_size = ADIOI_MIN(flat_file->blocklens[j], bufsize-i);
}
}
}
else {
/* blockindexed_vector_test()
*
* Tests behavior with a blockindexed of some vector types;
* this shouldn't be easily convertable into anything else.
*
* Returns the number of errors encountered.
*/
int blockindexed_vector_test(void)
{
#define NELT (18)
int buf[NELT] = { -1, -1, -1,
1, -2, 2,
-3, -3, -3,
-4, -4, -4,
3, -5, 4,
5, -6, 6
};
int expected[NELT] = {
0, 0, 0,
1, 0, 2,
0, 0, 0,
0, 0, 0,
3, 0, 4,
5, 0, 6
};
int err, errs = 0;
int i, count = 3;
int disp[] = { 1, 4, 5 };
MPI_Datatype vectype, newtype;
int size, int_size;
/* create a vector type of 2 ints, skipping one in between */
err = MPI_Type_vector(2, 1, 2, MPI_INT, &vectype);
if (err != MPI_SUCCESS) {
if (verbose) {
fprintf(stderr, "error creating vector type in blockindexed_contig_test()\n");
}
errs++;
}
err = MPI_Type_create_indexed_block(count, 1, disp, vectype, &newtype);
if (err != MPI_SUCCESS) {
if (verbose) {
fprintf(stderr, "error creating blockindexed type in blockindexed_contig_test()\n");
}
errs++;
}
MPI_Type_size(MPI_INT, &int_size);
err = MPI_Type_size(newtype, &size);
if (err != MPI_SUCCESS) {
if (verbose) {
fprintf(stderr, "error obtaining type size in blockindexed_contig_test()\n");
}
errs++;
}
if (size != 6 * int_size) {
if (verbose) {
fprintf(stderr, "error: size != 6 * int_size in blockindexed_contig_test()\n");
}
errs++;
}
MPI_Type_commit(&newtype);
err = pack_and_unpack((char *) buf, 1, newtype, NELT * sizeof(int));
if (err != 0) {
if (verbose) {
fprintf(stderr, "error packing/unpacking in blockindexed_vector_test()\n");
}
errs += err;
}
for (i = 0; i < NELT; i++) {
if (buf[i] != expected[i]) {
errs++;
if (verbose)
fprintf(stderr, "buf[%d] = %d; should be %d\n", i, buf[i], expected[i]);
}
}
MPI_Type_free(&vectype);
MPI_Type_free(&newtype);
return errs;
}
void ADIOI_Get_eof_offset(ADIO_File fd, ADIO_Offset *eof_offset)
{
unsigned filetype_size;
int error_code, filetype_is_contig, etype_size;
ADIO_Offset fsize, disp, sum=0, size_in_file, n_filetypes, rem;
int flag, i;
ADIO_Fcntl_t *fcntl_struct;
MPI_Aint filetype_extent;
ADIOI_Flatlist_node *flat_file;
/* find the eof in bytes */
fcntl_struct = (ADIO_Fcntl_t *) ADIOI_Malloc(sizeof(ADIO_Fcntl_t));
ADIO_Fcntl(fd, ADIO_FCNTL_GET_FSIZE, fcntl_struct, &error_code);
fsize = fcntl_struct->fsize;
ADIOI_Free(fcntl_struct);
/* Find the offset in etype units corresponding to eof.
The eof could lie in a hole in the current view, or in the
middle of an etype. In that case the offset will be the offset
corresponding to the start of the next etype in the current view.*/
ADIOI_Datatype_iscontig(fd->filetype, &filetype_is_contig);
etype_size = fd->etype_size;
if (filetype_is_contig)
*eof_offset = (fsize - fd->disp + etype_size - 1)/etype_size;
/* ceiling division in case fsize is not a multiple of etype_size;*/
else {
/* filetype already flattened in ADIO_Open */
flat_file = ADIOI_Flatlist;
while (flat_file->type != fd->filetype)
flat_file = flat_file->next;
MPI_Type_size(fd->filetype, (int*)&filetype_size);
MPI_Type_extent(fd->filetype, &filetype_extent);
disp = fd->disp;
n_filetypes = -1;
flag = 0;
while (!flag) {
sum = 0;
n_filetypes++;
for (i=0; i<flat_file->count; i++) {
sum += flat_file->blocklens[i];
if (disp + flat_file->indices[i] +
n_filetypes* ADIOI_AINT_CAST_TO_OFFSET filetype_extent +
flat_file->blocklens[i] >= fsize) {
if (disp + flat_file->indices[i] +
n_filetypes * ADIOI_AINT_CAST_TO_OFFSET filetype_extent >= fsize)
sum -= flat_file->blocklens[i];
else {
rem = (disp + flat_file->indices[i] +
n_filetypes* ADIOI_AINT_CAST_TO_OFFSET filetype_extent
+ flat_file->blocklens[i] - fsize);
sum -= rem;
}
flag = 1;
break;
}
}
}
size_in_file = n_filetypes*(ADIO_Offset)filetype_size + sum;
*eof_offset = (size_in_file+etype_size-1)/etype_size; /* ceiling division */
}
}
void IMB_igatherv(struct comm_info* c_info,
int size,
struct iter_schedule* ITERATIONS,
MODES RUN_MODE,
double* time)
/*
MPI-NBC benchmark kernel
Benchmarks MPI_Igatherv
Input variables:
-c_info (type struct comm_info*)
Collection of all base data for MPI;
see [1] for more information
-size (type int)
Basic message size in bytes
-ITERATIONS (type struct iter_schedule *)
Repetition scheduling
-RUN_MODE (type MODES)
(only MPI-2 case: see [1])
Output variables:
-time (type double*)
Timing result per sample
*/
{
int i = 0;
Type_Size s_size,
r_size;
int s_num = 0,
r_num = 0;
MPI_Request request;
MPI_Status status;
double t_pure = 0.,
t_comp = 0.,
t_ovrlp = 0.;
#ifdef CHECK
defect=0.;
#endif
ierr = 0;
/* GET SIZE OF DATA TYPE */
MPI_Type_size(c_info->s_data_type, &s_size);
MPI_Type_size(c_info->r_data_type, &r_size);
if ((s_size!=0) && (r_size!=0)) {
s_num = size / s_size;
r_num = size / r_size;
}
if(c_info->rank != -1) {
/* GET PURE TIME. DISPLACEMENT AND RECEIVE COUNT WILL BE INITIALIZED HERE */
IMB_igatherv_pure(c_info, size, ITERATIONS, RUN_MODE, &t_pure);
/* INITIALIZATION CALL */
IMB_cpu_exploit(t_pure, 1);
for(i=0; i<N_BARR; i++) {
MPI_Barrier(c_info->communicator);
}
t_ovrlp = MPI_Wtime();
for(i=0; i < ITERATIONS->n_sample; i++)
{
ierr = MPI_Igatherv((char*)c_info->s_buffer + i % ITERATIONS->s_cache_iter * ITERATIONS->s_offs,
s_num,
c_info->s_data_type,
(char*)c_info->r_buffer + i % ITERATIONS->r_cache_iter * ITERATIONS->r_offs,
c_info->reccnt,
c_info->rdispl,
c_info->r_data_type,
i % c_info->num_procs, // root = round robin
c_info->communicator,
&request);
MPI_ERRHAND(ierr);
t_comp -= MPI_Wtime();
IMB_cpu_exploit(t_pure, 0);
t_comp += MPI_Wtime();
MPI_Wait(&request, &status);
#ifdef CHECK
if (c_info->rank == i % c_info->num_procs) {
CHK_DIFF("Igatherv", c_info,
(char*)c_info->r_buffer + i % ITERATIONS->r_cache_iter * ITERATIONS->r_offs,
0, 0, ((size_t)c_info->num_procs * (size_t)size),
1, put, 0, ITERATIONS->n_sample, i, -2, &defect);
}
#endif // CHECK
}
t_ovrlp = (MPI_Wtime() - t_ovrlp) / ITERATIONS->n_sample;
t_comp /= ITERATIONS->n_sample;
}
time[0] = t_pure;
time[1] = t_ovrlp;
time[2] = t_comp;
}
/* simple linear MPI_Ialltoall the (simple) algorithm just sends to all nodes */
int ompi_coll_libnbc_ialltoall(void* sendbuf, int sendcount, MPI_Datatype sendtype, void* recvbuf, int recvcount,
MPI_Datatype recvtype, struct ompi_communicator_t *comm, ompi_request_t ** request,
struct mca_coll_base_module_2_1_0_t *module)
{
int rank, p, res, a2asize, sndsize, datasize;
NBC_Schedule *schedule;
MPI_Aint rcvext, sndext;
#ifdef NBC_CACHE_SCHEDULE
NBC_Alltoall_args *args, *found, search;
#endif
char *rbuf, *sbuf, inplace;
enum {NBC_A2A_LINEAR, NBC_A2A_PAIRWISE, NBC_A2A_DISS} alg;
NBC_Handle *handle;
ompi_coll_libnbc_request_t **coll_req = (ompi_coll_libnbc_request_t**) request;
ompi_coll_libnbc_module_t *libnbc_module = (ompi_coll_libnbc_module_t*) module;
NBC_IN_PLACE(sendbuf, recvbuf, inplace);
res = NBC_Init_handle(comm, coll_req, libnbc_module);
if(res != NBC_OK) { printf("Error in NBC_Init_handle(%i)\n", res); return res; }
handle = (*coll_req);
res = MPI_Comm_rank(comm, &rank);
if (MPI_SUCCESS != res) { printf("MPI Error in MPI_Comm_rank() (%i)\n", res); return res; }
res = MPI_Comm_size(comm, &p);
if (MPI_SUCCESS != res) { printf("MPI Error in MPI_Comm_size() (%i)\n", res); return res; }
res = MPI_Type_extent(sendtype, &sndext);
if (MPI_SUCCESS != res) { printf("MPI Error in MPI_Type_extent() (%i)\n", res); return res; }
res = MPI_Type_extent(recvtype, &rcvext);
if (MPI_SUCCESS != res) { printf("MPI Error in MPI_Type_extent() (%i)\n", res); return res; }
res = MPI_Type_size(sendtype, &sndsize);
if (MPI_SUCCESS != res) { printf("MPI Error in MPI_Type_size() (%i)\n", res); return res; }
/* algorithm selection */
a2asize = sndsize*sendcount*p;
/* this number is optimized for TCP on odin.cs.indiana.edu */
if((p <= 8) && ((a2asize < 1<<17) || (sndsize*sendcount < 1<<12))) {
/* just send as fast as we can if we have less than 8 peers, if the
* total communicated size is smaller than 1<<17 *and* if we don't
* have eager messages (msgsize < 1<<13) */
alg = NBC_A2A_LINEAR;
} else if(a2asize < (1<<12)*p) {
/*alg = NBC_A2A_DISS;*/
alg = NBC_A2A_LINEAR;
} else
alg = NBC_A2A_LINEAR; /*NBC_A2A_PAIRWISE;*/
if(!inplace) {
/* copy my data to receive buffer */
rbuf = ((char *)recvbuf) + (rank*recvcount*rcvext);
sbuf = ((char *)sendbuf) + (rank*sendcount*sndext);
res = NBC_Copy(sbuf, sendcount, sendtype, rbuf, recvcount, recvtype, comm);
if (NBC_OK != res) { printf("Error in NBC_Copy() (%i)\n", res); return res; }
}
/* allocate temp buffer if we need one */
if(alg == NBC_A2A_DISS) {
/* only A2A_DISS needs buffers */
if(NBC_Type_intrinsic(sendtype)) {
datasize = sndext*sendcount;
} else {
res = MPI_Pack_size(sendcount, sendtype, comm, &datasize);
if (MPI_SUCCESS != res) { printf("MPI Error in MPI_Pack_size() (%i)\n", res); return res; }
}
/* allocate temporary buffers */
if(p % 2 == 0) {
handle->tmpbuf=malloc(datasize*p*2);
} else {
/* we cannot divide p by two, so alloc more to be safe ... */
handle->tmpbuf=malloc(datasize*(p/2+1)*2*2);
}
/* phase 1 - rotate n data blocks upwards into the tmpbuffer */
#if OPAL_CUDA_SUPPORT
if(NBC_Type_intrinsic(sendtype) && !(opal_cuda_check_bufs((char *)sendbuf, (char *)recvbuf))) {
#else
if(NBC_Type_intrinsic(sendtype)) {
#endif /* OPAL_CUDA_SUPPORT */
/* contiguous - just copy (1st copy) */
memcpy(handle->tmpbuf, (char*)sendbuf+datasize*rank, datasize*(p-rank));
if(rank != 0) memcpy((char*)handle->tmpbuf+datasize*(p-rank), sendbuf, datasize*(rank));
} else {
int pos=0;
/* non-contiguous - pack */
res = MPI_Pack((char*)sendbuf+rank*sendcount*sndext, (p-rank)*sendcount, sendtype, handle->tmpbuf, (p-rank)*datasize, &pos, comm);
if (MPI_SUCCESS != res) { printf("MPI Error in MPI_Pack() (%i)\n", res); return res; }
if(rank != 0) {
pos = 0;
MPI_Pack(sendbuf, rank*sendcount, sendtype, (char*)handle->tmpbuf+datasize*(p-rank), rank*datasize, &pos, comm);
if (MPI_SUCCESS != res) { printf("MPI Error in MPI_Pack() (%i)\n", res); return res; }
}
}
} else {
handle->tmpbuf=NULL;
}
#ifdef NBC_CACHE_SCHEDULE
/* search schedule in communicator specific tree */
search.sendbuf=sendbuf;
search.sendcount=sendcount;
search.sendtype=sendtype;
search.recvbuf=recvbuf;
search.recvcount=recvcount;
search.recvtype=recvtype;
found = (NBC_Alltoall_args*)hb_tree_search((hb_tree*)handle->comminfo->NBC_Dict[NBC_ALLTOALL], &search);
if(found == NULL) {
#endif
/* not found - generate new schedule */
schedule = (NBC_Schedule*)malloc(sizeof(NBC_Schedule));
if (NULL == schedule) { printf("Error in malloc()\n"); return res; }
res = NBC_Sched_create(schedule);
if(res != NBC_OK) { printf("Error in NBC_Sched_create (%i)\n", res); return res; }
switch(alg) {
case NBC_A2A_LINEAR:
res = a2a_sched_linear(rank, p, sndext, rcvext, schedule, sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm);
break;
case NBC_A2A_DISS:
res = a2a_sched_diss(rank, p, sndext, rcvext, schedule, sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm, handle);
break;
case NBC_A2A_PAIRWISE:
res = a2a_sched_pairwise(rank, p, sndext, rcvext, schedule, sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm);
break;
}
if (NBC_OK != res) { return res; }
res = NBC_Sched_commit(schedule);
if (NBC_OK != res) { printf("Error in NBC_Sched_commit() (%i)\n", res); return res; }
#ifdef NBC_CACHE_SCHEDULE
/* save schedule to tree */
args = (NBC_Alltoall_args*)malloc(sizeof(NBC_Alltoall_args));
args->sendbuf=sendbuf;
args->sendcount=sendcount;
args->sendtype=sendtype;
args->recvbuf=recvbuf;
args->recvcount=recvcount;
args->recvtype=recvtype;
args->schedule=schedule;
res = hb_tree_insert ((hb_tree*)handle->comminfo->NBC_Dict[NBC_ALLTOALL], args, args, 0);
if(res != 0) printf("error in dict_insert() (%i)\n", res);
/* increase number of elements for A2A */
if(++handle->comminfo->NBC_Dict_size[NBC_ALLTOALL] > NBC_SCHED_DICT_UPPER) {
NBC_SchedCache_dictwipe((hb_tree*)handle->comminfo->NBC_Dict[NBC_ALLTOALL], &handle->comminfo->NBC_Dict_size[NBC_ALLTOALL]);
/*if(!rank) printf("[%i] removing %i elements - new size: %i \n", rank, SCHED_DICT_UPPER-SCHED_DICT_LOWER, handle->comminfo->NBC_Alltoall_size);*/
}
/*if(!rank) printf("[%i] added new schedule to tree - number %i\n", rank, handle->comminfo->NBC_Dict_size[NBC_ALLTOALL]);*/
} else {
/* found schedule */
schedule=found->schedule;
}
#endif
res = NBC_Start(handle, schedule);
if (NBC_OK != res) { printf("Error in NBC_Start() (%i)\n", res); return res; }
return NBC_OK;
}
int ompi_coll_libnbc_ialltoall_inter (void* sendbuf, int sendcount, MPI_Datatype sendtype, void* recvbuf, int recvcount,
MPI_Datatype recvtype, struct ompi_communicator_t *comm, ompi_request_t ** request,
struct mca_coll_base_module_2_1_0_t *module)
{
int rank, res, i, rsize;
MPI_Aint sndext, rcvext;
NBC_Schedule *schedule;
char *rbuf, *sbuf;
NBC_Handle *handle;
ompi_coll_libnbc_request_t **coll_req = (ompi_coll_libnbc_request_t**) request;
ompi_coll_libnbc_module_t *libnbc_module = (ompi_coll_libnbc_module_t*) module;
res = NBC_Init_handle(comm, coll_req, libnbc_module);
if(res != NBC_OK) { printf("Error in NBC_Init_handle(%i)\n", res); return res; }
handle = (*coll_req);
res = MPI_Comm_remote_size (comm, &rsize);
if (MPI_SUCCESS != res) { printf("MPI Error in MPI_Comm_remote_size() (%i)\n", res); return res; }
res = MPI_Comm_rank(comm, &rank);
if (MPI_SUCCESS != res) { printf("MPI Error in MPI_Comm_rank() (%i)\n", res); return res; }
res = MPI_Type_extent(sendtype, &sndext);
if (MPI_SUCCESS != res) { printf("MPI Error in MPI_Type_extent() (%i)\n", res); return res; }
res = MPI_Type_extent(recvtype, &rcvext);
if (MPI_SUCCESS != res) { printf("MPI Error in MPI_Type_extent() (%i)\n", res); return res; }
schedule = (NBC_Schedule*)malloc(sizeof(NBC_Schedule));
if (NULL == schedule) { printf("Error in malloc() (%i)\n", res); return res; }
handle->tmpbuf=NULL;
res = NBC_Sched_create(schedule);
if(res != NBC_OK) { printf("Error in NBC_Sched_create (%i)\n", res); return res; }
for (i = 0; i < rsize; i++) {
/* post all sends */
sbuf = ((char *) sendbuf) + (i * sendcount * sndext);
res = NBC_Sched_send(sbuf, false, sendcount, sendtype, i, schedule);
if (NBC_OK != res) { printf("Error in NBC_Sched_send() (%i)\n", res); return res; }
/* post all receives */
rbuf = ((char *) recvbuf) + (i * recvcount * rcvext);
res = NBC_Sched_recv(rbuf, false, recvcount, recvtype, i, schedule);
if (NBC_OK != res) { printf("Error in NBC_Sched_recv() (%i)\n", res); return res; }
}
/*NBC_PRINT_SCHED(*schedule);*/
res = NBC_Sched_commit(schedule);
if (NBC_OK != res) { printf("Error in NBC_Sched_commit() (%i)\n", res); return res; }
res = NBC_Start(handle, schedule);
if (NBC_OK != res) { printf("Error in NBC_Start() (%i)\n", res); return res; }
return NBC_OK;
}
void ADIOI_PIOFS_WriteContig(ADIO_File fd, void *buf, int count,
MPI_Datatype datatype, int file_ptr_type,
ADIO_Offset offset, ADIO_Status *status, int *error_code)
{
int err=-1, datatype_size, len;
#ifndef PRINT_ERR_MSG
static char myname[] = "ADIOI_PIOFS_WRITECONTIG";
#endif
MPI_Type_size(datatype, &datatype_size);
len = datatype_size * count;
if (file_ptr_type == ADIO_EXPLICIT_OFFSET) {
if (fd->fp_sys_posn != offset) {
#ifdef PROFILE
MPE_Log_event(11, 0, "start seek");
#endif
llseek(fd->fd_sys, offset, SEEK_SET);
#ifdef PROFILE
MPE_Log_event(12, 0, "end seek");
#endif
}
#ifdef PROFILE
MPE_Log_event(5, 0, "start write");
#endif
err = write(fd->fd_sys, buf, len);
#ifdef PROFILE
MPE_Log_event(6, 0, "end write");
#endif
fd->fp_sys_posn = offset + err;
/* individual file pointer not updated */
}
else { /* write from curr. location of ind. file pointer */
if (fd->fp_sys_posn != fd->fp_ind) {
#ifdef PROFILE
MPE_Log_event(11, 0, "start seek");
#endif
llseek(fd->fd_sys, fd->fp_ind, SEEK_SET);
#ifdef PROFILE
MPE_Log_event(12, 0, "end seek");
#endif
}
#ifdef PROFILE
MPE_Log_event(5, 0, "start write");
#endif
err = write(fd->fd_sys, buf, len);
#ifdef PROFILE
MPE_Log_event(6, 0, "end write");
#endif
fd->fp_ind += err;
fd->fp_sys_posn = fd->fp_ind;
}
#ifdef HAVE_STATUS_SET_BYTES
if (err != -1) MPIR_Status_set_bytes(status, datatype, err);
#endif
if (err == -1) {
#ifdef MPICH2
*error_code = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_IO, "**io",
"**io %s", strerror(errno));
#elif defined(PRINT_ERR_MSG)
*error_code = MPI_ERR_UNKNOWN;
#else
*error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ADIO_ERROR,
myname, "I/O Error", "%s", strerror(errno));
ADIOI_Error(fd, *error_code, myname);
#endif
}
else *error_code = MPI_SUCCESS;
}
int PLA_API_Poll_request ( )
/*--------------------------------------------------------------------------
Purpose : Poll to see if messages have come in
----------------------------------------------------------------------------*/
{
int
msgtype,
m, n, lda,
obj_index, source,
align_row, align_col,
typesize,
local_ldim,
temp;
PLA_Obj
obj_source = NULL;
void
*local_buf;
MPI_Datatype
datatype;
if ( PLA_API_Accept_recv_request_buffer( ) ){
/* New recv put_buffer has come in */
while ( !PLA_API_End_of_recv_request_buffer ( ) ){
/* Process next message */
PLA_API_read_data_from_request_buffer( sizeof( int ),
( char * ) &msgtype );
switch ( msgtype ){
case PLA_API_TYPE_PUT:
PLA_Abort( "API illegal type", __LINE__, __FILE__ );
case PLA_API_TYPE_SYNC:
request_sync_counter ++;
break;
case PLA_API_TYPE_GET:
PLA_API_read_data_from_request_buffer( sizeof( int ), ( char * ) &m );
PLA_API_read_data_from_request_buffer( sizeof( int ), ( char * ) &n );
PLA_API_read_data_from_request_buffer( sizeof( int ),
( char * ) &obj_index );
PLA_API_read_data_from_request_buffer( sizeof( int ),
( char * ) &align_row );
PLA_API_read_data_from_request_buffer( sizeof( int ),
( char * ) &align_col );
PLA_API_read_data_from_request_buffer( sizeof( void * ),
( char * ) &local_buf );
PLA_API_read_data_from_request_buffer( sizeof( int ),
( char * ) &lda );
PLA_API_read_data_from_request_buffer( sizeof( int ),
( char * ) &source );
/* Take view into appropriate object */
PLA_Obj_view( open_objects_list[ obj_index ],
m, n, align_row, align_col, &obj_source );
/* Create room to send current message */
PLA_Obj_datatype( obj_source, &datatype );
MPI_Type_size( datatype, &typesize );
PLA_API_put_buffer_make_room( 5 * sizeof( int ) +
sizeof( void * ) +
m * n * typesize, source );
/* Enter put destination information in the buffer */
temp = PLA_API_TYPE_GET;
PLA_API_add_data_to_put_buffer( sizeof( int ), ( char * ) &temp,
source );
/* PLA_API_add_data_to_put_buffer( sizeof( int ), ( char * ) &datatype,
source ); */
PLA_API_add_data_to_put_buffer( sizeof( int ), ( char * ) &obj_index,
source );
PLA_API_add_data_to_put_buffer( sizeof( int ), ( char * ) &m,
source );
PLA_API_add_data_to_put_buffer( sizeof( int ), ( char * ) &n,
source );
PLA_API_add_data_to_put_buffer( sizeof( void * ),
( char * ) &local_buf, source );
PLA_API_add_data_to_put_buffer( sizeof( int ), ( char * ) &lda,
source );
/* Add the contents of the object to the buffer */
PLA_API_add_contents_from_obj_to_put_buffer( obj_source, source );
break;
default:
PLA_Abort( "API illegal type", __LINE__, __FILE__ );
}
}
}
PLA_Obj_free( &obj_source );
return PLA_SUCCESS;
}
void ADIOI_GEN_ReadStrided_naive(ADIO_File fd, void *buf, int count,
MPI_Datatype buftype, int file_ptr_type,
ADIO_Offset offset, ADIO_Status *status, int
*error_code)
{
/* offset is in units of etype relative to the filetype. */
ADIOI_Flatlist_node *flat_buf, *flat_file;
int brd_size, frd_size=0, b_index;
int bufsize, size, sum, n_etypes_in_filetype, size_in_filetype;
int n_filetypes, etype_in_filetype;
ADIO_Offset abs_off_in_filetype=0;
int filetype_size, etype_size, buftype_size, req_len;
MPI_Aint filetype_extent, buftype_extent;
int buf_count, buftype_is_contig, filetype_is_contig;
ADIO_Offset userbuf_off;
ADIO_Offset off, req_off, disp, end_offset=0, start_off;
ADIO_Status status1;
*error_code = MPI_SUCCESS; /* changed below if error */
ADIOI_Datatype_iscontig(buftype, &buftype_is_contig);
ADIOI_Datatype_iscontig(fd->filetype, &filetype_is_contig);
MPI_Type_size(fd->filetype, &filetype_size);
if ( ! filetype_size ) {
*error_code = MPI_SUCCESS;
return;
}
MPI_Type_extent(fd->filetype, &filetype_extent);
MPI_Type_size(buftype, &buftype_size);
MPI_Type_extent(buftype, &buftype_extent);
etype_size = fd->etype_size;
bufsize = buftype_size * count;
/* contiguous in buftype and filetype is handled elsewhere */
if (!buftype_is_contig && filetype_is_contig) {
int b_count;
/* noncontiguous in memory, contiguous in file. */
ADIOI_Flatten_datatype(buftype);
flat_buf = ADIOI_Flatlist;
while (flat_buf->type != buftype) flat_buf = flat_buf->next;
off = (file_ptr_type == ADIO_INDIVIDUAL) ? fd->fp_ind :
fd->disp + etype_size * offset;
start_off = off;
end_offset = off + bufsize - 1;
/* if atomicity is true, lock (exclusive) the region to be accessed */
if ((fd->atomicity) && (fd->file_system != ADIO_PIOFS) &&
(fd->file_system != ADIO_PVFS))
{
ADIOI_WRITE_LOCK(fd, start_off, SEEK_SET, end_offset-start_off+1);
}
/* for each region in the buffer, grab the data and put it in
* place
*/
for (b_count=0; b_count < count; b_count++) {
for (b_index=0; b_index < flat_buf->count; b_index++) {
userbuf_off = b_count*buftype_extent +
flat_buf->indices[b_index];
req_off = off;
req_len = flat_buf->blocklens[b_index];
ADIO_ReadContig(fd,
(char *) buf + userbuf_off,
req_len,
MPI_BYTE,
ADIO_EXPLICIT_OFFSET,
req_off,
&status1,
error_code);
if (*error_code != MPI_SUCCESS) return;
/* off is (potentially) used to save the final offset later */
off += flat_buf->blocklens[b_index];
}
}
if ((fd->atomicity) && (fd->file_system != ADIO_PIOFS) &&
(fd->file_system != ADIO_PVFS))
{
ADIOI_UNLOCK(fd, start_off, SEEK_SET, end_offset-start_off+1);
}
if (file_ptr_type == ADIO_INDIVIDUAL) fd->fp_ind = off;
}
else { /* noncontiguous in file */
int f_index, st_frd_size, st_index = 0, st_n_filetypes;
int flag;
/* First we're going to calculate a set of values for use in all
* the noncontiguous in file cases:
* start_off - starting byte position of data in file
* end_offset - last byte offset to be acessed in the file
* st_n_filetypes - how far into the file we start in terms of
* whole filetypes
* st_index - index of block in first filetype that we will be
* starting in (?)
* st_frd_size - size of the data in the first filetype block
* that we will read (accounts for being part-way
* into reading this block of the filetype
*
*/
/* filetype already flattened in ADIO_Open */
flat_file = ADIOI_Flatlist;
while (flat_file->type != fd->filetype) flat_file = flat_file->next;
disp = fd->disp;
if (file_ptr_type == ADIO_INDIVIDUAL) {
start_off = fd->fp_ind; /* in bytes */
n_filetypes = -1;
flag = 0;
while (!flag) {
n_filetypes++;
for (f_index=0; f_index < flat_file->count; f_index++) {
if (disp + flat_file->indices[f_index] +
(ADIO_Offset) n_filetypes*filetype_extent +
flat_file->blocklens[f_index] >= start_off)
{
/* this block contains our starting position */
st_index = f_index;
frd_size = (int) (disp + flat_file->indices[f_index] +
(ADIO_Offset) n_filetypes*filetype_extent +
flat_file->blocklens[f_index] - start_off);
flag = 1;
break;
}
}
}
}
else {
n_etypes_in_filetype = filetype_size/etype_size;
n_filetypes = (int) (offset / n_etypes_in_filetype);
etype_in_filetype = (int) (offset % n_etypes_in_filetype);
size_in_filetype = etype_in_filetype * etype_size;
sum = 0;
for (f_index=0; f_index < flat_file->count; f_index++) {
sum += flat_file->blocklens[f_index];
if (sum > size_in_filetype) {
st_index = f_index;
frd_size = sum - size_in_filetype;
abs_off_in_filetype = flat_file->indices[f_index] +
size_in_filetype -
(sum - flat_file->blocklens[f_index]);
break;
}
}
/* abs. offset in bytes in the file */
start_off = disp + (ADIO_Offset) n_filetypes*filetype_extent +
abs_off_in_filetype;
}
st_frd_size = frd_size;
st_n_filetypes = n_filetypes;
/* start_off, st_n_filetypes, st_index, and st_frd_size are
* all calculated at this point
*/
/* Calculate end_offset, the last byte-offset that will be accessed.
* e.g., if start_off=0 and 100 bytes to be read, end_offset=99
*/
userbuf_off = 0;
f_index = st_index;
off = start_off;
frd_size = ADIOI_MIN(st_frd_size, bufsize);
while (userbuf_off < bufsize) {
userbuf_off += frd_size;
end_offset = off + frd_size - 1;
if (f_index < (flat_file->count - 1)) f_index++;
else {
f_index = 0;
n_filetypes++;
}
off = disp + flat_file->indices[f_index] +
(ADIO_Offset) n_filetypes*filetype_extent;
frd_size = ADIOI_MIN(flat_file->blocklens[f_index],
bufsize-(int)userbuf_off);
}
/* End of calculations. At this point the following values have
* been calculated and are ready for use:
* - start_off
* - end_offset
* - st_n_filetypes
* - st_index
* - st_frd_size
*/
/* if atomicity is true, lock (exclusive) the region to be accessed */
if ((fd->atomicity) && (fd->file_system != ADIO_PIOFS) &&
(fd->file_system != ADIO_PVFS))
{
ADIOI_WRITE_LOCK(fd, start_off, SEEK_SET, end_offset-start_off+1);
}
if (buftype_is_contig && !filetype_is_contig) {
/* contiguous in memory, noncontiguous in file. should be the
* most common case.
*/
userbuf_off = 0;
f_index = st_index;
off = start_off;
n_filetypes = st_n_filetypes;
frd_size = ADIOI_MIN(st_frd_size, bufsize);
/* while there is still space in the buffer, read more data */
while (userbuf_off < bufsize) {
if (frd_size) {
/* TYPE_UB and TYPE_LB can result in
frd_size = 0. save system call in such cases */
req_off = off;
req_len = frd_size;
ADIO_ReadContig(fd,
(char *) buf + userbuf_off,
req_len,
MPI_BYTE,
ADIO_EXPLICIT_OFFSET,
req_off,
&status1,
error_code);
if (*error_code != MPI_SUCCESS) return;
}
userbuf_off += frd_size;
if (off + frd_size < disp + flat_file->indices[f_index] +
flat_file->blocklens[f_index] +
(ADIO_Offset) n_filetypes*filetype_extent)
{
/* important that this value be correct, as it is
* used to set the offset in the fd near the end of
* this function.
*/
off += frd_size;
}
/* did not reach end of contiguous block in filetype.
* no more I/O needed. off is incremented by frd_size.
*/
else {
if (f_index < (flat_file->count - 1)) f_index++;
else {
f_index = 0;
n_filetypes++;
}
off = disp + flat_file->indices[f_index] +
(ADIO_Offset) n_filetypes*filetype_extent;
frd_size = ADIOI_MIN(flat_file->blocklens[f_index],
bufsize-(int)userbuf_off);
}
}
}
else {
int i, tmp_bufsize = 0;
/* noncontiguous in memory as well as in file */
ADIOI_Flatten_datatype(buftype);
flat_buf = ADIOI_Flatlist;
while (flat_buf->type != buftype) flat_buf = flat_buf->next;
b_index = buf_count = 0;
i = (int) (flat_buf->indices[0]);
f_index = st_index;
off = start_off;
n_filetypes = st_n_filetypes;
frd_size = st_frd_size;
brd_size = flat_buf->blocklens[0];
/* while we haven't read size * count bytes, keep going */
while (tmp_bufsize < bufsize) {
int new_brd_size = brd_size, new_frd_size = frd_size;
size = ADIOI_MIN(frd_size, brd_size);
if (size) {
req_off = off;
req_len = size;
userbuf_off = i;
ADIO_ReadContig(fd,
(char *) buf + userbuf_off,
req_len,
MPI_BYTE,
ADIO_EXPLICIT_OFFSET,
req_off,
&status1,
error_code);
if (*error_code != MPI_SUCCESS) return;
}
if (size == frd_size) {
/* reached end of contiguous block in file */
if (f_index < (flat_file->count - 1)) f_index++;
else {
f_index = 0;
n_filetypes++;
}
off = disp + flat_file->indices[f_index] +
(ADIO_Offset) n_filetypes*filetype_extent;
new_frd_size = flat_file->blocklens[f_index];
if (size != brd_size) {
i += size;
new_brd_size -= size;
}
}
if (size == brd_size) {
/* reached end of contiguous block in memory */
b_index = (b_index + 1)%flat_buf->count;
buf_count++;
i = (int) (buftype_extent*(buf_count/flat_buf->count) +
flat_buf->indices[b_index]);
new_brd_size = flat_buf->blocklens[b_index];
if (size != frd_size) {
off += size;
new_frd_size -= size;
}
}
tmp_bufsize += size;
frd_size = new_frd_size;
brd_size = new_brd_size;
}
}
/* unlock the file region if we locked it */
if ((fd->atomicity) && (fd->file_system != ADIO_PIOFS) &&
(fd->file_system != ADIO_PVFS))
{
ADIOI_UNLOCK(fd, start_off, SEEK_SET, end_offset-start_off+1);
}
if (file_ptr_type == ADIO_INDIVIDUAL) fd->fp_ind = off;
} /* end of (else noncontiguous in file) */
fd->fp_sys_posn = -1; /* mark it as invalid. */
#ifdef HAVE_STATUS_SET_BYTES
MPIR_Status_set_bytes(status, buftype, bufsize);
/* This is a temporary way of filling in status. The right way is to
* keep track of how much data was actually read and placed in buf
*/
#endif
if (!buftype_is_contig) ADIOI_Delete_flattened(buftype);
}
int PLA_API_add_matrix_from_recv_buffer_to_local(
MPI_Datatype datatype, int m, int n,
void *local_buf, int lda )
{
int i, j, typesize, cur_length;
/* align */
cur_length = recv_put_buffer_done;
cur_length = ( ( cur_length % SIZE_OF_UNIT ) == 0 ?
cur_length : ( cur_length / SIZE_OF_UNIT + 1 ) * SIZE_OF_UNIT );
recv_put_buffer_done = cur_length;
MPI_Type_size( datatype, &typesize );
if ( datatype == MPI_DOUBLE ) {
double *buf_local, *buf_recv, *tempp_local, *tempp_recv;
buf_local = (double *) local_buf;
buf_recv = ( double * ) ( ( char * ) recv_put_buffer + recv_put_buffer_done );
for ( j=0; j<n; j++ ){
tempp_local = buf_local + j*lda;
tempp_recv = buf_recv + j*m;
for ( i=0; i<m; i++ )
*tempp_local++ += *tempp_recv++;
}
recv_put_buffer_done += m * n * typesize;
}
else if ( datatype == MPI_FLOAT ) {
float *buf_local, *buf_recv, *tempp_local, *tempp_recv;
buf_local = (float *) local_buf;
buf_recv = ( float * ) ( ( char * ) recv_put_buffer + recv_put_buffer_done );
for ( j=0; j<n; j++ ){
tempp_local = buf_local + j*lda;
tempp_recv = buf_recv + j*m;
for ( i=0; i<m; i++ )
*tempp_local++ += *tempp_recv++;
}
recv_put_buffer_done += m * n * typesize;
}
else if ( datatype == MPI_DOUBLE_COMPLEX ) {
double *buf_local, *buf_recv, *tempp_local, *tempp_recv;
buf_local = (double *) local_buf;
buf_recv = ( double * ) ( ( char * ) recv_put_buffer + recv_put_buffer_done );
for ( j=0; j<n; j++ ){
tempp_local = buf_local + j*lda*2;
tempp_recv = buf_recv + j*m*2;
for ( i=0; i<2*m; i++ )
*tempp_local++ += *tempp_recv++;
}
recv_put_buffer_done += m * n * typesize;
}
else if ( datatype == MPI_COMPLEX ) {
float *buf_local, *buf_recv, *tempp_local, *tempp_recv;
buf_local = (float *) local_buf;
buf_recv = ( float * ) ( ( char * ) recv_put_buffer + recv_put_buffer_done );
for ( j=0; j<n; j++ ){
tempp_local = buf_local + j*lda*2;
tempp_recv = buf_recv + j*m*2;
for ( i=0; i<2*m; i++ )
*tempp_local++ += *tempp_recv++;
}
recv_put_buffer_done += m * n * typesize;
}
else {
PLA_Abort( "datatype not yet implemented", __LINE__, __FILE__ );
}
}
void IMB_bcast(struct comm_info* c_info, int size, struct iter_schedule* ITERATIONS,
MODES RUN_MODE, double* time)
/*
MPI-1 benchmark kernel
Benchmarks MPI_Bcast
Input variables:
-c_info (type struct comm_info*)
Collection of all base data for MPI;
see [1] for more information
-size (type int)
Basic message size in bytes
-ITERATIONS (type struct iter_schedule *)
Repetition scheduling
-RUN_MODE (type MODES)
(only MPI-2 case: see [1])
Output variables:
-time (type double*)
Timing result per sample
*/
{
double t1, t2;
int i,i1;
Type_Size s_size;
int s_num;
void* bc_buf;
#ifdef CHECK
defect=0.;
#endif
ierr = 0;
/* GET SIZE OF DATA TYPE */
MPI_Type_size(c_info->s_data_type,&s_size);
if (s_size!=0) s_num=size/s_size;
if(c_info->rank!=-1)
{
i1=0;
for(i=0; i<N_BARR; i++) MPI_Barrier(c_info->communicator);
t1 = MPI_Wtime();
for(i=0;i< ITERATIONS->n_sample;i++)
{
/* Provide that s_buffer is not overwritten */
bc_buf = (i1 == c_info->rank) ? c_info->s_buffer : c_info->r_buffer;
ierr= MPI_Bcast((char*)bc_buf+i%ITERATIONS->s_cache_iter*ITERATIONS->s_offs,
s_num,c_info->s_data_type,
i1,c_info->communicator);
MPI_ERRHAND(ierr);
CHK_DIFF("Bcast", c_info,
(char*)bc_buf + i % ITERATIONS->s_cache_iter * ITERATIONS->s_offs,
0, size, size, 1, put, 0, ITERATIONS->n_sample, i, i1, &defect);
/* CHANGE THE ROOT NODE */
i1=(++i1)%c_info->num_procs;
}
t2 = MPI_Wtime();
*time=(t2 - t1)/(ITERATIONS->n_sample);
}
else
{
*time = 0.;
}
}
void IMB_ibcast_pure(struct comm_info* c_info,
int size,
struct iter_schedule* ITERATIONS,
MODES RUN_MODE,
double* time)
/*
MPI-NBC benchmark kernel
Benchmarks MPI_Ibcast
Input variables:
-c_info (type struct comm_info*)
Collection of all base data for MPI;
see [1] for more information
-size (type int)
Basic message size in bytes
-ITERATIONS (type struct iter_schedule *)
Repetition scheduling
-RUN_MODE (type MODES)
(only MPI-2 case: see [1])
Output variables:
-time (type double*)
Timing result per sample
*/
{
int i = 0,
root = 0;
Type_Size s_size;
int s_num = 0;
void* bc_buf = NULL;
MPI_Request request;
MPI_Status status;
double t_pure = 0.;
#ifdef CHECK
defect = 0.;
#endif
ierr = 0;
/* GET SIZE OF DATA TYPE */
MPI_Type_size(c_info->s_data_type, &s_size);
if (s_size != 0) {
s_num = size / s_size;
}
if(c_info->rank != -1) {
root = 0;
for (i = 0; i < N_BARR; i++) {
MPI_Barrier(c_info->communicator);
}
t_pure = MPI_Wtime();
for(i = 0; i < ITERATIONS->n_sample; i++)
{
bc_buf = (root == c_info->rank)
? c_info->s_buffer
: c_info->r_buffer;
ierr = MPI_Ibcast((char*)bc_buf + i % ITERATIONS->s_cache_iter * ITERATIONS->s_offs,
s_num,
c_info->s_data_type,
root,
c_info->communicator,
&request);
MPI_ERRHAND(ierr);
MPI_Wait(&request, &status);
CHK_DIFF("Ibcast_pure", c_info,
(char*)bc_buf + i % ITERATIONS->s_cache_iter * ITERATIONS->s_offs,
0, size, size, 1, put, 0, ITERATIONS->n_sample, i, root, &defect);
root = (++root) % c_info->num_procs;
}
t_pure = (MPI_Wtime() - t_pure) / ITERATIONS->n_sample;
}
time[0] = t_pure;
}
void ADIOI_NFS_WriteStrided(ADIO_File fd, const void *buf, int count,
MPI_Datatype datatype, int file_ptr_type,
ADIO_Offset offset, ADIO_Status *status, int
*error_code)
{
/* offset is in units of etype relative to the filetype. */
ADIOI_Flatlist_node *flat_buf, *flat_file;
int i, j, k, err=-1, bwr_size, fwr_size=0, st_index=0;
int bufsize, num, size, sum, n_etypes_in_filetype, size_in_filetype;
int n_filetypes, etype_in_filetype;
ADIO_Offset abs_off_in_filetype=0;
int filetype_size, etype_size, buftype_size, req_len;
MPI_Aint filetype_extent, buftype_extent;
int buf_count, buftype_is_contig, filetype_is_contig;
ADIO_Offset userbuf_off;
ADIO_Offset off, req_off, disp, end_offset=0, writebuf_off, start_off;
char *writebuf, *value;
int st_fwr_size, st_n_filetypes, writebuf_len, write_sz;
int new_bwr_size, new_fwr_size, err_flag=0, info_flag, max_bufsize;
static char myname[] = "ADIOI_NFS_WRITESTRIDED";
ADIOI_Datatype_iscontig(datatype, &buftype_is_contig);
ADIOI_Datatype_iscontig(fd->filetype, &filetype_is_contig);
MPI_Type_size(fd->filetype, &filetype_size);
if ( ! filetype_size ) {
#ifdef HAVE_STATUS_SET_BYTES
MPIR_Status_set_bytes(status, datatype, 0);
#endif
*error_code = MPI_SUCCESS;
return;
}
MPI_Type_extent(fd->filetype, &filetype_extent);
MPI_Type_size(datatype, &buftype_size);
MPI_Type_extent(datatype, &buftype_extent);
etype_size = fd->etype_size;
bufsize = buftype_size * count;
/* get max_bufsize from the info object. */
value = (char *) ADIOI_Malloc((MPI_MAX_INFO_VAL+1)*sizeof(char));
ADIOI_Info_get(fd->info, "ind_wr_buffer_size", MPI_MAX_INFO_VAL, value,
&info_flag);
max_bufsize = atoi(value);
ADIOI_Free(value);
if (!buftype_is_contig && filetype_is_contig) {
/* noncontiguous in memory, contiguous in file. */
ADIOI_Flatten_datatype(datatype);
flat_buf = ADIOI_Flatlist;
while (flat_buf->type != datatype) flat_buf = flat_buf->next;
off = (file_ptr_type == ADIO_INDIVIDUAL) ? fd->fp_ind :
fd->disp + etype_size * offset;
start_off = off;
end_offset = off + bufsize - 1;
writebuf_off = off;
writebuf = (char *) ADIOI_Malloc(max_bufsize);
writebuf_len = (int) (ADIOI_MIN(max_bufsize,end_offset-writebuf_off+1));
/* if atomicity is true, lock the region to be accessed */
if (fd->atomicity)
ADIOI_WRITE_LOCK(fd, start_off, SEEK_SET, end_offset-start_off+1);
for (j=0; j<count; j++)
for (i=0; i<flat_buf->count; i++) {
userbuf_off = j*buftype_extent + flat_buf->indices[i];
req_off = off;
req_len = flat_buf->blocklens[i];
ADIOI_BUFFERED_WRITE_WITHOUT_READ
off += flat_buf->blocklens[i];
}
/* write the buffer out finally */
#ifdef ADIOI_MPE_LOGGING
MPE_Log_event( ADIOI_MPE_lseek_a, 0, NULL );
#endif
lseek(fd->fd_sys, writebuf_off, SEEK_SET);
#ifdef ADIOI_MPE_LOGGING
MPE_Log_event( ADIOI_MPE_lseek_b, 0, NULL );
#endif
if (!(fd->atomicity)) ADIOI_WRITE_LOCK(fd, writebuf_off, SEEK_SET, writebuf_len);
#ifdef ADIOI_MPE_LOGGING
MPE_Log_event( ADIOI_MPE_write_a, 0, NULL );
#endif
err = write(fd->fd_sys, writebuf, writebuf_len);
#ifdef ADIOI_MPE_LOGGING
MPE_Log_event( ADIOI_MPE_write_b, 0, NULL );
#endif
if (!(fd->atomicity)) ADIOI_UNLOCK(fd, writebuf_off, SEEK_SET, writebuf_len);
if (err == -1) err_flag = 1;
if (fd->atomicity)
ADIOI_UNLOCK(fd, start_off, SEEK_SET, end_offset-start_off+1);
ADIOI_Free(writebuf); /* malloced in the buffered_write macro */
if (file_ptr_type == ADIO_INDIVIDUAL) fd->fp_ind = off;
if (err_flag) {
*error_code = MPIO_Err_create_code(MPI_SUCCESS,
MPIR_ERR_RECOVERABLE, myname,
__LINE__, MPI_ERR_IO, "**io",
"**io %s", strerror(errno));
}
else *error_code = MPI_SUCCESS;
}
else { /* noncontiguous in file */
/* filetype already flattened in ADIO_Open */
flat_file = ADIOI_Flatlist;
while (flat_file->type != fd->filetype) flat_file = flat_file->next;
disp = fd->disp;
if (file_ptr_type == ADIO_INDIVIDUAL) {
/* Wei-keng reworked type processing to be a bit more efficient */
offset = fd->fp_ind - disp;
n_filetypes = (offset - flat_file->indices[0]) / filetype_extent;
offset -= (ADIO_Offset)n_filetypes * filetype_extent;
/* now offset is local to this extent */
/* find the block where offset is located, skip blocklens[i]==0 */
for (i=0; i<flat_file->count; i++) {
ADIO_Offset dist;
if (flat_file->blocklens[i] == 0) continue;
dist = flat_file->indices[i] + flat_file->blocklens[i] - offset;
/* fwr_size is from offset to the end of block i */
if (dist == 0) {
i++;
offset = flat_file->indices[i];
fwr_size = flat_file->blocklens[i];
break;
}
if (dist > 0) {
fwr_size = dist;
break;
}
}
st_index = i; /* starting index in flat_file->indices[] */
offset += disp + (ADIO_Offset)n_filetypes*filetype_extent;
}
else {
n_etypes_in_filetype = filetype_size/etype_size;
n_filetypes = (int) (offset / n_etypes_in_filetype);
etype_in_filetype = (int) (offset % n_etypes_in_filetype);
size_in_filetype = etype_in_filetype * etype_size;
sum = 0;
for (i=0; i<flat_file->count; i++) {
sum += flat_file->blocklens[i];
if (sum > size_in_filetype) {
st_index = i;
fwr_size = sum - size_in_filetype;
abs_off_in_filetype = flat_file->indices[i] +
size_in_filetype - (sum - flat_file->blocklens[i]);
break;
}
}
/* abs. offset in bytes in the file */
offset = disp + (ADIO_Offset) n_filetypes*filetype_extent +
abs_off_in_filetype;
}
start_off = offset;
/* Wei-keng Liao:write request is within single flat_file contig block*/
/* this could happen, for example, with subarray types that are
* actually fairly contiguous */
if (buftype_is_contig && bufsize <= fwr_size) {
ADIO_WriteContig(fd, buf, bufsize, MPI_BYTE, ADIO_EXPLICIT_OFFSET,
offset, status, error_code);
if (file_ptr_type == ADIO_INDIVIDUAL) {
/* update MPI-IO file pointer to point to the first byte
* that can be accessed in the fileview. */
fd->fp_ind = offset + bufsize;
if (bufsize == fwr_size) {
do {
st_index++;
if (st_index == flat_file->count) {
st_index = 0;
n_filetypes++;
}
} while (flat_file->blocklens[st_index] == 0);
fd->fp_ind = disp + flat_file->indices[st_index]
+ (ADIO_Offset)n_filetypes*filetype_extent;
}
}
fd->fp_sys_posn = -1; /* set it to null. */
#ifdef HAVE_STATUS_SET_BYTES
MPIR_Status_set_bytes(status, datatype, bufsize);
#endif
return;
}
/* Calculate end_offset, the last byte-offset that will be accessed.
e.g., if start_offset=0 and 100 bytes to be write, end_offset=99*/
st_fwr_size = fwr_size;
st_n_filetypes = n_filetypes;
i = 0;
j = st_index;
off = offset;
fwr_size = ADIOI_MIN(st_fwr_size, bufsize);
while (i < bufsize) {
i += fwr_size;
end_offset = off + fwr_size - 1;
j = (j+1) % flat_file->count;
n_filetypes += (j == 0) ? 1 : 0;
while (flat_file->blocklens[j]==0) {
j = (j+1) % flat_file->count;
n_filetypes += (j == 0) ? 1 : 0;
}
off = disp + flat_file->indices[j] +
(ADIO_Offset) n_filetypes*filetype_extent;
fwr_size = ADIOI_MIN(flat_file->blocklens[j], bufsize-i);
}
/* if atomicity is true, lock the region to be accessed */
if (fd->atomicity)
ADIOI_WRITE_LOCK(fd, start_off, SEEK_SET, end_offset-start_off+1);
/* initial read for the read-modify-write */
writebuf_off = offset;
writebuf = (char *) ADIOI_Malloc(max_bufsize);
writebuf_len = (int)(ADIOI_MIN(max_bufsize,end_offset-writebuf_off+1));
if (!(fd->atomicity)) ADIOI_WRITE_LOCK(fd, writebuf_off, SEEK_SET, writebuf_len);
#ifdef ADIOI_MPE_LOGGING
MPE_Log_event( ADIOI_MPE_lseek_a, 0, NULL );
#endif
lseek(fd->fd_sys, writebuf_off, SEEK_SET);
#ifdef ADIOI_MPE_LOGGING
MPE_Log_event( ADIOI_MPE_lseek_b, 0, NULL );
#endif
#ifdef ADIOI_MPE_LOGGING
MPE_Log_event( ADIOI_MPE_read_a, 0, NULL );
#endif
err = read(fd->fd_sys, writebuf, writebuf_len);
#ifdef ADIOI_MPE_LOGGING
MPE_Log_event( ADIOI_MPE_read_b, 0, NULL );
#endif
if (err == -1) {
*error_code = MPIO_Err_create_code(MPI_SUCCESS,
MPIR_ERR_RECOVERABLE,
myname, __LINE__,
MPI_ERR_IO,
"ADIOI_NFS_WriteStrided: ROMIO tries to optimize this access by doing a read-modify-write, but is unable to read the file. Please give the file read permission and open it with MPI_MODE_RDWR.", 0);
return;
}
if (buftype_is_contig && !filetype_is_contig) {
/* contiguous in memory, noncontiguous in file. should be the most
common case. */
i = 0;
j = st_index;
off = offset;
n_filetypes = st_n_filetypes;
fwr_size = ADIOI_MIN(st_fwr_size, bufsize);
while (i < bufsize) {
if (fwr_size) {
/* TYPE_UB and TYPE_LB can result in
fwr_size = 0. save system call in such cases */
/* lseek(fd->fd_sys, off, SEEK_SET);
err = write(fd->fd_sys, ((char *) buf) + i, fwr_size);*/
req_off = off;
req_len = fwr_size;
userbuf_off = i;
ADIOI_BUFFERED_WRITE
}
i += fwr_size;
if (off + fwr_size < disp + flat_file->indices[j] +
flat_file->blocklens[j] + (ADIO_Offset) n_filetypes*filetype_extent)
off += fwr_size;
/* did not reach end of contiguous block in filetype.
no more I/O needed. off is incremented by fwr_size. */
else {
j = (j+1) % flat_file->count;
n_filetypes += (j == 0) ? 1 : 0;
while (flat_file->blocklens[j]==0) {
j = (j+1) % flat_file->count;
n_filetypes += (j == 0) ? 1 : 0;
}
off = disp + flat_file->indices[j] +
(ADIO_Offset) n_filetypes*filetype_extent;
fwr_size = ADIOI_MIN(flat_file->blocklens[j], bufsize-i);
}
}
}
else {
void ADIOI_PIOFS_WriteStrided(ADIO_File fd, void *buf, int count,
MPI_Datatype datatype, int file_ptr_type,
ADIO_Offset offset, ADIO_Status *status, int
*error_code)
{
/* Since PIOFS does not support file locking, can't do buffered writes
as on Unix */
/* offset is in units of etype relative to the filetype. */
ADIOI_Flatlist_node *flat_buf, *flat_file;
struct iovec *iov;
int i, j, k, err=-1, bwr_size, fwr_size=0, st_index=0;
int bufsize, num, size, sum, n_etypes_in_filetype, size_in_filetype;
int n_filetypes, etype_in_filetype;
ADIO_Offset abs_off_in_filetype=0;
int filetype_size, etype_size, buftype_size;
MPI_Aint filetype_extent, buftype_extent, indx;
int buf_count, buftype_is_contig, filetype_is_contig;
ADIO_Offset off, disp;
int flag, new_bwr_size, new_fwr_size, err_flag=0;
#ifndef PRINT_ERR_MSG
static char myname[] = "ADIOI_PIOFS_WRITESTRIDED";
#endif
if (fd->atomicity) {
FPRINTF(stderr, "ROMIO cannot guarantee atomicity of noncontiguous accesses in atomic mode, as PIOFS doesn't support file locking. Use nonatomic mode and its associated semantics.\n");
MPI_Abort(MPI_COMM_WORLD, 1);
}
ADIOI_Datatype_iscontig(datatype, &buftype_is_contig);
ADIOI_Datatype_iscontig(fd->filetype, &filetype_is_contig);
MPI_Type_size(fd->filetype, &filetype_size);
if ( ! filetype_size ) {
*error_code = MPI_SUCCESS;
return;
}
MPI_Type_extent(fd->filetype, &filetype_extent);
MPI_Type_size(datatype, &buftype_size);
MPI_Type_extent(datatype, &buftype_extent);
etype_size = fd->etype_size;
bufsize = buftype_size * count;
if (!buftype_is_contig && filetype_is_contig) {
/* noncontiguous in memory, contiguous in file. use writev */
ADIOI_Flatten_datatype(datatype);
flat_buf = ADIOI_Flatlist;
while (flat_buf->type != datatype) flat_buf = flat_buf->next;
/* There is a limit of 16 on the number of iovecs for readv/writev! */
iov = (struct iovec *) ADIOI_Malloc(16*sizeof(struct iovec));
if (file_ptr_type == ADIO_EXPLICIT_OFFSET) {
off = fd->disp + etype_size * offset;
llseek(fd->fd_sys, off, SEEK_SET);
}
else off = llseek(fd->fd_sys, fd->fp_ind, SEEK_SET);
k = 0;
for (j=0; j<count; j++)
for (i=0; i<flat_buf->count; i++) {
iov[k].iov_base = ((char *) buf) + j*buftype_extent +
flat_buf->indices[i];
iov[k].iov_len = flat_buf->blocklens[i];
/*FPRINTF(stderr, "%d %d\n", iov[k].iov_base, iov[k].iov_len);*/
off += flat_buf->blocklens[i];
k = (k+1)%16;
if (!k) {
err = writev(fd->fd_sys, iov, 16);
if (err == -1) err_flag = 1;
}
}
if (k) {
err = writev(fd->fd_sys, iov, k);
if (err == -1) err_flag = 1;
}
if (file_ptr_type == ADIO_INDIVIDUAL) fd->fp_ind = off;
ADIOI_Free(iov);
if (err_flag) {
#ifdef MPICH2
*error_code = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_IO, "**io",
"**io %s", strerror(errno));
#elif defined(PRINT_ERR_MSG)
*error_code = MPI_ERR_UNKNOWN;
#else /* MPICH-1 */
*error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ADIO_ERROR,
myname, "I/O Error", "%s", strerror(errno));
ADIOI_Error(fd, *error_code, myname);
#endif
}
else *error_code = MPI_SUCCESS;
} /* if (!buftype_is_contig && filetype_is_contig) ... */
else { /* noncontiguous in file */
/* split up into several contiguous writes */
/* find starting location in the file */
/* filetype already flattened in ADIO_Open */
flat_file = ADIOI_Flatlist;
while (flat_file->type != fd->filetype) flat_file = flat_file->next;
disp = fd->disp;
if (file_ptr_type == ADIO_INDIVIDUAL) {
offset = fd->fp_ind; /* in bytes */
n_filetypes = -1;
flag = 0;
while (!flag) {
n_filetypes++;
for (i=0; i<flat_file->count; i++) {
if (disp + flat_file->indices[i] +
(ADIO_Offset) n_filetypes*filetype_extent + flat_file->blocklens[i]
>= offset) {
st_index = i;
fwr_size = disp + flat_file->indices[i] +
(ADIO_Offset) n_filetypes*filetype_extent
+ flat_file->blocklens[i] - offset;
flag = 1;
break;
}
}
}
}
else {
n_etypes_in_filetype = filetype_size/etype_size;
n_filetypes = (int) (offset / n_etypes_in_filetype);
etype_in_filetype = (int) (offset % n_etypes_in_filetype);
size_in_filetype = etype_in_filetype * etype_size;
sum = 0;
for (i=0; i<flat_file->count; i++) {
sum += flat_file->blocklens[i];
if (sum > size_in_filetype) {
st_index = i;
fwr_size = sum - size_in_filetype;
abs_off_in_filetype = flat_file->indices[i] +
size_in_filetype - (sum - flat_file->blocklens[i]);
break;
}
}
/* abs. offset in bytes in the file */
offset = disp + (ADIO_Offset) n_filetypes*filetype_extent + abs_off_in_filetype;
}
if (buftype_is_contig && !filetype_is_contig) {
/* contiguous in memory, noncontiguous in file. should be the most
common case. */
i = 0;
j = st_index;
off = offset;
fwr_size = ADIOI_MIN(fwr_size, bufsize);
while (i < bufsize) {
if (fwr_size) {
/* TYPE_UB and TYPE_LB can result in
fwr_size = 0. save system call in such cases */
#ifdef PROFILE
MPE_Log_event(11, 0, "start seek");
#endif
llseek(fd->fd_sys, off, SEEK_SET);
#ifdef PROFILE
MPE_Log_event(12, 0, "end seek");
MPE_Log_event(5, 0, "start write");
#endif
err = write(fd->fd_sys, ((char *) buf) + i, fwr_size);
#ifdef PROFILE
MPE_Log_event(6, 0, "end write");
#endif
if (err == -1) err_flag = 1;
}
i += fwr_size;
if (off + fwr_size < disp + flat_file->indices[j] +
flat_file->blocklens[j] + (ADIO_Offset) n_filetypes*filetype_extent)
off += fwr_size;
/* did not reach end of contiguous block in filetype.
no more I/O needed. off is incremented by fwr_size. */
else {
if (j < (flat_file->count - 1)) j++;
else {
j = 0;
n_filetypes++;
}
off = disp + flat_file->indices[j] +
(ADIO_Offset) n_filetypes*filetype_extent;
fwr_size = ADIOI_MIN(flat_file->blocklens[j], bufsize-i);
}
}
}
else {
/* noncontiguous in memory as well as in file */
ADIOI_Flatten_datatype(datatype);
flat_buf = ADIOI_Flatlist;
while (flat_buf->type != datatype) flat_buf = flat_buf->next;
k = num = buf_count = 0;
indx = flat_buf->indices[0];
j = st_index;
off = offset;
bwr_size = flat_buf->blocklens[0];
while (num < bufsize) {
size = ADIOI_MIN(fwr_size, bwr_size);
if (size) {
#ifdef PROFILE
MPE_Log_event(11, 0, "start seek");
#endif
llseek(fd->fd_sys, off, SEEK_SET);
#ifdef PROFILE
MPE_Log_event(12, 0, "end seek");
MPE_Log_event(5, 0, "start write");
#endif
err = write(fd->fd_sys, ((char *) buf) + indx, size);
#ifdef PROFILE
MPE_Log_event(6, 0, "end write");
#endif
if (err == -1) err_flag = 1;
}
new_fwr_size = fwr_size;
new_bwr_size = bwr_size;
if (size == fwr_size) {
/* reached end of contiguous block in file */
if (j < (flat_file->count - 1)) j++;
else {
j = 0;
n_filetypes++;
}
off = disp + flat_file->indices[j] +
(ADIO_Offset) n_filetypes*filetype_extent;
new_fwr_size = flat_file->blocklens[j];
if (size != bwr_size) {
indx += size;
new_bwr_size -= size;
}
}
if (size == bwr_size) {
/* reached end of contiguous block in memory */
k = (k + 1)%flat_buf->count;
buf_count++;
indx = buftype_extent*(buf_count/flat_buf->count) +
flat_buf->indices[k];
new_bwr_size = flat_buf->blocklens[k];
if (size != fwr_size) {
off += size;
new_fwr_size -= size;
}
}
num += size;
fwr_size = new_fwr_size;
bwr_size = new_bwr_size;
}
}
if (file_ptr_type == ADIO_INDIVIDUAL) fd->fp_ind = off;
if (err_flag) {
#ifdef MPICH2
*error_code = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_IO, "**io",
"**io %s", strerror(errno));
#elif defined(PRINT_ERR_MSG)
*error_code = MPI_ERR_UNKNOWN;
#else /* MPICH-1 */
*error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ADIO_ERROR,
myname, "I/O Error", "%s", strerror(errno));
ADIOI_Error(fd, *error_code, myname);
#endif
}
else *error_code = MPI_SUCCESS;
}
fd->fp_sys_posn = -1; /* set it to null. */
#ifdef HAVE_STATUS_SET_BYTES
MPIR_Status_set_bytes(status, datatype, bufsize);
/* This is a temporary way of filling in status. The right way is to
keep track of how much data was actually written by ADIOI_BUFFERED_WRITE. */
#endif
if (!buftype_is_contig) ADIOI_Delete_flattened(datatype);
}
void IMB_bidir_get(struct comm_info* c_info, int size, struct iter_schedule* ITERATIONS,
MODES RUN_MODE, double* time)
/*
MPI-2 benchmark kernel
Driver for aggregate / non agg. bidirectional MPI_Get benchmarks
Input variables:
-c_info (type struct comm_info*)
Collection of all base data for MPI;
see [1] for more information
-size (type int)
Basic message size in bytes
-ITERATIONS (type struct iter_schedule *)
Repetition scheduling
-RUN_MODE (type MODES)
Mode (aggregate/non aggregate; blocking/nonblocking);
see "IMB_benchmark.h" for definition
Output variables:
-time (type double*)
Timing result per sample
*/
{
double t1, t2;
Type_Size s_size,r_size;
int s_num, r_num;
int dest, source,sender;
MPI_Status stat;
ierr = 0;
/* GET SIZE OF DATA TYPE */
MPI_Type_size(c_info->s_data_type,&s_size);
MPI_Type_size(c_info->r_data_type,&r_size);
if ((s_size!=0) && (r_size!=0))
{
s_num=size/s_size;
r_num=size/r_size;
}
if (c_info->rank == c_info->pair0)
{
dest = c_info->pair1;
}
else if (c_info->rank == c_info->pair1)
{
dest =c_info->pair0 ;
}
else
{
dest = -1;
}
sender=0;
if( !RUN_MODE->AGGREGATE )
IMB_ones_get( c_info,
s_num, dest,
r_num, sender,
size, ITERATIONS,
time);
if( RUN_MODE->AGGREGATE )
IMB_ones_mget( c_info,
s_num, dest,
r_num, sender,
size, ITERATIONS,
time);
}
/* blockindexed_test()
*
* Tests behavior with a zero-count blockindexed.
*
* Returns the number of errors encountered.
*/
int blockindexed_test(void)
{
int err, errs = 0;
int count = 0;
MPI_Datatype newtype;
int size;
MPI_Aint extent;
err = MPI_Type_create_indexed_block(count,
0,
(int *) 0,
MPI_INT,
&newtype);
if (err != MPI_SUCCESS) {
if (verbose) {
fprintf(stderr,
"error creating struct type in blockindexed_test()\n");
}
errs++;
}
err = MPI_Type_size(newtype, &size);
if (err != MPI_SUCCESS) {
if (verbose) {
fprintf(stderr,
"error obtaining type size in blockindexed_test()\n");
}
errs++;
}
if (size != 0) {
if (verbose) {
fprintf(stderr,
"error: size != 0 in blockindexed_test()\n");
}
errs++;
}
err = MPI_Type_extent(newtype, &extent);
if (err != MPI_SUCCESS) {
if (verbose) {
fprintf(stderr,
"error obtaining type extent in blockindexed_test()\n");
}
errs++;
}
if (extent != 0) {
if (verbose) {
fprintf(stderr,
"error: extent != 0 in blockindexed_test()\n");
}
errs++;
}
MPI_Type_free( &newtype );
return errs;
}
void mpi_type_size ( int *datatype, int *size, int *ierr )
{
*ierr = MPI_Type_size ( *datatype, size );
return;
}
void ADIOI_GEN_WriteStridedColl(ADIO_File fd, void *buf, int count,
MPI_Datatype datatype, int file_ptr_type,
ADIO_Offset offset, ADIO_Status *status, int
*error_code)
{
/* Uses a generalized version of the extended two-phase method described
in "An Extended Two-Phase Method for Accessing Sections of
Out-of-Core Arrays", Rajeev Thakur and Alok Choudhary,
Scientific Programming, (5)4:301--317, Winter 1996.
http://www.mcs.anl.gov/home/thakur/ext2ph.ps */
ADIOI_Access *my_req;
/* array of nprocs access structures, one for each other process in
whose file domain this process's request lies */
ADIOI_Access *others_req;
/* array of nprocs access structures, one for each other process
whose request lies in this process's file domain. */
int i, filetype_is_contig, nprocs, nprocs_for_coll, myrank;
int contig_access_count=0, interleave_count = 0, buftype_is_contig;
int *count_my_req_per_proc, count_my_req_procs, count_others_req_procs;
ADIO_Offset orig_fp, start_offset, end_offset, fd_size, min_st_offset, off;
ADIO_Offset *offset_list = NULL, *st_offsets = NULL, *fd_start = NULL,
*fd_end = NULL, *end_offsets = NULL;
int *buf_idx = NULL;
ADIO_Offset *len_list = NULL;
int old_error, tmp_error;
if (fd->hints->cb_pfr != ADIOI_HINT_DISABLE) {
ADIOI_IOStridedColl (fd, buf, count, ADIOI_WRITE, datatype,
file_ptr_type, offset, status, error_code);
return;
}
MPI_Comm_size(fd->comm, &nprocs);
MPI_Comm_rank(fd->comm, &myrank);
/* the number of processes that actually perform I/O, nprocs_for_coll,
* is stored in the hints off the ADIO_File structure
*/
nprocs_for_coll = fd->hints->cb_nodes;
orig_fp = fd->fp_ind;
/* only check for interleaving if cb_write isn't disabled */
if (fd->hints->cb_write != ADIOI_HINT_DISABLE) {
/* For this process's request, calculate the list of offsets and
lengths in the file and determine the start and end offsets. */
/* Note: end_offset points to the last byte-offset that will be accessed.
e.g., if start_offset=0 and 100 bytes to be read, end_offset=99*/
ADIOI_Calc_my_off_len(fd, count, datatype, file_ptr_type, offset,
&offset_list, &len_list, &start_offset,
&end_offset, &contig_access_count);
/* each process communicates its start and end offsets to other
processes. The result is an array each of start and end offsets stored
in order of process rank. */
st_offsets = (ADIO_Offset *) ADIOI_Malloc(nprocs*sizeof(ADIO_Offset));
end_offsets = (ADIO_Offset *) ADIOI_Malloc(nprocs*sizeof(ADIO_Offset));
MPI_Allgather(&start_offset, 1, ADIO_OFFSET, st_offsets, 1,
ADIO_OFFSET, fd->comm);
MPI_Allgather(&end_offset, 1, ADIO_OFFSET, end_offsets, 1,
ADIO_OFFSET, fd->comm);
/* are the accesses of different processes interleaved? */
for (i=1; i<nprocs; i++)
if ((st_offsets[i] < end_offsets[i-1]) &&
(st_offsets[i] <= end_offsets[i]))
interleave_count++;
/* This is a rudimentary check for interleaving, but should suffice
for the moment. */
}
ADIOI_Datatype_iscontig(datatype, &buftype_is_contig);
if (fd->hints->cb_write == ADIOI_HINT_DISABLE ||
(!interleave_count && (fd->hints->cb_write == ADIOI_HINT_AUTO)))
{
/* use independent accesses */
if (fd->hints->cb_write != ADIOI_HINT_DISABLE) {
ADIOI_Free(offset_list);
ADIOI_Free(len_list);
ADIOI_Free(st_offsets);
ADIOI_Free(end_offsets);
}
fd->fp_ind = orig_fp;
ADIOI_Datatype_iscontig(fd->filetype, &filetype_is_contig);
if (buftype_is_contig && filetype_is_contig) {
if (file_ptr_type == ADIO_EXPLICIT_OFFSET) {
off = fd->disp + (ADIO_Offset)(fd->etype_size) * offset;
ADIO_WriteContig(fd, buf, count, datatype,
ADIO_EXPLICIT_OFFSET,
off, status, error_code);
}
else ADIO_WriteContig(fd, buf, count, datatype, ADIO_INDIVIDUAL,
0, status, error_code);
}
else ADIO_WriteStrided(fd, buf, count, datatype, file_ptr_type,
offset, status, error_code);
return;
}
/* Divide the I/O workload among "nprocs_for_coll" processes. This is
done by (logically) dividing the file into file domains (FDs); each
process may directly access only its own file domain. */
ADIOI_Calc_file_domains(st_offsets, end_offsets, nprocs,
nprocs_for_coll, &min_st_offset,
&fd_start, &fd_end,
fd->hints->min_fdomain_size, &fd_size,
fd->hints->striping_unit);
/* calculate what portions of the access requests of this process are
located in what file domains */
ADIOI_Calc_my_req(fd, offset_list, len_list, contig_access_count,
min_st_offset, fd_start, fd_end, fd_size,
nprocs, &count_my_req_procs,
&count_my_req_per_proc, &my_req,
&buf_idx);
/* based on everyone's my_req, calculate what requests of other
processes lie in this process's file domain.
count_others_req_procs = number of processes whose requests lie in
this process's file domain (including this process itself)
count_others_req_per_proc[i] indicates how many separate contiguous
requests of proc. i lie in this process's file domain. */
ADIOI_Calc_others_req(fd, count_my_req_procs,
count_my_req_per_proc, my_req,
nprocs, myrank,
&count_others_req_procs, &others_req);
ADIOI_Free(count_my_req_per_proc);
for (i=0; i < nprocs; i++) {
if (my_req[i].count) {
ADIOI_Free(my_req[i].offsets);
ADIOI_Free(my_req[i].lens);
}
}
ADIOI_Free(my_req);
/* exchange data and write in sizes of no more than coll_bufsize. */
ADIOI_Exch_and_write(fd, buf, datatype, nprocs, myrank,
others_req, offset_list,
len_list, contig_access_count, min_st_offset,
fd_size, fd_start, fd_end, buf_idx, error_code);
/* If this collective write is followed by an independent write,
* it's possible to have those subsequent writes on other processes
* race ahead and sneak in before the read-modify-write completes.
* We carry out a collective communication at the end here so no one
* can start independent i/o before collective I/O completes.
*
* need to do some gymnastics with the error codes so that if something
* went wrong, all processes report error, but if a process has a more
* specific error code, we can still have that process report the
* additional information */
old_error = *error_code;
if (*error_code != MPI_SUCCESS) *error_code = MPI_ERR_IO;
/* optimization: if only one process performing i/o, we can perform
* a less-expensive Bcast */
#ifdef ADIOI_MPE_LOGGING
MPE_Log_event( ADIOI_MPE_postwrite_a, 0, NULL );
#endif
if (fd->hints->cb_nodes == 1)
MPI_Bcast(error_code, 1, MPI_INT,
fd->hints->ranklist[0], fd->comm);
else {
tmp_error = *error_code;
MPI_Allreduce(&tmp_error, error_code, 1, MPI_INT,
MPI_MAX, fd->comm);
}
#ifdef ADIOI_MPE_LOGGING
MPE_Log_event( ADIOI_MPE_postwrite_b, 0, NULL );
#endif
#ifdef AGGREGATION_PROFILE
MPE_Log_event (5012, 0, NULL);
#endif
if ( (old_error != MPI_SUCCESS) && (old_error != MPI_ERR_IO) )
*error_code = old_error;
if (!buftype_is_contig) ADIOI_Delete_flattened(datatype);
/* free all memory allocated for collective I/O */
for (i=0; i<nprocs; i++) {
if (others_req[i].count) {
ADIOI_Free(others_req[i].offsets);
ADIOI_Free(others_req[i].lens);
ADIOI_Free(others_req[i].mem_ptrs);
}
}
ADIOI_Free(others_req);
ADIOI_Free(buf_idx);
ADIOI_Free(offset_list);
ADIOI_Free(len_list);
ADIOI_Free(st_offsets);
ADIOI_Free(end_offsets);
ADIOI_Free(fd_start);
ADIOI_Free(fd_end);
#ifdef HAVE_STATUS_SET_BYTES
if (status) {
int bufsize, size;
/* Don't set status if it isn't needed */
MPI_Type_size(datatype, &size);
bufsize = size * count;
MPIR_Status_set_bytes(status, datatype, bufsize);
}
/* This is a temporary way of filling in status. The right way is to
keep track of how much data was actually written during collective I/O. */
#endif
fd->fp_sys_posn = -1; /* set it to null. */
#ifdef AGGREGATION_PROFILE
MPE_Log_event (5013, 0, NULL);
#endif
}
void IMB_gatherv(struct comm_info* c_info, int size, struct iter_schedule* ITERATIONS,
MODES RUN_MODE, double* time)
/*
MPI-1 benchmark kernel
Benchmarks MPI_Gatherv
Input variables:
-c_info (type struct comm_info*)
Collection of all base data for MPI;
see [1] for more information
-size (type int)
Basic message size in bytes
-ITERATIONS (type struct iter_schedule *)
Repetition scheduling
-RUN_MODE (type MODES)
(only MPI-2 case: see [1])
Output variables:
-time (type double*)
Timing result per sample
*/
{
double t1, t2;
int i;
Type_Size s_size,r_size;
int s_num, r_num;
#ifdef CHECK
defect=0.;
#endif
ierr = 0;
/* GET SIZE OF DATA TYPE */
MPI_Type_size(c_info->s_data_type,&s_size);
MPI_Type_size(c_info->r_data_type,&r_size);
if ((s_size!=0) && (r_size!=0))
{
s_num=size/s_size;
r_num=size/r_size;
}
/* INITIALIZATION OF DISPLACEMENT and RECEIVE COUNTS */
for (i=0;i<c_info->num_procs ;i++)
{
c_info->rdispl[i] = r_num*i;
c_info->reccnt[i] = r_num;
}
if(c_info->rank!=-1)
{
for(i=0; i<N_BARR; i++) MPI_Barrier(c_info->communicator);
t1 = MPI_Wtime();
for(i=0;i<ITERATIONS->n_sample;i++)
{
ierr = MPI_Gatherv((char*)c_info->s_buffer+i%ITERATIONS->s_cache_iter*ITERATIONS->s_offs,
s_num,c_info->s_data_type,
(char*)c_info->r_buffer+i%ITERATIONS->r_cache_iter*ITERATIONS->r_offs,
c_info->reccnt,c_info->rdispl,
// root = round robin
c_info->r_data_type, i%c_info->num_procs,
c_info->communicator);
MPI_ERRHAND(ierr);
#ifdef CHECK
if( c_info->rank == i%c_info->num_procs )
{
CHK_DIFF("Gatherv",c_info,
(char*)c_info->r_buffer+i%ITERATIONS->r_cache_iter*ITERATIONS->r_offs, 0,
0, (size_t) c_info->num_procs * (size_t) size, 1,
put, 0, ITERATIONS->n_sample, i,
-2, &defect);
}
#endif
}
t2 = MPI_Wtime();
*time=(t2 - t1)/ITERATIONS->n_sample;
}
else
{
*time = 0.;
}
}
void IMB_iallreduce(struct comm_info* c_info,
int size,
struct iter_schedule* ITERATIONS,
MODES RUN_MODE,
double* time)
{
int i = 0;
Type_Size s_size;
int s_num = 0;
MPI_Request request;
MPI_Status status;
double t_pure = 0.,
t_comp = 0.,
t_ovrlp = 0.;
#ifdef CHECK
defect=0.;
#endif
ierr = 0;
/* GET SIZE OF DATA TYPE */
MPI_Type_size(c_info->red_data_type, &s_size);
if (s_size != 0) {
s_num = size / s_size;
}
if(c_info->rank != -1) {
IMB_iallreduce_pure(c_info, size, ITERATIONS, RUN_MODE, &t_pure);
/* INITIALIZATION CALL */
IMB_cpu_exploit(t_pure, 1);
IMB_do_n_barriers (c_info->communicator, N_BARR);
for(i = 0; i < ITERATIONS->n_sample; i++)
{
t_ovrlp -= MPI_Wtime();
ierr = MPI_Iallreduce((char*)c_info->s_buffer + i % ITERATIONS->s_cache_iter * ITERATIONS->s_offs,
(char*)c_info->r_buffer + i % ITERATIONS->r_cache_iter * ITERATIONS->r_offs,
s_num,
c_info->red_data_type,
c_info->op_type,
c_info->communicator,
&request);
MPI_ERRHAND(ierr);
t_comp -= MPI_Wtime();
IMB_cpu_exploit(t_pure, 0);
t_comp += MPI_Wtime();
MPI_Wait(&request, &status);
t_ovrlp += MPI_Wtime();
CHK_DIFF("Iallreduce", c_info,
(char*)c_info->r_buffer + i % ITERATIONS->r_cache_iter * ITERATIONS->r_offs,
0, size, size, asize, put, 0, ITERATIONS->n_sample, i, -1, &defect);
IMB_do_n_barriers (c_info->communicator, c_info->sync);
}
t_ovrlp /= ITERATIONS->n_sample;
t_comp /= ITERATIONS->n_sample;
}
time[0] = t_pure;
time[1] = t_ovrlp;
time[2] = t_comp;
}
ADIO_Offset ADIOI_GEN_SeekIndividual(ADIO_File fd, ADIO_Offset offset,
int whence, int *error_code)
{
/* implemented for whence=SEEK_SET only. SEEK_CUR and SEEK_END must
be converted to the equivalent with SEEK_SET before calling this
routine. */
/* offset is in units of etype relative to the filetype */
ADIO_Offset off;
ADIOI_Flatlist_node *flat_file;
int i;
ADIO_Offset n_etypes_in_filetype, n_filetypes, etype_in_filetype;
ADIO_Offset abs_off_in_filetype=0;
ADIO_Offset size_in_filetype, sum;
unsigned filetype_size;
int etype_size, filetype_is_contig;
MPI_Aint filetype_extent;
ADIOI_UNREFERENCED_ARG(whence);
ADIOI_Datatype_iscontig(fd->filetype, &filetype_is_contig);
etype_size = fd->etype_size;
if (filetype_is_contig) off = fd->disp + (ADIO_Offset)etype_size * offset;
else {
flat_file = ADIOI_Flatlist;
while (flat_file->type != fd->filetype) flat_file = flat_file->next;
MPI_Type_extent(fd->filetype, &filetype_extent);
MPI_Type_size(fd->filetype, (int*)&filetype_size);
if ( ! filetype_size ) {
/* Since offset relative to the filetype size, we can't
do compute the offset when that result is zero.
Return zero for the offset for now */
*error_code = MPI_SUCCESS;
return 0;
}
n_etypes_in_filetype = filetype_size/etype_size;
n_filetypes = offset / n_etypes_in_filetype;
etype_in_filetype = offset % n_etypes_in_filetype;
size_in_filetype = etype_in_filetype * etype_size;
sum = 0;
for (i=0; i<flat_file->count; i++) {
sum += flat_file->blocklens[i];
if (sum > size_in_filetype) {
abs_off_in_filetype = flat_file->indices[i] +
size_in_filetype - (sum - flat_file->blocklens[i]);
break;
}
}
/* abs. offset in bytes in the file */
off = fd->disp + n_filetypes * filetype_extent +
abs_off_in_filetype;
}
/*
* we used to call lseek here and update both fp_ind and fp_sys_posn, but now
* we don't seek and only update fp_ind (ROMIO's idea of where we are in the
* file). We leave the system file descriptor and fp_sys_posn alone.
* The fs-specifc ReadContig and WriteContig will seek to the correct place in
* the file before reading/writing if the 'offset' parameter doesn't match
* fp_sys_posn
*/
fd->fp_ind = off;
*error_code = MPI_SUCCESS;
return off;
}
void IMB_allreduce(struct comm_info* c_info, int size, struct iter_schedule* ITERATIONS,
MODES RUN_MODE, double* time)
/*
MPI-1 benchmark kernel
Benchmarks MPI_Allreduce
Input variables:
-c_info (type struct comm_info*)
Collection of all base data for MPI;
see [1] for more information
-size (type int)
Basic message size in bytes
-ITERATIONS (type struct iter_schedule *)
Repetition scheduling
-RUN_MODE (type MODES)
(only MPI-2 case: see [1])
Output variables:
-time (type double*)
Timing result per sample
*/
{
double t1, t2;
int i;
Type_Size s_size;
int s_num;
#ifdef CHECK
defect=0.;
#endif
ierr = 0;
*time = 0.;
/* GET SIZE OF DATA TYPE */
MPI_Type_size(c_info->red_data_type,&s_size);
if (s_size!=0) s_num=size/s_size;
if(c_info->rank!=-1)
{
IMB_do_n_barriers (c_info->communicator, N_BARR);
for(i=0;i< ITERATIONS->n_sample;i++)
{
t1 = MPI_Wtime();
ierr = MPI_Allreduce((char*)c_info->s_buffer+i%ITERATIONS->s_cache_iter*ITERATIONS->s_offs,
(char*)c_info->r_buffer+i%ITERATIONS->r_cache_iter*ITERATIONS->r_offs,
s_num,
c_info->red_data_type,c_info->op_type,
c_info->communicator);
MPI_ERRHAND(ierr);
t2 = MPI_Wtime();
*time += (t2 - t1);
CHK_DIFF("Allreduce",c_info, (char*)c_info->r_buffer+i%ITERATIONS->r_cache_iter*ITERATIONS->r_offs, 0,
size, size, asize,
put, 0, ITERATIONS->n_sample, i,
-1, &defect);
IMB_do_n_barriers (c_info->communicator, c_info->sync);
}
*time /= ITERATIONS->n_sample;
}
}
/* pack_and_unpack()
*
* Perform packing and unpacking of a buffer for the purposes of checking
* to see if we are processing a type correctly. Zeros the buffer between
* these two operations, so the data described by the type should be in
* place upon return but all other regions of the buffer should be zero.
*
* Parameters:
* typebuf - pointer to buffer described by datatype and count that
* will be packed and then unpacked into
* count, datatype - description of typebuf
* typebufsz - size of typebuf; used specifically to zero the buffer
* between the pack and unpack steps
*
*/
static int pack_and_unpack(char *typebuf, int count, MPI_Datatype datatype, int typebufsz)
{
char *packbuf;
int err, errs = 0, pack_size, type_size, position;
err = MPI_Type_size(datatype, &type_size);
if (err != MPI_SUCCESS) {
errs++;
if (verbose) {
fprintf(stderr, "error in MPI_Type_size call; aborting after %d errors\n", errs);
}
return errs;
}
type_size *= count;
err = MPI_Pack_size(count, datatype, MPI_COMM_SELF, &pack_size);
if (err != MPI_SUCCESS) {
errs++;
if (verbose) {
fprintf(stderr, "error in MPI_Pack_size call; aborting after %d errors\n", errs);
}
return errs;
}
packbuf = (char *) malloc(pack_size);
if (packbuf == NULL) {
errs++;
if (verbose) {
fprintf(stderr, "error in malloc call; aborting after %d errors\n", errs);
}
return errs;
}
position = 0;
err = MPI_Pack(typebuf, count, datatype, packbuf, type_size, &position, MPI_COMM_SELF);
if (position != type_size) {
errs++;
if (verbose)
fprintf(stderr, "position = %d; should be %d (pack)\n", position, type_size);
}
memset(typebuf, 0, typebufsz);
position = 0;
err = MPI_Unpack(packbuf, type_size, &position, typebuf, count, datatype, MPI_COMM_SELF);
if (err != MPI_SUCCESS) {
errs++;
if (verbose) {
fprintf(stderr, "error in MPI_Unpack call; aborting after %d errors\n", errs);
}
return errs;
}
free(packbuf);
if (position != type_size) {
errs++;
if (verbose)
fprintf(stderr, "position = %d; should be %d (unpack)\n", position, type_size);
}
return errs;
}
/*
* This test looks at the handling of logical and for types that are not
* integers or are not required integers (e.g., long long). MPICH allows
* these as well. A strict MPI test should not include this test.
*/
int main( int argc, char *argv[] )
{
int errs = 0;
int rank, size;
MPI_Comm comm;
char cinbuf[3], coutbuf[3];
signed char scinbuf[3], scoutbuf[3];
unsigned char ucinbuf[3], ucoutbuf[3];
d_complex dinbuf[3], doutbuf[3];
MTest_Init( &argc, &argv );
comm = MPI_COMM_WORLD;
MPI_Comm_rank( comm, &rank );
MPI_Comm_size( comm, &size );
#ifndef USE_STRICT_MPI
/* char */
MTestPrintfMsg( 10, "Reduce of MPI_CHAR\n" );
cinbuf[0] = 1;
cinbuf[1] = 0;
cinbuf[2] = (rank > 0);
coutbuf[0] = 0;
coutbuf[1] = 1;
coutbuf[2] = 1;
MPI_Reduce( cinbuf, coutbuf, 3, MPI_CHAR, MPI_SUM, 0, comm );
if (rank == 0) {
if (size < 128 && coutbuf[0] != size) {
errs++;
fprintf( stderr, "char SUM(1) test failed\n" );
}
if (size < 128 && coutbuf[1] != 0) {
errs++;
fprintf( stderr, "char SUM(0) test failed\n" );
}
if (size < 128 && coutbuf[2] != size - 1) {
errs++;
fprintf( stderr, "char SUM(>) test failed\n" );
}
}
#endif /* USE_MPI_STRICT */
/* signed char */
MTestPrintfMsg( 10, "Reduce of MPI_SIGNED_CHAR\n" );
scinbuf[0] = 1;
scinbuf[1] = 0;
scinbuf[2] = (rank > 0);
scoutbuf[0] = 0;
scoutbuf[1] = 1;
scoutbuf[2] = 1;
MPI_Reduce( scinbuf, scoutbuf, 3, MPI_SIGNED_CHAR, MPI_SUM, 0, comm );
if (rank == 0) {
if (size < 128 && scoutbuf[0] != size) {
errs++;
fprintf( stderr, "signed char SUM(1) test failed\n" );
}
if (size < 128 && scoutbuf[1] != 0) {
errs++;
fprintf( stderr, "signed char SUM(0) test failed\n" );
}
if (size < 128 && scoutbuf[2] != size - 1) {
errs++;
fprintf( stderr, "signed char SUM(>) test failed\n" );
}
}
/* unsigned char */
MTestPrintfMsg( 10, "Reduce of MPI_UNSIGNED_CHAR\n" );
ucinbuf[0] = 1;
ucinbuf[1] = 0;
ucinbuf[2] = (rank > 0);
ucoutbuf[0] = 0;
ucoutbuf[1] = 1;
ucoutbuf[2] = 1;
MPI_Reduce( ucinbuf, ucoutbuf, 3, MPI_UNSIGNED_CHAR, MPI_SUM, 0, comm );
if (rank == 0) {
if (size < 128 && ucoutbuf[0] != size) {
errs++;
fprintf( stderr, "unsigned char SUM(1) test failed\n" );
}
if (size < 128 && ucoutbuf[1]) {
errs++;
fprintf( stderr, "unsigned char SUM(0) test failed\n" );
}
if (size < 128 && ucoutbuf[2] != size - 1) {
errs++;
fprintf( stderr, "unsigned char SUM(>) test failed\n" );
}
}
#ifndef USE_STRICT_MPI
/* For some reason, complex is not allowed for sum and prod */
if (MPI_DOUBLE_COMPLEX != MPI_DATATYPE_NULL) {
int dc;
#ifdef HAVE_LONG_DOUBLE
ld_complex ldinbuf[3], ldoutbuf[3];
#endif
/* Must determine which C type matches this Fortran type */
MPI_Type_size( MPI_DOUBLE_COMPLEX, &dc );
if (dc == sizeof(d_complex)) {
MTestPrintfMsg( 10, "Reduce of MPI_DOUBLE_COMPLEX\n" );
/* double complex; may be null if we do not have Fortran support */
dinbuf[0].r = 1;
dinbuf[1].r = 0;
dinbuf[2].r = (rank > 0);
dinbuf[0].i = -1;
dinbuf[1].i = 0;
dinbuf[2].i = -(rank > 0);
doutbuf[0].r = 0;
doutbuf[1].r = 1;
doutbuf[2].r = 1;
doutbuf[0].i = 0;
doutbuf[1].i = 1;
doutbuf[2].i = 1;
MPI_Reduce( dinbuf, doutbuf, 3, MPI_DOUBLE_COMPLEX, MPI_SUM, 0, comm );
if (rank == 0) {
if (doutbuf[0].r != size || doutbuf[0].i != -size) {
errs++;
fprintf( stderr, "double complex SUM(1) test failed\n" );
}
if (doutbuf[1].r != 0 || doutbuf[1].i != 0) {
errs++;
fprintf( stderr, "double complex SUM(0) test failed\n" );
}
if (doutbuf[2].r != size - 1 || doutbuf[2].i != 1 - size) {
errs++;
fprintf( stderr, "double complex SUM(>) test failed\n" );
}
}
}
#ifdef HAVE_LONG_DOUBLE
else if (dc == sizeof(ld_complex)) {
MTestPrintfMsg( 10, "Reduce of MPI_DOUBLE_COMPLEX\n" );
/* double complex; may be null if we do not have Fortran support */
ldinbuf[0].r = 1;
ldinbuf[1].r = 0;
ldinbuf[2].r = (rank > 0);
ldinbuf[0].i = -1;
ldinbuf[1].i = 0;
ldinbuf[2].i = -(rank > 0);
ldoutbuf[0].r = 0;
ldoutbuf[1].r = 1;
ldoutbuf[2].r = 1;
ldoutbuf[0].i = 0;
ldoutbuf[1].i = 1;
ldoutbuf[2].i = 1;
MPI_Reduce( ldinbuf, ldoutbuf, 3, MPI_DOUBLE_COMPLEX,
MPI_SUM, 0, comm );
if (rank == 0) {
if (ldoutbuf[0].r != size || ldoutbuf[0].i != -size) {
errs++;
fprintf( stderr, "double complex SUM(1) test failed\n" );
}
if (ldoutbuf[1].r != 0 || ldoutbuf[1].i != 0) {
errs++;
fprintf( stderr, "double complex SUM(0) test failed\n" );
}
if (ldoutbuf[2].r != size - 1 || ldoutbuf[2].i != 1 - size) {
errs++;
fprintf( stderr, "double complex SUM(>) test failed\n" );
}
}
}
#endif
/* Implicitly ignore if there is no matching C type */
}
#endif /* USE_STRICT_MPI */
#ifdef HAVE_LONG_DOUBLE
{ long double ldinbuf[3], ldoutbuf[3];
/* long double */
ldinbuf[0] = 1;
ldinbuf[1] = 0;
ldinbuf[2] = (rank > 0);
ldoutbuf[0] = 0;
ldoutbuf[1] = 1;
ldoutbuf[2] = 1;
if (MPI_LONG_DOUBLE != MPI_DATATYPE_NULL) {
MTestPrintfMsg( 10, "Reduce of MPI_LONG_DOUBLE\n" );
MPI_Reduce( ldinbuf, ldoutbuf, 3, MPI_LONG_DOUBLE, MPI_SUM, 0, comm );
if (rank == 0) {
if (ldoutbuf[0] != size) {
errs++;
fprintf( stderr, "long double SUM(1) test failed\n" );
}
if (ldoutbuf[1] != 0.0) {
errs++;
fprintf( stderr, "long double SUM(0) test failed\n" );
}
if (ldoutbuf[2] != size - 1) {
errs++;
fprintf( stderr, "long double SUM(>) test failed\n" );
}
}
}
}
#endif
#ifdef HAVE_LONG_LONG
{
long long llinbuf[3], lloutbuf[3];
/* long long */
llinbuf[0] = 1;
llinbuf[1] = 0;
llinbuf[2] = (rank > 0);
lloutbuf[0] = 0;
lloutbuf[1] = 1;
lloutbuf[2] = 1;
if (MPI_LONG_LONG != MPI_DATATYPE_NULL) {
MTestPrintfMsg( 10, "Reduce of MPI_LONG_LONG\n" );
MPI_Reduce( llinbuf, lloutbuf, 3, MPI_LONG_LONG, MPI_SUM, 0, comm );
if (rank == 0) {
if (lloutbuf[0] != size) {
errs++;
fprintf( stderr, "long long SUM(1) test failed\n" );
}
if (lloutbuf[1] != 0) {
errs++;
fprintf( stderr, "long long SUM(0) test failed\n" );
}
if (lloutbuf[2] != size - 1) {
errs++;
fprintf( stderr, "long long SUM(>) test failed\n" );
}
}
}
}
#endif
MTest_Finalize( errs );
MPI_Finalize();
return 0;
}
/* the non-blocking reduce */
int ompi_coll_libnbc_ireduce(void* sendbuf, void* recvbuf, int count, MPI_Datatype datatype,
MPI_Op op, int root, struct ompi_communicator_t *comm, ompi_request_t ** request,
struct mca_coll_base_module_2_0_0_t *module) {
int rank, p, res, segsize, size;
MPI_Aint ext;
NBC_Schedule *schedule;
char *redbuf=NULL, inplace;
#ifdef NBC_CACHE_SCHEDULE
NBC_Reduce_args *args, *found, search;
#endif
enum { NBC_RED_BINOMIAL, NBC_RED_CHAIN } alg;
NBC_Handle *handle;
ompi_coll_libnbc_request_t **coll_req = (ompi_coll_libnbc_request_t**) request;
ompi_coll_libnbc_module_t *libnbc_module = (ompi_coll_libnbc_module_t*) module;
NBC_IN_PLACE(sendbuf, recvbuf, inplace);
res = NBC_Init_handle(comm, coll_req, libnbc_module);
if(res != NBC_OK) { printf("Error in NBC_Init_handle(%i)\n", res); return res; }
handle = (*coll_req);
res = MPI_Comm_rank(comm, &rank);
if (MPI_SUCCESS != res) { printf("MPI Error in MPI_Comm_rank() (%i)\n", res); return res; }
res = MPI_Comm_size(comm, &p);
if (MPI_SUCCESS != res) { printf("MPI Error in MPI_Comm_size() (%i)\n", res); return res; }
res = MPI_Type_extent(datatype, &ext);
if (MPI_SUCCESS != res) { printf("MPI Error in MPI_Type_extent() (%i)\n", res); return res; }
res = MPI_Type_size(datatype, &size);
if (MPI_SUCCESS != res) { printf("MPI Error in MPI_Type_size() (%i)\n", res); return res; }
/* only one node -> copy data */
if((p == 1) && !inplace) {
res = NBC_Copy(sendbuf, count, datatype, recvbuf, count, datatype, comm);
if (NBC_OK != res) { printf("Error in NBC_Copy() (%i)\n", res); return res; }
}
/* algorithm selection */
if(p > 4 || size*count < 65536) {
alg = NBC_RED_BINOMIAL;
if(rank == root) {
/* root reduces in receivebuffer */
handle->tmpbuf = malloc(ext*count);
} else {
/* recvbuf may not be valid on non-root nodes */
handle->tmpbuf = malloc(ext*count*2);
redbuf = ((char*)handle->tmpbuf)+(ext*count);
}
} else {
handle->tmpbuf = malloc(ext*count);
alg = NBC_RED_CHAIN;
segsize = 16384/2;
}
if (NULL == handle->tmpbuf) { printf("Error in malloc() (%i)\n", res); return res; }
#ifdef NBC_CACHE_SCHEDULE
/* search schedule in communicator specific tree */
search.sendbuf=sendbuf;
search.recvbuf=recvbuf;
search.count=count;
search.datatype=datatype;
search.op=op;
search.root=root;
found = (NBC_Reduce_args*)hb_tree_search((hb_tree*)handle->comminfo->NBC_Dict[NBC_REDUCE], &search);
if(found == NULL) {
#endif
schedule = (NBC_Schedule*)malloc(sizeof(NBC_Schedule));
if (NULL == schedule) { printf("Error in malloc() (%i)\n", res); return res; }
res = NBC_Sched_create(schedule);
if(res != NBC_OK) { printf("Error in NBC_Sched_create (%i)\n", res); return res; }
switch(alg) {
case NBC_RED_BINOMIAL:
res = red_sched_binomial(rank, p, root, sendbuf, recvbuf, count, datatype, op, redbuf, schedule, handle);
break;
case NBC_RED_CHAIN:
res = red_sched_chain(rank, p, root, sendbuf, recvbuf, count, datatype, op, ext, size, schedule, handle, segsize);
break;
}
if (NBC_OK != res) { printf("Error in Schedule creation() (%i)\n", res); return res; }
res = NBC_Sched_commit(schedule);
if (NBC_OK != res) { free(handle->tmpbuf); printf("Error in NBC_Sched_commit() (%i)\n", res); return res; }
#ifdef NBC_CACHE_SCHEDULE
/* save schedule to tree */
args = (NBC_Reduce_args*)malloc(sizeof(NBC_Alltoall_args));
args->sendbuf=sendbuf;
args->recvbuf=recvbuf;
args->count=count;
args->datatype=datatype;
args->op=op;
args->root=root;
args->schedule=schedule;
res = hb_tree_insert ((hb_tree*)handle->comminfo->NBC_Dict[NBC_REDUCE], args, args, 0);
if(res != 0) printf("error in dict_insert() (%i)\n", res);
/* increase number of elements for Reduce */
if(++handle->comminfo->NBC_Dict_size[NBC_REDUCE] > NBC_SCHED_DICT_UPPER) {
NBC_SchedCache_dictwipe((hb_tree*)handle->comminfo->NBC_Dict[NBC_REDUCE], &handle->comminfo->NBC_Dict_size[NBC_REDUCE]);
}
} else {
/* found schedule */
schedule=found->schedule;
}
#endif
res = NBC_Start(handle, schedule);
if (NBC_OK != res) { free(handle->tmpbuf); printf("Error in NBC_Start() (%i)\n", res); return res; }
/* tmpbuf is freed with the handle */
return NBC_OK;
}
void ADIOI_NFS_WriteContig(ADIO_File fd, const void *buf, int count,
MPI_Datatype datatype, int file_ptr_type,
ADIO_Offset offset, ADIO_Status *status, int *error_code)
{
int err=-1, datatype_size, len;
static char myname[] = "ADIOI_NFS_WRITECONTIG";
MPI_Type_size(datatype, &datatype_size);
len = datatype_size * count;
if (file_ptr_type == ADIO_EXPLICIT_OFFSET) {
if (fd->fp_sys_posn != offset) {
#ifdef ADIOI_MPE_LOGGING
MPE_Log_event( ADIOI_MPE_lseek_a, 0, NULL );
#endif
lseek(fd->fd_sys, offset, SEEK_SET);
#ifdef ADIOI_MPE_LOGGING
MPE_Log_event( ADIOI_MPE_lseek_b, 0, NULL );
#endif
}
ADIOI_WRITE_LOCK(fd, offset, SEEK_SET, len);
#ifdef ADIOI_MPE_LOGGING
MPE_Log_event( ADIOI_MPE_write_a, 0, NULL );
#endif
err = write(fd->fd_sys, buf, len);
#ifdef ADIOI_MPE_LOGGING
MPE_Log_event( ADIOI_MPE_write_b, 0, NULL );
#endif
ADIOI_UNLOCK(fd, offset, SEEK_SET, len);
fd->fp_sys_posn = offset + err;
/* individual file pointer not updated */
}
else { /* write from curr. location of ind. file pointer */
offset = fd->fp_ind;
if (fd->fp_sys_posn != fd->fp_ind) {
#ifdef ADIOI_MPE_LOGGING
MPE_Log_event( ADIOI_MPE_lseek_a, 0, NULL );
#endif
lseek(fd->fd_sys, fd->fp_ind, SEEK_SET);
#ifdef ADIOI_MPE_LOGGING
MPE_Log_event( ADIOI_MPE_lseek_b, 0, NULL );
#endif
}
ADIOI_WRITE_LOCK(fd, offset, SEEK_SET, len);
#ifdef ADIOI_MPE_LOGGING
MPE_Log_event( ADIOI_MPE_write_a, 0, NULL );
#endif
err = write(fd->fd_sys, buf, len);
#ifdef ADIOI_MPE_LOGGING
MPE_Log_event( ADIOI_MPE_write_b, 0, NULL );
#endif
ADIOI_UNLOCK(fd, offset, SEEK_SET, len);
fd->fp_ind += err;
fd->fp_sys_posn = fd->fp_ind;
}
/* --BEGIN ERROR HANDLING-- */
if (err == -1) {
*error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**io",
"**io %s", strerror(errno));
return;
}
/* --END ERROR HANDLING-- */
#ifdef HAVE_STATUS_SET_BYTES
MPIR_Status_set_bytes(status, datatype, err);
#endif
*error_code = MPI_SUCCESS;
}
int main (int argc, char **argv)
{
int i;
ADIO_File fd;
ADIO_Offset min_st_offset, max_end_offset;
int rank;
int nprocs_for_coll;
int lb;
int size, extent;
MPI_Init (&argc, &argv);
MPI_Comm_rank (MPI_COMM_WORLD, &rank);
if (argc != 4) {
if (!rank)
printf ("Usage: file_realms_test <number of aggregators> <lower bound> <upper bound>\n"
" simulates file_realm calculation\n");
MPI_Finalize();
return 1;
}
nprocs_for_coll = atoi (argv[1]);
min_st_offset = atoi (argv[2]);
max_end_offset = atoi (argv[3]);
if (max_end_offset < min_st_offset){
if (!rank)
printf ("end offset %lld is less then start offset %lld\n",
max_end_offset, min_st_offset);
MPI_Finalize();
return 1;
}
printf ("min_st_offset = %lld\nmax_end_offset = %lld\n",
min_st_offset, max_end_offset);
fd = (ADIO_File) ADIOI_Malloc (sizeof (struct ADIOI_FileD));
fd->hints = (ADIOI_Hints *)
ADIOI_Malloc (sizeof(struct ADIOI_Hints_struct));
fd->hints->cb_nodes = nprocs_for_coll;
ADIOI_Calc_file_realms (fd, min_st_offset, max_end_offset);
for (i=0; i < nprocs_for_coll; i++) {
printf ("file_realm_st_offs[%d] = %lld\n", i, fd->file_realm_st_offs[i]);
}
for (i=0; i < nprocs_for_coll; i++) {
MPI_Type_size (fd->file_realm_types[i], &size);
printf ("file_realm [%d] size = %d\n", i, size);
}
for (i=0; i < nprocs_for_coll; i++) {
MPI_Type_get_extent (fd->file_realm_types[i], &lb, &extent);
printf ("file_realm [%d] extent = %d\n", i, extent);
}
for (i=0; i < nprocs_for_coll; i++)
MPI_Type_free (&fd->file_realm_types[i]);
ADIOI_Free (fd->file_realm_st_offs);
ADIOI_Free (fd->file_realm_types);
ADIOI_Free (fd->hints);
ADIOI_Free (fd);
MPI_Finalize();
return 0;
}
void Bidir_Get(struct comm_info* c_info,
int size,int n_sample,MODES RUN_MODE, double* time)
/*************************************************************************/
/*------------------------------------------------------------
VARIABLE | TYPE | MEANING
------------------------------------------------------------
Input : c_info | struct comm_info* | see comm_info.h
size | int | message length in byte
n_sample | int | repetition count
RUN_MODE | MODES (typedef, | Distinction aggregate/
| see Benchmark.h) | non aggr., see docu.
| |
Output : time | double* | *time: time/sample in usec
| |
In/Out : - | - | -
| |
------------------------------------------------------------
------------------------------------------------------------
Description: see the accompanying document
-------------------------------------------------------------*/
{
double t1, t2;
Type_Size s_size,r_size;
int s_num, r_num;
int dest, source,sender;
MPI_Status stat;
ierr = 0;
/* GET SIZE OF DATA TYPE */
MPI_Type_size(c_info->s_data_type,&s_size);
MPI_Type_size(c_info->r_data_type,&r_size);
if ((s_size!=0) && (r_size!=0))
{
s_num=size/s_size;
r_num=size/r_size;
}
if (c_info->rank == c_info->pair0)
{
dest = c_info->pair1;
}
else if (c_info->rank == c_info->pair1)
{
dest =c_info->pair0 ;
}
sender=0;
if( !RUN_MODE->AGGREGATE )
OneS_Get( c_info,
s_num, dest,
r_num, sender,
size, n_sample,
time);
if( RUN_MODE->AGGREGATE )
OneS_mGet( c_info,
s_num, dest,
r_num, sender,
size, n_sample,
time);
}
