Make a gkpStore pointer mandatory for creating an ovOverlap object.

src/bogart/AS_BAT_OverlapCache.C

@@ -199,7 +199,7 @@ OverlapCache::OverlapCache(ovStore *ovlStoreUniq,
 
   _maxPer  = maxOverlaps;
 
-  _ovs     = new ovOverlap [_ovsMax];
+  _ovs     = ovOverlap::allocateOverlaps(NULL, _ovsMax);  //  So can't call bgn or end.
   _ovsSco  = new uint64     [_ovsMax];
   _ovsTmp  = new uint64     [_ovsMax];
 
@@ -550,7 +550,7 @@ OverlapCache::loadOverlaps(double erate, uint32 minOverlap, const char *prefix,
       delete [] _ovs;
       delete [] _ovsSco;
       delete [] _ovsTmp;
-      _ovs    = new ovOverlap [_ovsMax];
+      _ovs    = ovOverlap::allocateOverlaps(NULL, _ovsMax);  //  So can't call bgn or end.
       _ovsSco = new uint64     [_ovsMax];
       _ovsTmp = new uint64     [_ovsMax];
       _memUsed += (_ovsMax) * sizeof(ovOverlap);

src/correction/filterCorrectionOverlaps.C

@@ -157,8 +157,8 @@ main(int argc, char **argv) {
 
   uint32      ovlLen = 0;
   uint32      ovlMax = 131072;
-  ovOverlap *ovl    = new ovOverlap [ovlMax];
-  ovOverlap  swapped;
+  ovOverlap  *ovl    = ovOverlap::allocateOverlaps(gkpStore, ovlMax);
+  ovOverlap  swapped(gkpStore);
 
   uint32      histLen = 0;
   uint32      histMax = ovlMax;

src/correction/generateCorrectionLayouts.C

@@ -355,7 +355,7 @@ main(int argc, char **argv) {
 
   uint32       ovlMax = 1024 * 1024;
   uint32       ovlLen = 0;
-  ovOverlap  *ovl    = new ovOverlap [ovlMax];
+  ovOverlap   *ovl    = ovOverlap::allocateOverlaps(gkpStore, ovlMax);
 
   ovlLen = ovlStore->readOverlaps(ovl, ovlMax, true);
 

src/erateEstimate/erateEstimate.C

@@ -423,7 +423,7 @@ outputOverlaps(gkStore           *gkpStore,
   //  walk down each.
 
   uint32            overlapblock = 100000000;
-  ovOverlap       *overlapsload = new ovOverlap [overlapblock];
+  ovOverlap        *overlapsload = ovOverlap::allocateOverlaps(gkpStore, overlapblock);
 
   for (uint64 no=0; no<numOvls; ) {
     uint64 nLoad  = inpStore->readOverlaps(overlapsload, overlapblock, false);
@@ -669,7 +669,7 @@ main(int argc, char **argv) {
   } else {
     FILE             *ESTcache     = NULL;
     uint32            overlapblock = 100000000;
-    ovOverlap       *overlapsload = new ovOverlap [overlapblock];
+    ovOverlap        *overlapsload = ovOverlap::allocateOverlaps(gkpStore, overlapblock);
 
     overlaps       = new ESToverlap [numOvls];
 

src/mhap/mhapConvert.C

@@ -67,7 +67,7 @@ main(int argc, char **argv) {
 
   char        *ovStr = new char [1024];
 
-  ovOverlap   ov;
+  ovOverlap   ov(NULL);
   ovFile      *of = new ovFile(outName, ovFileFullWrite);
 
   for (uint32 ff=0; ff<files.size(); ff++) {

src/overlapBasedTrimming/splitReads.C

@@ -148,7 +148,7 @@ main(int argc, char **argv) {
 
   uint32      ovlLen = 0;
   uint32      ovlMax = 64 * 1024;
-  ovOverlap *ovl    = new ovOverlap [ovlMax];
+  ovOverlap  *ovl    = ovOverlap::allocateOverlaps(gkp, ovlMax);
 
   memset(ovl, 0, sizeof(ovOverlap) * ovlMax);
 

src/overlapBasedTrimming/trimReads.C

@@ -235,7 +235,7 @@ main(int argc, char **argv) {
 
   uint32      ovlLen       = 0;
   uint32      ovlMax       = 64 * 1024;
-  ovOverlap *ovl          = new ovOverlap [ovlMax];
+  ovOverlap  *ovl          = ovOverlap::allocateOverlaps(gkp, ovlMax);
 
   memset(ovl, 0, sizeof(ovOverlap) * ovlMax);
 

src/overlapErrorAdjustment/correctOverlaps-Read_Olaps.C

@@ -25,7 +25,7 @@ Read_Olaps(coParameters *G, gkStore *gkpStore) {
   G->olaps    = new Olap_Info_t [numolaps];
   G->olapsLen = 0;
 
-  ovOverlap  olap;
+  ovOverlap  olap(gkpStore);
 
   while (ovs->readOverlap(&olap)) {
     G->olaps[G->olapsLen].a_iid  =  olap.a_iid;

src/overlapErrorAdjustment/findErrors-Read_Olaps.C

@@ -22,7 +22,7 @@ Read_Olaps(feParameters *G, gkStore *gkpStore) {
   G->olaps    = new Olap_Info_t [numolaps];
   G->olapsLen = 0;
 
-  ovOverlap  olap;
+  ovOverlap  olap(gkpStore);
 
   while (ovs->readOverlap(&olap)) {
     G->olaps[G->olapsLen].a_iid  =  olap.a_iid;

src/overlapInCore/overlapConvert.C

@@ -74,7 +74,7 @@ main(int argc, char **argv) {
 
   for (uint32 ff=0; ff<files.size(); ff++) {
     ovFile      *of = new ovFile(files[ff], ovFileFull);
-    ovOverlap   ov;
+    ovOverlap   ov(gkpStore);
 
     while (of->readOverlap(&ov))
       fputs(ov.toString(ovStr, dt, true), stdout);

src/overlapInCore/overlapImport.C

@@ -108,7 +108,7 @@ main(int argc, char **argv) {
 
   char         *S     = new char [1024];
   splitToWords  W;
-  ovOverlap    ov;
+  ovOverlap    ov(gkpStore);
 
   ovFile       *of    = (ovlFileName  == NULL) ? NULL : new ovFile(ovlFileName, ovFileFullWrite);
   ovStore      *os    = (ovlStoreName == NULL) ? NULL : new ovStore(ovlStoreName, gkpStore, ovStoreWrite);

src/overlapInCore/overlapInCore.C

@@ -134,7 +134,7 @@ Initialize_Work_Area(Work_Area_t *WA, int id) {
 
   WA->overlapsLen = 0;
   WA->overlapsMax = 1024 * 1024 / sizeof(ovOverlap);
-  WA->overlaps    = new ovOverlap [WA->overlapsMax];
+  WA->overlaps    = ovOverlap::allocateOverlaps(WA->gkpStore, WA->overlapsMax);
 
   allocated += sizeof(ovOverlap) * WA->overlapsMax;
 

src/overlapInCore/overlapPair.C

@@ -381,8 +381,8 @@ main(int argc, char **argv) {
 
   uint32       overlapsALen = 0;
   uint32       overlapsBLen = 0;
-  ovOverlap  *overlapsA    = new ovOverlap [overlapsMax];
-  ovOverlap  *overlapsB    = new ovOverlap [overlapsMax];
+  ovOverlap  *overlapsA    = ovOverlap::allocateOverlaps(gkpStore, overlapsMax);
+  ovOverlap  *overlapsB    = ovOverlap::allocateOverlaps(gkpStore, overlapsMax);
 
   //  Set the globals
 

src/stores/ovStore.C

@@ -430,7 +430,7 @@ ovStore::readOverlaps(uint32         iid,
   if (ovl == NULL) {
     ovlLen = 0;
     ovlMax = 65 * 1024;
-    ovl    = new ovOverlap [ovlMax];
+    ovl    = ovOverlap::allocateOverlaps(_gkp, ovlMax);
   }
 
   if (iid < ovl[0].a_iid)
@@ -456,7 +456,7 @@ ovStore::readOverlaps(uint32         iid,
     while (ovlMax < ovlLen) {
       ovlMax *= 2;
       delete [] ovl;
-      ovl = new ovOverlap [ovlMax];
+      ovl = ovOverlap::allocateOverlaps(_gkp, ovlMax);
     }
 
     //  Load the overlaps

src/stores/ovStore.H

@@ -131,13 +131,31 @@ enum ovOverlapDisplayType {
 
 
 class ovOverlap {
-public:
+private:
   ovOverlap() {
     clear();
   };
+
+public:
+  ovOverlap(gkStore *gkp) {
+    g = gkp;
+    clear();
+  };
+
   ~ovOverlap() {
   };
 
+  static
+  ovOverlap  *allocateOverlaps(gkStore *gkp, uint64 num) {
+    ovOverlap *r = new ovOverlap [num];
+
+    for (uint32 ii=0; ii<num; ii++)
+      r[ii].g = gkp;
+
+    return(r);
+  };
+
+
   //  Dovetail if any of the following are true:
   //    ahg3 == 0  &&  ahg5 == 0  (a is contained)
   //    ahg3 == 0  &&  bhg5 == 0  (a3' dovetail b5')
@@ -223,9 +241,6 @@ public:
 #endif
   };
 
-  //gkStore    *gkpStore(void)          { return(g); };
-  //void        gkpStore(gkStore *g_)   { g = g_;    };
-
   bool
   operator<(const ovOverlap &that) const {
     if (a_iid      < that.a_iid)       return(true);
@@ -261,6 +276,7 @@ public:
 };
 
 
+
 //  If ovOverlapWORD is uint32, we have no problems.
 
 //  If ovOverlapWORD is uint64, and we are internal, then we have a problem with the internal format.

src/stores/ovStoreBucketizer.C

@@ -274,8 +274,8 @@ main(int argc, char **argv) {
   fprintf(stderr, "Bucketizing %s\n", ovlInput);
 
   ovStoreFilter *filter = new ovStoreFilter(gkp, maxError);
-  ovOverlap     foverlap;
-  ovOverlap     roverlap;
+  ovOverlap     foverlap(gkp);
+  ovOverlap     roverlap(gkp);
   ovFile        *inputFile = new ovFile(ovlInput, ovFileFull);
 
   //  Do bigger buffers increase performance?  Do small ones hurt?

src/stores/ovStoreBuild.C

@@ -372,8 +372,8 @@ main(int argc, char **argv) {
   ovStoreFilter *filter = new ovStoreFilter(gkp, maxError);
 
   for (uint32 i=0; i<fileList.size(); i++) {
-    ovOverlap    foverlap;
-    ovOverlap    roverlap;
+    ovOverlap    foverlap(gkp);
+    ovOverlap    roverlap(gkp);
 
     fprintf(stderr, "bucketizing %s\n", fileList[i]);
 
@@ -421,7 +421,7 @@ main(int argc, char **argv) {
     if (dumpLengthMax < dumpLength[i])
       dumpLengthMax = dumpLength[i];
 
-  ovOverlap  *overlapsort = new ovOverlap [dumpLengthMax];
+  ovOverlap  *overlapsort = ovOverlap::allocateOverlaps(gkp, dumpLengthMax);
 
   time_t  beginTime = time(NULL);
 

src/stores/ovStoreDump.C

@@ -65,7 +65,7 @@ dumpStore(ovStore *ovlStore,
           ovOverlapDisplayType    type,
           bool     beVerbose) {
 
-  ovOverlap     overlap;
+  ovOverlap     overlap(gkpStore);
   uint64         evalue = AS_OVS_encodeEvalue(dumpERate);
   char           ovlString[1024];
 
@@ -314,8 +314,8 @@ dumpPicture(ovStore  *ovlStore,
   ovlStore->setRange(qryID, qryID);
 
   uint64         novl     = 0;
-  ovOverlap     overlap;
-  ovOverlap    *overlaps = new ovOverlap [ovlStore->numOverlapsInRange()];
+  ovOverlap     overlap(gkpStore);
+  ovOverlap    *overlaps = ovOverlap::allocateOverlaps(gkpStore, ovlStore->numOverlapsInRange());
   uint64         evalue   = AS_OVS_encodeEvalue(dumpERate);
 
   //  Load all the overlaps so we can sort by the A begin position.

src/stores/ovStoreSorter.C

@@ -35,11 +35,13 @@ using namespace std;
 int
 main(int argc, char **argv) {
   char           *storePath      = NULL;
-  uint32          fileLimit    = 512;   //  Number of 'slices' from bucketizer
-  uint32          fileID     = 0;     //  'slice' that we are going to be sorting
-  uint32          jobIdxMax    = 0;     //  Number of 'buckets' from bucketizer
+  char           *gkpName        = NULL;
 
-  uint64          maxMemory    = UINT64_MAX;
+  uint32          fileLimit      = 512;   //  Number of 'slices' from bucketizer
+  uint32          fileID         = 0;     //  'slice' that we are going to be sorting
+  uint32          jobIdxMax      = 0;     //  Number of 'buckets' from bucketizer
+
+  uint64          maxMemory      = UINT64_MAX;
 
   bool            deleteIntermediateEarly = false;
   bool            deleteIntermediateLate  = false;
@@ -55,8 +57,7 @@ main(int argc, char **argv) {
       storePath = argv[++arg];
 
     } else if (strcmp(argv[arg], "-g") == 0) {
-      //unused gkpName = argv[++arg];
-      ++arg;
+      gkpName = argv[++arg];
 
     } else if (strcmp(argv[arg], "-F") == 0) {
       fileLimit = atoi(argv[++arg]);
@@ -177,7 +178,7 @@ main(int argc, char **argv) {
   fprintf(stderr, "Overlaps need %.2f GB memory, allowed to use up to (via -M) "F_U64" GB.\n",
           sizeof(ovOverlap) * totOvl / (1024.0 * 1024.0 * 1024.0), maxMemory >> 30);
 
-  ovOverlap *ovls = new ovOverlap [totOvl];
+  ovOverlap *ovls = ovOverlap::allocateOverlaps(NULL, totOvl);
 
   //  Load all overlaps - we're guaranteed that either 'name.gz' or 'name' exists (we checked above)
   //  or funny business is happening with our files.

src/unitigger/AS_CGB_Bubble.C

@@ -476,7 +476,7 @@ AS_CGB_Bubble_find_and_remove_bubbles
     ALNoverlapFull *ovl = AS_CGB_Bubble_pop_bubble(&bp, bubs->start, bubs->start_sx, bubs->end, bubs->end_sx, &num_ovl);
 
     for (int32 o=0; o<num_ovl; ++o) {
-      ovOverlap   olap;
+      ovOverlap   olap(gkpStore);
 
 #if 0
       fprintf(stderr, "ALNoverlapFull: ID %d %d HG %d %d orient %c type %c qual %f\n",

src/unitigger/AS_CGB_unitigger.C

@@ -554,7 +554,7 @@ main(int argc, char **argv) {
   sprintf(bon, "%s.edges.blessed", rg->Output_Graph_Store_Prefix);
 
   ovFile    *bof = new ovFile(bon, ovFileFullWrite);
-  ovOverlap overlap;
+  ovOverlap overlap(NULL);  //  We could keep the gkpStore around, but we don't call bgn/end in unitigger.
 
   for (ie=0; ie < nedge; ie ++) {
     Tnes nes = get_nes_edge(heapva->edges,ie);

src/unitigger/AS_FGB_io.C

@@ -597,7 +597,7 @@ void process_ovl_store(char * OVL_Store_Path,
                        const int intrude_with_non_blessed_overlaps_flag,
                        const uint32 overlap_error_threshold) {
   ovStore       *ovs;
-  ovOverlap     olap;
+  ovOverlap     olap(NULL);  //  Don't call bgn/end!
 
   IntEdge_ID novl_dovetail = 0;
   IntEdge_ID novl_containment = 0;
@@ -724,7 +724,7 @@ void input_messages_from_a_file(ovFile *bof,
   /* It is assumed that in the overlap records that new fragments
      point to old fragments.  */
 
-  ovOverlap    olap;
+  ovOverlap    olap(NULL);  //  Don't call bgn/end!
 
   while (bof->readOverlap(&olap)) {
 

src/unitigger/AS_FGB_main.C

@@ -94,7 +94,7 @@ static void output_mesgs(Tfragment          frags[],
   const IntEdge_ID  nedge = GetNumEdges(edges);
   IntEdge_ID ie;
   for(ie=0;ie<nedge;ie++){
-    ovOverlap overlap;
+    ovOverlap overlap(NULL);  //  Don't call bgn/end!
 
     const uint32 avx = get_avx_edge(edges,ie);
     const int asx = get_asx_edge(edges,ie);