mumps_io.h File Reference

#include "mumps_common.h"
#include "mumps_c_types.h"

Go to the source code of this file.

Macros
#define	MUMPS_OOC_PREFIX_MAX_LENGTH   63
#define	MUMPS_OOC_TMPDIR_MAX_LENGTH   255
#define	MUMPS_DUMPRHSBINARY_C    F_SYMBOL(dumprhsbinary_c,DUMPRHSBINARY_C)
#define	MUMPS_DUMPMATBINARY_C    F_SYMBOL(dumpmatbinary_c,DUMPMATBINARY_C)
#define	MUMPS_LOW_LEVEL_INIT_PREFIX    F_SYMBOL(low_level_init_prefix,LOW_LEVEL_INIT_PREFIX)
#define	MUMPS_LOW_LEVEL_INIT_TMPDIR    F_SYMBOL(low_level_init_tmpdir,LOW_LEVEL_INIT_TMPDIR)
#define	MUMPS_LOW_LEVEL_INIT_OOC_C    F_SYMBOL(low_level_init_ooc_c,LOW_LEVEL_INIT_OOC_C)
#define	MUMPS_TEST_REQUEST_C    F_SYMBOL(test_request_c,TEST_REQUEST_C)
#define	MUMPS_WAIT_REQUEST    F_SYMBOL(wait_request,WAIT_REQUEST)
#define	MUMPS_LOW_LEVEL_WRITE_OOC_C    F_SYMBOL(low_level_write_ooc_c,LOW_LEVEL_WRITE_OOC_C)
#define	MUMPS_LOW_LEVEL_READ_OOC_C    F_SYMBOL(low_level_read_ooc_c,LOW_LEVEL_READ_OOC_C)
#define	MUMPS_LOW_LEVEL_DIRECT_READ    F_SYMBOL(low_level_direct_read,LOW_LEVEL_DIRECT_READ)
#define	MUMPS_CLEAN_IO_DATA_C    F_SYMBOL(clean_io_data_c,CLEAN_IO_DATA_C)
#define	MUMPS_GET_MAX_NB_REQ_C    F_SYMBOL(get_max_nb_req_c,GET_MAX_NB_REQ_C)
#define	MUMPS_GET_MAX_FILE_SIZE_C    F_SYMBOL(get_max_file_size_c,GET_MAX_FILE_SIZE_C)
#define	MUMPS_OOC_GET_NB_FILES_C    F_SYMBOL(ooc_get_nb_files_c,OOC_GET_NB_FILES_C)
#define	MUMPS_OOC_GET_FILE_NAME_C    F_SYMBOL(ooc_get_file_name_c,OOC_GET_FILE_NAME_C)
#define	MUMPS_OOC_SET_FILE_NAME_C    F_SYMBOL(ooc_set_file_name_c,OOC_SET_FILE_NAME_C)
#define	MUMPS_OOC_ALLOC_POINTERS_C    F_SYMBOL(ooc_alloc_pointers_c,OOC_ALLOC_POINTERS_C)
#define	MUMPS_OOC_INIT_VARS_C    F_SYMBOL(ooc_init_vars_c,OOC_INIT_VARS_C)
#define	MUMPS_OOC_START_LOW_LEVEL    F_SYMBOL(ooc_start_low_level,OOC_START_LOW_LEVEL)
#define	MUMPS_OOC_PRINT_STATS    F_SYMBOL(ooc_print_stats,OOC_PRINT_STATS)
#define	MUMPS_OOC_REMOVE_FILE_C    F_SYMBOL(ooc_remove_file_c,OOC_REMOVE_FILE_C)
#define	MUMPS_OOC_END_WRITE_C    F_SYMBOL(ooc_end_write_c,OOC_END_WRITE_C)
#define	MUMPS_OOC_IS_ASYNC_AVAIL    F_SYMBOL(ooc_is_async_avail,OOC_IS_ASYNC_AVAIL)

Functions
void MUMPS_CALL	MUMPS_DUMPRHSBINARY_C (MUMPS_INT *N, MUMPS_INT *NRHS, MUMPS_INT *LRHS, float *RHS, MUMPS_INT *K35, char *filename, mumps_ftnlen l1)
void MUMPS_CALL	MUMPS_DUMPMATBINARY_C (MUMPS_INT *N, MUMPS_INT8 *NNZ, MUMPS_INT *K35, MUMPS_INT *irn, MUMPS_INT *jcn, void *A, MUMPS_INT *is_A_provided, char *file_name, mumps_ftnlen l1)
void MUMPS_CALL	MUMPS_LOW_LEVEL_INIT_PREFIX (MUMPS_INT *dim, char *str, mumps_ftnlen l1)
void MUMPS_CALL	MUMPS_LOW_LEVEL_INIT_TMPDIR (MUMPS_INT *dim, char *str, mumps_ftnlen l1)
MUMPS_INLINE MUMPS_INT	mumps_convert_2fint_to_longlong (MUMPS_INT *, MUMPS_INT *, long long *)
void MUMPS_CALL	MUMPS_LOW_LEVEL_INIT_OOC_C (MUMPS_INT *_myid, MUMPS_INT *total_size_io, MUMPS_INT *size_element, MUMPS_INT *async, MUMPS_INT *k211, MUMPS_INT *nb_file_type, MUMPS_INT *flag_tab, MUMPS_INT *ierr)
void MUMPS_CALL	MUMPS_TEST_REQUEST_C (MUMPS_INT *request_id, MUMPS_INT *flag, MUMPS_INT *ierr)
void MUMPS_CALL	MUMPS_WAIT_REQUEST (MUMPS_INT *request_id, MUMPS_INT *ierr)
void MUMPS_CALL	MUMPS_LOW_LEVEL_WRITE_OOC_C (const MUMPS_INT *strat_IO, void *address_block, MUMPS_INT *block_size_int1, MUMPS_INT *block_size_int2, MUMPS_INT *inode, MUMPS_INT *request_arg, MUMPS_INT *type, MUMPS_INT *vaddr_int1, MUMPS_INT *vaddr_int2, MUMPS_INT *ierr)
void MUMPS_CALL	MUMPS_LOW_LEVEL_READ_OOC_C (const MUMPS_INT *strat_IO, void *address_block, MUMPS_INT *block_size_int1, MUMPS_INT *block_size_int2, MUMPS_INT *inode, MUMPS_INT *request_arg, MUMPS_INT *type, MUMPS_INT *vaddr_int1, MUMPS_INT *vaddr_int2, MUMPS_INT *ierr)
void MUMPS_CALL	MUMPS_LOW_LEVEL_DIRECT_READ (void *address_block, MUMPS_INT *block_size_int1, MUMPS_INT *block_size_int2, MUMPS_INT *type, MUMPS_INT *vaddr_int1, MUMPS_INT *vaddr_int2, MUMPS_INT *ierr)
void MUMPS_CALL	MUMPS_CLEAN_IO_DATA_C (MUMPS_INT *myid, MUMPS_INT *step, MUMPS_INT *ierr)
void MUMPS_CALL	MUMPS_GET_MAX_NB_REQ_C (MUMPS_INT *max, MUMPS_INT *ierr)
void MUMPS_CALL	MUMPS_GET_MAX_FILE_SIZE_C (double *max_ooc_file_size)
void MUMPS_CALL	MUMPS_OOC_GET_NB_FILES_C (const MUMPS_INT *type, MUMPS_INT *nb_files)
void MUMPS_CALL	MUMPS_OOC_GET_FILE_NAME_C (MUMPS_INT *type, MUMPS_INT *indice, MUMPS_INT *length, char *name, mumps_ftnlen l1)
void MUMPS_CALL	MUMPS_OOC_SET_FILE_NAME_C (MUMPS_INT *type, MUMPS_INT *indice, MUMPS_INT *length, MUMPS_INT *ierr, char *name, mumps_ftnlen l1)
void MUMPS_CALL	MUMPS_OOC_ALLOC_POINTERS_C (MUMPS_INT *nb_file_type, MUMPS_INT *dim, MUMPS_INT *ierr)
void MUMPS_CALL	MUMPS_OOC_INIT_VARS_C (MUMPS_INT *myid_arg, MUMPS_INT *size_element, MUMPS_INT *async, MUMPS_INT *k211, MUMPS_INT *ierr)
void MUMPS_CALL	MUMPS_OOC_START_LOW_LEVEL (MUMPS_INT *ierr)
void MUMPS_CALL	MUMPS_OOC_REMOVE_FILE_C (MUMPS_INT *ierr, char *name, mumps_ftnlen l1)
void MUMPS_CALL	MUMPS_OOC_END_WRITE_C (MUMPS_INT *ierr)
void MUMPS_CALL	MUMPS_OOC_IS_ASYNC_AVAIL (MUMPS_INT *flag)

Variables
static char	MUMPS_OOC_STORE_PREFIX [MUMPS_OOC_PREFIX_MAX_LENGTH]
static MUMPS_INT	MUMPS_OOC_STORE_PREFIXLEN =-1
static char	MUMPS_OOC_STORE_TMPDIR [MUMPS_OOC_TMPDIR_MAX_LENGTH]
static MUMPS_INT	MUMPS_OOC_STORE_TMPDIRLEN =-1

Macro Definition Documentation

MUMPS_CLEAN_IO_DATA_C

#define MUMPS_CLEAN_IO_DATA_C    F_SYMBOL(clean_io_data_c,CLEAN_IO_DATA_C)

Definition at line 106 of file mumps_io.h.

#define MUMPS_CLEAN_IO_DATA_C \
    F_SYMBOL(clean_io_data_c,CLEAN_IO_DATA_C)

MUMPS_DUMPMATBINARY_C

#define MUMPS_DUMPMATBINARY_C    F_SYMBOL(dumpmatbinary_c,DUMPMATBINARY_C)

Definition at line 40 of file mumps_io.h.

#define MUMPS_DUMPMATBINARY_C \
    F_SYMBOL(dumpmatbinary_c,DUMPMATBINARY_C)

MUMPS_DUMPRHSBINARY_C

#define MUMPS_DUMPRHSBINARY_C    F_SYMBOL(dumprhsbinary_c,DUMPRHSBINARY_C)

Definition at line 35 of file mumps_io.h.

#define MUMPS_DUMPRHSBINARY_C \
    F_SYMBOL(dumprhsbinary_c,DUMPRHSBINARY_C)

MUMPS_GET_MAX_FILE_SIZE_C

#define MUMPS_GET_MAX_FILE_SIZE_C    F_SYMBOL(get_max_file_size_c,GET_MAX_FILE_SIZE_C)

Definition at line 114 of file mumps_io.h.

#define MUMPS_GET_MAX_FILE_SIZE_C \
    F_SYMBOL(get_max_file_size_c,GET_MAX_FILE_SIZE_C)

MUMPS_GET_MAX_NB_REQ_C

#define MUMPS_GET_MAX_NB_REQ_C    F_SYMBOL(get_max_nb_req_c,GET_MAX_NB_REQ_C)

Definition at line 110 of file mumps_io.h.

#define MUMPS_GET_MAX_NB_REQ_C \
    F_SYMBOL(get_max_nb_req_c,GET_MAX_NB_REQ_C)

MUMPS_LOW_LEVEL_DIRECT_READ

#define MUMPS_LOW_LEVEL_DIRECT_READ    F_SYMBOL(low_level_direct_read,LOW_LEVEL_DIRECT_READ)

Definition at line 96 of file mumps_io.h.

#define MUMPS_LOW_LEVEL_DIRECT_READ \
    F_SYMBOL(low_level_direct_read,LOW_LEVEL_DIRECT_READ)

MUMPS_LOW_LEVEL_INIT_OOC_C

#define MUMPS_LOW_LEVEL_INIT_OOC_C    F_SYMBOL(low_level_init_ooc_c,LOW_LEVEL_INIT_OOC_C)

Definition at line 56 of file mumps_io.h.

#define MUMPS_LOW_LEVEL_INIT_OOC_C \
    F_SYMBOL(low_level_init_ooc_c,LOW_LEVEL_INIT_OOC_C)

MUMPS_LOW_LEVEL_INIT_PREFIX

#define MUMPS_LOW_LEVEL_INIT_PREFIX    F_SYMBOL(low_level_init_prefix,LOW_LEVEL_INIT_PREFIX)

Definition at line 46 of file mumps_io.h.

#define MUMPS_LOW_LEVEL_INIT_PREFIX \
    F_SYMBOL(low_level_init_prefix,LOW_LEVEL_INIT_PREFIX)

MUMPS_LOW_LEVEL_INIT_TMPDIR

#define MUMPS_LOW_LEVEL_INIT_TMPDIR    F_SYMBOL(low_level_init_tmpdir,LOW_LEVEL_INIT_TMPDIR)

Definition at line 50 of file mumps_io.h.

#define MUMPS_LOW_LEVEL_INIT_TMPDIR \
    F_SYMBOL(low_level_init_tmpdir,LOW_LEVEL_INIT_TMPDIR)

MUMPS_LOW_LEVEL_READ_OOC_C

#define MUMPS_LOW_LEVEL_READ_OOC_C    F_SYMBOL(low_level_read_ooc_c,LOW_LEVEL_READ_OOC_C)

Definition at line 83 of file mumps_io.h.

#define MUMPS_LOW_LEVEL_READ_OOC_C \
    F_SYMBOL(low_level_read_ooc_c,LOW_LEVEL_READ_OOC_C)

MUMPS_LOW_LEVEL_WRITE_OOC_C

#define MUMPS_LOW_LEVEL_WRITE_OOC_C    F_SYMBOL(low_level_write_ooc_c,LOW_LEVEL_WRITE_OOC_C)

Definition at line 70 of file mumps_io.h.

#define MUMPS_LOW_LEVEL_WRITE_OOC_C \
    F_SYMBOL(low_level_write_ooc_c,LOW_LEVEL_WRITE_OOC_C)

MUMPS_OOC_ALLOC_POINTERS_C

#define MUMPS_OOC_ALLOC_POINTERS_C    F_SYMBOL(ooc_alloc_pointers_c,OOC_ALLOC_POINTERS_C)

Definition at line 132 of file mumps_io.h.

#define MUMPS_OOC_ALLOC_POINTERS_C \
    F_SYMBOL(ooc_alloc_pointers_c,OOC_ALLOC_POINTERS_C)

MUMPS_OOC_END_WRITE_C

#define MUMPS_OOC_END_WRITE_C    F_SYMBOL(ooc_end_write_c,OOC_END_WRITE_C)

Definition at line 153 of file mumps_io.h.

#define MUMPS_OOC_END_WRITE_C \
    F_SYMBOL(ooc_end_write_c,OOC_END_WRITE_C)

MUMPS_OOC_GET_FILE_NAME_C

#define MUMPS_OOC_GET_FILE_NAME_C    F_SYMBOL(ooc_get_file_name_c,OOC_GET_FILE_NAME_C)

Definition at line 122 of file mumps_io.h.

#define MUMPS_OOC_GET_FILE_NAME_C \
    F_SYMBOL(ooc_get_file_name_c,OOC_GET_FILE_NAME_C)

MUMPS_OOC_GET_NB_FILES_C

#define MUMPS_OOC_GET_NB_FILES_C    F_SYMBOL(ooc_get_nb_files_c,OOC_GET_NB_FILES_C)

Definition at line 118 of file mumps_io.h.

#define MUMPS_OOC_GET_NB_FILES_C \
    F_SYMBOL(ooc_get_nb_files_c,OOC_GET_NB_FILES_C)

MUMPS_OOC_INIT_VARS_C

#define MUMPS_OOC_INIT_VARS_C    F_SYMBOL(ooc_init_vars_c,OOC_INIT_VARS_C)

Definition at line 136 of file mumps_io.h.

#define MUMPS_OOC_INIT_VARS_C \
    F_SYMBOL(ooc_init_vars_c,OOC_INIT_VARS_C)

MUMPS_OOC_IS_ASYNC_AVAIL

#define MUMPS_OOC_IS_ASYNC_AVAIL    F_SYMBOL(ooc_is_async_avail,OOC_IS_ASYNC_AVAIL)

Definition at line 157 of file mumps_io.h.

#define MUMPS_OOC_IS_ASYNC_AVAIL \
    F_SYMBOL(ooc_is_async_avail,OOC_IS_ASYNC_AVAIL)

MUMPS_OOC_PREFIX_MAX_LENGTH

#define MUMPS_OOC_PREFIX_MAX_LENGTH   63

Definition at line 29 of file mumps_io.h.

MUMPS_OOC_PRINT_STATS

void MUMPS_CALL MUMPS_OOC_PRINT_STATS    F_SYMBOL(ooc_print_stats,OOC_PRINT_STATS)

Definition at line 145 of file mumps_io.h.

#define MUMPS_OOC_PRINT_STATS \
    F_SYMBOL(ooc_print_stats,OOC_PRINT_STATS)

MUMPS_OOC_REMOVE_FILE_C

#define MUMPS_OOC_REMOVE_FILE_C    F_SYMBOL(ooc_remove_file_c,OOC_REMOVE_FILE_C)

Definition at line 149 of file mumps_io.h.

#define MUMPS_OOC_REMOVE_FILE_C \
    F_SYMBOL(ooc_remove_file_c,OOC_REMOVE_FILE_C)

MUMPS_OOC_SET_FILE_NAME_C

#define MUMPS_OOC_SET_FILE_NAME_C    F_SYMBOL(ooc_set_file_name_c,OOC_SET_FILE_NAME_C)

Definition at line 127 of file mumps_io.h.

#define MUMPS_OOC_SET_FILE_NAME_C \
    F_SYMBOL(ooc_set_file_name_c,OOC_SET_FILE_NAME_C)

MUMPS_OOC_START_LOW_LEVEL

#define MUMPS_OOC_START_LOW_LEVEL    F_SYMBOL(ooc_start_low_level,OOC_START_LOW_LEVEL)

Definition at line 141 of file mumps_io.h.

#define MUMPS_OOC_START_LOW_LEVEL \
    F_SYMBOL(ooc_start_low_level,OOC_START_LOW_LEVEL)

MUMPS_OOC_TMPDIR_MAX_LENGTH

#define MUMPS_OOC_TMPDIR_MAX_LENGTH   255

Definition at line 30 of file mumps_io.h.

MUMPS_TEST_REQUEST_C

#define MUMPS_TEST_REQUEST_C    F_SYMBOL(test_request_c,TEST_REQUEST_C)

Definition at line 62 of file mumps_io.h.

#define MUMPS_TEST_REQUEST_C \
    F_SYMBOL(test_request_c,TEST_REQUEST_C)

MUMPS_WAIT_REQUEST

#define MUMPS_WAIT_REQUEST    F_SYMBOL(wait_request,WAIT_REQUEST)

Definition at line 66 of file mumps_io.h.

#define MUMPS_WAIT_REQUEST \
    F_SYMBOL(wait_request,WAIT_REQUEST)

Function Documentation

MUMPS_CLEAN_IO_DATA_C()

void MUMPS_CALL MUMPS_CLEAN_IO_DATA_C	(	MUMPS_INT *	myid,
		MUMPS_INT *	step,
		MUMPS_INT *	ierr )

Definition at line 463 of file mumps_io.c.

{
  char buf[64]; /* for error message */
  MUMPS_INT step_loc,myid_loc,ierr_loc;
  step_loc=(MUMPS_INT)*step;
  myid_loc=(MUMPS_INT)*myid;
  if(!mumps_io_is_init_called){
    return;
  }
  switch(mumps_io_flag_async){
  case IO_SYNC:
    break;
#if ! defined(MUMPS_WIN32) && ! defined(WITHOUT_PTHREAD)
  case IO_ASYNC_TH:
    ierr_loc=mumps_clean_io_data_c_th(&myid_loc);
    *ierr=(MUMPS_INT)ierr_loc;
    break;
#endif
  default:
    *ierr=-91;
    sprintf(buf,"Error: unknown I/O strategy : %d\n",(int)mumps_io_flag_async);
    mumps_io_error((MUMPS_INT)*ierr,buf);
    return;
  }
  mumps_free_file_pointers(&step_loc);
  mumps_io_is_init_called=0;
  return;
}

mumps_convert_2fint_to_longlong()

MUMPS_INLINE MUMPS_INT mumps_convert_2fint_to_longlong	(	MUMPS_INT *	short_int1,
		MUMPS_INT *	short_int2,
		long long *	long_int )

IMPORTANT:

After every modification of the code of convert_2fint_to_longlong update the corresponding fortran subroutines MUMPS_OOC_CONVERT_2INTTOVADDR and MUMPS_OOC_CONVERT_VADDRTO2INT

Definition at line 668 of file mumps_io.c.

{
  *long_int=((long long)(*short_int1)*((long long)1073741824))+(long long)(*short_int2);
  return 0;
}

MUMPS_DUMPMATBINARY_C()

void MUMPS_CALL MUMPS_DUMPMATBINARY_C	(	MUMPS_INT *	N,
		MUMPS_INT8 *	NNZ,
		MUMPS_INT *	K35,
		MUMPS_INT *	irn,
		MUMPS_INT *	jcn,
		void *	A,
		MUMPS_INT *	is_A_provided,
		char *	file_name,
		mumps_ftnlen	l1 )

Definition at line 43 of file mumps_io.c.

{
   int64_t i8;
   int32_t myN, tmpi;
   FILE *fd;
   fd=fopen(filename, "w");
   /* cast to int32_t in case MUMPS_INT is 64-bits */
   myN=(int32_t)(*N);
   fwrite( &myN, sizeof(int32_t), 1, fd);
   fwrite( NNZ, sizeof(int64_t), 1, fd);
   if (*NNZ > 0)
   {
     if ( sizeof(MUMPS_INT) == 4 )
     {
       /* write irn and jcn contents directly */
       fwrite( irn, sizeof(int32_t), (size_t)(*NNZ), fd);
       fwrite( jcn, sizeof(int32_t), (size_t)(*NNZ), fd);
     }
     else
     {
       for(i8=0;i8 < *NNZ;i8++)
       {
          tmpi=irn[i8];
          fwrite(&tmpi, sizeof(int32_t), 1, fd);
       }
       for(i8=0;i8 < *NNZ;i8++)
       {
          tmpi=jcn[i8];
          fwrite(&tmpi, sizeof(int32_t), 1, fd);
       }
     }
     if (*is_A_provided)
     {
       fwrite(A, (size_t)(*K35), (size_t)(*NNZ), fd);
     }
   }
   fclose(fd);
}

MUMPS_DUMPRHSBINARY_C()

void MUMPS_CALL MUMPS_DUMPRHSBINARY_C	(	MUMPS_INT *	N,
		MUMPS_INT *	NRHS,
		MUMPS_INT *	LRHS,
		float *	RHS,
		MUMPS_INT *	K35,
		char *	filename,
		mumps_ftnlen	l1 )

Definition at line 27 of file mumps_io.c.

{
   float *RHSshift; /* float: arbitrary, we use binary content */
   FILE *fd;
   int icol;
   fd=fopen(filename, "w");
   RHSshift=RHS;
   for(icol=0;icol<*NRHS;icol++)
   {
     fwrite(RHSshift, (size_t)(*K35), (size_t)(*N), fd);
     RHSshift=RHSshift+(size_t)(*LRHS)*(size_t)(*K35/sizeof(float));
   }
   fclose(fd);
}

MUMPS_GET_MAX_FILE_SIZE_C()

void MUMPS_CALL MUMPS_GET_MAX_FILE_SIZE_C

(

double *

max_ooc_file_size

)

Definition at line 526 of file mumps_io.c.

{
  *max_ooc_file_size=(double)(MAX_FILE_SIZE);
  return;
}

MUMPS_GET_MAX_NB_REQ_C()

void MUMPS_CALL MUMPS_GET_MAX_NB_REQ_C	(	MUMPS_INT *	max,
		MUMPS_INT *	ierr )

Definition at line 504 of file mumps_io.c.

{
  char buf[64]; /* for error message */
  *ierr=0;
  switch(mumps_io_flag_async){
  case IO_SYNC:
    *max=1;
    break;
#if ! defined(MUMPS_WIN32) && ! defined(WITHOUT_PTHREAD)
  case IO_ASYNC_TH:
    *max=MAX_FINISH_REQ+MAX_IO;
    break;
#endif
  default:
    *ierr=-91;
    sprintf(buf,"Error: unknown I/O strategy : %d\n",(int)mumps_io_flag_async);
    mumps_io_error((MUMPS_INT)*ierr,buf);
    return;
  }
  return;
}

MUMPS_LOW_LEVEL_DIRECT_READ()

void MUMPS_CALL MUMPS_LOW_LEVEL_DIRECT_READ	(	void *	address_block,
		MUMPS_INT *	block_size_int1,
		MUMPS_INT *	block_size_int2,
		MUMPS_INT *	type,
		MUMPS_INT *	vaddr_int1,
		MUMPS_INT *	vaddr_int2,
		MUMPS_INT *	ierr )

Definition at line 421 of file mumps_io.c.

{
    /*  MUMPS_INT ret_code=0; */
  long long vaddr,block_size;
  MUMPS_INT type_loc,ierr_loc;
#if ! defined(MUMPS_WIN32)
  struct timeval start_time,end_time;
  gettimeofday(&start_time,NULL);
#endif
  type_loc=(MUMPS_INT)*type;
  mumps_convert_2fint_to_longlong(vaddr_int1,vaddr_int2,&vaddr);
  mumps_convert_2fint_to_longlong(block_size_int1,block_size_int2,&block_size);
#if ! defined(MUMPS_WIN32) && ! defined(WITHOUT_PTHREAD)
    if(mumps_io_flag_async==IO_ASYNC_TH||mumps_io_flag_async==0)
#else
    if(mumps_io_flag_async==0)
#endif
    {
      ierr_loc=mumps_io_do_read_block(address_block,block_size,&type_loc,vaddr,&ierr_loc);
      *ierr=(MUMPS_INT)ierr_loc;
      if(*ierr<0){
         return;
      }
    } else {
    }
#if ! defined(MUMPS_WIN32)
# if ! defined(WITHOUT_PTHREAD)
# endif
  gettimeofday(&end_time,NULL);
  mumps_time_spent_in_sync=mumps_time_spent_in_sync+((double)end_time.tv_sec+((double)end_time.tv_usec/1000000))-((double)start_time.tv_sec+((double)start_time.tv_usec/1000000));
#endif
  read_op_vol=read_op_vol+((double)(block_size)*(double)mumps_elementary_data_size);
  return;
}

MUMPS_LOW_LEVEL_INIT_OOC_C()

void MUMPS_CALL MUMPS_LOW_LEVEL_INIT_OOC_C	(	MUMPS_INT *	_myid,
		MUMPS_INT *	total_size_io,
		MUMPS_INT *	size_element,
		MUMPS_INT *	async,
		MUMPS_INT *	k211,
		MUMPS_INT *	nb_file_type,
		MUMPS_INT *	flag_tab,
		MUMPS_INT *	ierr )

Definition at line 200 of file mumps_io.c.

{
  char buf[128]; /* for error message */
  MUMPS_INT myid_loc,async_loc,size_element_loc,nb_file_type_loc,*flag_tab_loc;
#if ! defined(MUMPS_WIN32) && ! defined(WITHOUT_PTHREAD)
  MUMPS_INT ierr_loc;
#endif
  long long total_size_io_loc;
  MUMPS_INT i;
  myid_loc=(MUMPS_INT)*_myid;
  async_loc=(MUMPS_INT)*async;
  total_size_io_loc=(long long)*total_size_io;
  size_element_loc=(MUMPS_INT)*size_element;
  nb_file_type_loc=(MUMPS_INT)*nb_file_type;
  flag_tab_loc=(MUMPS_INT *)malloc(nb_file_type_loc*sizeof(MUMPS_INT));
  for (i=0;i<nb_file_type_loc;i++){
    flag_tab_loc[i]=(MUMPS_INT)flag_tab[i];
  }
#if defined(MUMPS_WIN32)
  if(async_loc==IO_ASYNC_AIO||async_loc==IO_ASYNC_TH){
    mumps_io_is_init_called=0;
    *ierr=-92;
    mumps_io_error((MUMPS_INT)*ierr,"Error: Forbidden value of Async flag with _WIN32\n");
    free(flag_tab_loc);
    return;
  }
#endif
#if defined (WITHOUT_PTHREAD)
  if(async_loc==IO_ASYNC_TH){
    mumps_io_is_init_called=0;
    *ierr=-92;
    mumps_io_error((MUMPS_INT)*ierr,"Error: Forbidden value of Async flag with WITHOUT_PTHREAD\n");
    free(flag_tab_loc);
    return;
  }
#endif
  total_vol=0;
  mumps_io_flag_async=async_loc;
  mumps_io_k211=(MUMPS_INT)*k211;
  if (MUMPS_OOC_STORE_PREFIXLEN==-1) {
    *ierr=-92;
    mumps_io_error((MUMPS_INT)*ierr,"Error: prefix not initialized\n");
    free(flag_tab_loc);
    return;
  }
  if (MUMPS_OOC_STORE_TMPDIRLEN==-1) {
    *ierr=-92;
    mumps_io_error((MUMPS_INT)*ierr,"Error: tmpdir not initialized\n");
    free(flag_tab_loc);
    return;
  }
  *ierr=(MUMPS_INT)mumps_init_file_name(MUMPS_OOC_STORE_TMPDIR, MUMPS_OOC_STORE_PREFIX,
                             &MUMPS_OOC_STORE_TMPDIRLEN, &MUMPS_OOC_STORE_PREFIXLEN, &myid_loc);
  if(*ierr<0){
    free(flag_tab_loc);
    return;
  }
  /* Re-initialize lenghts to -1 in order to enable the
   * check on initialization next time this routine is called
   */
  MUMPS_OOC_STORE_PREFIXLEN=-1;
  MUMPS_OOC_STORE_TMPDIRLEN=-1;
  *ierr=(MUMPS_INT)mumps_init_file_structure(&myid_loc,&total_size_io_loc,&size_element_loc,&nb_file_type_loc,flag_tab_loc);
  free(flag_tab_loc);
  if(*ierr<0){
    return;
  }
#if ! defined(MUMPS_WIN32)
  mumps_time_spent_in_sync=0;
#endif
  if(async_loc){
    switch(async_loc){
    case IO_SYNC:
      printf("mumps_low_level_init_ooc_c should not be called with strategy %d\n",(int)mumps_io_flag_async);
      break;
#if ! defined(MUMPS_WIN32) && ! defined(WITHOUT_PTHREAD)
    case IO_ASYNC_TH:
      mumps_low_level_init_ooc_c_th(&async_loc,&ierr_loc);
      *ierr=(MUMPS_INT)ierr_loc;
      if(*ierr<0){
        return;
      }
      break;
#endif
    default:
      *ierr=-92;
      sprintf(buf,"Error: unknown I/O strategy : %d\n",(int)*async);
      mumps_io_error((MUMPS_INT)*ierr,buf);
      return;
    }
  }
  mumps_io_is_init_called=1;
  return;
}

MUMPS_LOW_LEVEL_INIT_PREFIX()

void MUMPS_CALL MUMPS_LOW_LEVEL_INIT_PREFIX	(	MUMPS_INT *	dim,
		char *	str,
		mumps_ftnlen	l1 )

Inits the I/O OOC mechanism. Because on some computers, file size is limited, the I/O mechanism must be able to handle a multi-file access to data. Hence, we compute mumps_io_nb_file, which is the the number of files we estimate we need. Because of not exact matching between data packets written and size of files, the recoverment may be imperfect. Consequently, we must be able to reallocate if necessary.

Definition at line 173 of file mumps_io.c.

{
  MUMPS_INT i;
  MUMPS_OOC_STORE_PREFIXLEN = *dim;
  if( *dim > MUMPS_OOC_PREFIX_MAX_LENGTH )
      MUMPS_OOC_STORE_PREFIXLEN = MUMPS_OOC_PREFIX_MAX_LENGTH;
  for(i=0;i<MUMPS_OOC_STORE_PREFIXLEN;i++){
    MUMPS_OOC_STORE_PREFIX[i]=str[i];
  }
  return;
}

MUMPS_LOW_LEVEL_INIT_TMPDIR()

void MUMPS_CALL MUMPS_LOW_LEVEL_INIT_TMPDIR	(	MUMPS_INT *	dim,
		char *	str,
		mumps_ftnlen	l1 )

Definition at line 185 of file mumps_io.c.

{
  MUMPS_INT i;
  MUMPS_OOC_STORE_TMPDIRLEN=*dim;
  if( *dim > MUMPS_OOC_TMPDIR_MAX_LENGTH )
      MUMPS_OOC_STORE_TMPDIRLEN = MUMPS_OOC_TMPDIR_MAX_LENGTH;
  for(i=0;i<MUMPS_OOC_STORE_TMPDIRLEN;i++){
    MUMPS_OOC_STORE_TMPDIR[i]=str[i];
  }
  return;
}

MUMPS_LOW_LEVEL_READ_OOC_C()

void MUMPS_CALL MUMPS_LOW_LEVEL_READ_OOC_C	(	const MUMPS_INT *	strat_IO,
		void *	address_block,
		MUMPS_INT *	block_size_int1,
		MUMPS_INT *	block_size_int2,
		MUMPS_INT *	inode,
		MUMPS_INT *	request_arg,
		MUMPS_INT *	type,
		MUMPS_INT *	vaddr_int1,
		MUMPS_INT *	vaddr_int2,
		MUMPS_INT *	ierr )

Reads a contigous block of central memory from the disk.

Definition at line 367 of file mumps_io.c.

{
  char buf[64]; /* for error message */
  long long vaddr,block_size;
  MUMPS_INT inode_loc,request_arg_loc,type_loc,ierr_loc,strat_IO_loc;
#if ! defined(MUMPS_WIN32)
  struct timeval start_time,end_time;
  gettimeofday(&start_time,NULL);
#endif
  inode_loc=(MUMPS_INT)*inode;
  request_arg_loc=(MUMPS_INT)*request_arg;
  type_loc=(MUMPS_INT)*type;
  ierr_loc=(MUMPS_INT)*ierr;
  strat_IO_loc=(MUMPS_INT)*strat_IO;  
  mumps_convert_2fint_to_longlong(vaddr_int1,vaddr_int2,&vaddr);
  mumps_convert_2fint_to_longlong(block_size_int1,block_size_int2,&block_size);
  if(mumps_io_flag_async){
      switch(*strat_IO){
#if ! defined(MUMPS_WIN32) && ! defined(WITHOUT_PTHREAD)
      case IO_ASYNC_TH:
        mumps_async_read_th(&strat_IO_loc,address_block,block_size,&inode_loc,&request_arg_loc,&type_loc,vaddr,&ierr_loc);
        *ierr=(MUMPS_INT)ierr_loc;
        *request_arg=(MUMPS_INT)request_arg_loc;
        break;
#endif
      default:
        *ierr=-91;
        sprintf(buf,"Error: unknown I/O strategy : %d\n",(int)*strat_IO);
        mumps_io_error((MUMPS_INT)*ierr,buf);
        return;
      }
  }else{
    mumps_io_do_read_block(address_block,block_size,&type_loc,vaddr,&ierr_loc);
    *ierr=(MUMPS_INT)ierr_loc;
    *request_arg=1;
  }
#if ! defined(MUMPS_WIN32)
  gettimeofday(&end_time,NULL);
  mumps_time_spent_in_sync=mumps_time_spent_in_sync+((double)end_time.tv_sec+((double)end_time.tv_usec/1000000))-((double)start_time.tv_sec+((double)start_time.tv_usec/1000000));
#endif
  read_op_vol=read_op_vol+((double)(block_size)*(double)mumps_elementary_data_size);
  return;
}

MUMPS_LOW_LEVEL_WRITE_OOC_C()

void MUMPS_CALL MUMPS_LOW_LEVEL_WRITE_OOC_C	(	const MUMPS_INT *	strat_IO,
		void *	address_block,
		MUMPS_INT *	block_size_int1,
		MUMPS_INT *	block_size_int2,
		MUMPS_INT *	inode,
		MUMPS_INT *	request_arg,
		MUMPS_INT *	type,
		MUMPS_INT *	vaddr_int1,
		MUMPS_INT *	vaddr_int2,
		MUMPS_INT *	ierr )

Writes a contigous block of central memory to the disk.

Definition at line 300 of file mumps_io.c.

{
  MUMPS_INT ret_code=0;
  long long vaddr,block_size;
  char buf[64]; /* for error message */
  MUMPS_INT inode_loc,request_arg_loc,type_loc,ierr_loc,strat_IO_loc;
#if ! defined(MUMPS_WIN32)
  struct timeval start_time,end_time;
  gettimeofday(&start_time,NULL);
#endif
  inode_loc=(MUMPS_INT)*inode;
  request_arg_loc=(MUMPS_INT)*request_arg;
  type_loc=(MUMPS_INT)*type;
  ierr_loc=(MUMPS_INT)*ierr;
  strat_IO_loc=(MUMPS_INT)*strat_IO;
/* JY 27/2/08: initialize *request_arg to -1 (null request).
 * There were problems of uninitialized requests in the Fortran
 * code. For example when we use the synchronous version, there are
 * still some tests on *request_arg, which is not initialized.*/
  *request_arg=-1;
  mumps_convert_2fint_to_longlong(vaddr_int1,vaddr_int2,&vaddr);
  mumps_convert_2fint_to_longlong(block_size_int1,block_size_int2,&block_size);
  if(mumps_io_flag_async){
    switch(*strat_IO){
#if ! defined(MUMPS_WIN32) && ! defined(WITHOUT_PTHREAD)
    case IO_ASYNC_TH:
      ret_code=mumps_async_write_th(&strat_IO_loc, address_block, block_size,&inode_loc,&request_arg_loc,&type_loc,vaddr,&ierr_loc);
      *ierr=(MUMPS_INT)ierr_loc;
      *request_arg=(MUMPS_INT)request_arg_loc;
      if(ret_code<0){
        *ierr=ret_code;
      }
      break;
#endif
    default:
      *ierr=-91;
      sprintf(buf,"Error: unknown I/O strategy : %d\n",(int)*strat_IO);
      mumps_io_error((MUMPS_INT)*ierr,buf);
      return;
    }
  } else {
    ret_code=mumps_io_do_write_block(address_block,block_size,&type_loc,vaddr,&ierr_loc);
    *ierr=(MUMPS_INT)ierr_loc;
    if(ret_code<0){
      *ierr=ret_code;
    }
  }
#if ! defined(MUMPS_WIN32)
  gettimeofday(&end_time,NULL);
  mumps_time_spent_in_sync=mumps_time_spent_in_sync+((double)end_time.tv_sec+((double)end_time.tv_usec/1000000))-((double)start_time.tv_sec+((double)start_time.tv_usec/1000000));
#endif
  write_op_vol=write_op_vol+((double)(block_size)*(double)mumps_elementary_data_size);
  return;
}

MUMPS_OOC_ALLOC_POINTERS_C()

void MUMPS_CALL MUMPS_OOC_ALLOC_POINTERS_C	(	MUMPS_INT *	nb_file_type,
		MUMPS_INT *	dim,
		MUMPS_INT *	ierr )

Definition at line 562 of file mumps_io.c.

{
  MUMPS_INT i=0;
  MUMPS_INT nb_file_type_loc, *dim_loc;
  nb_file_type_loc=(MUMPS_INT)*nb_file_type;  
  dim_loc=(MUMPS_INT *)malloc(*nb_file_type*sizeof(MUMPS_INT));
  for(i=0;i<nb_file_type_loc;i++){
    dim_loc[i]=(MUMPS_INT)dim[i];
  }
  *ierr=(MUMPS_INT)mumps_io_alloc_pointers(&nb_file_type_loc,dim_loc);
  for(i=0;i<nb_file_type_loc;i++){
    mumps_io_set_last_file(dim_loc+i,&i);
  }
  free(dim_loc);
  return;
}

MUMPS_OOC_END_WRITE_C()

void MUMPS_CALL MUMPS_OOC_END_WRITE_C

(

MUMPS_INT *

ierr

)

Definition at line 646 of file mumps_io.c.

{
  return;
}

MUMPS_OOC_GET_FILE_NAME_C()

void MUMPS_CALL MUMPS_OOC_GET_FILE_NAME_C	(	MUMPS_INT *	type,
		MUMPS_INT *	indice,
		MUMPS_INT *	length,
		char *	name,
		mumps_ftnlen	l1 )

Definition at line 541 of file mumps_io.c.

{
  MUMPS_INT type_loc,indice_loc,length_loc;
  type_loc=(MUMPS_INT)*type;
  indice_loc=(MUMPS_INT)*indice;
  mumps_io_get_file_name(&indice_loc,name,&length_loc,&type_loc);
  *length=(MUMPS_INT)length_loc;
  return;
}

MUMPS_OOC_GET_NB_FILES_C()

void MUMPS_CALL MUMPS_OOC_GET_NB_FILES_C	(	const MUMPS_INT *	type,
		MUMPS_INT *	nb_files )

Definition at line 532 of file mumps_io.c.

{
  MUMPS_INT type_loc,nb_files_loc;
  type_loc=(MUMPS_INT)*type;
  mumps_io_get_nb_files(&nb_files_loc,&type_loc);
  *nb_files=(MUMPS_INT)nb_files_loc;
  return;
}

MUMPS_OOC_INIT_VARS_C()

void MUMPS_CALL MUMPS_OOC_INIT_VARS_C	(	MUMPS_INT *	myid_arg,
		MUMPS_INT *	size_element,
		MUMPS_INT *	async,
		MUMPS_INT *	k211,
		MUMPS_INT *	ierr )

Definition at line 579 of file mumps_io.c.

{
  MUMPS_INT size_element_loc,async_loc,myid_arg_loc;
#if ! defined(MUMPS_WIN32) && ! defined(WITHOUT_PTHREAD)
  mumps_time_spent_in_sync=0;
#endif
  mumps_io_k211=(MUMPS_INT)*k211;
  size_element_loc=(MUMPS_INT)*size_element;
  async_loc=(MUMPS_INT)*async;
  myid_arg_loc=(MUMPS_INT)*myid_arg;
  *ierr=(MUMPS_INT)mumps_io_init_vars(&myid_arg_loc,&size_element_loc,&async_loc);
  return;
}

MUMPS_OOC_IS_ASYNC_AVAIL()

void MUMPS_CALL MUMPS_OOC_IS_ASYNC_AVAIL

(

MUMPS_INT *

flag

)

Definition at line 651 of file mumps_io.c.

{
#if ( defined (WITHOUT_PTHREAD) || defined(MUMPS_WIN32) ) && ! defined(WITH_AIO)
  *flag=0;
#else
  *flag=1;
#endif
}

MUMPS_OOC_REMOVE_FILE_C()

void MUMPS_CALL MUMPS_OOC_REMOVE_FILE_C	(	MUMPS_INT *	ierr,
		char *	name,
		mumps_ftnlen	l1 )

Definition at line 629 of file mumps_io.c.

{
  char buf[256]; /* for error message, count 256 chars for name */
  *ierr=(MUMPS_INT)remove(name);
  if(*ierr<0){
#if ! defined(MUMPS_WIN32)
    sprintf(buf,"Unable to remove OOC file %s",name);
#else
    sprintf(buf,"Unable to remove OOC file %s with return value %d",name,*ierr);
#endif
    *ierr = -90;
    mumps_io_sys_error((MUMPS_INT)*ierr,buf);
    return;
  }
  return;
}

MUMPS_OOC_SET_FILE_NAME_C()

void MUMPS_CALL MUMPS_OOC_SET_FILE_NAME_C	(	MUMPS_INT *	type,
		MUMPS_INT *	indice,
		MUMPS_INT *	length,
		MUMPS_INT *	ierr,
		char *	name,
		mumps_ftnlen	l1 )

Definition at line 551 of file mumps_io.c.

{
  MUMPS_INT type_loc,indice_loc,length_loc;
  type_loc=(MUMPS_INT)*type;
  indice_loc=(MUMPS_INT)*indice;
  length_loc=(MUMPS_INT)*length;
  *ierr=(MUMPS_INT)mumps_io_set_file_name(&indice_loc,name,&length_loc,&type_loc);
  return;
}

MUMPS_OOC_START_LOW_LEVEL()

void MUMPS_CALL MUMPS_OOC_START_LOW_LEVEL

(

MUMPS_INT *

ierr

)

Definition at line 595 of file mumps_io.c.

{
  char buf[64]; /* for error message */
  MUMPS_INT ierr_loc;
  read_op_vol=0;
  write_op_vol=0;
  *ierr=(MUMPS_INT)mumps_io_open_files_for_read();
  if(*ierr<0){
    return;
  }
  if(mumps_io_flag_async){
    switch(mumps_io_flag_async){
    case IO_SYNC:
      break;
#if ! defined(MUMPS_WIN32) && ! defined(WITHOUT_PTHREAD)
    case IO_ASYNC_TH:
      mumps_low_level_init_ooc_c_th(&mumps_io_flag_async,&ierr_loc);
      *ierr=(MUMPS_INT)ierr_loc;
      if(*ierr<0){
        return;
      }
      break;
#endif
    default:
      *ierr=-91;
      sprintf(buf,"Error: unknown I/O strategy : %d\n",(int)mumps_io_flag_async);
      mumps_io_error((MUMPS_INT)*ierr,buf);
      return;
    }
  }
  mumps_io_is_init_called=1;
  return;
}

MUMPS_TEST_REQUEST_C()

void MUMPS_CALL MUMPS_TEST_REQUEST_C	(	MUMPS_INT *	request_id,
		MUMPS_INT *	flag,
		MUMPS_INT *	ierr )

Definition at line 87 of file mumps_io.c.

{
  char buf[64]; /* for error message */
  MUMPS_INT request_id_loc;
#if ! defined(MUMPS_WIN32) && ! defined(WITHOUT_PTHREAD)
  MUMPS_INT flag_loc;
#endif
#if ! defined(MUMPS_WIN32)
  struct timeval start_time,end_time;
  gettimeofday(&start_time,NULL);
#endif
  request_id_loc=(MUMPS_INT)*request_id;
  switch(mumps_io_flag_async){
  case IO_SYNC:
    /* printf("mumps_test_request_c should not be called with strategy %d\n",mumps_io_flag_async);*/
    /* JY+EA: Allow for this option, since it is similar to wait_request
     * and wait_request is allowed in synchronous mode.
     * We always return TRUE.
     */
    *flag=1;
    break;
#if ! defined(MUMPS_WIN32) && ! defined(WITHOUT_PTHREAD)
  case IO_ASYNC_TH:
    *ierr=(MUMPS_INT)mumps_test_request_th(&request_id_loc,&flag_loc);
    *flag=(MUMPS_INT)flag_loc;
    break;
#endif
  default:
    *ierr=-92;
    sprintf(buf,"Error: unknown I/O strategy : %d\n",(int)mumps_io_flag_async);
    mumps_io_error((MUMPS_INT)*ierr,buf);
    return;
  }
#if ! defined(MUMPS_WIN32)
  gettimeofday(&end_time,NULL);
  mumps_time_spent_in_sync=mumps_time_spent_in_sync+((double)end_time.tv_sec+((double)end_time.tv_usec/1000000))-((double)start_time.tv_sec+((double)start_time.tv_usec/1000000));
#endif
  return;
}

MUMPS_WAIT_REQUEST()

void MUMPS_CALL MUMPS_WAIT_REQUEST	(	MUMPS_INT *	request_id,
		MUMPS_INT *	ierr )

Definition at line 128 of file mumps_io.c.

{
  char buf[64]; /* for error message */
  MUMPS_INT request_id_loc;
#if ! defined(MUMPS_WIN32)
  struct timeval start_time,end_time;
  gettimeofday(&start_time,NULL);
#endif
  request_id_loc=(MUMPS_INT)*request_id;
  if(*request_id==-1)
    return;
  switch(mumps_io_flag_async){
  case IO_SYNC:
    /* printf("mumps_wait_request should not be called with strategy %d\n",mumps_io_flag_async); */
    break;
#if ! defined(MUMPS_WIN32) && ! defined(WITHOUT_PTHREAD)
  case IO_ASYNC_TH:
    *ierr=(MUMPS_INT)mumps_wait_request_th(&request_id_loc);
    break;
#endif
  default:
    *ierr=-92;
    sprintf(buf,"Error: unknown I/O strategy : %d\n",(int)mumps_io_flag_async);
    mumps_io_error((MUMPS_INT)*ierr,buf);
    return;
    /*    printf("Error: unknown I/O strategy : %d\n",mumps_io_flag_async);
          exit (-3);*/
  }
#if ! defined(MUMPS_WIN32)
  gettimeofday(&end_time,NULL);
  mumps_time_spent_in_sync=mumps_time_spent_in_sync+((double)end_time.tv_sec+((double)end_time.tv_usec/1000000))-((double)start_time.tv_sec+((double)start_time.tv_usec/1000000));
#endif
  return;
}

Variable Documentation

MUMPS_OOC_STORE_PREFIX

char MUMPS_OOC_STORE_PREFIX[MUMPS_OOC_PREFIX_MAX_LENGTH]

static

Definition at line 31 of file mumps_io.h.

MUMPS_OOC_STORE_PREFIXLEN

MUMPS_INT MUMPS_OOC_STORE_PREFIXLEN =-1

static

Definition at line 32 of file mumps_io.h.

MUMPS_OOC_STORE_TMPDIR

char MUMPS_OOC_STORE_TMPDIR[MUMPS_OOC_TMPDIR_MAX_LENGTH]

static

Definition at line 33 of file mumps_io.h.

MUMPS_OOC_STORE_TMPDIRLEN

MUMPS_INT MUMPS_OOC_STORE_TMPDIRLEN =-1

static

Definition at line 34 of file mumps_io.h.