Added mmap support for references.

This greatly reduces memory usage when many jobs are running on the
same machine as the references are then shared between processes.

Author: jkbonfield

cram/cram_io.c

@@ -1462,6 +1462,19 @@ int paranoid_fclose(FILE *fp) {
  * track the number of callers interested in any specific reference.
  */
 
+/*
+ * Frees/unmaps a reference sequence and associated file handles.
+ */
+static void ref_entry_free_seq(ref_entry *e) {
+    if (e->mf)
+	mfclose(e->mf);
+    if (e->seq && !e->mf)
+	free(e->seq);
+
+    e->seq = NULL;
+    e->mf = NULL;
+}
+
 void refs_free(refs_t *r) {
     RP("refs_free()\n");
 
@@ -1484,8 +1497,7 @@ void refs_free(refs_t *r) {
 		continue;
 	    if (!(e = kh_val(r->h_meta, k)))
 		continue;
-	    if (e->seq)
-		free(e->seq);
+	    ref_entry_free_seq(e);
 	    free(e);
 	}
 
@@ -1660,6 +1672,7 @@ static refs_t *refs_load_fai(refs_t *r_orig, char *fn, int is_err) {
 
 	e->count = 0;
 	e->seq = NULL;
+	e->mf = NULL;
 
 	k = kh_put(refs, r->h_meta, e->name, &n);
 	if (-1 == n)  {
@@ -2027,6 +2040,13 @@ static int cram_populate_ref(cram_fd *fd, int id, ref_entry *r) {
     if ((mf = open_path_mfile(tag->str+3, ref_path, NULL))) {
 	size_t sz;
 	r->seq = mfsteal(mf, &sz);
+	if (r->seq) {
+	    r->mf = NULL;
+	} else {
+	    // keep mf around as we couldn't detach
+	    r->seq = mf->data;
+	    r->mf = mf;
+	}
 	r->length = sz;
     } else {
 	refs_t *refs;
@@ -2141,8 +2161,7 @@ static void cram_ref_decr_locked(refs_t *r, int id) {
 		r->ref_id[r->last_id]->seq) {
 		RP("%d FREE REF %d (%p)\n", gettid(),
 		   r->last_id, r->ref_id[r->last_id]->seq);
-		free(r->ref_id[r->last_id]->seq);
-		r->ref_id[r->last_id]->seq = NULL;
+		ref_entry_free_seq(r->ref_id[r->last_id]);
 		r->ref_id[r->last_id]->length = 0;
 	    }
 	}
@@ -2257,10 +2276,8 @@ ref_entry *cram_ref_load(refs_t *r, int id) {
 	assert(r->last->count > 0);
 	if (--r->last->count <= 0) {
 	    RP("%d FREE REF %d (%p)\n", gettid(), id, r->ref_id[id]->seq);
-	    if (r->last->seq) {
-		free(r->last->seq);
-		r->last->seq = NULL;
-	    }
+	    if (r->last->seq)
+		ref_entry_free_seq(r->last);
 	}
     }
 
@@ -2284,6 +2301,7 @@ ref_entry *cram_ref_load(refs_t *r, int id) {
 
     RP("%d INC REF %d, %d\n", gettid(), id, (int)(e->count+1));
     e->seq = seq;
+    e->mf = NULL;
     e->count++;
 
     /*

cram/cram_structs.h

@@ -50,6 +50,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "cram/thread_pool.h"
 #include "cram/string_alloc.h"
+#include "cram/mFILE.h"
 #include "htslib/khash.h"
 
 #ifdef __cplusplus
@@ -585,6 +586,7 @@ typedef struct ref_entry {
     int line_length;
     int64_t count;	   // for shared references so we know to dealloc seq
     char *seq;
+    mFILE *mf;
 } ref_entry;
 
 KHASH_MAP_INIT_STR(refs, ref_entry*)

cram/mFILE.c

@@ -47,6 +47,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "cram/mFILE.h"
 #include "cram/vlen.h"
 
+#include <sys/mman.h>
+
 /*
  * This file contains memory-based versions of the most commonly used
  * (by io_lib) stdio functions.
@@ -106,6 +108,33 @@ static char *mfload(FILE *fp, const char *fn, size_t *size, int binary) {
     return data;
 }
 
+
+#ifdef HAVE_MMAP
+/*
+ * mmaps in the file, but only for reading currently.
+ *
+ * Returns 0 on success
+ *        -1 on failure
+ */
+int mfmmap(mFILE *mf, FILE *fp, const char *fn) {
+    struct stat sb;
+
+    if (stat(fn, &sb) != 0)
+	return -1;
+
+    mf->size = sb.st_size;
+    mf->data = mmap(NULL, mf->size, PROT_READ, MAP_SHARED,
+		    fileno(fp), 0);
+
+    if (!mf->data)
+	return -1;
+
+    mf->alloced = 0;
+    return 0;
+}
+#endif
+
+
 /*
  * Creates and returns m_channel[0].
  * We initialise this on the first attempted read, which then slurps in
@@ -233,6 +262,8 @@ mFILE *mfreopen(const char *path, const char *mode_str, FILE *fp) {
      * w = write on close
      * a = position at end of buffer
      * x = position at same location as the original fp, don't seek on flush
+     * + = for update (read and write)
+     * m = mmap (read only)
      */
     if (strchr(mode_str, 'r'))
 	r = 1, mode |= MF_READ;
@@ -249,15 +280,29 @@ mFILE *mfreopen(const char *path, const char *mode_str, FILE *fp) {
 	if (a)
 	    r = 1;
     }
+#ifdef HAVE_MMAP
+    if (strchr(mode_str, 'm'))
+	if (!w) mode |= MF_MMAP;
+#endif
 
     if (r) {
 	mf = mfcreate(NULL, 0);
 	if (NULL == mf) return NULL;
 	if (!(mode & MF_TRUNC)) {
-	    mf->data = mfload(fp, path, &mf->size, b);
-	    mf->alloced = mf->size;
-	    if (!a)
-		fseek(fp, 0, SEEK_SET);
+#ifdef HAVE_MMAP
+	    if (mode & MF_MMAP) {
+		if (mfmmap(mf, fp, path) == -1) {
+		    mf->data = NULL;
+		    mode &= ~MF_MMAP;
+		}
+	    }
+#endif
+	    if (!mf->data) {
+		mf->data = mfload(fp, path, &mf->size, b);
+		mf->alloced = mf->size;
+		if (!a)
+		    fseek(fp, 0, SEEK_SET);
+	    }
 	}
     } else if (w) {
 	/* Write - initialise the data structures */
@@ -307,6 +352,14 @@ int mfclose(mFILE *mf) {
 
     mfflush(mf);
 
+#ifdef HAVE_MMAP
+    if ((mf->mode & MF_MMAP) && mf->data) {
+	/* Mmaped */
+	munmap(mf->data, mf->size);
+	mf->data = NULL;
+    }
+#endif
+
     if (mf->fp)
 	fclose(mf->fp);
 
@@ -318,12 +371,16 @@ int mfclose(mFILE *mf) {
 /*
  * Closes the file pointer contained within the mFILE without destroying
  * the in-memory data.
+ *
+ * Attempting to do this on an mmaped buffer is an error.
  */
 int mfdetach(mFILE *mf) {
     if (!mf)
 	return -1;
 
     mfflush(mf);
+    if (mf->mode & MF_MMAP)
+	return -1;
 
     if (mf->fp) {
 	fclose(mf->fp);
@@ -352,6 +409,8 @@ int mfdestroy(mFILE *mf) {
  * It is up to the caller to free the stolen buffer.  If size_out is
  * not NULL, mf->size will be stored in it.
  * This is more-or-less the opposite of mfcreate().
+ *
+ * Note, we cannot steal the allocated buffer from an mmaped mFILE.
  */
 
 void *mfsteal(mFILE *mf, size_t *size_out) {
@@ -363,7 +422,9 @@ void *mfsteal(mFILE *mf, size_t *size_out) {
 
     if (NULL != size_out) *size_out = mf->size;
 
-    mfdetach(mf);
+    if (mfdetach(mf) != 0)
+	return NULL;
+
     mf->data = NULL;
     mfdestroy(mf);
 

cram/mFILE.h

@@ -54,6 +54,7 @@ typedef struct {
 #define MF_BINARY  8
 #define MF_TRUNC  16
 #define MF_MODEX  32
+#define MF_MMAP   64
 
 mFILE *mfreopen(const char *path, const char *mode, FILE *fp);
 mFILE *mfopen(const char *path, const char *mode);

cram/open_trace_file.c

@@ -259,7 +259,7 @@ static mFILE *find_file_dir(char *file, char *dirname) {
     }
 
     if (is_file(path)) {
-	return mfopen(path, "rb");
+	return mfopen(path, "rbm");
     }
 
     return NULL;