ports/openmpi
ports/openmpi
1
1
Форкнуть 0
Код Релизы Активность

Remove a bunch of the old ROMIO io component stuff in preparation for

Просмотр исходного кода 
Weikaun's new IO stuff.

This commit was SVN r1764.
Этот коммит содержится в:
Weikuan Yu 2004-07-16 17:00:26 +00:00
родитель 525c9e08c2
Коммит 81679785e3
13 изменённых файлов: 2 добавлений и 1512 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

0
src/mca/io/romio/.ompi_ignore Обычный файл
Просмотреть файл

2
src/mca/io/romio/configure.params
Просмотреть файл

@ -7,4 +7,4 @@
PARAM_INIT_FILE=src/io_romio_module.c
PARAM_CONFIG_HEADER_FILE="src/romio_config.h"
PARAM_CONFIG_FILES="Makefile src/Makefile src/romio-1.2.5.1/Makefile src/romio-1.2.5.1/include/Makefile"
PARAM_CONFIG_FILES="Makefile src/Makefile"

12
src/mca/io/romio/src/Makefile.am
Просмотреть файл

@ -5,15 +5,5 @@
include $(top_ompi_srcdir)/config/Makefile.options
SUBDIRS = romio-1.2.5.1
noinst_LTLIBRARIES = libmca_io_romio.la
libmca_io_romio_la_SOURCES = \
io_romio_module.c \
io_romio.h \
file_request.c \
file_open.c \
file_read.c \
file_write.c \
global.c
libmca_io_romio_la_SOURCES =

403
src/mca/io/romio/src/file_open.c
Просмотреть файл

@ -1,403 +0,0 @@
/*
* $HEADER$
*/
#include "mpi.h"
#include "file/file.h"
#include "io_romio.h"
#include "request/request.h"
#include <string.h>
int mca_io_romio_File_open(MPI_Comm comm, char *filename, int amode,
MPI_Info info, MPI_File *fh){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
/* create a new ompi_file_t */
mca_romio_fh = malloc(sizeof(mca_io_romio_file_t));
(*fh) = (ompi_file_t *) mca_romio_fh;
strncpy((*fh)->f_name,filename,MPI_MAX_OBJECT_NAME);
(*fh)->ompi_io_version=OMPI_IO_1_0_0;
(*fh)->mca_io_functions.f_io=romio_actions;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_open(comm,filename,amode,info,&romio_fh);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_close(MPI_File *fh) {
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *)(*fh);
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_close(&romio_fh);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
free(*fh);
return ret;
}
int mca_io_romio_File_delete(char *filename, MPI_Info info) {
int ret;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_delete(filename, info);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_set_size(MPI_File fh, MPI_Offset size){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_set_size(romio_fh, size);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_preallocate(MPI_File fh, MPI_Offset size){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_preallocate(romio_fh,size);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_get_size(MPI_File fh, MPI_Offset *size){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_get_size(romio_fh,size);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_get_group(MPI_File fh, MPI_Group *group){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_get_group(romio_fh,group);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_get_amode(MPI_File fh, int *amode){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_get_amode(romio_fh, amode);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_set_info(MPI_File fh, MPI_Info info){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_set_info(romio_fh,info);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_get_info(MPI_File fh, MPI_Info *info_used){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_get_info(romio_fh,info_used);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_set_view(MPI_File fh, MPI_Offset disp, MPI_Datatype etype,
MPI_Datatype filetype, char *datarep, MPI_Info info){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_set_view(romio_fh,disp,etype,filetype,datarep,info);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_get_view(MPI_File fh, MPI_Offset *disp, MPI_Datatype *etype, MPI_Datatype *filetype, char *datarep){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_get_view(romio_fh,disp,etype,filetype,datarep);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_get_type_extent(MPI_File fh, MPI_Datatype datatype, MPI_Aint *extent){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_get_type_extent(romio_fh,datatype,extent);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_set_atomicity(MPI_File fh, int flag){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_set_atomicity(romio_fh,flag);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_get_atomicity(MPI_File fh, int *flag){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_get_atomicity(romio_fh,flag);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_sync(MPI_File fh){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_sync(romio_fh);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_seek_shared(MPI_File fh, MPI_Offset offset, int whence){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_seek_shared(romio_fh, offset, whence);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_get_position_shared(MPI_File fh, MPI_Offset *offset){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_get_position_shared(romio_fh,offset);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_seek(MPI_File fh, MPI_Offset offset, int whence){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_seek(romio_fh,offset,whence);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_get_position(MPI_File fh, MPI_Offset *offset){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_get_position(romio_fh,offset);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_get_byte_offset(MPI_File fh, MPI_Offset offset, MPI_Offset *disp){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_get_byte_offset(romio_fh,offset,disp);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_set_errhandler(MPI_File fh, MPI_Errhandler eh){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_set_errhandler(romio_fh,eh);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_get_errhandler(MPI_File fh, MPI_Errhandler *eh ){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_get_errhandler(romio_fh,eh );
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}

279
src/mca/io/romio/src/file_read.c
Просмотреть файл

@ -1,279 +0,0 @@
/*
* $HEADER$
*/
#include "mpi.h"
#include "file/file.h"
#include "io_romio.h"
#include "request/request.h"
int mca_io_romio_File_read_at(MPI_File fh, MPI_Offset offset, void *buf,int count, MPI_Datatype datatype, MPI_Status *status){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_read_at(romio_fh,offset,buf,count,datatype,status);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_read_at_all(MPI_File fh, MPI_Offset offset, void *buf,int count, MPI_Datatype datatype, MPI_Status *status){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_read_at_all(romio_fh,offset,buf,count,datatype,status);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_iread_at(MPI_File fh, MPI_Offset offset, void *buf, int count, MPI_Datatype datatype, MPI_Request *request){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
mca_io_romio_request_t *rq;
mca_io_romio_MPIO_Request romio_rq;
/* create MPI_request */
rq = malloc(sizeof(mca_io_romio_request_t));
(*request) = (ompi_request_t *) rq;
(*request)->req_type = OMPI_REQUEST_IO;
/* extract the ROMIO request */
romio_rq = rq->romio_rq;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_iread_at(romio_fh,offset,buf,count,datatype,
&romio_rq);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_read(MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Status *status){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_read(romio_fh,buf,count,datatype,status);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_read_all(MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Status *status){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_read_all(romio_fh,buf,count,datatype,status);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_iread(MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Request *request){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
mca_io_romio_request_t *rq;
mca_io_romio_MPIO_Request romio_rq;
/* create MPI_request */
rq = malloc(sizeof(mca_io_romio_request_t));
(*request) = (ompi_request_t *) rq;
(*request)->req_type = OMPI_REQUEST_IO;
/* extract the ROMIO request */
romio_rq = rq->romio_rq;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_iread(romio_fh,buf,count,datatype,&romio_rq);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_read_shared(MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Status *status){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_read_shared(romio_fh, buf, count, datatype,status);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_iread_shared(MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Request *request){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
mca_io_romio_request_t *rq;
mca_io_romio_MPIO_Request romio_rq;
/* create MPI_request */
rq = malloc(sizeof(mca_io_romio_request_t));
(*request) = (ompi_request_t *) rq;
(*request)->req_type = OMPI_REQUEST_IO;
/* extract the ROMIO request */
romio_rq = rq->romio_rq;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_iread_shared(romio_fh,buf,count,datatype,&romio_rq);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_read_ordered(MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Status *status){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_read_ordered(romio_fh,buf,count,datatype,status);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_read_at_all_begin(MPI_File fh, MPI_Offset offset, void *buf, int count, MPI_Datatype datatype){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_read_at_all_begin(romio_fh,offset,buf,count,datatype);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_read_at_all_end(MPI_File fh, void *buf, MPI_Status *status){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_read_at_all_end(romio_fh, buf, status);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_read_all_begin(MPI_File fh, void *buf, int count, MPI_Datatype datatype){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_read_all_begin(romio_fh,buf,count,datatype);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_read_all_end(MPI_File fh, void *buf, MPI_Status *status){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_read_all_end(romio_fh,buf,status);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_read_ordered_begin(MPI_File fh, void *buf, int count, MPI_Datatype datatype){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_read_ordered_begin(romio_fh,buf,count,datatype);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_read_ordered_end(MPI_File fh, void *buf, MPI_Status *status){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_read_ordered_end(romio_fh, buf,status);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}

52
src/mca/io/romio/src/file_request.c
Просмотреть файл

@ -1,52 +0,0 @@
/*
* $HEADER$
*/
#include "mpi.h"
#include "file/file.h"
#include "io_romio.h"
#include "request/request.h"
#include <string.h>
int mca_io_romio_Test(MPI_Request *request, int *flag, MPI_Status *status){
int ret;
mca_io_romio_request_t *rq;
mca_io_romio_MPIO_Request romio_rq;
/* extract the ROMIO request */
rq=(mca_io_romio_request_t *)(*request);
romio_rq = rq->romio_rq;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPIO_Test(&romio_rq, flag,status);
if (*flag) {
free(*request);
*request = MPI_REQUEST_NULL;
}
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_Wait(MPI_Request *request, MPI_Status *status){
int ret;
mca_io_romio_request_t *rq;
mca_io_romio_MPIO_Request romio_rq;
/* extract the ROMIO request */
rq=(mca_io_romio_request_t *)(*request);
romio_rq = rq->romio_rq;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPIO_Wait(&romio_rq, status);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
free(*request);
*request = MPI_REQUEST_NULL;
return ret;
}

293
src/mca/io/romio/src/file_write.c
Просмотреть файл

@ -1,293 +0,0 @@
/*
* $HEADER$
*/
#include "mpi.h"
#include "file/file.h"
#include "io_romio.h"
#include "request/request.h"
int mca_io_romio_File_write_at(MPI_File fh, MPI_Offset offset, void *buf,int count, MPI_Datatype datatype, MPI_Status *status){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_write_at(romio_fh,offset,buf,count,datatype,status);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_write_at_all(MPI_File fh, MPI_Offset offset, void *buf, int count, MPI_Datatype datatype, MPI_Status *status){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_write_at_all(romio_fh,offset,buf,count,datatype,status);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_iwrite_at(MPI_File fh, MPI_Offset offset, void *buf,int count, MPI_Datatype datatype, MPI_Request *request){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
mca_io_romio_request_t *rq;
mca_io_romio_MPIO_Request romio_rq;
/* create MPI_request */
rq = malloc(sizeof(mca_io_romio_request_t));
(*request) = (ompi_request_t *) rq;
(*request)->req_type = OMPI_REQUEST_IO;
/* extract the ROMIO request */
romio_rq = rq->romio_rq;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_iwrite_at(romio_fh,offset,buf,count,datatype,
&romio_rq);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_write(MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Status *status){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_write(romio_fh,buf,count,datatype,status);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_write_all(MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Status *status){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_write_all(romio_fh,buf,count,datatype,status);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_iwrite(MPI_File fh, void *buf, int count,
MPI_Datatype datatype, ompi_request_t **request)
{
mca_io_romio_request_t *rq;
mca_io_romio_MPIO_Request romio_rq;
mca_io_romio_MPI_File romio_fh;
int ret;
/* create MPI_request */
rq = malloc(sizeof(mca_io_romio_request_t));
*request = (ompi_request_t*) rq;
(*request)->req_type = OMPI_REQUEST_IO;
/* extract the ROMIO request */
romio_rq = rq->romio_rq;
romio_fh = ((mca_io_romio_file_t *) fh)->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_iwrite(romio_fh, buf, count, datatype, &romio_rq);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_write_shared(MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Status *status){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_write_shared(romio_fh,buf,count,datatype,status);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_iwrite_shared(MPI_File fh, void *buf, int count,
MPI_Datatype datatype, MPI_Request *request){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
mca_io_romio_request_t *rq;
mca_io_romio_MPIO_Request romio_rq;
/* create MPI_request */
rq = malloc(sizeof(mca_io_romio_request_t));
(*request) = (ompi_request_t *) rq;
(*request)->req_type = OMPI_REQUEST_IO;
/* extract the ROMIO request */
romio_rq = rq->romio_rq;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret= mca_io_romio_MPI_File_iwrite_shared(romio_fh,buf,count,datatype,&romio_rq);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_write_ordered(MPI_File fh, void *buf, int count,
MPI_Datatype datatype, MPI_Status *status){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret= mca_io_romio_MPI_File_write_ordered(romio_fh,buf,count,datatype,status);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_write_at_all_begin(MPI_File fh, MPI_Offset offset, void *buf,
int count, MPI_Datatype datatype){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret= mca_io_romio_MPI_File_write_at_all_begin(romio_fh,offset, buf,
count, datatype);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_write_at_all_end(MPI_File fh, void *buf, MPI_Status *status){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_write_at_all_end(romio_fh,buf,status);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_write_all_begin(MPI_File fh, void *buf, int count,
MPI_Datatype datatype){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret= mca_io_romio_MPI_File_write_all_begin(romio_fh, buf, count,
datatype);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_write_all_end(MPI_File fh, void *buf, MPI_Status *status){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret= mca_io_romio_MPI_File_write_all_end(romio_fh,buf,status);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_write_ordered_begin(MPI_File fh, void *buf, int count,MPI_Datatype datatype){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_write_ordered_begin(romio_fh,buf,count,datatype);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}
int mca_io_romio_File_write_ordered_end(MPI_File fh, void *buf, MPI_Status *status){
int ret;
mca_io_romio_MPI_File romio_fh;
mca_io_romio_file_t *mca_romio_fh;
/* extract the ROMIO file handle: */
mca_romio_fh = (mca_io_romio_file_t *) fh;
romio_fh = mca_romio_fh->romio_fh;
OMPI_THREAD_LOCK(&mca_io_romio_mutex);
ret=mca_io_romio_MPI_File_write_ordered_end(romio_fh,buf,status);
OMPI_THREAD_UNLOCK(&mca_io_romio_mutex);
return ret;
}

72
src/mca/io/romio/src/global.c
Просмотреть файл

@ -1,72 +0,0 @@
/*
* $HEADER
*/
#include "threads/mutex.h"
#include "io_romio.h"
ompi_mutex_t mca_io_romio_mutex;
mca_io_1_0_0_t romio_actions = {
mca_io_romio_File_open,
mca_io_romio_File_close,
mca_io_romio_File_delete,
mca_io_romio_File_set_size,
mca_io_romio_File_preallocate,
mca_io_romio_File_get_size,
mca_io_romio_File_get_group,
mca_io_romio_File_get_amode,
mca_io_romio_File_set_info,
mca_io_romio_File_get_info,
mca_io_romio_File_set_view,
mca_io_romio_File_get_view,
mca_io_romio_File_read_at,
mca_io_romio_File_read_at_all,
mca_io_romio_File_write_at,
mca_io_romio_File_write_at_all,
mca_io_romio_File_iread_at,
mca_io_romio_File_iwrite_at,
mca_io_romio_File_read,
mca_io_romio_File_read_all,
mca_io_romio_File_write,
mca_io_romio_File_write_all,
mca_io_romio_File_iread,
mca_io_romio_File_iwrite,
mca_io_romio_File_seek,
mca_io_romio_File_get_position,
mca_io_romio_File_get_byte_offset,
mca_io_romio_File_read_shared,
mca_io_romio_File_write_shared,
mca_io_romio_File_iread_shared,
mca_io_romio_File_iwrite_shared,
mca_io_romio_File_read_ordered,
mca_io_romio_File_write_ordered,
mca_io_romio_File_seek_shared,
mca_io_romio_File_get_position_shared,
mca_io_romio_File_read_at_all_begin,
mca_io_romio_File_read_at_all_end,
mca_io_romio_File_write_at_all_begin,
mca_io_romio_File_write_at_all_end,
mca_io_romio_File_read_all_begin,
mca_io_romio_File_read_all_end,
mca_io_romio_File_write_all_begin,
mca_io_romio_File_write_all_end,
mca_io_romio_File_read_ordered_begin,
mca_io_romio_File_read_ordered_end,
mca_io_romio_File_write_ordered_begin,
mca_io_romio_File_write_ordered_end,
mca_io_romio_File_get_type_extent,
mca_io_romio_File_set_atomicity,
mca_io_romio_File_get_atomicity,
mca_io_romio_File_sync,
mca_io_romio_File_set_errhandler,
mca_io_romio_File_get_errhandler,
mca_io_romio_Test,
mca_io_romio_Wait
};

168
src/mca/io/romio/src/io_romio.h
Просмотреть файл

@ -1,168 +0,0 @@
/*
* $HEADER
*/
#ifndef MCA_IO_ROMIO_H
#define MCA_IO_ROMIO_H
#include "request/request.h"
#include "file/file.h"
#include "threads/mutex.h"
#include "romio-1.2.5.1/include/mpio.h"
/* global variables, instantiated in global.c */
extern ompi_mutex_t mca_io_romio_mutex;
extern mca_io_1_0_0_t romio_actions;
/*
MPI_Request: "inherit" the ompi_request, and add more stuff:
(romio module will instantiate)
*/
struct mca_io_romio_request_t {
ompi_request_t super;
mca_io_romio_MPIO_Request romio_rq;
};
typedef struct mca_io_romio_request_t mca_io_romio_request_t;
/*
MPI_File: "inherit" the ompi_file_t, and add more stuff
(romio module will instantiate)
*/
struct mca_io_romio_file_t {
ompi_file_t super;
mca_io_romio_MPI_File romio_fh;
};
typedef struct mca_io_romio_file_t mca_io_romio_file_t;
/* function prototypes
*
* ROMIO MCA module routines are named: mca_io_romio_File_routine
* which wrap the original Romio routines, which have been renamed
* mca_io_romio_MPI_File_routine
*
*/
/* Section 9.2 */
int mca_io_romio_File_open(MPI_Comm comm, char *filename, int amode,
MPI_Info info, MPI_File *fh);
int mca_io_romio_File_close(MPI_File *fh);
int mca_io_romio_File_delete(char *filename, MPI_Info info);
int mca_io_romio_File_set_size(MPI_File fh, MPI_Offset size);
int mca_io_romio_File_preallocate(MPI_File fh, MPI_Offset size);
int mca_io_romio_File_get_size(MPI_File fh, MPI_Offset *size);
int mca_io_romio_File_get_group(MPI_File fh, MPI_Group *group);
int mca_io_romio_File_get_amode(MPI_File fh, int *amode);
int mca_io_romio_File_set_info(MPI_File fh, MPI_Info info);
int mca_io_romio_File_get_info(MPI_File fh, MPI_Info *info_used);
/* Section 9.3 */
int mca_io_romio_File_set_view(MPI_File fh, MPI_Offset disp, MPI_Datatype etype,
MPI_Datatype filetype, char *datarep, MPI_Info info);
int mca_io_romio_File_get_view(MPI_File fh, MPI_Offset *disp,
MPI_Datatype *etype, MPI_Datatype *filetype, char *datarep);
/* Section 9.4.2 */
int mca_io_romio_File_read_at(MPI_File fh, MPI_Offset offset, void *buf,
int count, MPI_Datatype datatype, MPI_Status *status);
int mca_io_romio_File_read_at_all(MPI_File fh, MPI_Offset offset, void *buf,
int count, MPI_Datatype datatype, MPI_Status *status);
int mca_io_romio_File_write_at(MPI_File fh, MPI_Offset offset, void *buf,
int count, MPI_Datatype datatype, MPI_Status *status);
int mca_io_romio_File_write_at_all(MPI_File fh, MPI_Offset offset, void *buf,
int count, MPI_Datatype datatype, MPI_Status *status);
int mca_io_romio_File_iread_at(MPI_File fh, MPI_Offset offset, void *buf,
int count, MPI_Datatype datatype, MPI_Request *request);
int mca_io_romio_File_iwrite_at(MPI_File fh, MPI_Offset offset, void *buf,
int count, MPI_Datatype datatype, MPI_Request *request);
/* Section 9.4.3 */
int mca_io_romio_File_read(MPI_File fh, void *buf, int count, MPI_Datatype
datatype, MPI_Status *status);
int mca_io_romio_File_read_all(MPI_File fh, void *buf, int count, MPI_Datatype
datatype, MPI_Status *status);
int mca_io_romio_File_write(MPI_File fh, void *buf, int count, MPI_Datatype
datatype, MPI_Status *status);
int mca_io_romio_File_write_all(MPI_File fh, void *buf, int count, MPI_Datatype
datatype, MPI_Status *status);
int mca_io_romio_File_iread(MPI_File fh, void *buf, int count, MPI_Datatype
datatype, MPI_Request *request);
int mca_io_romio_File_iwrite(MPI_File fh, void *buf, int count,
MPI_Datatype datatype, ompi_request_t **request);
int mca_io_romio_File_seek(MPI_File fh, MPI_Offset offset, int whence);
int mca_io_romio_File_get_position(MPI_File fh, MPI_Offset *offset);
int mca_io_romio_File_get_byte_offset(MPI_File fh, MPI_Offset offset,
MPI_Offset *disp);
/* Section 9.4.4 */
int mca_io_romio_File_read_shared(MPI_File fh, void *buf, int count,
MPI_Datatype datatype, MPI_Status *status);
int mca_io_romio_File_write_shared(MPI_File fh, void *buf, int count,
MPI_Datatype datatype, MPI_Status *status);
int mca_io_romio_File_iread_shared(MPI_File fh, void *buf, int count,
MPI_Datatype datatype, MPI_Request *request);
int mca_io_romio_File_iwrite_shared(MPI_File fh, void *buf, int count,
MPI_Datatype datatype, MPI_Request *request);
int mca_io_romio_File_read_ordered(MPI_File fh, void *buf, int count,
MPI_Datatype datatype, MPI_Status *status);
int mca_io_romio_File_write_ordered(MPI_File fh, void *buf, int count,
MPI_Datatype datatype, MPI_Status *status);
int mca_io_romio_File_seek_shared(MPI_File fh, MPI_Offset offset, int whence);
int mca_io_romio_File_get_position_shared(MPI_File fh, MPI_Offset *offset);
/* Section 9.4.5 */
int mca_io_romio_File_read_at_all_begin(MPI_File fh, MPI_Offset offset, void *buf,
int count, MPI_Datatype datatype);
int mca_io_romio_File_read_at_all_end(MPI_File fh, void *buf, MPI_Status *status);
int mca_io_romio_File_write_at_all_begin(MPI_File fh, MPI_Offset offset, void *buf,
int count, MPI_Datatype datatype);
int mca_io_romio_File_write_at_all_end(MPI_File fh, void *buf, MPI_Status *status);
int mca_io_romio_File_read_all_begin(MPI_File fh, void *buf, int count,
MPI_Datatype datatype);
int mca_io_romio_File_read_all_end(MPI_File fh, void *buf, MPI_Status *status);
int mca_io_romio_File_write_all_begin(MPI_File fh, void *buf, int count,
MPI_Datatype datatype);
int mca_io_romio_File_write_all_end(MPI_File fh, void *buf, MPI_Status *status);
int mca_io_romio_File_read_ordered_begin(MPI_File fh, void *buf, int count,
MPI_Datatype datatype);
int mca_io_romio_File_read_ordered_end(MPI_File fh, void *buf, MPI_Status *status);
int mca_io_romio_File_write_ordered_begin(MPI_File fh, void *buf, int count,
MPI_Datatype datatype);
int mca_io_romio_File_write_ordered_end(MPI_File fh, void *buf, MPI_Status *status);
/* Section 9.5.1 */
int mca_io_romio_File_get_type_extent(MPI_File fh, MPI_Datatype datatype,
MPI_Aint *extent);
/* Section 9.6.1 */
int mca_io_romio_File_set_atomicity(MPI_File fh, int flag);
int mca_io_romio_File_get_atomicity(MPI_File fh, int *flag);
int mca_io_romio_File_sync(MPI_File fh);
/* Section 4.13.3 */
int mca_io_romio_File_set_errhandler( MPI_File, MPI_Errhandler );
int mca_io_romio_File_get_errhandler( MPI_File, MPI_Errhandler * );
/* End Prototypes */
/* The funtions will not be called by users, but by OMPI's MPI_Test/Wait
* functions when they are called with an I/O request. */
int mca_io_romio_Test(MPI_Request *request, int *flag, MPI_Status *status);
int mca_io_romio_Wait(MPI_Request *request, MPI_Status *status);
#endif /* MCA_IO_ROMIO_H */

70
src/mca/io/romio/src/io_romio_module.c
Просмотреть файл

@ -1,70 +0,0 @@
/*
* $HEADER$
*/
#include "mpi.h"
#include "mca/io/io.h"
#include "io_romio.h"
int mca_io_romio_module_open(void);
int mca_io_romio_module_close(void);
mca_io_1_0_0_t* mca_io_romio_module_init(int* priority, int* min_thread, int* max_thread);
mca_io_base_module_1_0_0_t mca_io_romio_module = {
/* First, the mca_base_module_t struct containing meta information
about the module itself */
{
/* Indicate that we are a io v1.0.0 module (which also implies a
specific MCA version) */
MCA_IO_BASE_VERSION_1_0_0,
"romio", /* MCA module name */
1, /* MCA module major version */
0, /* MCA module minor version */
0, /* MCA module release version */
mca_io_romio_module_open, /* module open */
mca_io_romio_module_close /* module close */
},
/* Next the MCA v1.0.0 module meta data */
{
/* Whether the module is checkpointable or not */
false
},
mca_io_romio_module_init /* module init */
};
int mca_io_romio_module_open(void)
{
return OMPI_SUCCESS;
/* register all mca parameters */
}
int mca_io_romio_module_close(void)
{
return OMPI_SUCCESS;
}
mca_io_1_0_0_t* mca_io_romio_module_init(int* priority, int* min_thread, int* max_thread)
{
*priority=10;
*min_thread = MPI_THREAD_SINGLE;
*max_thread = MPI_THREAD_SERIALIZED;
return &romio_actions;
}

8
src/mca/io/romio/src/romio-1.2.5.1/Makefile.am
Просмотреть файл

@ -1,8 +0,0 @@
# -*- makefile -*-
#
# $HEADER$
#
include $(top_ompi_srcdir)/config/Makefile.options
SUBDIRS = include

8
src/mca/io/romio/src/romio-1.2.5.1/include/Makefile.am
Просмотреть файл

@ -1,8 +0,0 @@
# -*- makefile -*-
#
# $HEADER$
#
include $(top_ompi_srcdir)/config/Makefile.options
noinst_HEADERS = mpio.h

147
src/mca/io/romio/src/romio-1.2.5.1/include/mpio.h
Просмотреть файл

@ -1,147 +0,0 @@
/*
* $HEADER
*
* The actual ROMIO routines.
* all of these routines have been renamed: prefix with "mca_io_romio"
*
* Two ROMIO specific types have also been renamed: (cant do this with #define
* since this file is included by OMPI's I/O module)
* all ROMIO references to:
* MPIO_Request changed to: mca_io_romio_MPIO_Request
* MPI_File changed to: mca_io_romio_MPI_File
*
* All other types have been deleted, since they appear in OMPI's mpi.h
*
*/
#ifndef MCA_IO_ROMIO_DUMMY_H
#define MCA_IO_ROMIO_DUMMY_H
typedef struct ADIOI_FileD *mca_io_romio_MPI_File;
typedef struct ADIOI_RequestD *mca_io_romio_MPIO_Request;
/* Section 9.2 */
int mca_io_romio_MPI_File_open(MPI_Comm comm, char *filename, int amode,
MPI_Info info, mca_io_romio_MPI_File *fh);
int mca_io_romio_MPI_File_close(mca_io_romio_MPI_File *fh);
int mca_io_romio_MPI_File_delete(char *filename, MPI_Info info);
int mca_io_romio_MPI_File_set_size(mca_io_romio_MPI_File fh, MPI_Offset size);
int mca_io_romio_MPI_File_preallocate(mca_io_romio_MPI_File fh, MPI_Offset size);
int mca_io_romio_MPI_File_get_size(mca_io_romio_MPI_File fh, MPI_Offset *size);
int mca_io_romio_MPI_File_get_group(mca_io_romio_MPI_File fh, MPI_Group *group);
int mca_io_romio_MPI_File_get_amode(mca_io_romio_MPI_File fh, int *amode);
int mca_io_romio_MPI_File_set_info(mca_io_romio_MPI_File fh, MPI_Info info);
int mca_io_romio_MPI_File_get_info(mca_io_romio_MPI_File fh, MPI_Info *info_used);
/* Section 9.3 */
int mca_io_romio_MPI_File_set_view(mca_io_romio_MPI_File fh, MPI_Offset disp, MPI_Datatype etype,
MPI_Datatype filetype, char *datarep, MPI_Info info);
int mca_io_romio_MPI_File_get_view(mca_io_romio_MPI_File fh, MPI_Offset *disp,
MPI_Datatype *etype, MPI_Datatype *filetype, char *datarep);
/* Section 9.4.2 */
int mca_io_romio_MPI_File_read_at(mca_io_romio_MPI_File fh, MPI_Offset offset, void *buf,
int count, MPI_Datatype datatype, MPI_Status *status);
int mca_io_romio_MPI_File_read_at_all(mca_io_romio_MPI_File fh, MPI_Offset offset, void *buf,
int count, MPI_Datatype datatype, MPI_Status *status);
int mca_io_romio_MPI_File_write_at(mca_io_romio_MPI_File fh, MPI_Offset offset, void *buf,
int count, MPI_Datatype datatype, MPI_Status *status);
int mca_io_romio_MPI_File_write_at_all(mca_io_romio_MPI_File fh, MPI_Offset offset, void *buf,
int count, MPI_Datatype datatype, MPI_Status *status);
int mca_io_romio_MPI_File_iread_at(mca_io_romio_MPI_File fh, MPI_Offset offset, void *buf,
int count, MPI_Datatype datatype, mca_io_romio_MPIO_Request *request);
int mca_io_romio_MPI_File_iwrite_at(mca_io_romio_MPI_File fh, MPI_Offset offset, void *buf,
int count, MPI_Datatype datatype, mca_io_romio_MPIO_Request *request);
/* Section 9.4.3 */
int mca_io_romio_MPI_File_read(mca_io_romio_MPI_File fh, void *buf, int count, MPI_Datatype
datatype, MPI_Status *status);
int mca_io_romio_MPI_File_read_all(mca_io_romio_MPI_File fh, void *buf, int count, MPI_Datatype
datatype, MPI_Status *status);
int mca_io_romio_MPI_File_write(mca_io_romio_MPI_File fh, void *buf, int count, MPI_Datatype
datatype, MPI_Status *status);
int mca_io_romio_MPI_File_write_all(mca_io_romio_MPI_File fh, void *buf, int count, MPI_Datatype
datatype, MPI_Status *status);
int mca_io_romio_MPI_File_iread(mca_io_romio_MPI_File fh, void *buf, int count, MPI_Datatype
datatype, mca_io_romio_MPIO_Request *request);
int mca_io_romio_MPI_File_iwrite(mca_io_romio_MPI_File fh, void *buf, int count,
MPI_Datatype datatype, mca_io_romio_MPIO_Request *request);
int mca_io_romio_MPI_File_seek(mca_io_romio_MPI_File fh, MPI_Offset offset, int whence);
int mca_io_romio_MPI_File_get_position(mca_io_romio_MPI_File fh, MPI_Offset *offset);
int mca_io_romio_MPI_File_get_byte_offset(mca_io_romio_MPI_File fh, MPI_Offset offset,
MPI_Offset *disp);
/* Section 9.4.4 */
int mca_io_romio_MPI_File_read_shared(mca_io_romio_MPI_File fh, void *buf, int count,
MPI_Datatype datatype, MPI_Status *status);
int mca_io_romio_MPI_File_write_shared(mca_io_romio_MPI_File fh, void *buf, int count,
MPI_Datatype datatype, MPI_Status *status);
int mca_io_romio_MPI_File_iread_shared(mca_io_romio_MPI_File fh, void *buf, int count,
MPI_Datatype datatype, mca_io_romio_MPIO_Request *request);
int mca_io_romio_MPI_File_iwrite_shared(mca_io_romio_MPI_File fh, void *buf, int count,
MPI_Datatype datatype, mca_io_romio_MPIO_Request *request);
int mca_io_romio_MPI_File_read_ordered(mca_io_romio_MPI_File fh, void *buf, int count,
MPI_Datatype datatype, MPI_Status *status);
int mca_io_romio_MPI_File_write_ordered(mca_io_romio_MPI_File fh, void *buf, int count,
MPI_Datatype datatype, MPI_Status *status);
int mca_io_romio_MPI_File_seek_shared(mca_io_romio_MPI_File fh, MPI_Offset offset, int whence);
int mca_io_romio_MPI_File_get_position_shared(mca_io_romio_MPI_File fh, MPI_Offset *offset);
/* Section 9.4.5 */
int mca_io_romio_MPI_File_read_at_all_begin(mca_io_romio_MPI_File fh, MPI_Offset offset, void *buf,
int count, MPI_Datatype datatype);
int mca_io_romio_MPI_File_read_at_all_end(mca_io_romio_MPI_File fh, void *buf, MPI_Status *status);
int mca_io_romio_MPI_File_write_at_all_begin(mca_io_romio_MPI_File fh, MPI_Offset offset, void *buf,
int count, MPI_Datatype datatype);
int mca_io_romio_MPI_File_write_at_all_end(mca_io_romio_MPI_File fh, void *buf, MPI_Status *status);
int mca_io_romio_MPI_File_read_all_begin(mca_io_romio_MPI_File fh, void *buf, int count,
MPI_Datatype datatype);
int mca_io_romio_MPI_File_read_all_end(mca_io_romio_MPI_File fh, void *buf, MPI_Status *status);
int mca_io_romio_MPI_File_write_all_begin(mca_io_romio_MPI_File fh, void *buf, int count,
MPI_Datatype datatype);
int mca_io_romio_MPI_File_write_all_end(mca_io_romio_MPI_File fh, void *buf, MPI_Status *status);
int mca_io_romio_MPI_File_read_ordered_begin(mca_io_romio_MPI_File fh, void *buf, int count,
MPI_Datatype datatype);
int mca_io_romio_MPI_File_read_ordered_end(mca_io_romio_MPI_File fh, void *buf, MPI_Status *status);
int mca_io_romio_MPI_File_write_ordered_begin(mca_io_romio_MPI_File fh, void *buf, int count,
MPI_Datatype datatype);
int mca_io_romio_MPI_File_write_ordered_end(mca_io_romio_MPI_File fh, void *buf, MPI_Status *status);
/* Section 9.5.1 */
int mca_io_romio_MPI_File_get_type_extent(mca_io_romio_MPI_File fh, MPI_Datatype datatype,
MPI_Aint *extent);
/* Section 9.6.1 */
int mca_io_romio_MPI_File_set_atomicity(mca_io_romio_MPI_File fh, int flag);
int mca_io_romio_MPI_File_get_atomicity(mca_io_romio_MPI_File fh, int *flag);
int mca_io_romio_MPI_File_sync(mca_io_romio_MPI_File fh);
/* Section 4.13.3 */
int mca_io_romio_MPI_File_set_errhandler(mca_io_romio_MPI_File, MPI_Errhandler );
int mca_io_romio_MPI_File_get_errhandler(mca_io_romio_MPI_File, MPI_Errhandler * );
/* End Prototypes */
int mca_io_romio_MPIO_Test(mca_io_romio_MPIO_Request *request, int *flag, MPI_Status *status);
int mca_io_romio_MPIO_Wait(mca_io_romio_MPIO_Request *request, MPI_Status *status);
MPI_Fint mca_io_romio_MPIO_Request_c2f(mca_io_romio_MPIO_Request request);
mca_io_romio_MPIO_Request mca_io_romio_MPIO_Request_f2c(MPI_Fint request);
#endif