Update molfile plugin from John 29/4129/1
authorDavid <dhardy@ks.uiuc.edu>
Fri, 4 May 2018 16:50:05 +0000 (11:50 -0500)
committerDavid <dhardy@ks.uiuc.edu>
Fri, 4 May 2018 16:50:05 +0000 (11:50 -0500)
The update from John fixes issues with reading JS files, so that NAMD is
not forced to follow the new block alignment conventions.  We will later
want to modify NAMD to improve file reading performance by following the
new conventions, which is especially important for large systems.

Change-Id: I295c2a9b9529a72bf4355c4fd4fdf30f74450f7e

15 files changed:
plugins/include/molfile_plugin.h
plugins/include/vmdplugin.h
plugins/molfile_plugin/src/dcdplugin.c
plugins/molfile_plugin/src/endianswap.h
plugins/molfile_plugin/src/fastio.h
plugins/molfile_plugin/src/fortread.h
plugins/molfile_plugin/src/hash.c
plugins/molfile_plugin/src/hash.h
plugins/molfile_plugin/src/jsplugin.c
plugins/molfile_plugin/src/largefiles.h
plugins/molfile_plugin/src/namdbinplugin.c
plugins/molfile_plugin/src/pdbplugin.c
plugins/molfile_plugin/src/periodic_table.h
plugins/molfile_plugin/src/psfplugin.c
plugins/molfile_plugin/src/readpdb.h

index e1d38b0..09ea410 100644 (file)
@@ -10,8 +10,8 @@
  * RCS INFORMATION:
  *
  *      $RCSfile: molfile_plugin.h,v $
- *      $Author: jim $       $Locker:  $             $State: Exp $
- *      $Revision: 1.7 $       $Date: 2016/04/25 01:57:28 $
+ *      $Author: johns $       $Locker:  $             $State: Exp $
+ *      $Revision: 1.110 $       $Date: 2018/05/02 03:12:56 $
  *
  ***************************************************************************/
 
@@ -111,7 +111,7 @@ typedef struct {
   char resname[8];    /**< required residue name string          */
   int resid;          /**< required integer residue ID           */
   char segid[8];      /**< required segment name string, or ""   */
-#if 0 && vmdplugin_ABIVERSION > 17
+#if 0 && vmdplugin_ABIVERSION > 10000
   /* The new PDB file formats allows for much larger structures, */
   /* which can therefore require longer chain ID strings.  The   */
   /* new PDBx/mmCIF file formats do not have length limits on    */
@@ -839,6 +839,29 @@ typedef struct {
   int (* read_qm_rundata)(void *, molfile_qm_t *qmdata);
 
 
+  /**
+   * Query the molfile plugin to determine whether or not memory
+   * allocations used for atomic coordinates and PBC unit cell information
+   * need to be aligned to a particular virtual memory or filesystem 
+   * page size boundary to facilitate kernel-bypass unbuffered I/O,
+   * e.g., as used by jsplugin.  This API should be called prior to the
+   * first call to read a timestep.  The required page alignment size 
+   * (in bytes) is returned to the caller.  If this API has not been 
+   * called, then the molfile plugin should revert to standard 
+   * kernel-buffered I/O and suffer the associated performance loss.
+   * The caller can be assured that the plugin will not request any 
+   * page alignment size that is greater than the value of 
+   * MOLFILE_DIRECTIO_MAX_BLOCK_SIZE, both as a runtime sanity check,
+   * and to ensure that a caller that is unable to perform the max 
+   * aligned allocation doesn't call the API in the first place.
+   * If a page-aligned allocation is not required for the file being read,
+   * the plugin will return an alignment size of 1. 
+   */ 
+#if vmdplugin_ABIVERSION > 17
+  int (* read_timestep_pagealign_size)(void *, int *pagealignsize);
+#endif
+
+
   /**
    * Read the next timestep from the file.  Return MOLFILE_SUCCESS, or 
    * MOLFILE_EOF on EOF.  If the molfile_timestep_t or molfile_qm_metadata_t
index aa04d7b..1bd32cf 100644 (file)
@@ -10,8 +10,8 @@
  * RCS INFORMATION:
  *
  *      $RCSfile: vmdplugin.h,v $
- *      $Author: jim $       $Locker:  $             $State: Exp $
- *      $Revision: 1.7 $       $Date: 2016/04/25 01:57:28 $
+ *      $Author: johns $       $Locker:  $             $State: Exp $
+ *      $Revision: 1.34 $       $Date: 2018/05/02 03:12:56 $
  *
  ***************************************************************************/
 
@@ -144,7 +144,7 @@ typedef struct {
 /**
  * Use this macro to initialize the abiversion member of each plugin
  */
-#define vmdplugin_ABIVERSION  17
+#define vmdplugin_ABIVERSION  18
 
 /*@{*/
 /** Use this macro to indicate a plugin's thread-safety at registration time */
index 728b77c..9cfc3e7 100644 (file)
@@ -10,8 +10,8 @@
  * RCS INFORMATION:
  *
  *      $RCSfile: dcdplugin.c,v $
- *      $Author: jim $       $Locker:  $             $State: Exp $
- *      $Revision: 1.8 $       $Date: 2017/03/29 21:38:53 $
+ *      $Author: johns $       $Locker:  $             $State: Exp $
+ *      $Revision: 1.80 $       $Date: 2018/03/06 21:13:36 $
  *
  ***************************************************************************
  * DESCRIPTION:
@@ -485,7 +485,7 @@ static int read_fixed_atoms(fio_fd fd, int N, int num_free, const int *indexes,
 }
   
 static int read_charmm_4dim(fio_fd fd, int charmm, int reverseEndian) {
-  int input_integer[2],rec_scale;
+  int input_integer[2], rec_scale;
 
   if (charmm & DCD_HAS_64BIT_REC) {
     rec_scale=RECSCALE64BIT;
@@ -524,8 +524,9 @@ static int read_dcdstep(fio_fd fd, int N, float *X, float *Y, float *Z,
                         float *unitcell, int num_fixed,
                         int first, int *indexes, float *fixedcoords, 
                         int reverseEndian, int charmm) {
-  int ret_val, rec_scale;   /* Return value from read */
-  
+  int ret_val;    /* Return value from read */
+  long rec_scale;
   if (charmm & DCD_HAS_64BIT_REC) {
     rec_scale=RECSCALE64BIT;
   } else {
@@ -535,7 +536,7 @@ static int read_dcdstep(fio_fd fd, int N, float *X, float *Y, float *Z,
   if ((num_fixed==0) || first) {
     /* temp storage for reading formatting info */
     /* note: has to be max size we'll ever use  */
-    int tmpbuf[6*RECSCALEMAX]; 
+    int tmpbuf[6L*RECSCALEMAX]; 
 
     fio_iovec iov[7];   /* I/O vector for fio_readv() call          */
     fio_size_t readlen; /* number of bytes actually read            */
@@ -559,18 +560,18 @@ static int read_dcdstep(fio_fd fd, int N, float *X, float *Y, float *Z,
     iov[1].iov_len  = sizeof(float)*N;
 
     iov[2].iov_base = (fio_caddr_t) &tmpbuf[1*rec_scale]; /* read 2 format integers */
-    iov[2].iov_len  = rec_scale*sizeof(int) * 2;
+    iov[2].iov_len  = rec_scale*sizeof(int) * 2L;
 
     iov[3].iov_base = (fio_caddr_t) Y;          /* read Y coordinates     */
     iov[3].iov_len  = sizeof(float)*N;
 
-    iov[4].iov_base = (fio_caddr_t) &tmpbuf[3*rec_scale]; /* read 2 format integers */
-    iov[4].iov_len  = rec_scale*sizeof(int) * 2;
+    iov[4].iov_base = (fio_caddr_t) &tmpbuf[3L*rec_scale]; /* read 2 format integers */
+    iov[4].iov_len  = rec_scale*sizeof(int) * 2L;
 
     iov[5].iov_base = (fio_caddr_t) Z;          /* read Y coordinates     */
     iov[5].iov_len  = sizeof(float)*N;
 
-    iov[6].iov_base = (fio_caddr_t) &tmpbuf[5*rec_scale]; /* read format integer    */
+    iov[6].iov_base = (fio_caddr_t) &tmpbuf[5L*rec_scale]; /* read format integer    */
     iov[6].iov_len  = rec_scale*sizeof(int);
 
 #if 1
@@ -598,26 +599,26 @@ static int read_dcdstep(fio_fd fd, int N, float *X, float *Y, float *Z,
     }
 #else
     readlen = fio_readv(fd, &iov[0], 7);
-    if (readlen != (rec_scale*6*sizeof(int) + 3*N*sizeof(float)))
+    if (readlen != (rec_scale*6L*sizeof(int) + 3L*N*sizeof(float)))
       return DCD_BADREAD;
 #endif
 
     /* convert endianism if necessary */
     if (reverseEndian) {
-      swap4_aligned(&tmpbuf[0], rec_scale*6);
+      swap4_aligned(&tmpbuf[0], rec_scale*6L);
       swap4_aligned(X, N);
       swap4_aligned(Y, N);
       swap4_aligned(Z, N);
     }
 
     /* double-check the fortran format size values for safety */
-    if(rec_scale == 1) {
+    if (rec_scale == 1) {
       for (i=0; i<6; i++) {
         if (tmpbuf[i] != sizeof(float)*N) return DCD_BADFORMAT;
       }
     } else {
       for (i=0; i<6; i++) {
-          if ((tmpbuf[2*i]+tmpbuf[2*i+1]) != sizeof(float)*N) return DCD_BADFORMAT;
+        if ((tmpbuf[2L*i]+tmpbuf[2L*i+1L]) != sizeof(float)*N) return DCD_BADFORMAT;
       }
     }
 
@@ -626,7 +627,7 @@ static int read_dcdstep(fio_fd fd, int N, float *X, float *Y, float *Z,
     if (num_fixed && first) {
       memcpy(fixedcoords, X, N*sizeof(float));
       memcpy(fixedcoords+N, Y, N*sizeof(float));
-      memcpy(fixedcoords+2*N, Z, N*sizeof(float));
+      memcpy(fixedcoords+2L*N, Z, N*sizeof(float));
     }
 
     /* read in the optional charmm 4th array */
@@ -641,13 +642,13 @@ static int read_dcdstep(fio_fd fd, int N, float *X, float *Y, float *Z,
     ret_val = read_charmm_extrablock(fd, charmm, reverseEndian, unitcell);
     if (ret_val) return ret_val;
     ret_val = read_fixed_atoms(fd, N, N-num_fixed, indexes, reverseEndian,
-                               fixedcoords, fixedcoords+3*N, X, charmm);
+                               fixedcoords, fixedcoords+3L*N, X, charmm);
     if (ret_val) return ret_val;
     ret_val = read_fixed_atoms(fd, N, N-num_fixed, indexes, reverseEndian,
-                               fixedcoords+N, fixedcoords+3*N, Y, charmm);
+                               fixedcoords+N, fixedcoords+3L*N, Y, charmm);
     if (ret_val) return ret_val;
     ret_val = read_fixed_atoms(fd, N, N-num_fixed, indexes, reverseEndian,
-                               fixedcoords+2*N, fixedcoords+3*N, Z, charmm);
+                               fixedcoords+2*N, fixedcoords+3L*N, Z, charmm);
     if (ret_val) return ret_val;
     ret_val = read_charmm_4dim(fd, charmm, reverseEndian);
     if (ret_val) return ret_val;
@@ -669,9 +670,8 @@ static int read_dcdstep(fio_fd fd, int N, float *X, float *Y, float *Z,
  *               next timestep.
  */
 static int skip_dcdstep(fio_fd fd, int natoms, int nfixed, int charmm) {
-  
-  int seekoffset = 0;
-  int rec_scale;
+  long seekoffset = 0;
+  long rec_scale;
 
   if (charmm & DCD_HAS_64BIT_REC) {
     rec_scale=RECSCALE64BIT;
@@ -681,15 +681,15 @@ static int skip_dcdstep(fio_fd fd, int natoms, int nfixed, int charmm) {
 
   /* Skip charmm extra block */
   if ((charmm & DCD_IS_CHARMM) && (charmm & DCD_HAS_EXTRA_BLOCK)) {
-    seekoffset += 4*rec_scale + 48 + 4*rec_scale;
+    seekoffset += 4L*rec_scale + 48L + 4L*rec_scale;
   }
 
   /* For each atom set, seek past an int, the free atoms, and another int. */
-  seekoffset += 3 * (2*rec_scale + natoms - nfixed) * 4;
+  seekoffset += 3L * (2L*rec_scale + natoms - nfixed) * 4L;
 
   /* Assume that charmm 4th dim is the same size as the other three. */
   if ((charmm & DCD_IS_CHARMM) && (charmm & DCD_HAS_4DIMS)) {
-    seekoffset += (2*rec_scale + natoms - nfixed) * 4;
+    seekoffset += (2L*rec_scale + natoms - nfixed) * 4L;
   }
  
   if (fio_fseek(fd, seekoffset, FIO_SEEK_CUR)) return DCD_BADEOF;
@@ -916,7 +916,10 @@ static void *open_dcd_read(const char *path, const char *filetype,
     newnsets = trjsize / framesize + 1;
 
     if (dcd->nsets > 0 && newnsets != dcd->nsets) {
-      printf("dcdplugin) Warning: DCD header claims %d frames, file size indicates there are actually %d frames\n", dcd->nsets, newnsets);
+      printf("dcdplugin) Warning: DCD header claims %d frames, but \n"
+             "dcdplugin) file size (%l) indicates there are actually \n"
+             "%d frames of size (%l)\n", 
+             dcd->nsets, trjsize, newnsets, framesize);
     }
 
     dcd->nsets = newnsets; 
@@ -1153,7 +1156,7 @@ VMDPLUGIN_API int VMDPLUGIN_init() {
   plugin.prettyname = "CHARMM,NAMD,XPLOR DCD Trajectory";
   plugin.author = "Axel Kohlmeyer, Justin Gullingsrud, John Stone";
   plugin.majorv = 1;
-  plugin.minorv = 12;
+  plugin.minorv = 13;
   plugin.is_reentrant = VMDPLUGIN_THREADSAFE;
   plugin.filename_extension = "dcd";
   plugin.open_file_read = open_dcd_read;
index 6acce56..06af6c2 100644 (file)
@@ -9,8 +9,8 @@
  * RCS INFORMATION:
  *
  *      $RCSfile: endianswap.h,v $
- *      $Author: jim $       $Locker:  $             $State: Exp $
- *      $Revision: 1.6 $       $Date: 2017/03/29 21:38:53 $
+ *      $Author: johns $       $Locker:  $             $State: Exp $
+ *      $Revision: 1.7 $       $Date: 2016/11/28 05:01:53 $
  *
  ***************************************************************************
  * DESCRIPTION:
index e996864..3be0b4f 100644 (file)
@@ -9,8 +9,8 @@
  * RCS INFORMATION:
  *
  *      $RCSfile: fastio.h,v $
- *      $Author: jim $       $Locker:  $             $State: Exp $
- *      $Revision: 1.9 $       $Date: 2017/03/29 21:38:15 $
+ *      $Author: johns $       $Locker:  $             $State: Exp $
+ *      $Revision: 1.34 $       $Date: 2016/11/28 05:01:53 $
  *
  ***************************************************************************
  * DESCRIPTION:
index e5ce57a..6fad94d 100644 (file)
@@ -10,8 +10,8 @@
  * RCS INFORMATION:
  *
  *      $RCSfile: fortread.h,v $
- *      $Author: jim $       $Locker:  $             $State: Exp $
- *      $Revision: 1.4 $       $Date: 2017/03/29 21:38:53 $
+ *      $Author: johns $       $Locker:  $             $State: Exp $
+ *      $Revision: 1.10 $       $Date: 2016/11/28 05:01:54 $
  *
  ***************************************************************************
  * DESCRIPTION:
index a63ba89..03584fa 100644 (file)
@@ -10,8 +10,8 @@
  * RCS INFORMATION:
  *
  *      $RCSfile: hash.c,v $
- *      $Author: jim $        $Locker:  $             $State: Exp $
- *      $Revision: 1.5 $      $Date: 2017/03/29 21:38:53 $
+ *      $Author: johns $        $Locker:  $             $State: Exp $
+ *      $Revision: 1.7 $      $Date: 2016/11/28 05:01:54 $
  *
  ***************************************************************************
  * DESCRIPTION:
index 8cfa312..49a9e69 100644 (file)
@@ -10,8 +10,8 @@
  * RCS INFORMATION:
  *
  *      $RCSfile: hash.h,v $
- *      $Author: jim $        $Locker:  $             $State: Exp $
- *      $Revision: 1.5 $      $Date: 2017/03/29 21:38:53 $
+ *      $Author: johns $        $Locker:  $             $State: Exp $
+ *      $Revision: 1.9 $      $Date: 2016/11/28 05:01:54 $
  *
  ***************************************************************************
  * DESCRIPTION:
index 25b5123..82da24d 100644 (file)
@@ -10,8 +10,8 @@
  * RCS INFORMATION:
  *
  *      $RCSfile: jsplugin.c,v $
- *      $Author: jim $       $Locker:  $             $State: Exp $
- *      $Revision: 1.7 $       $Date: 2017/03/30 19:53:15 $
+ *      $Author: johns $       $Locker:  $             $State: Exp $
+ *      $Revision: 1.80 $       $Date: 2018/05/04 16:24:56 $
  *
  ***************************************************************************
  * DESCRIPTION:
@@ -118,7 +118,7 @@ static void *alloc_aligned_ptr(size_t sz, size_t blocksz, void **unalignedptr) {
 #define JSENDIANISM      0x12345678
 
 #define JSMAJORVERSION   2
-#define JSMINORVERSION   15
+#define JSMINORVERSION   16
 
 #define JSNFRAMESOFFSET  (strlen(JSHEADERSTRING) + 20)
 
@@ -171,6 +171,7 @@ typedef struct {
   char *path;                  /* path to file                          */
 
   /* info for block-based direct I/O */ 
+  int directio_pgsize_queried; /* caller has queried page/blocksz       */
   int directio_enabled;        /* block-based direct I/O is available   */
   fio_fd directio_fd;          /* block-based direct I/O using O_DIRECT */
   int directio_block_size;     /* block size to use for direct ts I/O   */
@@ -207,15 +208,31 @@ typedef struct {
   double tsdelta;
   int reverseendian;
   int with_unitcell;
-
 } jshandle;
 
 
+/* report the block size required to read this JS file */
+static int read_js_timestep_pagealign_size(void *v, int *pagealignsz) {
+  jshandle *js = (jshandle *)v;
+
+  // mark that the caller has queried the page alignment size
+  js->directio_pgsize_queried = 1;
+
+  /* assigne page alignment size based on file contents */
+  if (js->optflags & JSOPT_TS_BLOCKIO) 
+    *pagealignsz = js->directio_block_size;
+  else 
+    *pagealignsz = 1;
+
+  return 0;
+}
+
+
 /* Use block-based I/O by default when writing structures larger */
 /* than JSBLOCKIO_THRESH atoms, or when directed by the user and */
 /* not otherwise prohibited...                                   */
 static void js_blockio_check_and_set(jshandle *js) {
-  if ( 0 && (getenv("VMDJSNOBLOCKIO") == NULL) && 
+  if ((getenv("VMDJSNOBLOCKIO") == NULL) && 
       ((js->natoms > JSBLOCKIO_THRESH) || getenv("VMDJSBLOCKIO"))) {
     js->optflags |= JSOPT_TS_BLOCKIO;
     js->directio_block_size = MOLFILE_DIRECTIO_MIN_BLOCK_SIZE; 
@@ -249,6 +266,7 @@ static void *open_js_read(const char *path, const char *filetype, int *natoms) {
   js->directio_ucell_ptr = NULL;
   js->directio_ucell_blkbuf = NULL;
 
+  js->directio_pgsize_queried=0;
   js->directio_enabled=0;
   js->ts_file_offset=0;
   js->ts_crd_sz=0;
@@ -324,6 +342,65 @@ static void *open_js_read(const char *path, const char *filetype, int *natoms) {
   js->path = (char *) calloc(strlen(path)+1, 1);
   strcpy(js->path, path);
 
+#if 1
+  /* read flags data from the file */
+  fio_read_int32(js->fd, &js->optflags); 
+  if (js->reverseendian)
+    swap4_aligned(&js->optflags, 1);
+
+#if defined(INFOMSGS)
+  if (js->verbose)
+    printf("jsplugin) read option flags: %0x08x\n", js->optflags);
+#endif
+
+  /* Check to see if block-based trajectory I/O is used  */
+  /* and read in the block size for this file.           */
+  if (js->optflags & JSOPT_TS_BLOCKIO) {
+    fio_fread(&js->directio_block_size, sizeof(int), 1, js->fd);
+    if (js->reverseendian)
+      swap4_aligned(&js->directio_block_size, 1);
+
+#if defined(INFOMSGS)
+    if (js->verbose) {
+      printf("jsplugin) File uses direct I/O block size: %d bytes\n", 
+             js->directio_block_size);
+    }
+#endif
+
+    /* Check to ensure that we can handle the block size used by the */
+    /* file we are reading.  We may use variable block sizes in      */
+    /* the future as more high-end filesystems begin to support      */
+    /* 8KB, 16KB, or larger block sizes for enhanced sequential I/O  */
+    /* performance on very large files.                              */
+    if (js->directio_block_size > MOLFILE_DIRECTIO_MAX_BLOCK_SIZE) {
+      printf("jsplugin) File block size exceeds jsplugin block size limit.\n");
+      printf("jsplugin) Direct I/O unavailable for file '%s'\n", js->path);
+    } else {
+      if (fio_open(js->path, FIO_READ | FIO_DIRECT, &js->directio_fd) < 0) {
+        printf("jsplugin) Direct I/O unavailable for file '%s'\n", js->path);
+      } else {
+        js->directio_enabled = 1;
+      } 
+    }
+  }
+
+#if defined(ENABLEJSSHORTREADS)
+  /* test code for an implementation that does short reads that */
+  /* skip bulk solvent, useful for faster loading of very large */
+  /* structures                                                 */
+  if (getenv("VMDJSMAXATOMIDX") != NULL) {
+    long maxatomidx = atoi(getenv("VMDJSMAXATOMIDX"));
+    if (maxatomidx < 0)
+      maxatomidx = 0;
+    if (maxatomidx >= js->natoms)
+      maxatomidx = js->natoms - 1;
+
+    printf("jsplugin) Short-reads of timesteps enabled: %ld / %ld atoms (%.2f%%)\n",
+           maxatomidx, js->natoms, 100.0*(maxatomidx+1) / ((double) js->natoms));
+  }
+#endif
+#endif
+
   return js;
 }
 
@@ -411,6 +488,7 @@ static int read_js_structure(void *mydata, int *optflags,
   if (optflags != NULL)
     *optflags = MOLFILE_NOOPTIONS; /* set to no options until we read them */
 
+#if 0
   /* read flags data from the file */
   fio_read_int32(js->fd, &js->optflags); 
   if (js->reverseendian)
@@ -430,7 +508,7 @@ static int read_js_structure(void *mydata, int *optflags,
 
 #if defined(INFOMSGS)
     if (js->verbose) {
-      printf("jsplugin) Block-based I/O enabled: block size %d bytes\n", 
+      printf("jsplugin) File uses direct I/O block size: %d bytes\n", 
              js->directio_block_size);
     }
 #endif
@@ -448,15 +526,31 @@ static int read_js_structure(void *mydata, int *optflags,
         printf("jsplugin) Direct I/O unavailable for file '%s'\n", js->path);
       } else {
         js->directio_enabled = 1;
-#if defined(INFOMSGS)
-        if (js->verbose) {
-          printf("jsplugin) Direct I/O enabled for file '%s'\n", js->path);
-        }
-#endif
       } 
     }
   }
+#endif
+
+
+  /* emit warning message if the caller didn't check the required */
+  /* alignment size, but the file supports block based direct I/O */
+  if (js->directio_enabled && !js->directio_pgsize_queried) {
+    printf("jsplugin) Warning: File supports block-based direct I/O, but\n");
+    printf("jsplugin)          caller failed to query required alignment.\n");
+    printf("jsplugin)          Block-based direct I/O is now disabled.\n");
+     
+    js->directio_enabled=0; // ensure we disable direct I/O early on
+  }
+
+#if defined(INFOMSGS)
+  if (js->verbose) {
+    printf("jsplugin) Direct I/O %sabled for file '%s'\n", 
+           (js->directio_enabled) ? "en" : "dis", js->path);
+  }
+#endif
+
 
+#if 0
 #if defined(ENABLEJSSHORTREADS)
   /* test code for an implementation that does short reads that */
   /* skip bulk solvent, useful for faster loading of very large */
@@ -471,6 +565,7 @@ static int read_js_structure(void *mydata, int *optflags,
     printf("jsplugin) Short-reads of timesteps enabled: %ld / %ld atoms (%.2f%%)\n",
            maxatomidx, js->natoms, 100.0*(maxatomidx+1) / ((double) js->natoms));
   }
+#endif
 #endif
 
   /* Mark the handle to indicate we've parsed the structure.             */
@@ -958,6 +1053,7 @@ static int read_js_structure(void *mydata, int *optflags,
       if (js->reverseendian)
         swap4_aligned(js->impropers, 4L*js->numimpropers);
     }
+
     if (js->optflags & JSOPT_CTERMS) {
       fio_fread(&js->numcterms, sizeof(int), 1, js->fd);
       if (js->reverseendian)
@@ -1126,7 +1222,7 @@ static int read_js_timestep(void *v, int natoms, molfile_timestep_t *ts) {
 
   /* if we have a valid ts pointer, read the timestep, otherwise skip it */ 
   if (ts != NULL) {
-    fio_size_t readlen
+    fio_size_t readlen=0;
     fio_iovec iov[2];
 
     /* set unit cell pointer to the TS block-aligned buffer area */
@@ -1181,10 +1277,16 @@ static int read_js_timestep(void *v, int natoms, molfile_timestep_t *ts) {
  
     /* setup the I/O vector */
     iov[0].iov_base = (fio_caddr_t) ts->coords;   /* read coordinates    */
-    iov[0].iov_len  = js->ts_crd_padsz;
     iov[1].iov_base = (fio_caddr_t) unitcell;     /* read PBC unit cell  */
-    iov[1].iov_len  = js->ts_ucell_padsz;
 
+    if (js->directio_enabled) {
+      iov[0].iov_len  = js->ts_crd_padsz;
+      iov[1].iov_len  = js->ts_ucell_padsz;
+    } else {
+      iov[0].iov_len  = js->ts_crd_sz;
+      iov[1].iov_len  = js->ts_ucell_sz;
+    }
+   
 #if 1
     /* Use fall-back code instead of readv():                            */
     /*  Some platforms implement readv() as user level code in libc,     */
@@ -1200,8 +1302,16 @@ static int read_js_timestep(void *v, int natoms, molfile_timestep_t *ts) {
         readcnt =  fio_fread(iov[0].iov_base, iov[0].iov_len, 1, js->directio_fd);
         readcnt += fio_fread(iov[1].iov_base, iov[1].iov_len, 1, js->directio_fd);
       } else {
+        fio_size_t seeklen=0;
+      
         readcnt =  fio_fread(iov[0].iov_base, iov[0].iov_len, 1, js->fd);
+        seeklen = js->ts_crd_padsz - js->ts_crd_sz;
+        if (seeklen > 0)
+          fio_fseek(js->fd, seeklen, FIO_SEEK_CUR);
         readcnt += fio_fread(iov[1].iov_base, iov[1].iov_len, 1, js->fd);
+        seeklen = js->ts_ucell_padsz - js->ts_ucell_sz;
+        if (seeklen > 0)
+          fio_fseek(js->fd, seeklen, FIO_SEEK_CUR);
       }
 
       /* if both records read correctly, then the reads are okay */
@@ -1212,10 +1322,24 @@ static int read_js_timestep(void *v, int natoms, molfile_timestep_t *ts) {
     /* Do all of the reads with a single syscall, for peak efficiency.   */
     /* On smart kernels, readv() causes only one context switch, and     */
     /* can effeciently scatter the reads to the various buffers.         */
-    if (js->directio_enabled)
+    if (js->directio_enabled) {
       readlen = fio_readv(js->directio_fd, &iov[0], 2); 
-    else
-      readlen = fio_readv(js->fd, &iov[0], 2); 
+    } else {
+      // XXX we can't use readv() when not using direct I/O since we 
+      // can't make intervening seek calls required if the caller
+      // doesn't provide appropriate buffers.
+      // readlen = fio_readv(js->fd, &iov[0], 2); 
+
+      fio_size_t seeklen=0;
+      readcnt =  fio_fread(iov[0].iov_base, iov[0].iov_len, 1, js->fd);
+      seeklen = js->ts_crd_padsz - js->ts_crd_sz;
+      if (seeklen > 0)
+        fio_fseek(js->fd, seeklen, FIO_SEEK_CUR);
+      readcnt += fio_fread(iov[1].iov_base, iov[1].iov_len, 1, js->fd);
+      seeklen = js->ts_ucell_padsz - js->ts_ucell_sz;
+      if (seeklen > 0)
+        fio_fseek(js->fd, seeklen, FIO_SEEK_CUR);
+    }
 #endif
 
 #if defined(ENABLEJSSHORTREADS)
@@ -1971,6 +2095,9 @@ VMDPLUGIN_API int VMDPLUGIN_init() {
 #endif
   plugin.write_timestep = write_js_timestep;
   plugin.close_file_write = close_js_write;
+#if vmdplugin_ABIVERSION > 17
+  plugin.read_timestep_pagealign_size = read_js_timestep_pagealign_size;
+#endif
   return VMDPLUGIN_SUCCESS;
 }
 
index b623937..4495e1c 100644 (file)
@@ -10,8 +10,8 @@
  * RCS INFORMATION:
  *
  *      $RCSfile: largefiles.h,v $
- *      $Author: jim $       $Locker:  $             $State: Exp $
- *      $Revision: 1.5 $       $Date: 2017/03/29 21:38:53 $
+ *      $Author: johns $       $Locker:  $             $State: Exp $
+ *      $Revision: 1.4 $       $Date: 2016/11/28 05:01:54 $
  *
  ***************************************************************************
  * DESCRIPTION:
index 016f47e..8397178 100644 (file)
@@ -10,8 +10,8 @@
  * RCS INFORMATION:
  *
  *      $RCSfile: namdbinplugin.c,v $
- *      $Author: jim $       $Locker:  $             $State: Exp $
- *      $Revision: 1.4 $       $Date: 2017/03/29 21:38:53 $
+ *      $Author: johns $       $Locker:  $             $State: Exp $
+ *      $Revision: 1.23 $       $Date: 2016/11/28 05:01:54 $
  *
  ***************************************************************************/
 
index f652574..18cd9fb 100644 (file)
@@ -10,8 +10,8 @@
  * RCS INFORMATION:
  *
  *      $RCSfile: pdbplugin.c,v $
- *      $Author: jim $       $Locker:  $             $State: Exp $
- *      $Revision: 1.4 $       $Date: 2017/03/29 21:38:53 $
+ *      $Author: johns $       $Locker:  $             $State: Exp $
+ *      $Revision: 1.73 $       $Date: 2016/11/28 05:01:54 $
  *
  ***************************************************************************/
 
index 82a10dd..36f9e5a 100644 (file)
@@ -2,8 +2,8 @@
  * RCS INFORMATION:
  *
  *      $RCSfile: periodic_table.h,v $
- *      $Author: jim $       $Locker:  $             $State: Exp $
- *      $Revision: 1.3 $       $Date: 2012/01/27 01:41:54 $
+ *      $Author: johns $       $Locker:  $             $State: Exp $
+ *      $Revision: 1.12 $       $Date: 2009/01/21 17:45:41 $
  *
  ***************************************************************************/
 
index 6f6c802..012a161 100644 (file)
@@ -10,8 +10,8 @@
  * RCS INFORMATION:
  *
  *      $RCSfile: psfplugin.c,v $
- *      $Author: jim $       $Locker:  $             $State: Exp $
- *      $Revision: 1.10 $       $Date: 2017/03/29 21:38:53 $
+ *      $Author: johns $       $Locker:  $             $State: Exp $
+ *      $Revision: 1.83 $       $Date: 2016/11/28 05:01:54 $
  *
  ***************************************************************************/
 
index fe87134..d3c8798 100644 (file)
@@ -10,8 +10,8 @@
  * RCS INFORMATION:
  *
  *      $RCSfile: readpdb.h,v $
- *      $Author: jim $       $Locker:  $             $State: Exp $
- *      $Revision: 1.4 $       $Date: 2017/03/29 21:38:53 $
+ *      $Author: johns $       $Locker:  $             $State: Exp $
+ *      $Revision: 1.43 $       $Date: 2016/11/28 05:01:54 $
  *
  ***************************************************************************/