sion_fortran.c

Go to the documentation of this file.

/****************************************************************************
**  SIONLIB     http://www.fz-juelich.de/jsc/sionlib                       **
*****************************************************************************
**  Copyright (c) 2008-2019                                                **
**  Forschungszentrum Juelich, Juelich Supercomputing Centre               **
**                                                                         **
**  See the file COPYRIGHT in the package base directory for details       **
****************************************************************************/
#define _XOPEN_SOURCE 700
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
/* #define _FORTRANUNDERSCORE
   #define _FORTRANNOCAPS
   #define _FORTRANCAPS
   #define _FORTRANDOUBLEUNDERSCORE */
#include "sion.h"
#include "sion_debug.h"
#include "sion_fd.h"
#include "sion_filedesc.h"
#include "sion_fortran.h"
 
#define DFUNCTION "fsion_open_c"
void fsion_open_c(char *fname,
              char *file_mode,
              int  *ntasks, 
              int  *nfiles, 
          sion_int64 *chunksizes,
          sion_int32 *fsblksize, 
          int *globalranks, 
          int *sid, 
          int fname_len, 
          int file_mode_len)
{
  /* Fortran strings are not NULL-terminated => insert \0 at the end */
  char     *fname_tmp, *fmode_tmp;
  
 
  fname_tmp = (char *) malloc((size_t) ((fname_len + 1) * sizeof(char)));
  if(fname_tmp == NULL) {
    fprintf(stderr, "could not allocate memory for internal filename buffer, returning ...\n");
    *sid=-1;
    return;
  }
 
  fmode_tmp = (char *) malloc((size_t) ((file_mode_len + 1) * sizeof(char)));
  if(fmode_tmp == NULL) {
    fprintf(stderr, "could not allocate memory for internal filemode buffer, returning ...\n");
    *sid=-1;
    free(fname_tmp); fname_tmp=NULL;
    return;
  }
 
 
  /* printf("sizeof(fname_len)=%d\n",sizeof(fname_len));  */
  /* printf("%s fname_len=%d %x %d\n",fname, fname_len,fname_tmp,((fname_len + 1) * sizeof(char)));  */
  /* printf("file_mode_len=%d %x %d\n",file_mode_len,fmode_tmp,((file_mode_len + 1) * sizeof(char)));  */
 
  /* Copy the strings to the new buffers and pad with nulls */
  strncpy(fname_tmp, fname, fname_len);
  strncpy(fmode_tmp, file_mode, file_mode_len);
 
  fname_tmp[fname_len] = '\0';
  fmode_tmp[file_mode_len] = '\0';
 
  
 
  DPRINTFP((2, DFUNCTION, -1, "params: %s %s %d %ld \n", fname_tmp, fmode_tmp, (int) *ntasks, (long) *fsblksize)); 
 
  if (!strcmp(fmode_tmp, "bw") || !strcmp(fmode_tmp, "wb")) {
    /* **************** WRITE mode **************** */
    (*sid) = sion_open(fname_tmp, fmode_tmp, ntasks, nfiles, &chunksizes, fsblksize, &globalranks, NULL);
  } else {
    (*sid) = sion_open(fname_tmp, fmode_tmp, ntasks, nfiles, NULL, fsblksize, NULL, NULL);
  }
  DPRINTFP((2, DFUNCTION, -1, "sid: %d\n", *sid));
 
  /* Free the used memory */
  free(fname_tmp); fname_tmp=NULL;
  free(fmode_tmp); fmode_tmp=NULL;
}
#undef DFUNCTION
 
 
void fsion_open_rank_c(char *fname,
                       char *file_mode, 
                       sion_int64 *chunksize, 
                       sion_int32 *fsblksize, 
                       int *rank, 
                       int *sid, 
                       int fname_len, 
                       int file_mode_len)
{
  /* Fortran strings are not NULL-terminated => insert \0 at the end */
  char     *fname_tmp, *fmode_tmp;
 
  fname_tmp = (char *) malloc((size_t) ((fname_len + 1) * sizeof(char)));
  fmode_tmp = (char *) malloc((size_t) ((file_mode_len + 1) * sizeof(char)));
  /* Copy the strings to the new buffers and pad with nulls */
  strncpy(fname_tmp, fname, fname_len);
  strncpy(fmode_tmp, file_mode, file_mode_len);
  fname_tmp[fname_len] = '\0';
  fmode_tmp[file_mode_len] = '\0';
 
  (*sid) = sion_open_rank(fname_tmp, fmode_tmp, chunksize, fsblksize, rank, NULL);
 
  /* Free the used memory */
  free(fname_tmp);
  free(fmode_tmp);
}
 
void fsion_close_c(int *sid, 
                   int *ierr)
{
  (*ierr) = sion_close(*sid);
}
 
void fsion_feof_c(int *sid, 
                  int *eof)
{
 
  *eof = sion_feof(*sid);
}
 
#define DFUNCTION "fsion_seek_c"
void fsion_seek_c(int *sid, 
                  int *rank, 
                  int *currentblocknr, 
                  sion_int64 *posinblk, 
                  int *ierr)
{
 
  DPRINTFP((2, DFUNCTION, -1, "params: %d %d %d %lld\n", *sid, *rank, *currentblocknr, *posinblk));
 
  (*ierr) = sion_seek(*sid, *rank, *currentblocknr, *posinblk);
}
#undef DFUNCTION
 
void fsion_ensure_free_space_c(int *sid, 
                               sion_int64 *bytes, 
                               int *ierr)
{
 
  (*ierr) = sion_ensure_free_space(*sid, *bytes);
}
 
 
 
void fsion_flush_c(int *sid, 
                   int *ierr)
{
 
  (*ierr) = sion_flush(*sid);
 
}
 
 
sion_int64 fsion_bytes_avail_in_block_c(int *sid)
{
 
  return sion_bytes_avail_in_block(*sid);
}
 
void fsion_get_locations_c(int *sid,
                           int *ntasks,
                           int *maxblocks,
                           sion_int64 *globalskip,
                           sion_int64 *start_of_varheader,
                           sion_int64 **sion_localsizes,
                           sion_int64 **sion_globalranks, 
                           sion_int64 **sion_chunkcount, 
                           sion_int64 **sion_chunksizes, 
                           int *ierr)
{
 
  (*ierr) = sion_get_locations(*sid, ntasks, maxblocks, globalskip, start_of_varheader, sion_localsizes,
                               sion_globalranks, sion_chunkcount, sion_chunksizes);
}
 
sion_int64 fsion_get_position_c(int *sid)
{
 
  return sion_get_position(*sid);
}
 
/* OTHER UNDOCUMENTED FUNCTIONS */
 
void fsion_get_current_locations_c(int *sid, 
                                   int *ntasks, 
                                   sion_int64 **sion_currentpos, 
                                   sion_int64 **sion_currentblocknr, 
                                   int *ierr)
{
 
  (*ierr) = sion_get_current_locations(*sid, ntasks, sion_currentpos, sion_currentblocknr);
}
 
 
void fsion_get_chunksizes_c(int *sid,
                sion_int64 *chunksizes, 
                int *ierr)
{
  _sion_filedesc *sion_filedesc;
 
  if ((_sion_vcdtype(*sid) != SION_FILEDESCRIPTOR)
      || !(sion_filedesc = _sion_vcdtovcon(*sid))) {
    fprintf(stderr, "invalid sion_filedesc, aborting %d ...\n", *sid);
    if (ierr) {
      *ierr=-1;
    }
    return;
  }
  if(sion_filedesc->all_chunksizes) {
    int i;
    for(i=0;i<sion_filedesc->ntasks;i++) {
      chunksizes[i]=sion_filedesc->all_chunksizes[i];
    }
  }
 
}
 
void fsion_get_globalranks_c(int *sid,
                 int *globalranks, 
                 int *ierr)
{
  _sion_filedesc *sion_filedesc;
 
  if ((_sion_vcdtype(*sid) != SION_FILEDESCRIPTOR)
      || !(sion_filedesc = _sion_vcdtovcon(*sid))) {
    fprintf(stderr, "invalid sion_filedesc, aborting %d ...\n", *sid);
    if (ierr) {
      *ierr=-1;
    }
    return;
  }
  if(sion_filedesc->all_globalranks) {
    int i;
    for(i=0;i<sion_filedesc->ntasks;i++) {
      globalranks[i]=sion_filedesc->all_globalranks[i];
    }
  }
 
}
 
void fsion_get_mapping_spec_c(int *sid,
                  int *mapping_size, 
                  int *numfiles, 
                  int *ierr)
{
  _sion_filedesc *sion_filedesc;
  if ((_sion_vcdtype(*sid) != SION_FILEDESCRIPTOR)
      || !(sion_filedesc = _sion_vcdtovcon(*sid))) {
    fprintf(stderr, "invalid sion_filedesc, aborting %d ...\n", *sid);
    if (ierr) {
      *ierr=-1;
    }
    return;
  }
  *mapping_size = sion_filedesc->mapping_size;
  *numfiles     = sion_filedesc->nfiles;
 
}
 
#define DFUNCTION "fsion_get_mapping_c"
void fsion_get_mapping_c(int *sid, 
                         sion_int32 *mapping, 
                         int *ierr)
{
  _sion_filedesc *sion_filedesc;
 
  if ((_sion_vcdtype(*sid) != SION_FILEDESCRIPTOR)
      || !(sion_filedesc = _sion_vcdtovcon(*sid))) {
    fprintf(stderr, "invalid sion_filedesc, aborting %d ...\n", *sid);
    *ierr=-1;
    return;
  }
  if(sion_filedesc->nfiles>1) {
    int rank;
    for (rank = 0; rank < sion_filedesc->mapping_size; rank++) {
      DPRINTFP((32, DFUNCTION, 0, " mapping[%d] = %d , %d \n", rank,sion_filedesc->mapping[rank*2+0],sion_filedesc->mapping[rank*2+1]));
      mapping[rank*2+0]=sion_filedesc->mapping[rank*2+0];
      mapping[rank*2+1]=sion_filedesc->mapping[rank*2+1];
    }
  } else {
    *ierr=-1;
  }
}
#undef DFUNCTION
 
void fsion_get_fileno_c(int *sid, 
                        int *filenumber)
{
  _sion_filedesc *sion_filedesc;
  if ((_sion_vcdtype(*sid) != SION_FILEDESCRIPTOR)
      || !(sion_filedesc = _sion_vcdtovcon(*sid))) {
    fprintf(stderr, "invalid sion_filedesc, aborting %d ...\n", *sid);
    *filenumber=-1;
    return;
  }
  *filenumber = _sion_file_get_fd(sion_filedesc->fileptr);
  return;
}
 
 
void fsion_get_file_endianness_c(int *sid, 
                                 int *endianness)
{
  *endianness = sion_get_file_endianness(*sid);
  return;
}
 
 
void fsion_get_endianness_c(int *endianness)
{
  *endianness = sion_get_endianness();
  return;
}
 
 
void fsion_endianness_swap_needed_c(int *sid,
                                    int *needed)
{
  *needed = sion_endianness_swap_needed(*sid);
  return;
}
 
 
void fsion_swap_c(void *target, 
                  void *source, 
                  int *size, 
                  int *n, 
                  int *do_swap, 
                  int *rc)
{
  (*rc) = 1;
  sion_swap( (void *) target, 
         (void *) source,
         (int) *size,
         (int) *n,
         (int) *do_swap
         );
}