mumps_io_basic.h File Reference

#include "mumps_compat.h"
#include "mumps_c_types.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/time.h>
#include <time.h>

Go to the source code of this file.

Data Structures
struct	__mumps_file_struct
struct	__mumps_file_type

Macros
#define	_XOPEN_SOURCE   500
#define	MAX_FILE_SIZE   1879048192 /* (2^31)-1-(2^27) */
#define	MUMPS_IO_FLAG_O_DIRECT   0
#define	IO_SYNC   0
#define	IO_ASYNC_TH   1
#define	IO_ASYNC_AIO   2
#define	IO_READ   1
#define	IO_WRITE   0
#define	UNITIALIZED   "NAME_NOT_INITIALIZED"
#define	MUMPS_OOC_DEFAULT_DIR   "/tmp"
#define	SEPARATOR   "/"
#define	my_max(x, y)
#define	my_ceil(x)

Typedefs
typedef struct __mumps_file_struct	mumps_file_struct
typedef struct __mumps_file_type	mumps_file_type

Functions
MUMPS_INT	mumps_set_file (MUMPS_INT type, MUMPS_INT file_number_arg)
void	mumps_update_current_file_position (mumps_file_struct *file_arg)
MUMPS_INT	mumps_compute_where_to_write (const double to_be_written, const MUMPS_INT type, long long vaddr, size_t already_written)
MUMPS_INT	mumps_prepare_pointers_for_write (double to_be_written, MUMPS_INT *pos_in_file, MUMPS_INT *file_number, const MUMPS_INT type, long long vaddr, size_t already_written)
MUMPS_INT	mumps_io_do_write_block (void *address_block, long long block_size, MUMPS_INT *type, long long vaddr, MUMPS_INT *ierr)
MUMPS_INT	mumps_io_do_read_block (void *address_block, long long block_size, MUMPS_INT *type, long long vaddr, MUMPS_INT *ierr)
MUMPS_INT	mumps_compute_nb_concerned_files (long long block_size, MUMPS_INT *nb_concerned_files, long long vaddr)
MUMPS_INLINE MUMPS_INT	mumps_gen_file_info (long long vaddr, MUMPS_INT *pos, MUMPS_INT *file)
MUMPS_INT	mumps_free_file_pointers (MUMPS_INT *step)
MUMPS_INT	mumps_init_file_structure (MUMPS_INT *_myid, long long *total_size_io, MUMPS_INT *size_element, MUMPS_INT *nb_file_type, MUMPS_INT *flag_tab)
MUMPS_INT	mumps_init_file_name (char *mumps_dir, char *mumps_file, MUMPS_INT *mumps_dim_dir, MUMPS_INT *mumps_dim_file, MUMPS_INT *_myid)
void	mumps_io_init_file_struct (MUMPS_INT *nb, MUMPS_INT which)
MUMPS_INT	mumps_io_alloc_file_struct (MUMPS_INT *nb, MUMPS_INT which)
MUMPS_INT	mumps_io_get_nb_files (MUMPS_INT *nb_files, const MUMPS_INT *type)
MUMPS_INT	mumps_io_get_file_name (MUMPS_INT *indice, char *name, MUMPS_INT *length, MUMPS_INT *type)
MUMPS_INT	mumps_io_alloc_pointers (MUMPS_INT *nb_file_type, MUMPS_INT *dim)
MUMPS_INT	mumps_io_init_vars (MUMPS_INT *myid_arg, MUMPS_INT *size_element, MUMPS_INT *async_arg)
MUMPS_INT	mumps_io_set_file_name (MUMPS_INT *indice, char *name, MUMPS_INT *length, MUMPS_INT *type)
MUMPS_INT	mumps_io_open_files_for_read ()
MUMPS_INT	mumps_io_set_last_file (MUMPS_INT *dim, MUMPS_INT *type)
MUMPS_INT	mumps_io_write__ (void *file, void *loc_add, size_t write_size, MUMPS_INT where, MUMPS_INT type)
MUMPS_INT	mumps_io_write_os_buff__ (void *file, void *loc_add, size_t write_size, MUMPS_INT where)
MUMPS_INT	mumps_io_write_direct_io__ (void *file, void *loc_addr, size_t write_size, MUMPS_INT where, MUMPS_INT type)
MUMPS_INT	mumps_io_flush_write__ (MUMPS_INT type)
MUMPS_INT	mumps_io_read__ (void *file, void *loc_addr, size_t size, MUMPS_INT local_offset, MUMPS_INT type)
MUMPS_INT	mumps_io_read_os_buff__ (void *file, void *loc_addr, size_t size, MUMPS_INT local_offset)
MUMPS_INT	mumps_io_read_direct_io__ (void *file, void *loc_addr, size_t size, MUMPS_INT local_offset, MUMPS_INT type)
MUMPS_INT	mumps_compute_file_size (void *file, size_t *size)

Variables
mumps_file_type *	mumps_files
char *	mumps_ooc_file_prefix
MUMPS_INT	mumps_elementary_data_size
MUMPS_INT	mumps_io_is_init_called
MUMPS_INT	mumps_io_myid
MUMPS_INT	mumps_io_max_file_size
MUMPS_INT	mumps_io_flag_async
MUMPS_INT	mumps_io_k211
MUMPS_INT	directio_flag
MUMPS_INT	mumps_directio_flag
MUMPS_INT	mumps_io_nb_file_type

Macro Definition Documentation

_XOPEN_SOURCE

#define _XOPEN_SOURCE   500

Definition at line 33 of file mumps_io_basic.h.

IO_ASYNC_AIO

#define IO_ASYNC_AIO   2

Definition at line 65 of file mumps_io_basic.h.

IO_ASYNC_TH

#define IO_ASYNC_TH   1

Definition at line 64 of file mumps_io_basic.h.

IO_READ

#define IO_READ   1

Definition at line 66 of file mumps_io_basic.h.

IO_SYNC

#define IO_SYNC   0

Definition at line 63 of file mumps_io_basic.h.

IO_WRITE

#define IO_WRITE   0

Definition at line 67 of file mumps_io_basic.h.

MAX_FILE_SIZE

#define MAX_FILE_SIZE   1879048192 /* (2^31)-1-(2^27) */

Definition at line 36 of file mumps_io_basic.h.

MUMPS_IO_FLAG_O_DIRECT

#define MUMPS_IO_FLAG_O_DIRECT   0

Definition at line 56 of file mumps_io_basic.h.

MUMPS_OOC_DEFAULT_DIR

#define MUMPS_OOC_DEFAULT_DIR   "/tmp"

Definition at line 69 of file mumps_io_basic.h.

my_ceil

#define my_ceil

(

x

)

Value:

( (MUMPS_INT)(x) >= (x) ? (MUMPS_INT)(x) : ( (MUMPS_INT)(x) + 1 ) )

Definition at line 78 of file mumps_io_basic.h.

my_max

#define my_max	(		x,
			y )

Value:

( (x) > (y) ? (x) : (y) )

Definition at line 77 of file mumps_io_basic.h.

SEPARATOR

#define SEPARATOR   "/"

Definition at line 73 of file mumps_io_basic.h.

UNITIALIZED

#define UNITIALIZED   "NAME_NOT_INITIALIZED"

Definition at line 68 of file mumps_io_basic.h.

Typedef Documentation

mumps_file_struct

typedef struct __mumps_file_struct mumps_file_struct

mumps_file_type

typedef struct __mumps_file_type mumps_file_type

Function Documentation

mumps_compute_file_size()

MUMPS_INT mumps_compute_file_size	(	void *	file,
		size_t *	size )

Definition at line 801 of file mumps_io_basic.c.

                                                          {
  /* Compute the size of the file pointed by file and return it in
     size */
#if defined(MUMPS_WIN32)
  /* This works well as soon as we don't use threads under WIN32 */
  MUMPS_INT ret_code;
  long pos=0;
  /* Get the current position */
  pos=ftell(*(FILE **)file);
  /* Move the file pointer to the end of the file */
  fseek(*(FILE **)file,0,SEEK_END);
  /* Get the current position which is in fact the size */
  *size=(size_t)ftell(*(FILE **)file);
  /* Restore the old position */
  fseek(*(FILE **)file,pos,SEEK_SET);
#else
  struct stat file_info;
  /* fstat does everything :-) */
  fstat(*(MUMPS_INT *)file, &file_info);
  *size = (size_t)file_info.st_size;
#endif
  return 0;
}

mumps_compute_nb_concerned_files()

MUMPS_INT mumps_compute_nb_concerned_files	(	long long	block_size,
		MUMPS_INT *	nb_concerned_files,
		long long	vaddr )

Definition at line 187 of file mumps_io_basic.c.

                                                                                                                {
  MUMPS_INT file,pos,available_size;
  long long vaddr_loc;
  vaddr_loc=vaddr*(long long)mumps_elementary_data_size;
  mumps_gen_file_info(vaddr_loc,&pos,&file);
  available_size=mumps_io_max_file_size-pos+1;
  *nb_concerned_files=(MUMPS_INT)my_ceil((double)(my_max(0,((block_size)*(double)(mumps_elementary_data_size))-available_size))/(double)mumps_io_max_file_size)+1;
  return 0;
}

mumps_compute_where_to_write()

MUMPS_INT mumps_compute_where_to_write	(	const double	to_be_written,
		const MUMPS_INT	type,
		long long	vaddr,
		size_t	already_written )

Definition at line 152 of file mumps_io_basic.c.

                                                                                                                              {
  /* Check if the current file has enough memory to receive the whole block*/
  MUMPS_INT ret_code;
  MUMPS_INT file;
  mumps_file_struct *current_file;
  long long vaddr_loc;
  MUMPS_INT pos;
  /* Virtual address based file management scheme */
  vaddr_loc=vaddr*(long long)mumps_elementary_data_size+(long long)already_written;
  mumps_gen_file_info(vaddr_loc,&pos,&file);
  ret_code=mumps_set_file(type,file);
  if(ret_code<0){
    return ret_code;
  }
  current_file=(mumps_files+type)->mumps_io_current_file;
  current_file->write_pos=pos;
  mumps_update_current_file_position(current_file);
  return 0;
}

mumps_free_file_pointers()

MUMPS_INT mumps_free_file_pointers

(

MUMPS_INT *

step

)

Definition at line 373 of file mumps_io_basic.c.

                                                   {
  MUMPS_INT i,j,bound,ierr;
/*   Free prefix only for facto  */
  if (*step == 0) free(mumps_ooc_file_prefix);
  if(mumps_files == NULL )
      return 0;
#if ! defined( MUMPS_WIN32 )
#endif
  bound=mumps_io_nb_file_type;
/*   if(*step==0){ */
/*     /\* factorization *\/ */
/*     bound=NB_FILE_TYPE_FACTO; */
/*   }else{ */
/*     /\* solve *\/ */
/*     bound=NB_FILE_TYPE_SOLVE; */
/*   } */
  for(j=0;j<bound;j++){
    if( mumps_files[j].mumps_io_pfile_pointer_array == NULL ) {
      continue;
    }
    for(i=0;i<(mumps_files+j)->mumps_io_nb_file_opened;i++){
#if ! defined( MUMPS_WIN32 )
      ierr=close((((mumps_files+j)->mumps_io_pfile_pointer_array)+i)->file);
      if(ierr==-1){
        return mumps_io_sys_error(-90,"Problem while closing OOC file");
      }
#else
      ierr=fclose((((mumps_files+j)->mumps_io_pfile_pointer_array)+i)->file);
      if(ierr==-1){
        return mumps_io_error(-90,"Problem while closing OOC file\n");
      }    
#endif
      /*     free(*(mumps_io_pfile_name+i)); */
    }
    free((mumps_files+j)->mumps_io_pfile_pointer_array);
  }
/*   free(mumps_io_pfile_name); */
  free(mumps_files);
#if ! defined( MUMPS_WIN32 )
#endif
  return 0;
}

mumps_gen_file_info()

MUMPS_INLINE MUMPS_INT mumps_gen_file_info	(	long long	vaddr,
		MUMPS_INT *	pos,
		MUMPS_INT *	file )

Definition at line 182 of file mumps_io_basic.c.

                                                                                              {
  *file=(MUMPS_INT)(vaddr/(long long)mumps_io_max_file_size);
  *pos=(MUMPS_INT)(vaddr%(long long)mumps_io_max_file_size);
  return 0;
}

mumps_init_file_name()

MUMPS_INT mumps_init_file_name	(	char *	mumps_dir,
		char *	mumps_file,
		MUMPS_INT *	mumps_dim_dir,
		MUMPS_INT *	mumps_dim_file,
		MUMPS_INT *	_myid )

Definition at line 518 of file mumps_io_basic.c.

                                                                                             {
  MUMPS_INT i;
  char *tmp_dir,*tmp_fname;
  char base_name[20];
  MUMPS_INT dir_flag=0,file_flag=0;
  char mumps_base[10]="mumps_";
  tmp_dir=(char *)malloc(((*mumps_dim_dir)+1)*sizeof(char));
  if(tmp_dir==NULL){
    return mumps_io_error(-13,"Allocation problem in low-level OOC layer\n");
  }
  tmp_fname=(char *)malloc(((*mumps_dim_file)+1)*sizeof(char));
  if(tmp_fname==NULL){
    return mumps_io_error(-13,"Allocation problem in low-level OOC layer\n");
  }
  for(i=0;i<*mumps_dim_dir;i++){
    tmp_dir[i]=mumps_dir[i];
  }
  tmp_dir[i]=0;
  for(i=0;i<*mumps_dim_file;i++){
    tmp_fname[i]=mumps_file[i];
  }
  tmp_fname[i]=0;  
  if(strcmp(tmp_dir,UNITIALIZED)==0){
    dir_flag=1;
    free(tmp_dir);
    tmp_dir=getenv("MUMPS_OOC_TMPDIR");
    if(tmp_dir==NULL){
#ifdef _AIX
# ifndef CINES_
      tmp_dir=getenv("TMPDIR");
      if(tmp_dir==NULL){
        tmp_dir=MUMPS_OOC_DEFAULT_DIR;
      }
# else
      tmp_dir=MUMPS_OOC_DEFAULT_DIR;       
# endif       
#else
      tmp_dir=MUMPS_OOC_DEFAULT_DIR;
#endif      
    }
  }
  if(strcmp(tmp_fname,UNITIALIZED)==0){
    free(tmp_fname);
    tmp_fname=getenv("MUMPS_OOC_PREFIX");
    file_flag=1;
  }
  if(tmp_fname!=NULL){
#if ! defined( MUMPS_WIN32 )
      sprintf(base_name,"_%s%d_XXXXXX",mumps_base,(int)*_myid);
#else
      sprintf(base_name,"_%s%d",mumps_base,*_myid);
#endif
      mumps_ooc_file_prefix=(char *)malloc((strlen(SEPARATOR)+strlen(tmp_dir)+strlen(tmp_fname)+strlen(base_name)+1+1)*sizeof(char));
      if(mumps_ooc_file_prefix==NULL){
        return mumps_io_error(-13,"Allocation problem in low-level OOC layer\n");
      }
      sprintf(mumps_ooc_file_prefix,"%s%s%s%s",tmp_dir,SEPARATOR,tmp_fname,base_name);
  }else{
#if ! defined( MUMPS_WIN32 )
    sprintf(base_name,"%s%s%d_XXXXXX",SEPARATOR,mumps_base,(int)*_myid);
#else
    sprintf(base_name,"%s%s%d",SEPARATOR,mumps_base,*_myid);
#endif
      mumps_ooc_file_prefix=(char *)malloc((strlen(SEPARATOR)+strlen(tmp_dir)+strlen(base_name)+1)*sizeof(char));
      if(mumps_ooc_file_prefix==NULL){
        return mumps_io_error(-13,"Allocation problem in low-level OOC layer\n");
      }
      sprintf(mumps_ooc_file_prefix,"%s%s%s",tmp_dir,SEPARATOR,base_name);
  }  
  if(!dir_flag){
    free(tmp_dir);
  }
  if(!file_flag){
    free(tmp_fname);
  }
  return 0;
}

mumps_init_file_structure()

MUMPS_INT mumps_init_file_structure	(	MUMPS_INT *	_myid,
		long long *	total_size_io,
		MUMPS_INT *	size_element,
		MUMPS_INT *	nb_file_type,
		MUMPS_INT *	flag_tab )

Definition at line 439 of file mumps_io_basic.c.

{
  /* Computes the number of files needed. Uses ceil value. */
  MUMPS_INT ierr;
#if ! defined( MUMPS_WIN32 )
  MUMPS_INT mumps_flag_open;
#endif
  MUMPS_INT i,nb;
  MUMPS_INT mumps_io_nb_file;
  mumps_io_max_file_size=MAX_FILE_SIZE;
  mumps_io_nb_file_type=*nb_file_type;
  mumps_io_nb_file=(MUMPS_INT)((((double)(*total_size_io)*1000000)*((double)(*size_element)))/(double)mumps_io_max_file_size)+1;
  mumps_directio_flag=0;
#if ! defined( MUMPS_WIN32 )
  mumps_flag_open=0;
#endif
  mumps_io_myid=*_myid;
  mumps_elementary_data_size=*size_element;
  /* Allocates the memory necessary to handle the file pointer array.*/
  mumps_files=(mumps_file_type *)malloc(mumps_io_nb_file_type*sizeof(mumps_file_type));
  if(mumps_files==NULL){
    return mumps_io_error(-13,"Allocation problem in low-level OOC layer\n");
  }
  /* Safe initialization of the mumps_file_type elements */
  for(i=0;i<mumps_io_nb_file_type;i++){
    nb=(flag_tab[i]==0||flag_tab[i]==1) ? mumps_io_nb_file : 1;
    mumps_io_init_file_struct(&nb,i);
  }
  ierr=0;
  for(i=0;i<mumps_io_nb_file_type;i++){
    switch(flag_tab[i]){
    case 0:
#if ! defined( MUMPS_WIN32 )
      (mumps_files+i)->mumps_flag_open=mumps_flag_open|O_WRONLY|O_CREAT|O_TRUNC;
#  if defined(__MINGW32__)
      /* O_BINARY necessary */
      (mumps_files+i)->mumps_flag_open=(mumps_files+i)->mumps_flag_open|O_BINARY;
#  endif
#else
      strcpy((mumps_files+i)->mumps_flag_open,"wb");
#endif
      break;
    case 1:
#if ! defined( MUMPS_WIN32 )
      (mumps_files+i)->mumps_flag_open=mumps_flag_open|O_RDONLY|O_CREAT|O_TRUNC;
#  if defined(__MINGW32__)
      /* O_BINARY necessary */
      (mumps_files+i)->mumps_flag_open=(mumps_files+i)->mumps_flag_open|O_BINARY;
#  endif
#else
      strcpy((mumps_files+i)->mumps_flag_open,"rb");
#endif
      break;
    case 2:
#if ! defined( MUMPS_WIN32 )
      (mumps_files+i)->mumps_flag_open=mumps_flag_open|O_RDWR|O_CREAT|O_TRUNC;
#  if defined(__MINGW32__)
      /* O_BINARY necessary */
      (mumps_files+i)->mumps_flag_open=(mumps_files+i)->mumps_flag_open|O_BINARY;
#  endif
#else
      strcpy((mumps_files+i)->mumps_flag_open,"rwb");
#endif
      break;
    default:
      return mumps_io_error(-90,"unknown value of flag_open\n");
    }
    ierr=mumps_io_alloc_file_struct(&nb,i);
    if(ierr<0){
      return ierr;
    }
    ierr=mumps_set_file(i,0);
    if(ierr<0){
      return ierr;
    }
  }
  /* Init the current file.*/
  return 0;
}

mumps_io_alloc_file_struct()

MUMPS_INT mumps_io_alloc_file_struct	(	MUMPS_INT *	nb,
		MUMPS_INT	which )

Definition at line 427 of file mumps_io_basic.c.

{
  MUMPS_INT i;
  (mumps_files+which)->mumps_io_pfile_pointer_array=(mumps_file_struct *)malloc((*nb)*sizeof(mumps_file_struct));
  if((mumps_files+which)->mumps_io_pfile_pointer_array==NULL){
    return mumps_io_error(-13,"Allocation problem in low-level OOC layer\n");
  }
  for(i=0;i<*nb;i++){
    (((mumps_files+which)->mumps_io_pfile_pointer_array)+i)->is_opened=0;
  }
  return 0;
}

mumps_io_alloc_pointers()

MUMPS_INT mumps_io_alloc_pointers	(	MUMPS_INT *	nb_file_type,
		MUMPS_INT *	dim )

Definition at line 607 of file mumps_io_basic.c.

                                                                          {
  MUMPS_INT ierr;
  MUMPS_INT i;
  /* This is called by solve step, we have only one type of files */
  mumps_io_nb_file_type=*nb_file_type;
  mumps_files=(mumps_file_type *)malloc(mumps_io_nb_file_type*sizeof(mumps_file_type));
  if(mumps_files==NULL){
    return mumps_io_error(-13,"Allocation problem in low-level OOC layer\n");
  }
  for(i=0;i<mumps_io_nb_file_type;i++){
    mumps_io_init_file_struct(dim+i,i);
    ierr=mumps_io_alloc_file_struct(dim+i,i);
    if(ierr<0){
      return ierr;
    }
  }
  return 0;
}

mumps_io_do_read_block()

MUMPS_INT mumps_io_do_read_block	(	void *	address_block,
		long long	block_size,
		MUMPS_INT *	type,
		long long	vaddr,
		MUMPS_INT *	ierr )

Definition at line 304 of file mumps_io_basic.c.

                                     {
  size_t size;
#if ! defined( MUMPS_WIN32 )
  MUMPS_INT* file;
#else
  FILE** file;
#endif
  double read_size;
  MUMPS_INT local_fnum,local_offset;
  void *loc_addr;
  long long vaddr_loc;
  MUMPS_INT type;
  type=*type_arg;
  /*  if(((double)(*block_size))*((double)(mumps_elementary_data_size))>(double)mumps_io_max_file_size){
    sprintf(error_str,"Internal error in low-level I/O operation (requested size too big for file system) \n");
    return -90;
    }*/
  if(block_size==0){
    return 0;
  }
  read_size=(double)mumps_elementary_data_size*(double)(block_size);
  /*  if((*file_number<0)&&(read_size<(double)mumps_io_max_file_size)){
    sprintf(error_str,"Internal error (1) in low level read op\n");
    return -90;
    }*/
  loc_addr=address_block;
  vaddr_loc=vaddr*(long long)mumps_elementary_data_size;
  while(read_size>0){
    /* Virtual addressing based management stuff */
    local_fnum=(MUMPS_INT)(vaddr_loc/(long long)mumps_io_max_file_size);
    local_offset=(MUMPS_INT)(vaddr_loc%(long long)mumps_io_max_file_size);
    file=&((((mumps_files+type)->mumps_io_pfile_pointer_array)+local_fnum)->file);
    /* printf("1 read | file -> %d | fnum -> %d | vaddr -> %d \n",*file,local_fnum,(MUMPS_INT)vaddr_loc); */
#if ! defined( MUMPS_WIN32 )
    if(read_size+(double)local_offset>(double)mumps_io_max_file_size){
      size=(size_t)mumps_io_max_file_size-(size_t)local_offset;
    }else{
      size=(size_t)read_size;
    }
#else
    if(read_size+(double)local_offset>(double)mumps_io_max_file_size){
      size=((size_t)mumps_io_max_file_size-(size_t)local_offset)/(size_t)mumps_elementary_data_size;
    }else{
      size=(size_t)(read_size/mumps_elementary_data_size);
    }
#endif
    *ierr=mumps_io_read__(file,loc_addr,size,local_offset,type);
    if(*ierr<0){
      return *ierr;
    }
#if defined( MUMPS_WIN32 )
    size=size*mumps_elementary_data_size;
#endif
    vaddr_loc=vaddr_loc+(long long)size;
    read_size=read_size-(double)size;
    loc_addr=(void*)((size_t)loc_addr+size);
    local_fnum++;
    local_offset=0;
    if(local_fnum>(mumps_files+type)->mumps_io_nb_file){
      *ierr = -90;
      return mumps_io_error(*ierr,"Internal error (2) in low level read op\n");
    }
  }
  return 0;
}

mumps_io_do_write_block()

MUMPS_INT mumps_io_do_write_block	(	void *	address_block,
		long long	block_size,
		MUMPS_INT *	type,
		long long	vaddr,
		MUMPS_INT *	ierr )

Definition at line 196 of file mumps_io_basic.c.

                                             {   
  /* Type of fwrite : size_t fwrite(const void *ptr, size_t size, 
                                    *size_t nmemb, FILE *stream); */
  size_t write_size;
  MUMPS_INT i;
  MUMPS_INT nb_concerned_files=0;
  MUMPS_INT ret_code,file_number_loc,pos_in_file_loc;
  double to_be_written;
#if ! defined( MUMPS_WIN32 )
  MUMPS_INT* file;
#else
  FILE** file;
#endif
  MUMPS_INT where;
  void* loc_addr;
  MUMPS_INT type;
  size_t already_written=0;
  char buf[64];
  type=*type_arg;
  loc_addr=address_block;
  mumps_compute_nb_concerned_files(block_size,&nb_concerned_files,vaddr);
  to_be_written=((double)mumps_elementary_data_size)*((double)(block_size));
  /*  printf("nb_concerned -> %d | %lf \n",nb_concerned_files,to_be_written); */
  for(i=0;i<nb_concerned_files;i++){
#if ! defined( MUMPS_WIN32 ) && ! defined (WITHOUT_PTHREAD)
# ifdef WITH_PFUNC
    if(mumps_io_flag_async==IO_ASYNC_TH){
      mumps_io_protect_pointers();
    }
# endif
#endif
    ret_code=mumps_prepare_pointers_for_write(to_be_written,&pos_in_file_loc,&file_number_loc,type,vaddr,already_written);
    if(ret_code<0){
#if ! defined( MUMPS_WIN32 ) && ! defined (WITHOUT_PTHREAD)
# ifdef WITH_PFUNC
    if(mumps_io_flag_async==IO_ASYNC_TH){
      mumps_io_unprotect_pointers();
    }
# endif
#endif
      return ret_code;
    }
    if((double)(mumps_io_max_file_size-((mumps_files+type)->mumps_io_current_file)->write_pos)>to_be_written){
      write_size=(size_t)to_be_written;
      already_written=(size_t)to_be_written;
    }else{
      write_size=(size_t)((double)(mumps_io_max_file_size-((mumps_files+type)->mumps_io_current_file)->write_pos));
      already_written=already_written+(size_t)write_size;
    }
#if defined( MUMPS_WIN32 )
    write_size=(size_t)(MUMPS_INT)((write_size)/mumps_elementary_data_size);
#endif
    file=&(((mumps_files+type)->mumps_io_current_file)->file);
    where=((mumps_files+type)->mumps_io_current_file)->write_pos;
#if ! defined( MUMPS_WIN32 ) && ! defined (WITHOUT_PTHREAD)
# ifdef WITH_PFUNC
    if(mumps_io_flag_async==IO_ASYNC_TH){
      mumps_io_unprotect_pointers();
    }
# endif
#endif
    ret_code=mumps_io_write__(file,loc_addr,write_size,where,type);
    if(ret_code<0){
      return ret_code;
    }
#if ! defined( MUMPS_WIN32 ) && ! defined (WITHOUT_PTHREAD)
# ifdef WITH_PFUNC
    if(mumps_io_flag_async==IO_ASYNC_TH){
      mumps_io_protect_pointers();
    }
# endif
#endif
#if ! defined( MUMPS_WIN32 )
    ((mumps_files+type)->mumps_io_current_file)->write_pos=((mumps_files+type)->mumps_io_current_file)->write_pos+((MUMPS_INT)write_size);
    to_be_written=to_be_written-((MUMPS_INT)write_size);
    loc_addr=(void*)((size_t)loc_addr+write_size);
/*     mumps_io_write_pos=mumps_io_write_pos+((MUMPS_INT)write_size); */
/*     to_be_written=to_be_written-((MUMPS_INT)write_size); */
/*     loc_addr=(void*)((size_t)loc_addr+write_size); */
#else
    /* fread and write */
    ((mumps_files+type)->mumps_io_current_file)->write_pos=((mumps_files+type)->mumps_io_current_file)->write_pos+((MUMPS_INT)write_size*mumps_elementary_data_size);
    to_be_written=to_be_written-((MUMPS_INT)write_size*mumps_elementary_data_size);
    loc_addr=(void*)((size_t)loc_addr+(size_t)((MUMPS_INT)write_size*mumps_elementary_data_size));
/*     mumps_io_write_pos=mumps_io_write_pos+((MUMPS_INT)write_size*mumps_elementary_data_size); */
/*     to_be_written=to_be_written-((MUMPS_INT)write_size*mumps_elementary_data_size); */
/*     loc_addr=(void*)((size_t)loc_addr+(size_t)((MUMPS_INT)write_size*mumps_elementary_data_size)); */
#endif
#if ! defined( MUMPS_WIN32 ) && ! defined (WITHOUT_PTHREAD)
# ifdef WITH_PFUNC
    if(mumps_io_flag_async==IO_ASYNC_TH){
      mumps_io_unprotect_pointers();
    }
# endif
#endif
  }
  if(to_be_written!=0){
    *ierr = -90;
    sprintf(buf,"Internal (1) error in low-level I/O operation %lf",to_be_written);
    return mumps_io_error(*ierr,buf);
  }
  /* printf("write ok -> %d \n");*/
  return 0;
}

mumps_io_flush_write__()

MUMPS_INT mumps_io_flush_write__

(

MUMPS_INT

type

)

mumps_io_get_file_name()

MUMPS_INT mumps_io_get_file_name	(	MUMPS_INT *	indice,
		char *	name,
		MUMPS_INT *	length,
		MUMPS_INT *	type )

Definition at line 600 of file mumps_io_basic.c.

                                                                                                {
  MUMPS_INT i;
  i=(*indice)-1;
  strcpy(name,(((mumps_files+*type)->mumps_io_pfile_pointer_array)+i)->name);
  *length=(MUMPS_INT)strlen(name)+1;
  return 0;  
}

mumps_io_get_nb_files()

MUMPS_INT mumps_io_get_nb_files	(	MUMPS_INT *	nb_files,
		const MUMPS_INT *	type )

Definition at line 596 of file mumps_io_basic.c.

                                                                           {
  *nb_files=((mumps_files+*type)->mumps_io_last_file_opened)+1;
  return 0;
}

mumps_io_init_file_struct()

void mumps_io_init_file_struct	(	MUMPS_INT *	nb,
		MUMPS_INT	which )

Definition at line 417 of file mumps_io_basic.c.

{
  (mumps_files+which)->mumps_io_current_file_number = -1;
  (mumps_files+which)->mumps_io_last_file_opened = -1;
  (mumps_files+which)->mumps_io_nb_file_opened = 0;
  (mumps_files+which)->mumps_io_nb_file=*nb;
  (mumps_files+which)->mumps_io_pfile_pointer_array = NULL;
  (mumps_files+which)->mumps_io_current_file=NULL;
}

mumps_io_init_vars()

MUMPS_INT mumps_io_init_vars	(	MUMPS_INT *	myid_arg,
		MUMPS_INT *	size_element,
		MUMPS_INT *	async_arg )

Definition at line 625 of file mumps_io_basic.c.

                                                                                              {
#if ! defined( MUMPS_WIN32 )
  MUMPS_INT mumps_flag_open;
#endif
  MUMPS_INT i;
  mumps_io_max_file_size=MAX_FILE_SIZE;
  mumps_directio_flag=0;
#if ! defined( MUMPS_WIN32 )
  mumps_flag_open=0;
#endif
  /* must be changed when we will have more than one file type during solve step */
  for(i=0;i<mumps_io_nb_file_type;i++){
#if ! defined( MUMPS_WIN32 )
    (mumps_files+i)->mumps_flag_open=mumps_flag_open|O_RDONLY;
#else
    strcpy((mumps_files+i)->mumps_flag_open,"rb");
#endif
  }
  mumps_io_myid=*myid_arg;
  mumps_elementary_data_size=*size_element;
  mumps_io_flag_async=*async_arg;
  return 0;
}

mumps_io_open_files_for_read()

MUMPS_INT mumps_io_open_files_for_read

(

)

Definition at line 659 of file mumps_io_basic.c.

                                        {
  MUMPS_INT i,j;
  mumps_file_struct  *mumps_io_pfile_pointer_array;
#if defined (sgi) || defined (__sgi)
  struct dioattr dio;
#endif
  for(j=0;j<mumps_io_nb_file_type;j++){
    mumps_io_pfile_pointer_array=(mumps_files+j)->mumps_io_pfile_pointer_array;
    for(i=0;i<(mumps_files+j)->mumps_io_nb_file;i++){
#if ! defined( MUMPS_WIN32 )
      (mumps_io_pfile_pointer_array+i)->file=open((mumps_io_pfile_pointer_array+i)->name,(mumps_files+j)->mumps_flag_open);
      if((mumps_io_pfile_pointer_array+i)->file==-1){
        return mumps_io_sys_error(-90,"Problem while opening OOC file");
      }
#else
      (mumps_io_pfile_pointer_array+i)->file=fopen((mumps_io_pfile_pointer_array+i)->name,(mumps_files+j)->mumps_flag_open);      
      if((mumps_io_pfile_pointer_array+i)->file==NULL){
        return mumps_io_error(-90,"Problem while opening OOC file");
      }
      (mumps_io_pfile_pointer_array+i)->is_opened=1;
#endif
    }
  }
  return 0;
}

mumps_io_read__()

MUMPS_INT mumps_io_read__	(	void *	file,
		void *	loc_addr,
		size_t	size,
		MUMPS_INT	local_offset,
		MUMPS_INT	type )

Definition at line 709 of file mumps_io_basic.c.

                                                                                                         {
  MUMPS_INT ret_code;
#if ! defined( MUMPS_WIN32 )
  if(!mumps_directio_flag){
    ret_code=mumps_io_read_os_buff__(file,loc_addr, size,local_offset);
    if(ret_code<0){
      return ret_code;
    }
  }
#else
  ret_code=mumps_io_read_win32__(file,loc_addr, size,local_offset);
  if(ret_code<0){
    return ret_code;
  }
#endif  
  return 0;
}

mumps_io_read_direct_io__()

MUMPS_INT mumps_io_read_direct_io__	(	void *	file,
		void *	loc_addr,
		size_t	size,
		MUMPS_INT	local_offset,
		MUMPS_INT	type )

mumps_io_read_os_buff__()

MUMPS_INT mumps_io_read_os_buff__	(	void *	file,
		void *	loc_addr,
		size_t	size,
		MUMPS_INT	local_offset )

Definition at line 727 of file mumps_io_basic.c.

                                                                                                 {
  size_t ret_code;
  /* printf("Read with buff %d %d %d\n",(MUMPS_INT) size, local_offset,*((MUMPS_INT *)file)); */
# ifdef WITH_PFUNC
  ret_code=pread(*(MUMPS_INT *)file,loc_addr,size,local_offset);
# else
  lseek(*(MUMPS_INT *)file,(long) local_offset,SEEK_SET);
  ret_code=read(*(MUMPS_INT *)file,loc_addr,size);
# endif
  if((MUMPS_INT) ret_code==-1){
    return mumps_io_sys_error(-90,"Problem with low level read");
  }
  return 0;
}

mumps_io_set_file_name()

MUMPS_INT mumps_io_set_file_name	(	MUMPS_INT *	indice,
		char *	name,
		MUMPS_INT *	length,
		MUMPS_INT *	type )

Definition at line 648 of file mumps_io_basic.c.

                                                                                                {
  MUMPS_INT i;
  i=(*indice)-1;
/*   *(mumps_io_pfile_name+i)=(char *) malloc((*length)*strlen(name)); */
/*   if(*(mumps_io_pfile_name+i)==NULL){ */
/*     sprintf(error_str,"Allocation problem in low-level OOC layer"); */
/*     return -13; */
/*   } */
  strcpy((((mumps_files+*type)->mumps_io_pfile_pointer_array)+i)->name,name);
  return 0;  
}

mumps_io_set_last_file()

MUMPS_INT mumps_io_set_last_file	(	MUMPS_INT *	dim,
		MUMPS_INT *	type )

Definition at line 684 of file mumps_io_basic.c.

                                                                {
  (mumps_files+*type)->mumps_io_last_file_opened=*dim-1;
  (mumps_files+*type)->mumps_io_nb_file_opened=*dim;
  return 0;
}

mumps_io_write__()

MUMPS_INT mumps_io_write__	(	void *	file,
		void *	loc_add,
		size_t	write_size,
		MUMPS_INT	where,
		MUMPS_INT	type )

Definition at line 753 of file mumps_io_basic.c.

                                                                                                         {
  MUMPS_INT ret_code;
#if ! defined( MUMPS_WIN32 )
  if(!mumps_directio_flag){
    ret_code=mumps_io_write_os_buff__(file,loc_addr, write_size,where);
    if(ret_code<0){
      return ret_code;
    }
  }
#else
  ret_code=mumps_io_write_win32__(file,loc_addr, write_size,where);
  if(ret_code<0){
    return ret_code;
  }
#endif
  return 0;
}

mumps_io_write_direct_io__()

MUMPS_INT mumps_io_write_direct_io__	(	void *	file,
		void *	loc_addr,
		size_t	write_size,
		MUMPS_INT	where,
		MUMPS_INT	type )

mumps_io_write_os_buff__()

MUMPS_INT mumps_io_write_os_buff__	(	void *	file,
		void *	loc_add,
		size_t	write_size,
		MUMPS_INT	where )

Definition at line 771 of file mumps_io_basic.c.

                                                                                                  {
  size_t ret_code;
  /* printf("write with buff %d %d %d\n",(MUMPS_INT) write_size, where,*((MUMPS_INT *)file)); */
# ifdef WITH_PFUNC
  ret_code=pwrite(*(MUMPS_INT *)file,loc_addr,write_size,where);
# else
  /*in this case all the I/O's are made by the I/O thread => we don't
    need to protect the file pointer.*/
  lseek(*(MUMPS_INT *)file,(long)where,SEEK_SET); 
  ret_code=write(*(MUMPS_INT *)file,loc_addr,write_size);
# endif
  if((MUMPS_INT)ret_code==-1){
    return mumps_io_sys_error(-90,"Problem with low level write");
  } else if(ret_code!=write_size){
    return mumps_io_error(-90,"Error not enough space on disk \n");
  }
  return 0;
}

mumps_prepare_pointers_for_write()

MUMPS_INT mumps_prepare_pointers_for_write	(	double	to_be_written,
		MUMPS_INT *	pos_in_file,
		MUMPS_INT *	file_number,
		const MUMPS_INT	type,
		long long	vaddr,
		size_t	already_written )

Definition at line 171 of file mumps_io_basic.c.

                                                                                                                                                                             {
  MUMPS_INT ret_code;
  ret_code=mumps_compute_where_to_write(to_be_written,type,vaddr,already_written);
  if(ret_code<0){
    return ret_code;
  }
  *pos_in_file=((mumps_files+type)->mumps_io_current_file)->current_pos;
  /* should be modified to take into account the file arg */
  *file_number=(mumps_files+type)->mumps_io_current_file_number;
  return 0;
}

mumps_set_file()

MUMPS_INT mumps_set_file	(	MUMPS_INT	type,
		MUMPS_INT	file_number_arg )

Definition at line 51 of file mumps_io_basic.c.

                                                                  {
  /* Defines the pattern for the file name. The last 6 'X' will be replaced
     so as to name were unique */
  char name[351];
#if ! defined(_WIN32)
  MUMPS_INT fd;
  char buf[64]; /* for error message */
#endif
  mumps_file_struct  *mumps_io_pfile_pointer_array;
  if (file_number_arg > ((mumps_files+type)->mumps_io_nb_file)-1){
    /* mumps_io_nb_file was initialized to the estimated number
    of files inside mumps_io_init_file_struct; this block is
    entered in case of a too small estimation of the required
    number of files. */
    /* We increase the number of files needed and then realloc. */
    ((mumps_files+type)->mumps_io_nb_file)++;
    (mumps_files+type)->mumps_io_pfile_pointer_array=(mumps_file_struct*)realloc((void *)(mumps_files+type)->mumps_io_pfile_pointer_array,((mumps_files+type)->mumps_io_nb_file)*sizeof(mumps_file_struct));
    /* Check for reallocation problem */
    if((mumps_files+type)->mumps_io_pfile_pointer_array==NULL){
      return mumps_io_error(-13,"Allocation problem in low-level OOC layer\n");
    }
    /* initialize "is_opened", as in mumps_io_init_file_struct */
    ((mumps_files+type)->mumps_io_pfile_pointer_array+((mumps_files+type)->mumps_io_nb_file)-1)->is_opened = 0;
  }
  mumps_io_pfile_pointer_array=(mumps_files+type)->mumps_io_pfile_pointer_array;
  /* 
     Do change the current file 
     Careful: both mumps_io_current_file_number and
              mumps_io_current_file must be changed
   */
  ((mumps_files+type)->mumps_io_current_file_number)=file_number_arg;
  ((mumps_files+type)->mumps_io_current_file)=mumps_io_pfile_pointer_array+file_number_arg;
  if((mumps_io_pfile_pointer_array+file_number_arg)->is_opened!=0){
    /*
       The file already exists and is open.
       The i/o will be performed in the current file (which may not
       be the last one.
     */
    return 0;
  }
/*********************/
/* CREATE A NEW FILE */
/*********************/
/* #if ! defined( MUMPS_WIN32 )*/
/* MinGW does not have a mkstemp function and MinGW defines _WIN32,
 * so we also go in the else branch below with MinGW */
#if ! defined(_WIN32)
  strcpy(name,mumps_ooc_file_prefix);
  fd=mkstemp(name);  
  /* Note that a file name is built by mkstemp and that the file is 
     opened. fd hold the file descriptor to access it.
     We want to close the file that will be opened later
     and might be removed before the end of the processus.
  */
  if(fd < 0) {
    sprintf(buf,"File creation failure");
    return mumps_io_sys_error(-90,buf);
  } else {
    close(fd); 
  }
#else
  sprintf(name,"%s_%d_%d",mumps_ooc_file_prefix,((mumps_files+type)->mumps_io_current_file_number)+1,type);
#endif
/*   *(mumps_io_pfile_pointer_array+mumps_io_current_file_number)=fopen(name,"w+"); */
/*   *(mumps_io_pfile_name+mumps_io_current_file_number)=(char *)malloc((strlen(name)+1)*sizeof(char)); */
/*   if(*(mumps_io_pfile_name+mumps_io_current_file_number)==NULL){ */
/*     sprintf(error_str,"Allocation problem in low-level OOC layer\n"); */
/*     return -13; */
/*   } */
  strcpy((mumps_io_pfile_pointer_array+(mumps_files+type)->mumps_io_current_file_number)->name,name);
  /* See mumps_io_basic.h for comments on the I/O flags passed to open */
#if ! defined( MUMPS_WIN32 )
  (mumps_io_pfile_pointer_array+(mumps_files+type)->mumps_io_current_file_number)->file=open(name,(mumps_files+type)->mumps_flag_open,0666); 
  /* 
CPA: for LU factor file: 
(mumps_io_pfile_pointer_array+(mumps_files+type)->mumps_io_current_file_number)->file= open(name, O_WRONLY | O_CREAT | O_TRUNC, 0666); */
  if((mumps_io_pfile_pointer_array+(mumps_files+type)->mumps_io_current_file_number)->file==-1){
    return mumps_io_sys_error(-90,"Unable to open OOC file");
  }
#else
  (mumps_io_pfile_pointer_array+(mumps_files+type)->mumps_io_current_file_number)->file=fopen(name,(mumps_files+type)->mumps_flag_open);
  if((mumps_io_pfile_pointer_array+(mumps_files+type)->mumps_io_current_file_number)->file==NULL){
    return mumps_io_error(-90,"Problem while opening OOC file");
  }
#endif
  (mumps_files+type)->mumps_io_current_file=(mumps_io_pfile_pointer_array+(mumps_files+type)->mumps_io_current_file_number);
  ((mumps_files+type)->mumps_io_nb_file_opened)++;
  if((mumps_files+type)->mumps_io_current_file_number>(mumps_files+type)->mumps_io_last_file_opened){
    (mumps_files+type)->mumps_io_last_file_opened=(mumps_files+type)->mumps_io_current_file_number;
  }
  /*  if(*(mumps_io_pfile_pointer_array+mumps_io_current_file_number)==NULL) */
  ((mumps_files+type)->mumps_io_current_file)->write_pos=0;
  ((mumps_files+type)->mumps_io_current_file)->is_opened=1;
  /*  printf("new file created -> num = %d \n", ((mumps_files+type)->mumps_io_last_file_opened));*/
  /*  printf("new file created %d\n",mumps_io_current_file_number);*/
  return 0;
}

mumps_update_current_file_position()

void mumps_update_current_file_position

(

mumps_file_struct *

file_arg

)

Definition at line 148 of file mumps_io_basic.c.

                                                                    {
  file_arg->current_pos=file_arg->write_pos;
/*   mumps_io_current_file_position=mumps_io_write_pos; */
}

Variable Documentation

directio_flag

MUMPS_INT directio_flag

extern

mumps_directio_flag

MUMPS_INT mumps_directio_flag

extern

Definition at line 48 of file mumps_io_basic.c.

mumps_elementary_data_size

MUMPS_INT mumps_elementary_data_size

extern

Definition at line 40 of file mumps_io_basic.c.

mumps_files

mumps_file_type* mumps_files

extern

Definition at line 33 of file mumps_io_basic.c.

mumps_io_flag_async

MUMPS_INT mumps_io_flag_async

extern

Definition at line 45 of file mumps_io_basic.c.

mumps_io_is_init_called

MUMPS_INT mumps_io_is_init_called

extern

Definition at line 41 of file mumps_io_basic.c.

mumps_io_k211

MUMPS_INT mumps_io_k211

extern

Definition at line 46 of file mumps_io_basic.c.

mumps_io_max_file_size

MUMPS_INT mumps_io_max_file_size

extern

Definition at line 43 of file mumps_io_basic.c.

mumps_io_myid

MUMPS_INT mumps_io_myid

extern

Definition at line 42 of file mumps_io_basic.c.

mumps_io_nb_file_type

MUMPS_INT mumps_io_nb_file_type

extern

Definition at line 49 of file mumps_io_basic.c.

mumps_ooc_file_prefix

char* mumps_ooc_file_prefix

extern

Definition at line 35 of file mumps_io_basic.c.