From eb00f13df4cc29102c946f5ff069b206e4d6e92b Mon Sep 17 00:00:00 2001 From: "davidmc%netscape.com" Date: Wed, 22 Sep 1999 05:35:28 +0000 Subject: [PATCH] changes for hash tables and zone pooling. --- db/mdb/public/mdb.h | 8 +- db/mork/src/Makefile.in | 3 + db/mork/src/makefile.win | 3 + db/mork/src/mork.h | 12 ++ db/mork/src/morkAtom.cpp | 2 +- db/mork/src/morkAtom.h | 8 +- db/mork/src/morkAtomMap.cpp | 201 +++++++++++++++++++++++----- db/mork/src/morkAtomMap.h | 95 ++++++++++++- db/mork/src/morkAtomSpace.cpp | 30 +++-- db/mork/src/morkAtomSpace.h | 3 +- db/mork/src/morkBuilder.cpp | 6 +- db/mork/src/morkCell.cpp | 4 +- db/mork/src/morkCellObject.cpp | 2 +- db/mork/src/morkCellObject.h | 3 +- db/mork/src/morkConfig.h | 16 +++ db/mork/src/morkCursor.cpp | 2 +- db/mork/src/morkCursor.h | 3 +- db/mork/src/morkEnv.cpp | 14 +- db/mork/src/morkEnv.h | 6 +- db/mork/src/morkFactory.cpp | 6 +- db/mork/src/morkFactory.h | 3 +- db/mork/src/morkFile.cpp | 2 +- db/mork/src/morkFile.h | 3 +- db/mork/src/morkHandle.h | 5 +- db/mork/src/morkMap.h | 3 + db/mork/src/morkNode.cpp | 18 ++- db/mork/src/morkNode.h | 2 + db/mork/src/morkObject.cpp | 12 +- db/mork/src/morkObject.h | 13 +- db/mork/src/morkParser.cpp | 1 - db/mork/src/morkPool.cpp | 189 ++++++++++++++++++++++---- db/mork/src/morkPool.h | 29 ++-- db/mork/src/morkPortTableCursor.cpp | 9 ++ db/mork/src/morkRow.cpp | 18 ++- db/mork/src/morkRow.h | 2 +- db/mork/src/morkRowMap.cpp | 147 ++++++++++++++++++++ db/mork/src/morkRowMap.h | 107 ++++++++++++++- db/mork/src/morkRowObject.cpp | 2 +- db/mork/src/morkRowSpace.cpp | 47 +++++-- db/mork/src/morkRowSpace.h | 9 +- db/mork/src/morkSearchRowCursor.cpp | 11 +- db/mork/src/morkSorting.cpp | 2 +- db/mork/src/morkSorting.h | 3 +- db/mork/src/morkSpace.cpp | 9 +- db/mork/src/morkSpace.h | 17 ++- db/mork/src/morkStore.cpp | 13 +- db/mork/src/morkStore.h | 9 +- db/mork/src/morkTable.cpp | 11 +- db/mork/src/morkTable.h | 71 +++++++++- db/mork/src/morkThumb.cpp | 2 +- db/mork/src/morkThumb.h | 3 +- db/mork/src/morkWriter.cpp | 24 +++- db/mork/src/morkWriter.h | 5 + db/mork/src/orkinCell.h | 5 +- db/mork/src/orkinEnv.cpp | 2 +- db/mork/src/orkinEnv.h | 5 +- db/mork/src/orkinFactory.h | 5 +- db/mork/src/orkinFile.h | 5 +- db/mork/src/orkinHeap.cpp | 88 ++++++++++-- db/mork/src/orkinHeap.h | 26 +++- db/mork/src/orkinPortTableCursor.h | 5 +- db/mork/src/orkinRow.h | 5 +- db/mork/src/orkinRowCellCursor.h | 5 +- db/mork/src/orkinSorting.h | 5 +- db/mork/src/orkinStore.h | 5 +- db/mork/src/orkinTable.cpp | 2 +- db/mork/src/orkinTable.h | 5 +- db/mork/src/orkinTableRowCursor.h | 5 +- db/mork/src/orkinThumb.h | 5 +- 69 files changed, 1201 insertions(+), 205 deletions(-) diff --git a/db/mdb/public/mdb.h b/db/mdb/public/mdb.h index 4248339e627..ab30a756526 100644 --- a/db/mdb/public/mdb.h +++ b/db/mdb/public/mdb.h @@ -461,8 +461,8 @@ public: virtual mdb_err Free(nsIMdbEnv* ev, // free block from Alloc or Resize() void* ioBlock) = 0; // block to be destroyed/deallocated - virtual mdb_err AddStrongRef(nsIMdbEnv* ev) = 0; - virtual mdb_err CutStrongRef(nsIMdbEnv* ev) = 0; + virtual mdb_err HeapAddStrongRef(nsIMdbEnv* ev) = 0; + virtual mdb_err HeapCutStrongRef(nsIMdbEnv* ev) = 0; // } ===== end nsIMdbHeap methods ===== }; @@ -480,8 +480,8 @@ public: virtual mdb_err Free(nsIMdbEnv* ev, // free block allocated earlier by Alloc() void* inBlock); - virtual mdb_err AddStrongRef(nsIMdbEnv* ev); - virtual mdb_err CutStrongRef(nsIMdbEnv* ev); + virtual mdb_err HeapAddStrongRef(nsIMdbEnv* ev); + virtual mdb_err HeapCutStrongRef(nsIMdbEnv* ev); // } ===== end nsIMdbHeap methods ===== }; diff --git a/db/mork/src/Makefile.in b/db/mork/src/Makefile.in index a31348f4de7..8065d2fa497 100644 --- a/db/mork/src/Makefile.in +++ b/db/mork/src/Makefile.in @@ -81,6 +81,9 @@ CPPSRCS = \ morkThumb.cpp \ morkWriter.cpp \ morkYarn.cpp \ + morkBead.cpp \ + morkProbeMap.cpp \ + morkZone.cpp \ $(NULL) EXTRA_DSO_LDOPTS = \ diff --git a/db/mork/src/makefile.win b/db/mork/src/makefile.win index 46692b4a67c..4e02ec0579d 100644 --- a/db/mork/src/makefile.win +++ b/db/mork/src/makefile.win @@ -88,6 +88,9 @@ CPP_OBJS= .\$(OBJDIR)\orkinCell.obj \ .\$(OBJDIR)\morkThumb.obj \ .\$(OBJDIR)\morkWriter.obj \ .\$(OBJDIR)\morkYarn.obj \ + .\$(OBJDIR)\morkZone.cpp.obj \ + .\$(OBJDIR)\morkProbeMap.cpp.obj \ + .\$(OBJDIR)\morkBead.cpp.obj \ $(NULL) diff --git a/db/mork/src/mork.h b/db/mork/src/mork.h index ab2d551f52f..9e9ba86aa3b 100644 --- a/db/mork/src/mork.h +++ b/db/mork/src/mork.h @@ -82,6 +82,9 @@ typedef mork_token mork_aid; // token used to id atomize cell values typedef mork_token mork_column; // token used to id columns for rows typedef mork_column mork_delta; // mork_column plus mork_change +typedef mork_token mork_color; // bead ID +#define morkColor_kNone ((mork_color) 0) + typedef mork_u4 mork_magic; // unsigned magic signature typedef mork_u4 mork_seed; // unsigned collection change counter @@ -106,6 +109,13 @@ typedef mork_u1 mork_able; // on, off, asleep (clone IronDoc's fe_able) typedef mork_u1 mork_load; // dirty or clean (clone IronDoc's fe_load) // } %%%%% end specific-size integer scalar typedefs %%%%% +// 'test' is a public domain Mithril for key equality tests in probe maps +typedef mork_i2 mork_test; /* neg=>kVoid, zero=>kHit, pos=>kMiss */ + +#define morkTest_kVoid ((mork_test) -1) /* -1: nil key slot, no key order */ +#define morkTest_kHit ((mork_test) 0) /* 0: keys are equal, a map hit */ +#define morkTest_kMiss ((mork_test) 1) /* 1: keys not equal, a map miss */ + // { %%%%% begin constants for Mork scalar types %%%%% #define morkPriority_kHi ((mork_priority) 0) /* best priority */ #define morkPriority_kMin ((mork_priority) 0) /* best priority is smallest */ @@ -190,6 +200,7 @@ class morkPool; class morkPlace; class morkPort; class morkPortTableCursor; +class morkProbeMap; class morkRow; class morkRowCellCursor; class morkRowObject; @@ -205,6 +216,7 @@ class morkTableChange; class morkTableRowCursor; class morkThumb; class morkWriter; +class morkZone; // } %%%%% end class forward defines %%%%% // include this config file last for platform & environment specific stuff: diff --git a/db/mork/src/morkAtom.cpp b/db/mork/src/morkAtom.cpp index efec8d39d29..a0153fba606 100644 --- a/db/mork/src/morkAtom.cpp +++ b/db/mork/src/morkAtom.cpp @@ -219,7 +219,7 @@ morkAtom::GetBookAtomSpaceScope(morkEnv* ev) const // zero or book's space's sco const morkBookAtom* bookAtom = (const morkBookAtom*) this; morkAtomSpace* space = bookAtom->mBookAtom_Space; if ( space->IsAtomSpace() ) - outScope = space->mSpace_Scope; + outScope = space->SpaceScope(); else space->NonAtomSpaceTypeError(ev); } diff --git a/db/mork/src/morkAtom.h b/db/mork/src/morkAtom.h index 8e663a4111e..43bfc2478a7 100644 --- a/db/mork/src/morkAtom.h +++ b/db/mork/src/morkAtom.h @@ -213,7 +213,7 @@ class morkBookAtom : public morkAtom { // // mork_u1 mAtom_Size; // only for atoms smaller than 256 bytes public: - morkAtomSpace* mBookAtom_Space; // mBookAtom_Space->mSpace_Scope is atom scope + morkAtomSpace* mBookAtom_Space; // mBookAtom_Space->SpaceScope() is atom scope mork_aid mBookAtom_Id; // identity token for this shared atom public: // empty construction does nothing @@ -249,7 +249,7 @@ class morkWeeBookAtom : public morkBookAtom { // // mork_change mAtom_Change; // how has this atom been changed? // mork_u1 mAtom_Size; // only for atoms smaller than 256 bytes - // morkAtomSpace* mBookAtom_Space; // mBookAtom_Space->mSpace_Scope is scope + // morkAtomSpace* mBookAtom_Space; // mBookAtom_Space->SpaceScope() is scope // mork_aid mBookAtom_Id; // identity token for this shared atom public: @@ -280,7 +280,7 @@ class morkBigBookAtom : public morkBookAtom { // // mork_change mAtom_Change; // how has this atom been changed? // mork_u1 mAtom_Size; // NOT USED IN "BIG" format atoms - // morkAtomSpace* mBookAtom_Space; // mBookAtom_Space->mSpace_Scope is scope + // morkAtomSpace* mBookAtom_Space; // mBookAtom_Space->SpaceScope() is scope // mork_aid mBookAtom_Id; // identity token for this shared atom public: @@ -311,7 +311,7 @@ class morkMaxBookAtom : public morkBigBookAtom { // // mork_change mAtom_Change; // how has this atom been changed? // mork_u1 mAtom_Size; // NOT USED IN "BIG" format atoms - // morkAtomSpace* mBookAtom_Space; // mBookAtom_Space->mSpace_Scope is scope + // morkAtomSpace* mBookAtom_Space; // mBookAtom_Space->SpaceScope() is scope // mork_aid mBookAtom_Id; // identity token for this shared atom // mork_cscode mBigBookAtom_Form; // charset format encoding diff --git a/db/mork/src/morkAtomMap.cpp b/db/mork/src/morkAtomMap.cpp index 9ae46d14089..fc0b14e0dd4 100644 --- a/db/mork/src/morkAtomMap.cpp +++ b/db/mork/src/morkAtomMap.cpp @@ -74,13 +74,21 @@ morkAtomAidMap::~morkAtomAidMap() // assert CloseAtomAidMap() executed earlier MORK_ASSERT(this->IsShutNode()); } + /*public non-poly*/ morkAtomAidMap::morkAtomAidMap(morkEnv* ev, const morkUsage& inUsage, nsIMdbHeap* ioHeap, nsIMdbHeap* ioSlotHeap) +#ifdef MORK_ENABLE_PROBE_MAPS +: morkProbeMap(ev, inUsage, ioHeap, + /*inKeySize*/ sizeof(morkBookAtom*), /*inValSize*/ 0, + ioSlotHeap, morkAtomAidMap_kStartSlotCount, + /*inZeroIsClearKey*/ morkBool_kTrue) +#else /*MORK_ENABLE_PROBE_MAPS*/ : morkMap(ev, inUsage, ioHeap, /*inKeySize*/ sizeof(morkBookAtom*), /*inValSize*/ 0, morkAtomAidMap_kStartSlotCount, ioSlotHeap, /*inHoldChanges*/ morkBool_kFalse) +#endif /*MORK_ENABLE_PROBE_MAPS*/ { if ( ev->Good() ) mNode_Derived = morkDerived_kAtomAidMap; @@ -93,7 +101,11 @@ morkAtomAidMap::CloseAtomAidMap(morkEnv* ev) // called by CloseMorkNode(); { if ( this->IsNode() ) { +#ifdef MORK_ENABLE_PROBE_MAPS + this->CloseProbeMap(ev); +#else /*MORK_ENABLE_PROBE_MAPS*/ this->CloseMap(ev); +#endif /*MORK_ENABLE_PROBE_MAPS*/ this->MarkShut(); } else @@ -106,23 +118,68 @@ morkAtomAidMap::CloseAtomAidMap(morkEnv* ev) // called by CloseMorkNode(); // } ===== end morkNode methods ===== // ````` ````` ````` ````` ````` -// { ===== begin morkMap poly interface ===== -/*virtual*/ mork_bool // -morkAtomAidMap::Equal(morkEnv* ev, const void* inKeyA, - const void* inKeyB) const -{ - MORK_USED_1(ev); - return (*(const morkBookAtom**) inKeyA)->EqualAid( - *(const morkBookAtom**) inKeyB); -} +#ifdef MORK_ENABLE_PROBE_MAPS -/*virtual*/ mork_u4 // -morkAtomAidMap::Hash(morkEnv* ev, const void* inKey) const -{ - MORK_USED_1(ev); - return (*(const morkBookAtom**) inKey)->HashAid(); -} -// } ===== end morkMap poly interface ===== + /*virtual*/ mork_test // hit(a,b) implies hash(a) == hash(b) + morkAtomAidMap::MapTest(morkEnv* ev, const void* inMapKey, + const void* inAppKey) const + { + MORK_USED_1(ev); + const morkBookAtom* key = *(const morkBookAtom**) inMapKey; + if ( key ) + { + mork_bool hit = key->EqualAid(*(const morkBookAtom**) inAppKey); + return ( hit ) ? morkTest_kHit : morkTest_kMiss; + } + else + return morkTest_kVoid; + } + + /*virtual*/ mork_u4 // hit(a,b) implies hash(a) == hash(b) + morkAtomAidMap::MapHash(morkEnv* ev, const void* inAppKey) const + { + const morkBookAtom* key = *(const morkBookAtom**) inAppKey; + if ( key ) + return key->HashAid(); + else + { + ev->NilPointerWarning(); + return 0; + } + } + + /*virtual*/ mork_u4 + morkAtomAidMap::ProbeMapHashMapKey(morkEnv* ev, + const void* inMapKey) const + { + const morkBookAtom* key = *(const morkBookAtom**) inMapKey; + if ( key ) + return key->HashAid(); + else + { + ev->NilPointerWarning(); + return 0; + } + } +#else /*MORK_ENABLE_PROBE_MAPS*/ + // { ===== begin morkMap poly interface ===== + /*virtual*/ mork_bool // + morkAtomAidMap::Equal(morkEnv* ev, const void* inKeyA, + const void* inKeyB) const + { + MORK_USED_1(ev); + return (*(const morkBookAtom**) inKeyA)->EqualAid( + *(const morkBookAtom**) inKeyB); + } + + /*virtual*/ mork_u4 // + morkAtomAidMap::Hash(morkEnv* ev, const void* inKey) const + { + MORK_USED_1(ev); + return (*(const morkBookAtom**) inKey)->HashAid(); + } + // } ===== end morkMap poly interface ===== +#endif /*MORK_ENABLE_PROBE_MAPS*/ mork_bool @@ -130,8 +187,13 @@ morkAtomAidMap::AddAtom(morkEnv* ev, morkBookAtom* ioAtom) { if ( ev->Good() ) { +#ifdef MORK_ENABLE_PROBE_MAPS + this->MapAtPut(ev, &ioAtom, /*val*/ (void*) 0, + /*key*/ (void*) 0, /*val*/ (void*) 0); +#else /*MORK_ENABLE_PROBE_MAPS*/ this->Put(ev, &ioAtom, /*val*/ (void*) 0, /*key*/ (void*) 0, /*val*/ (void*) 0, (mork_change**) 0); +#endif /*MORK_ENABLE_PROBE_MAPS*/ } return ev->Good(); } @@ -140,8 +202,14 @@ morkBookAtom* morkAtomAidMap::CutAtom(morkEnv* ev, const morkBookAtom* inAtom) { morkBookAtom* oldKey = 0; + +#ifdef MORK_ENABLE_PROBE_MAPS + MORK_USED_1(inAtom); + morkProbeMap::ProbeMapCutError(ev); +#else /*MORK_ENABLE_PROBE_MAPS*/ this->Cut(ev, &inAtom, &oldKey, /*val*/ (void*) 0, (mork_change**) 0); +#endif /*MORK_ENABLE_PROBE_MAPS*/ return oldKey; } @@ -150,7 +218,12 @@ morkBookAtom* morkAtomAidMap::GetAtom(morkEnv* ev, const morkBookAtom* inAtom) { morkBookAtom* key = 0; // old val in the map + +#ifdef MORK_ENABLE_PROBE_MAPS + this->MapAt(ev, &inAtom, &key, /*val*/ (void*) 0); +#else /*MORK_ENABLE_PROBE_MAPS*/ this->Get(ev, &inAtom, &key, /*val*/ (void*) 0, (mork_change**) 0); +#endif /*MORK_ENABLE_PROBE_MAPS*/ return key; } @@ -161,7 +234,12 @@ morkAtomAidMap::GetAid(morkEnv* ev, mork_aid inAid) morkWeeBookAtom weeAtom(inAid); morkBookAtom* key = &weeAtom; // we need a pointer morkBookAtom* oldKey = 0; // old key in the map + +#ifdef MORK_ENABLE_PROBE_MAPS + this->MapAt(ev, &key, &oldKey, /*val*/ (void*) 0); +#else /*MORK_ENABLE_PROBE_MAPS*/ this->Get(ev, &key, &oldKey, /*val*/ (void*) 0, (mork_change**) 0); +#endif /*MORK_ENABLE_PROBE_MAPS*/ return oldKey; } @@ -191,13 +269,21 @@ morkAtomBodyMap::~morkAtomBodyMap() // assert CloseAtomBodyMap() executed earlie MORK_ASSERT(this->IsShutNode()); } + /*public non-poly*/ morkAtomBodyMap::morkAtomBodyMap(morkEnv* ev, const morkUsage& inUsage, nsIMdbHeap* ioHeap, nsIMdbHeap* ioSlotHeap) +#ifdef MORK_ENABLE_PROBE_MAPS +: morkProbeMap(ev, inUsage, ioHeap, + /*inKeySize*/ sizeof(morkBookAtom*), /*inValSize*/ 0, + ioSlotHeap, morkAtomBodyMap_kStartSlotCount, + /*inZeroIsClearKey*/ morkBool_kTrue) +#else /*MORK_ENABLE_PROBE_MAPS*/ : morkMap(ev, inUsage, ioHeap, /*inKeySize*/ sizeof(morkBookAtom*), /*inValSize*/ 0, morkAtomBodyMap_kStartSlotCount, ioSlotHeap, /*inHoldChanges*/ morkBool_kFalse) +#endif /*MORK_ENABLE_PROBE_MAPS*/ { if ( ev->Good() ) mNode_Derived = morkDerived_kAtomBodyMap; @@ -210,7 +296,11 @@ morkAtomBodyMap::CloseAtomBodyMap(morkEnv* ev) // called by CloseMorkNode(); { if ( this->IsNode() ) { +#ifdef MORK_ENABLE_PROBE_MAPS + this->CloseProbeMap(ev); +#else /*MORK_ENABLE_PROBE_MAPS*/ this->CloseMap(ev); +#endif /*MORK_ENABLE_PROBE_MAPS*/ this->MarkShut(); } else @@ -222,22 +312,58 @@ morkAtomBodyMap::CloseAtomBodyMap(morkEnv* ev) // called by CloseMorkNode(); // } ===== end morkNode methods ===== // ````` ````` ````` ````` ````` +#ifdef MORK_ENABLE_PROBE_MAPS -// { ===== begin morkMap poly interface ===== -/*virtual*/ mork_bool // -morkAtomBodyMap::Equal(morkEnv* ev, const void* inKeyA, - const void* inKeyB) const -{ - return (*(const morkBookAtom**) inKeyA)->EqualFormAndBody(ev, - *(const morkBookAtom**) inKeyB); -} + /*virtual*/ mork_test // hit(a,b) implies hash(a) == hash(b) + morkAtomBodyMap::MapTest(morkEnv* ev, const void* inMapKey, + const void* inAppKey) const + { + const morkBookAtom* key = *(const morkBookAtom**) inMapKey; + if ( key ) + { + return ( key->EqualFormAndBody(ev, *(const morkBookAtom**) inAppKey) ) ? + morkTest_kHit : morkTest_kMiss; + } + else + return morkTest_kVoid; + } -/*virtual*/ mork_u4 // -morkAtomBodyMap::Hash(morkEnv* ev, const void* inKey) const -{ - return (*(const morkBookAtom**) inKey)->HashFormAndBody(ev); -} -// } ===== end morkMap poly interface ===== + /*virtual*/ mork_u4 // hit(a,b) implies hash(a) == hash(b) + morkAtomBodyMap::MapHash(morkEnv* ev, const void* inAppKey) const + { + const morkBookAtom* key = *(const morkBookAtom**) inAppKey; + if ( key ) + return key->HashFormAndBody(ev); + else + return 0; + } + + /*virtual*/ mork_u4 + morkAtomBodyMap::ProbeMapHashMapKey(morkEnv* ev, const void* inMapKey) const + { + const morkBookAtom* key = *(const morkBookAtom**) inMapKey; + if ( key ) + return key->HashFormAndBody(ev); + else + return 0; + } +#else /*MORK_ENABLE_PROBE_MAPS*/ + // { ===== begin morkMap poly interface ===== + /*virtual*/ mork_bool // + morkAtomBodyMap::Equal(morkEnv* ev, const void* inKeyA, + const void* inKeyB) const + { + return (*(const morkBookAtom**) inKeyA)->EqualFormAndBody(ev, + *(const morkBookAtom**) inKeyB); + } + + /*virtual*/ mork_u4 // + morkAtomBodyMap::Hash(morkEnv* ev, const void* inKey) const + { + return (*(const morkBookAtom**) inKey)->HashFormAndBody(ev); + } + // } ===== end morkMap poly interface ===== +#endif /*MORK_ENABLE_PROBE_MAPS*/ mork_bool @@ -245,8 +371,13 @@ morkAtomBodyMap::AddAtom(morkEnv* ev, morkBookAtom* ioAtom) { if ( ev->Good() ) { +#ifdef MORK_ENABLE_PROBE_MAPS + this->MapAtPut(ev, &ioAtom, /*val*/ (void*) 0, + /*key*/ (void*) 0, /*val*/ (void*) 0); +#else /*MORK_ENABLE_PROBE_MAPS*/ this->Put(ev, &ioAtom, /*val*/ (void*) 0, /*key*/ (void*) 0, /*val*/ (void*) 0, (mork_change**) 0); +#endif /*MORK_ENABLE_PROBE_MAPS*/ } return ev->Good(); } @@ -255,8 +386,14 @@ morkBookAtom* morkAtomBodyMap::CutAtom(morkEnv* ev, const morkBookAtom* inAtom) { morkBookAtom* oldKey = 0; + +#ifdef MORK_ENABLE_PROBE_MAPS + MORK_USED_1(inAtom); + morkProbeMap::ProbeMapCutError(ev); +#else /*MORK_ENABLE_PROBE_MAPS*/ this->Cut(ev, &inAtom, &oldKey, /*val*/ (void*) 0, (mork_change**) 0); +#endif /*MORK_ENABLE_PROBE_MAPS*/ return oldKey; } @@ -265,7 +402,11 @@ morkBookAtom* morkAtomBodyMap::GetAtom(morkEnv* ev, const morkBookAtom* inAtom) { morkBookAtom* key = 0; // old val in the map +#ifdef MORK_ENABLE_PROBE_MAPS + this->MapAt(ev, &inAtom, &key, /*val*/ (void*) 0); +#else /*MORK_ENABLE_PROBE_MAPS*/ this->Get(ev, &inAtom, &key, /*val*/ (void*) 0, (mork_change**) 0); +#endif /*MORK_ENABLE_PROBE_MAPS*/ return key; } diff --git a/db/mork/src/morkAtomMap.h b/db/mork/src/morkAtomMap.h index 06d741451ba..eb0d6aa6426 100644 --- a/db/mork/src/morkAtomMap.h +++ b/db/mork/src/morkAtomMap.h @@ -31,6 +31,10 @@ #include "morkMap.h" #endif +#ifndef _MORKPROBEMAP_ +#include "morkProbeMap.h" +#endif + #ifndef _MORKINTMAP_ #include "morkIntMap.h" #endif @@ -39,11 +43,15 @@ #define morkDerived_kAtomAidMap /*i*/ 0x6141 /* ascii 'aA' */ -#define morkAtomAidMap_kStartSlotCount 512 +#define morkAtomAidMap_kStartSlotCount 23 /*| morkAtomAidMap: keys of morkBookAtom organized by atom ID |*/ +#ifdef MORK_ENABLE_PROBE_MAPS +class morkAtomAidMap : public morkProbeMap { // for mapping tokens to maps +#else /*MORK_ENABLE_PROBE_MAPS*/ class morkAtomAidMap : public morkMap { // for mapping tokens to maps +#endif /*MORK_ENABLE_PROBE_MAPS*/ // { ===== begin morkNode interface ===== public: // morkNode virtual methods @@ -60,6 +68,31 @@ public: // dynamic type identification { return IsNode() && mNode_Derived == morkDerived_kAtomAidMap; } // } ===== end morkNode methods ===== +public: +#ifdef MORK_ENABLE_PROBE_MAPS + // { ===== begin morkProbeMap methods ===== + virtual mork_test // hit(a,b) implies hash(a) == hash(b) + MapTest(morkEnv* ev, const void* inMapKey, const void* inAppKey) const; + + virtual mork_u4 // hit(a,b) implies hash(a) == hash(b) + MapHash(morkEnv* ev, const void* inAppKey) const; + + virtual mork_u4 ProbeMapHashMapKey(morkEnv* ev, const void* inMapKey) const; + + // virtual mork_bool ProbeMapIsKeyNil(morkEnv* ev, void* ioMapKey); + + // virtual void ProbeMapClearKey(morkEnv* ev, // put 'nil' alls keys inside map + // void* ioMapKey, mork_count inKeyCount); // array of keys inside map + + // virtual void ProbeMapPushIn(morkEnv* ev, // move (key,val) into the map + // const void* inAppKey, const void* inAppVal, // (key,val) outside map + // void* outMapKey, void* outMapVal); // (key,val) inside map + + // virtual void ProbeMapPullOut(morkEnv* ev, // move (key,val) out from the map + // const void* inMapKey, const void* inMapVal, // (key,val) inside map + // void* outAppKey, void* outAppVal) const; // (key,val) outside map + // } ===== end morkProbeMap methods ===== +#else /*MORK_ENABLE_PROBE_MAPS*/ // { ===== begin morkMap poly interface ===== virtual mork_bool // note: equal(a,b) implies hash(a) == hash(b) Equal(morkEnv* ev, const void* inKeyA, const void* inKeyB) const; @@ -69,6 +102,7 @@ public: // dynamic type identification Hash(morkEnv* ev, const void* inKey) const; // implemented using morkBookAtom::EqualAid() // } ===== end morkMap poly interface ===== +#endif /*MORK_ENABLE_PROBE_MAPS*/ public: // other map methods @@ -96,14 +130,25 @@ public: // typesafe refcounting inlines calling inherited morkNode methods { morkNode::SlotStrongNode((morkNode*) me, ev, (morkNode**) ioSlot); } }; - -class morkAtomAidMapIter: public morkMapIter{ // typesafe wrapper class +#ifdef MORK_ENABLE_PROBE_MAPS +class morkAtomAidMapIter: public morkProbeMapIter { // typesafe wrapper class +#else /*MORK_ENABLE_PROBE_MAPS*/ +class morkAtomAidMapIter: public morkMapIter { // typesafe wrapper class +#endif /*MORK_ENABLE_PROBE_MAPS*/ public: +#ifdef MORK_ENABLE_PROBE_MAPS + morkAtomAidMapIter(morkEnv* ev, morkAtomAidMap* ioMap) + : morkProbeMapIter(ev, ioMap) { } + + morkAtomAidMapIter( ) : morkProbeMapIter() { } +#else /*MORK_ENABLE_PROBE_MAPS*/ morkAtomAidMapIter(morkEnv* ev, morkAtomAidMap* ioMap) : morkMapIter(ev, ioMap) { } morkAtomAidMapIter( ) : morkMapIter() { } +#endif /*MORK_ENABLE_PROBE_MAPS*/ + void InitAtomAidMapIter(morkEnv* ev, morkAtomAidMap* ioMap) { this->InitMapIter(ev, ioMap); } @@ -127,11 +172,15 @@ public: #define morkDerived_kAtomBodyMap /*i*/ 0x6142 /* ascii 'aB' */ -#define morkAtomBodyMap_kStartSlotCount 512 +#define morkAtomBodyMap_kStartSlotCount 23 /*| morkAtomBodyMap: keys of morkBookAtom organized by body bytes |*/ +#ifdef MORK_ENABLE_PROBE_MAPS +class morkAtomBodyMap : public morkProbeMap { // for mapping tokens to maps +#else /*MORK_ENABLE_PROBE_MAPS*/ class morkAtomBodyMap : public morkMap { // for mapping tokens to maps +#endif /*MORK_ENABLE_PROBE_MAPS*/ // { ===== begin morkNode interface ===== public: // morkNode virtual methods @@ -148,6 +197,31 @@ public: // dynamic type identification { return IsNode() && mNode_Derived == morkDerived_kAtomBodyMap; } // } ===== end morkNode methods ===== +public: +#ifdef MORK_ENABLE_PROBE_MAPS + // { ===== begin morkProbeMap methods ===== + virtual mork_test // hit(a,b) implies hash(a) == hash(b) + MapTest(morkEnv* ev, const void* inMapKey, const void* inAppKey) const; + + virtual mork_u4 // hit(a,b) implies hash(a) == hash(b) + MapHash(morkEnv* ev, const void* inAppKey) const; + + virtual mork_u4 ProbeMapHashMapKey(morkEnv* ev, const void* inMapKey) const; + + // virtual mork_bool ProbeMapIsKeyNil(morkEnv* ev, void* ioMapKey); + + // virtual void ProbeMapClearKey(morkEnv* ev, // put 'nil' alls keys inside map + // void* ioMapKey, mork_count inKeyCount); // array of keys inside map + + // virtual void ProbeMapPushIn(morkEnv* ev, // move (key,val) into the map + // const void* inAppKey, const void* inAppVal, // (key,val) outside map + // void* outMapKey, void* outMapVal); // (key,val) inside map + + // virtual void ProbeMapPullOut(morkEnv* ev, // move (key,val) out from the map + // const void* inMapKey, const void* inMapVal, // (key,val) inside map + // void* outAppKey, void* outAppVal) const; // (key,val) outside map + // } ===== end morkProbeMap methods ===== +#else /*MORK_ENABLE_PROBE_MAPS*/ // { ===== begin morkMap poly interface ===== virtual mork_bool // note: equal(a,b) implies hash(a) == hash(b) Equal(morkEnv* ev, const void* inKeyA, const void* inKeyB) const; @@ -157,6 +231,7 @@ public: // dynamic type identification Hash(morkEnv* ev, const void* inKey) const; // implemented using morkBookAtom::HashFormAndBody() // } ===== end morkMap poly interface ===== +#endif /*MORK_ENABLE_PROBE_MAPS*/ public: // other map methods @@ -181,13 +256,25 @@ public: // typesafe refcounting inlines calling inherited morkNode methods { morkNode::SlotStrongNode((morkNode*) me, ev, (morkNode**) ioSlot); } }; +#ifdef MORK_ENABLE_PROBE_MAPS +class morkAtomBodyMapIter: public morkProbeMapIter{ // typesafe wrapper class +#else /*MORK_ENABLE_PROBE_MAPS*/ class morkAtomBodyMapIter: public morkMapIter{ // typesafe wrapper class +#endif /*MORK_ENABLE_PROBE_MAPS*/ public: +#ifdef MORK_ENABLE_PROBE_MAPS + morkAtomBodyMapIter(morkEnv* ev, morkAtomBodyMap* ioMap) + : morkProbeMapIter(ev, ioMap) { } + + morkAtomBodyMapIter( ) : morkProbeMapIter() { } +#else /*MORK_ENABLE_PROBE_MAPS*/ morkAtomBodyMapIter(morkEnv* ev, morkAtomBodyMap* ioMap) : morkMapIter(ev, ioMap) { } morkAtomBodyMapIter( ) : morkMapIter() { } +#endif /*MORK_ENABLE_PROBE_MAPS*/ + void InitAtomBodyMapIter(morkEnv* ev, morkAtomBodyMap* ioMap) { this->InitMapIter(ev, ioMap); } diff --git a/db/mork/src/morkAtomSpace.cpp b/db/mork/src/morkAtomSpace.cpp index 2c4709e7dd8..c8917f88d4b 100644 --- a/db/mork/src/morkAtomSpace.cpp +++ b/db/mork/src/morkAtomSpace.cpp @@ -138,22 +138,33 @@ morkAtomSpace::NonAtomSpaceTypeError(morkEnv* ev) mork_num morkAtomSpace::CutAllAtoms(morkEnv* ev, morkPool* ioPool) { +#ifdef MORK_ENABLE_ZONE_ARENAS + MORK_USED_2(ev, ioPool); + return 0; +#else /*MORK_ENABLE_ZONE_ARENAS*/ if ( this->IsAtomSpaceClean() ) this->MaybeDirtyStoreAndSpace(); - mork_num outSlots = mAtomSpace_AtomAids.mMap_Fill; + mork_num outSlots = mAtomSpace_AtomAids.MapFill(); morkBookAtom* a = 0; // old key atom in the map + morkStore* store = mSpace_Store; mork_change* c = 0; morkAtomAidMapIter i(ev, &mAtomSpace_AtomAids); for ( c = i.FirstAtom(ev, &a); c ; c = i.NextAtom(ev, &a) ) { if ( a ) - ioPool->ZapAtom(ev, a); + ioPool->ZapAtom(ev, a, &store->mStore_Zone); + +#ifdef MORK_ENABLE_PROBE_MAPS + // do not cut anything from the map +#else /*MORK_ENABLE_PROBE_MAPS*/ i.CutHereAtom(ev, /*key*/ (morkBookAtom**) 0); +#endif /*MORK_ENABLE_PROBE_MAPS*/ } return outSlots; +#endif /*MORK_ENABLE_ZONE_ARENAS*/ } @@ -163,13 +174,14 @@ morkAtomSpace::MakeBookAtomCopyWithAid(morkEnv* ev, // Make copy of inAtom and put it in both maps, using specified ID. { morkBookAtom* outAtom = 0; - if ( ev->Good() ) + morkStore* store = mSpace_Store; + if ( ev->Good() && store ) { morkPool* pool = this->GetSpaceStorePool(); - outAtom = pool->NewBookAtomCopy(ev, inAtom); + outAtom = pool->NewBookAtomCopy(ev, inAtom, &store->mStore_Zone); if ( outAtom ) { - if ( mSpace_Store->mStore_CanDirty ) + if ( store->mStore_CanDirty ) { outAtom->SetAtomDirty(); if ( this->IsAtomSpaceClean() ) @@ -180,7 +192,7 @@ morkAtomSpace::MakeBookAtomCopyWithAid(morkEnv* ev, outAtom->mBookAtom_Space = this; mAtomSpace_AtomAids.AddAtom(ev, outAtom); mAtomSpace_AtomBodies.AddAtom(ev, outAtom); - if ( mSpace_Scope == morkAtomSpace_kColumnScope ) + if ( this->SpaceScope() == morkAtomSpace_kColumnScope ) outAtom->MakeCellUseForever(ev); if ( mAtomSpace_HighUnderId <= inAid ) @@ -201,7 +213,7 @@ morkAtomSpace::MakeBookAtomCopy(morkEnv* ev, const morkBigBookAtom& inAtom) if ( store->mStore_CanAutoAssignAtomIdentity ) { morkPool* pool = this->GetSpaceStorePool(); - morkBookAtom* atom = pool->NewBookAtomCopy(ev, inAtom); + morkBookAtom* atom = pool->NewBookAtomCopy(ev, inAtom, &mSpace_Store->mStore_Zone); if ( atom ) { mork_aid id = this->MakeNewAtomId(ev, atom); @@ -218,11 +230,11 @@ morkAtomSpace::MakeBookAtomCopy(morkEnv* ev, const morkBigBookAtom& inAtom) atom->mBookAtom_Space = this; mAtomSpace_AtomAids.AddAtom(ev, atom); mAtomSpace_AtomBodies.AddAtom(ev, atom); - if ( mSpace_Scope == morkAtomSpace_kColumnScope ) + if ( this->SpaceScope() == morkAtomSpace_kColumnScope ) outAtom->MakeCellUseForever(ev); } else - pool->ZapAtom(ev, atom); + pool->ZapAtom(ev, atom, &mSpace_Store->mStore_Zone); } } else diff --git a/db/mork/src/morkAtomSpace.h b/db/mork/src/morkAtomSpace.h index 594e8dea195..08a37bc48aa 100644 --- a/db/mork/src/morkAtomSpace.h +++ b/db/mork/src/morkAtomSpace.h @@ -85,7 +85,6 @@ class morkAtomSpace : public morkSpace { // // mork_refs mNode_Refs; // refcount for strong refs + weak refs // morkStore* mSpace_Store; // weak ref to containing store - // mork_scope mSpace_Scope; // the scope for this space // mork_bool mSpace_DoAutoIDs; // whether db should assign member IDs // mork_bool mSpace_HaveDoneAutoIDs; // whether actually auto assigned IDs @@ -184,7 +183,7 @@ public: public: // other map methods mork_bool AddAtomSpace(morkEnv* ev, morkAtomSpace* ioAtomSpace) - { return this->AddNode(ev, ioAtomSpace->mSpace_Scope, ioAtomSpace); } + { return this->AddNode(ev, ioAtomSpace->SpaceScope(), ioAtomSpace); } // the AddAtomSpace() boolean return equals ev->Good(). mork_bool CutAtomSpace(morkEnv* ev, mork_scope inScope) diff --git a/db/mork/src/morkBuilder.cpp b/db/mork/src/morkBuilder.cpp index 5b3bfb32349..3eb2d820573 100644 --- a/db/mork/src/morkBuilder.cpp +++ b/db/mork/src/morkBuilder.cpp @@ -375,7 +375,7 @@ morkBuilder::OnNewTable(morkEnv* ev, const morkPlace& inPlace, if ( table ) { if ( table->mTable_RowSpace ) - mBuilder_TableRowScope = table->mTable_RowSpace->mSpace_Scope; + mBuilder_TableRowScope = table->mTable_RowSpace->SpaceScope(); if ( inCutAllRows ) table->CutAllRows(ev); @@ -993,7 +993,7 @@ morkBuilder::OnRowMid(morkEnv* ev, const morkSpan& inSpan, if ( ev->Good() ) { morkPool* pool = store->StorePool(); - morkAtom* atom = pool->NewRowOidAtom(ev, rowOid); + morkAtom* atom = pool->NewRowOidAtom(ev, rowOid, &store->mStore_Zone); if ( atom ) { cell->SetAtom(ev, atom, pool); @@ -1030,7 +1030,7 @@ morkBuilder::OnTableMid(morkEnv* ev, const morkSpan& inSpan, if ( ev->Good() ) { morkPool* pool = store->StorePool(); - morkAtom* atom = pool->NewTableOidAtom(ev, tableOid); + morkAtom* atom = pool->NewTableOidAtom(ev, tableOid, &store->mStore_Zone); if ( atom ) { cell->SetAtom(ev, atom, pool); diff --git a/db/mork/src/morkCell.cpp b/db/mork/src/morkCell.cpp index bb4608373f6..9ef94c21eba 100644 --- a/db/mork/src/morkCell.cpp +++ b/db/mork/src/morkCell.cpp @@ -105,8 +105,8 @@ morkCell::SetAtom(morkEnv* ev, morkAtom* ioAtom, morkPool* ioPool) mCell_Atom = 0; if ( oldAtom->CutCellUse(ev) == 0 ) { - // this was zapping atoms still in use - comment out until davidmc - // can figure out a better fix. + // this was zapping atoms still in use - comment out until davidmc + // can figure out a better fix. // if ( ioPool ) // { // if ( oldAtom->IsBook() ) diff --git a/db/mork/src/morkCellObject.cpp b/db/mork/src/morkCellObject.cpp index e480cf0ad95..af53e8a262b 100644 --- a/db/mork/src/morkCellObject.cpp +++ b/db/mork/src/morkCellObject.cpp @@ -82,7 +82,7 @@ morkCellObject::~morkCellObject() // assert CloseCellObject() executed earlier morkCellObject::morkCellObject(morkEnv* ev, const morkUsage& inUsage, nsIMdbHeap* ioHeap, morkRow* ioRow, morkCell* ioCell, mork_column inCol, mork_pos inPos) -: morkObject(ev, inUsage, ioHeap, (morkHandle*) 0) +: morkObject(ev, inUsage, ioHeap, morkColor_kNone, (morkHandle*) 0) , mCellObject_RowObject( 0 ) , mCellObject_Row( 0 ) , mCellObject_Cell( 0 ) diff --git a/db/mork/src/morkCellObject.h b/db/mork/src/morkCellObject.h index e94cf6d6436..56700e98fba 100644 --- a/db/mork/src/morkCellObject.h +++ b/db/mork/src/morkCellObject.h @@ -48,7 +48,8 @@ class morkCellObject : public morkObject { // blob attribute in column scope // mork_uses mNode_Uses; // refcount for strong refs // mork_refs mNode_Refs; // refcount for strong refs + weak refs - // morkFactory* mObject_Factory; // weak ref to suite factory + // mork_color mBead_Color; // ID for this bead + // morkHandle* mObject_Handle; // weak ref to handle for this object public: // state is public because the entire Mork system is private morkRowObject* mCellObject_RowObject; // strong ref to row's object diff --git a/db/mork/src/morkConfig.h b/db/mork/src/morkConfig.h index 8e1da1f216f..d9aa68d2754 100644 --- a/db/mork/src/morkConfig.h +++ b/db/mork/src/morkConfig.h @@ -98,6 +98,22 @@ #define MORK_FILECLOSE(file) XP_FileClose(file) #endif /*MORK_OBSOLETE*/ +/* ===== separating switchable features ===== */ + +//define MORK_ENABLE_ZONE_ARENAS 1 /* using morkZone for pooling */ + +//define MORK_ENABLE_PROBE_MAPS 1 /* use smaller hash tables */ + +//define MORK_BEAD_OVER_NODE_MAPS 1 /* use bead not node maps */ + +/* ===== pooling ===== */ + +#define MORK_CONFIG_PTR_SIZE_4 1 /* sizeof(void*) == 4 */ + +//define MORK_CONFIG_ALIGN_8 1 /* must have 8 byte alignment */ + +//define MORK_DEBUG_HEAP_STATS 1 /* analyze per-block heap usage */ + /* ===== ===== ===== ===== line characters ===== ===== ===== ===== */ #define mork_kCR 0x0D #define mork_kLF 0x0A diff --git a/db/mork/src/morkCursor.cpp b/db/mork/src/morkCursor.cpp index 3968786519c..7762c3d07c2 100644 --- a/db/mork/src/morkCursor.cpp +++ b/db/mork/src/morkCursor.cpp @@ -64,7 +64,7 @@ morkCursor::~morkCursor() // assert CloseCursor() executed earlier /*public non-poly*/ morkCursor::morkCursor(morkEnv* ev, const morkUsage& inUsage, nsIMdbHeap* ioHeap) -: morkObject(ev, inUsage, ioHeap, (morkHandle*) 0) +: morkObject(ev, inUsage, ioHeap, morkColor_kNone, (morkHandle*) 0) , mCursor_Seed( 0 ) , mCursor_Pos( -1 ) , mCursor_DoFailOnSeedOutOfSync( morkBool_kFalse ) diff --git a/db/mork/src/morkCursor.h b/db/mork/src/morkCursor.h index 21dc41c106f..67f929c64be 100644 --- a/db/mork/src/morkCursor.h +++ b/db/mork/src/morkCursor.h @@ -44,7 +44,8 @@ class morkCursor : public morkObject { // collection iterator // mork_uses mNode_Uses; // refcount for strong refs // mork_refs mNode_Refs; // refcount for strong refs + weak refs - // morkFactory* mObject_Factory; // weak ref to suite factory + // mork_color mBead_Color; // ID for this bead + // morkHandle* mObject_Handle; // weak ref to handle for this object public: // state is public because the entire Mork system is private mork_seed mCursor_Seed; diff --git a/db/mork/src/morkEnv.cpp b/db/mork/src/morkEnv.cpp index 624a24efff0..9ce183d15bb 100644 --- a/db/mork/src/morkEnv.cpp +++ b/db/mork/src/morkEnv.cpp @@ -73,7 +73,7 @@ morkEnv::~morkEnv() /*i*/ // assert CloseEnv() executed earlier /*public non-poly*/ morkEnv::morkEnv(const morkUsage& inUsage, nsIMdbHeap* ioHeap, morkFactory* ioFactory, nsIMdbHeap* ioSlotHeap) -: morkObject(inUsage, ioHeap) +: morkObject(inUsage, ioHeap, morkColor_kNone) , mEnv_Factory( ioFactory ) , mEnv_Heap( ioSlotHeap ) @@ -113,7 +113,7 @@ morkEnv::morkEnv(const morkUsage& inUsage, nsIMdbHeap* ioHeap, morkEnv::morkEnv(morkEnv* ev, /*i*/ const morkUsage& inUsage, nsIMdbHeap* ioHeap, nsIMdbEnv* inSelfAsMdbEnv, morkFactory* ioFactory, nsIMdbHeap* ioSlotHeap) -: morkObject(ev, inUsage, ioHeap, (morkHandle*) 0) +: morkObject(ev, inUsage, ioHeap, morkColor_kNone, (morkHandle*) 0) , mEnv_Factory( ioFactory ) , mEnv_Heap( ioSlotHeap ) @@ -399,10 +399,18 @@ morkEnv::CantMakeWhenBadError() this->NewError("can't make an object when ev->Bad()"); } +static const char* morkEnv_kNilPointer = "nil pointer"; + void morkEnv::NilPointerError() { - this->NewError("nil pointer"); + this->NewError(morkEnv_kNilPointer); +} + +void +morkEnv::NilPointerWarning() +{ + this->NewWarning(morkEnv_kNilPointer); } void diff --git a/db/mork/src/morkEnv.h b/db/mork/src/morkEnv.h index 5acd9d4abd4..6205e259d22 100644 --- a/db/mork/src/morkEnv.h +++ b/db/mork/src/morkEnv.h @@ -73,7 +73,8 @@ class morkEnv : public morkObject { // mork_uses mNode_Uses; // refcount for strong refs // mork_refs mNode_Refs; // refcount for strong refs + weak refs - // morkHandle* mObject_Handle; // weak ref to handle for this object + // mork_color mBead_Color; // ID for this bead + // morkHandle* mObject_Handle; // weak ref to handle for this object public: // state is public because the entire Mork system is private @@ -137,7 +138,7 @@ public: // other env methods // alloc and free individual handles in mEnv_HandlePool: morkHandleFace* NewHandle(mork_size inSize) - { return mEnv_HandlePool->NewHandle(this, inSize); } + { return mEnv_HandlePool->NewHandle(this, inSize, (morkZone*) 0); } void ZapHandle(morkHandleFace* ioHandle) { mEnv_HandlePool->ZapHandle(this, ioHandle); } @@ -158,6 +159,7 @@ public: // other env methods void StubMethodOnlyError(); void OutOfMemoryError(); void NilPointerError(); + void NilPointerWarning(); void CantMakeWhenBadError(); void NewNonEnvError(); void NilEnvSlotError(); diff --git a/db/mork/src/morkFactory.cpp b/db/mork/src/morkFactory.cpp index 67d93488ac8..7c0544cf2a5 100644 --- a/db/mork/src/morkFactory.cpp +++ b/db/mork/src/morkFactory.cpp @@ -73,7 +73,7 @@ morkFactory::~morkFactory() /*i*/ // assert CloseFactory() executed earlier /*public non-poly*/ morkFactory::morkFactory() // uses orkinHeap -: morkObject(morkUsage::kGlobal, (nsIMdbHeap*) 0) +: morkObject(morkUsage::kGlobal, (nsIMdbHeap*) 0, morkColor_kNone) , mFactory_Env(morkUsage::kMember, (nsIMdbHeap*) 0, this, new orkinHeap()) , mFactory_Heap() @@ -87,7 +87,7 @@ morkFactory::morkFactory() // uses orkinHeap /*public non-poly*/ morkFactory::morkFactory(nsIMdbHeap* ioHeap) -: morkObject(morkUsage::kHeap, ioHeap) +: morkObject(morkUsage::kHeap, ioHeap, morkColor_kNone) , mFactory_Env(morkUsage::kMember, (nsIMdbHeap*) 0, this, ioHeap) , mFactory_Heap() { @@ -101,7 +101,7 @@ morkFactory::morkFactory(nsIMdbHeap* ioHeap) /*public non-poly*/ morkFactory::morkFactory(morkEnv* ev, /*i*/ const morkUsage& inUsage, nsIMdbHeap* ioHeap) -: morkObject(ev, inUsage, ioHeap, (morkHandle*) 0) +: morkObject(ev, inUsage, ioHeap, morkColor_kNone, (morkHandle*) 0) , mFactory_Env(morkUsage::kMember, (nsIMdbHeap*) 0, this, ioHeap) , mFactory_Heap() { diff --git a/db/mork/src/morkFactory.h b/db/mork/src/morkFactory.h index c6e7cc454ea..08a1cce7bd7 100644 --- a/db/mork/src/morkFactory.h +++ b/db/mork/src/morkFactory.h @@ -57,7 +57,8 @@ class morkFactory : public morkObject { // nsIMdbObject // mork_uses mNode_Uses; // refcount for strong refs // mork_refs mNode_Refs; // refcount for strong refs + weak refs - // morkHandle* mObject_Handle; // weak ref to handle for this object + // mork_color mBead_Color; // ID for this bead + // morkHandle* mObject_Handle; // weak ref to handle for this object public: // state is public because the entire Mork system is private diff --git a/db/mork/src/morkFile.cpp b/db/mork/src/morkFile.cpp index 4eed7d5546d..296c0721c6a 100644 --- a/db/mork/src/morkFile.cpp +++ b/db/mork/src/morkFile.cpp @@ -73,7 +73,7 @@ morkFile::~morkFile() // assert CloseFile() executed earlier /*public non-poly*/ morkFile::morkFile(morkEnv* ev, const morkUsage& inUsage, nsIMdbHeap* ioHeap, nsIMdbHeap* ioSlotHeap) -: morkObject(ev, inUsage, ioHeap, (morkHandle*) 0) +: morkObject(ev, inUsage, ioHeap, morkColor_kNone, (morkHandle*) 0) , mFile_Frozen( 0 ) , mFile_DoTrace( 0 ) , mFile_IoOpen( 0 ) diff --git a/db/mork/src/morkFile.h b/db/mork/src/morkFile.h index 61bd45bb4b8..06241ffc638 100644 --- a/db/mork/src/morkFile.h +++ b/db/mork/src/morkFile.h @@ -57,7 +57,8 @@ class morkFile /*d*/ : public morkObject { /* ````` simple file API ````` */ // public: // slots inherited from morkObject (meant to inform only) - // morkHandle* mObject_Handle; // weak ref to handle for this object + // mork_color mBead_Color; // ID for this bead + // morkHandle* mObject_Handle; // weak ref to handle for this object // ````` ````` ````` ````` ````` ````` ````` ````` protected: // protected morkFile members (similar to public domain IronDoc) diff --git a/db/mork/src/morkHandle.h b/db/mork/src/morkHandle.h index f433b17febf..91c3f88167f 100644 --- a/db/mork/src/morkHandle.h +++ b/db/mork/src/morkHandle.h @@ -96,8 +96,11 @@ public: // dynamic type identification // } ===== end morkNode methods ===== public: // morkHandle memory management operators + void* operator new(size_t inSize, morkPool& ioPool, morkZone& ioZone, morkEnv* ev) + { return ioPool.NewHandle(ev, inSize, &ioZone); } + void* operator new(size_t inSize, morkPool& ioPool, morkEnv* ev) - { return ioPool.NewHandle(ev, inSize); } + { return ioPool.NewHandle(ev, inSize, (morkZone*) 0); } void* operator new(size_t inSize, morkHandleFace* ioFace) { MORK_USED_1(inSize); return ioFace; } diff --git a/db/mork/src/morkMap.h b/db/mork/src/morkMap.h index e379db11825..3f8cfa06208 100644 --- a/db/mork/src/morkMap.h +++ b/db/mork/src/morkMap.h @@ -202,6 +202,9 @@ public: // state is public because the entire Mork system is private // know all new assocs are contiguous and can chain together adjacently.) morkAssoc* mMap_FreeList; // list of unused mMap_Assocs array slots + +public: // getters (morkProbeMap compatibility) + mork_fill MapFill() const { return mMap_Fill; } // { ===== begin morkNode interface ===== public: // morkNode virtual methods diff --git a/db/mork/src/morkNode.cpp b/db/mork/src/morkNode.cpp index b5511f9b682..fe6b00c0f46 100644 --- a/db/mork/src/morkNode.cpp +++ b/db/mork/src/morkNode.cpp @@ -238,6 +238,20 @@ morkNode::~morkNode() // assert that CloseNode() executed earlier // subclasses should closely track any changes in base classes with care. +/*public non-poly*/ +morkNode::morkNode( mork_usage inCode ) +: mNode_Heap( 0 ) +, mNode_Base( morkBase_kNode ) +, mNode_Derived ( 0 ) // until subclass sets appropriately +, mNode_Access( morkAccess_kOpen ) +, mNode_Usage( inCode ) +, mNode_Mutable( morkAble_kEnabled ) +, mNode_Load( morkLoad_kClean ) +, mNode_Uses( 1 ) +, mNode_Refs( 1 ) +{ +} + /*public non-poly*/ morkNode::morkNode(const morkUsage& inUsage, nsIMdbHeap* ioHeap) : mNode_Heap( ioHeap ) @@ -403,9 +417,9 @@ nsIMdbHeap_SlotStrongHeap(nsIMdbHeap* self, morkEnv* ev, nsIMdbHeap** ioSlot) if ( heap ) { *ioSlot = 0; - heap->CutStrongRef(menv); + heap->HeapCutStrongRef(menv); } - if ( self && ev->Good() && (self->AddStrongRef(menv)==0) && ev->Good() ) + if ( self && ev->Good() && (self->HeapAddStrongRef(menv)==0) && ev->Good() ) *ioSlot = self; } } diff --git a/db/mork/src/morkNode.h b/db/mork/src/morkNode.h index 5193fce8a80..2320b379b01 100644 --- a/db/mork/src/morkNode.h +++ b/db/mork/src/morkNode.h @@ -147,6 +147,8 @@ public: // morkNode memory management operators protected: // construction without an anv needed for first env constructed: morkNode(const morkUsage& inUsage, nsIMdbHeap* ioHeap); + morkNode(mork_usage inCode); // usage == inCode, heap == nil + // { ===== begin basic node interface ===== public: // morkNode virtual methods // virtual FlushMorkNode(morkEnv* ev, morkStream* ioStream); diff --git a/db/mork/src/morkObject.cpp b/db/mork/src/morkObject.cpp index 704fc414378..ad7079ed32c 100644 --- a/db/mork/src/morkObject.cpp +++ b/db/mork/src/morkObject.cpp @@ -63,16 +63,18 @@ morkObject::~morkObject() // assert CloseObject() executed earlier } /*public non-poly*/ -morkObject::morkObject(const morkUsage& inUsage, nsIMdbHeap* ioHeap) -: morkNode(inUsage, ioHeap) +morkObject::morkObject(const morkUsage& inUsage, nsIMdbHeap* ioHeap, + mork_color inBeadColor) +: morkBead(inUsage, ioHeap, inBeadColor) , mObject_Handle( 0 ) { } /*public non-poly*/ morkObject::morkObject(morkEnv* ev, - const morkUsage& inUsage, nsIMdbHeap* ioHeap, morkHandle* ioHandle) -: morkNode(ev, inUsage, ioHeap) + const morkUsage& inUsage, nsIMdbHeap* ioHeap, + mork_color inBeadColor, morkHandle* ioHandle) +: morkBead(ev, inUsage, ioHeap, inBeadColor) , mObject_Handle( 0 ) { if ( ev->Good() ) @@ -96,6 +98,8 @@ morkObject::CloseObject(morkEnv* ev) // called by CloseMorkNode(); { if ( mObject_Handle ) morkHandle::SlotWeakHandle((morkHandle*) 0L, ev, &mObject_Handle); + + mBead_Color = 0; // this->CloseBead(ev); this->MarkShut(); } } diff --git a/db/mork/src/morkObject.h b/db/mork/src/morkObject.h index 1cb05e14620..0d19d1fc595 100644 --- a/db/mork/src/morkObject.h +++ b/db/mork/src/morkObject.h @@ -27,6 +27,10 @@ #include "morkNode.h" #endif +#ifndef _MORKBEAD_ +#include "morkBead.h" +#endif + //3456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789 #define morkDerived_kObject /*i*/ 0x6F42 /* ascii 'oB' */ @@ -35,7 +39,7 @@ **| and containing port to those objects that are exposed as instances of **| nsIMdbObject in the public interface. |*/ -class morkObject : public morkNode { +class morkObject : public morkBead { // public: // slots inherited from morkNode (meant to inform only) // nsIMdbHeap* mNode_Heap; @@ -50,6 +54,8 @@ class morkObject : public morkNode { // mork_uses mNode_Uses; // refcount for strong refs // mork_refs mNode_Refs; // refcount for strong refs + weak refs + + // mork_color mBead_Color; // ID for this bead public: // state is public because the entire Mork system is private @@ -61,11 +67,12 @@ public: // morkNode virtual methods virtual ~morkObject(); // assert that CloseObject() executed earlier protected: // special case construction of first env without preceding env - morkObject(const morkUsage& inUsage, nsIMdbHeap* ioHeap); + morkObject(const morkUsage& inUsage, nsIMdbHeap* ioHeap, + mork_color inBeadColor); public: // morkEnv construction & destruction morkObject(morkEnv* ev, const morkUsage& inUsage, nsIMdbHeap* ioHeap, - morkHandle* ioHandle); // ioHandle can be nil + mork_color inBeadColor, morkHandle* ioHandle); // ioHandle can be nil void CloseObject(morkEnv* ev); // called by CloseMorkNode(); private: // copying is not allowed diff --git a/db/mork/src/morkParser.cpp b/db/mork/src/morkParser.cpp index 46bbb3c9305..55188a0e24b 100644 --- a/db/mork/src/morkParser.cpp +++ b/db/mork/src/morkParser.cpp @@ -747,7 +747,6 @@ void morkParser::ReadTable(morkEnv* ev) mParser_Change = mParser_TableChange = morkChange_kNil; - int c; while ( (c = this->NextChar(ev)) != EOF && ev->Good() && c != '}' ) { if ( morkCh_IsHex(c) ) diff --git a/db/mork/src/morkPool.cpp b/db/mork/src/morkPool.cpp index 6d31a0c191e..4399d01d766 100644 --- a/db/mork/src/morkPool.cpp +++ b/db/mork/src/morkPool.cpp @@ -60,6 +60,10 @@ #include "morkDeque.h" #endif +#ifndef _MORKZONE_ +#include "morkZone.h" +#endif + //3456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789 // ````` ````` ````` ````` ````` @@ -87,6 +91,8 @@ morkPool::morkPool(const morkUsage& inUsage, nsIMdbHeap* ioHeap, nsIMdbHeap* ioSlotHeap) : morkNode(inUsage, ioHeap) , mPool_Heap( ioSlotHeap ) +, mPool_UsedFramesCount( 0 ) +, mPool_FreeFramesCount( 0 ) { // mPool_Heap is NOT refcounted MORK_ASSERT(ioSlotHeap); @@ -99,6 +105,8 @@ morkPool::morkPool(morkEnv* ev, const morkUsage& inUsage, nsIMdbHeap* ioHeap, nsIMdbHeap* ioSlotHeap) : morkNode(ev, inUsage, ioHeap) , mPool_Heap( ioSlotHeap ) +, mPool_UsedFramesCount( 0 ) +, mPool_FreeFramesCount( 0 ) { if ( ioSlotHeap ) { @@ -118,8 +126,18 @@ morkPool::ClosePool(morkEnv* ev) // called by CloseMorkNode(); { if ( this->IsNode() ) { - // mPool_Heap is NOT refcounted: - // nsIMdbHeap_SlotStrongHeap((nsIMdbHeap*) 0, ev, &mPool_Heap); +#ifdef morkZone_CONFIG_ARENA +#else /*morkZone_CONFIG_ARENA*/ + //MORK_USED_1(ioZone); +#endif /*morkZone_CONFIG_ARENA*/ + + nsIMdbHeap* heap = mPool_Heap; + nsIMdbEnv* mev = ev->AsMdbEnv(); + morkLink* link; + morkDeque* d = &mPool_FreeHandleFrames; + while ( (link = d->RemoveFirst()) != 0 ) + heap->Free(mev, link); + this->MarkShut(); } else @@ -135,10 +153,34 @@ morkPool::ClosePool(morkEnv* ev) // called by CloseMorkNode(); // alloc and free individual instances of handles (inside hand frames): morkHandleFace* -morkPool::NewHandle(morkEnv* ev, mork_size inSize) +morkPool::NewHandle(morkEnv* ev, mork_size inSize, morkZone* ioZone) { void* newBlock = 0; - mPool_Heap->Alloc(ev->AsMdbEnv(), inSize, (void**) &newBlock); + if ( inSize <= sizeof(morkHandleFrame) ) + { + morkLink* link = mPool_FreeHandleFrames.RemoveFirst(); + if ( link ) + { + newBlock = link; + if ( mPool_FreeFramesCount ) + --mPool_FreeFramesCount; + else + ev->NewWarning("mPool_FreeFramesCount underflow"); + } + else + mPool_Heap->Alloc(ev->AsMdbEnv(), sizeof(morkHandleFrame), + (void**) &newBlock); + } + else + { + ev->NewWarning("inSize > sizeof(morkHandleFrame)"); + mPool_Heap->Alloc(ev->AsMdbEnv(), inSize, (void**) &newBlock); + } +#ifdef morkZone_CONFIG_ARENA +#else /*morkZone_CONFIG_ARENA*/ + MORK_USED_1(ioZone); +#endif /*morkZone_CONFIG_ARENA*/ + return (morkHandleFace*) newBlock; } @@ -146,39 +188,66 @@ void morkPool::ZapHandle(morkEnv* ev, morkHandleFace* ioHandle) { if ( ioHandle ) - mPool_Heap->Free(ev->AsMdbEnv(), ioHandle); + { + morkLink* link = (morkLink*) ioHandle; + mPool_FreeHandleFrames.AddLast(link); + ++mPool_FreeFramesCount; + } } + // alloc and free individual instances of rows: morkRow* -morkPool::NewRow(morkEnv* ev) // allocate a new row instance +morkPool::NewRow(morkEnv* ev, morkZone* ioZone) // allocate a new row instance { morkRow* newRow = 0; + +#ifdef morkZone_CONFIG_ARENA + // a zone 'chip' remembers no size, and so cannot be deallocated: + newRow = (morkRow*) ioZone->ZoneNewChip(ev, sizeof(morkRow)); +#else /*morkZone_CONFIG_ARENA*/ + MORK_USED_1(ioZone); mPool_Heap->Alloc(ev->AsMdbEnv(), sizeof(morkRow), (void**) &newRow); +#endif /*morkZone_CONFIG_ARENA*/ + if ( newRow ) MORK_MEMSET(newRow, 0, sizeof(morkRow)); - if ( newRow ) - { - } return newRow; } void -morkPool::ZapRow(morkEnv* ev, morkRow* ioRow) // free old row instance +morkPool::ZapRow(morkEnv* ev, morkRow* ioRow, + morkZone* ioZone) // free old row instance { +#ifdef morkZone_CONFIG_ARENA + if ( !ioRow ) + ev->NilPointerWarning(); // a zone 'chip' cannot be freed +#else /*morkZone_CONFIG_ARENA*/ + MORK_USED_1(ioZone); if ( ioRow ) mPool_Heap->Free(ev->AsMdbEnv(), ioRow); +#endif /*morkZone_CONFIG_ARENA*/ } // alloc and free entire vectors of cells (not just one cell at a time) morkCell* -morkPool::NewCells(morkEnv* ev, mork_size inSize) +morkPool::NewCells(morkEnv* ev, mork_size inSize, + morkZone* ioZone) { morkCell* newCells = 0; + mork_size size = inSize * sizeof(morkCell); if ( size ) + { +#ifdef morkZone_CONFIG_ARENA + // a zone 'run' knows its size, and can indeed be deallocated: + newCells = (morkCell*) ioZone->ZoneNewRun(ev, size); +#else /*morkZone_CONFIG_ARENA*/ + MORK_USED_1(ioZone); mPool_Heap->Alloc(ev->AsMdbEnv(), size, (void**) &newCells); +#endif /*morkZone_CONFIG_ARENA*/ + } // note morkAtom depends on having nil stored in all new mCell_Atom slots: if ( newCells ) @@ -187,23 +256,39 @@ morkPool::NewCells(morkEnv* ev, mork_size inSize) } void -morkPool::ZapCells(morkEnv* ev, morkCell* ioVector, mork_size inSize) +morkPool::ZapCells(morkEnv* ev, morkCell* ioVector, mork_size inSize, + morkZone* ioZone) { MORK_USED_1(inSize); + if ( ioVector ) + { +#ifdef morkZone_CONFIG_ARENA + // a zone 'run' knows its size, and can indeed be deallocated: + ioZone->ZoneZapRun(ev, ioVector); +#else /*morkZone_CONFIG_ARENA*/ + MORK_USED_1(ioZone); mPool_Heap->Free(ev->AsMdbEnv(), ioVector); +#endif /*morkZone_CONFIG_ARENA*/ + } } // resize (grow or trim) cell vectors inside a containing row instance mork_bool -morkPool::AddRowCells(morkEnv* ev, morkRow* ioRow, mork_size inNewSize) +morkPool::AddRowCells(morkEnv* ev, morkRow* ioRow, mork_size inNewSize, + morkZone* ioZone) { // note strong implementation similarity to morkArray::Grow() + MORK_USED_1(ioZone); +#ifdef morkZone_CONFIG_ARENA +#else /*morkZone_CONFIG_ARENA*/ +#endif /*morkZone_CONFIG_ARENA*/ + mork_fill fill = ioRow->mRow_Length; if ( ev->Good() && fill < inNewSize ) // need more cells? { - morkCell* newCells = this->NewCells(ev, inNewSize); + morkCell* newCells = this->NewCells(ev, inNewSize, ioZone); if ( newCells ) { morkCell* c = newCells; // for iterating during copy @@ -219,7 +304,7 @@ morkPool::AddRowCells(morkEnv* ev, morkRow* ioRow, mork_size inNewSize) ++ioRow->mRow_Seed; if ( oldCells ) - this->ZapCells(ev, oldCells, fill); + this->ZapCells(ev, oldCells, fill, ioZone); } } return ( ev->Good() && ioRow->mRow_Length >= inNewSize ); @@ -227,14 +312,20 @@ morkPool::AddRowCells(morkEnv* ev, morkRow* ioRow, mork_size inNewSize) mork_bool morkPool::CutRowCells(morkEnv* ev, morkRow* ioRow, - mork_size inNewSize) + mork_size inNewSize, + morkZone* ioZone) { + MORK_USED_1(ioZone); +#ifdef morkZone_CONFIG_ARENA +#else /*morkZone_CONFIG_ARENA*/ +#endif /*morkZone_CONFIG_ARENA*/ + mork_fill fill = ioRow->mRow_Length; if ( ev->Good() && fill > inNewSize ) // need fewer cells? { if ( inNewSize ) // want any row cells at all? { - morkCell* newCells = this->NewCells(ev, inNewSize); + morkCell* newCells = this->NewCells(ev, inNewSize, ioZone); if ( newCells ) { morkCell* oldCells = ioRow->mRow_Cells; @@ -256,7 +347,7 @@ morkPool::CutRowCells(morkEnv* ev, morkRow* ioRow, ++ioRow->mRow_Seed; if ( oldCells ) - this->ZapCells(ev, oldCells, fill); + this->ZapCells(ev, oldCells, fill, ioZone); } } else // get rid of all row cells @@ -267,7 +358,7 @@ morkPool::CutRowCells(morkEnv* ev, morkRow* ioRow, ++ioRow->mRow_Seed; if ( oldCells ) - this->ZapCells(ev, oldCells, fill); + this->ZapCells(ev, oldCells, fill, ioZone); } } return ( ev->Good() && ioRow->mRow_Length <= inNewSize ); @@ -275,27 +366,51 @@ morkPool::CutRowCells(morkEnv* ev, morkRow* ioRow, // alloc & free individual instances of atoms (lots of atom subclasses): void -morkPool::ZapAtom(morkEnv* ev, morkAtom* ioAtom) // any subclass (by kind) +morkPool::ZapAtom(morkEnv* ev, morkAtom* ioAtom, + morkZone* ioZone) // any subclass (by kind) { +#ifdef morkZone_CONFIG_ARENA + if ( !ioAtom ) + ev->NilPointerWarning(); // a zone 'chip' cannot be freed +#else /*morkZone_CONFIG_ARENA*/ + MORK_USED_1(ioZone); if ( ioAtom ) mPool_Heap->Free(ev->AsMdbEnv(), ioAtom); +#endif /*morkZone_CONFIG_ARENA*/ } morkOidAtom* -morkPool::NewRowOidAtom(morkEnv* ev, const mdbOid& inOid) +morkPool::NewRowOidAtom(morkEnv* ev, const mdbOid& inOid, + morkZone* ioZone) { morkOidAtom* newAtom = 0; + +#ifdef morkZone_CONFIG_ARENA + // a zone 'chip' remembers no size, and so cannot be deallocated: + newAtom = (morkOidAtom*) ioZone->ZoneNewChip(ev, sizeof(morkOidAtom)); +#else /*morkZone_CONFIG_ARENA*/ + MORK_USED_1(ioZone); mPool_Heap->Alloc(ev->AsMdbEnv(), sizeof(morkOidAtom),(void**) &newAtom); +#endif /*morkZone_CONFIG_ARENA*/ + if ( newAtom ) newAtom->InitRowOidAtom(ev, inOid); return newAtom; } morkOidAtom* -morkPool::NewTableOidAtom(morkEnv* ev, const mdbOid& inOid) +morkPool::NewTableOidAtom(morkEnv* ev, const mdbOid& inOid, + morkZone* ioZone) { morkOidAtom* newAtom = 0; + +#ifdef morkZone_CONFIG_ARENA + // a zone 'chip' remembers no size, and so cannot be deallocated: + newAtom = (morkOidAtom*) ioZone->ZoneNewChip(ev, sizeof(morkOidAtom)); +#else /*morkZone_CONFIG_ARENA*/ + MORK_USED_1(ioZone); mPool_Heap->Alloc(ev->AsMdbEnv(), sizeof(morkOidAtom), (void**) &newAtom); +#endif /*morkZone_CONFIG_ARENA*/ if ( newAtom ) newAtom->InitTableOidAtom(ev, inOid); return newAtom; @@ -303,17 +418,25 @@ morkPool::NewTableOidAtom(morkEnv* ev, const mdbOid& inOid) morkAtom* morkPool::NewAnonAtom(morkEnv* ev, const morkBuf& inBuf, - mork_cscode inForm) + mork_cscode inForm, + morkZone* ioZone) // if inForm is zero, and inBuf.mBuf_Fill is less than 256, then a 'wee' // anon atom will be created, and otherwise a 'big' anon atom. { morkAtom* newAtom = 0; + mork_bool needBig = ( inForm || inBuf.mBuf_Fill > 255 ); mork_size size = ( needBig )? morkBigAnonAtom::SizeForFill(inBuf.mBuf_Fill) : morkWeeAnonAtom::SizeForFill(inBuf.mBuf_Fill); +#ifdef morkZone_CONFIG_ARENA + // a zone 'chip' remembers no size, and so cannot be deallocated: + newAtom = (morkAtom*) ioZone->ZoneNewChip(ev, size); +#else /*morkZone_CONFIG_ARENA*/ + MORK_USED_1(ioZone); mPool_Heap->Alloc(ev->AsMdbEnv(), size, (void**) &newAtom); +#endif /*morkZone_CONFIG_ARENA*/ if ( newAtom ) { if ( needBig ) @@ -326,17 +449,25 @@ morkPool::NewAnonAtom(morkEnv* ev, const morkBuf& inBuf, morkBookAtom* morkPool::NewBookAtom(morkEnv* ev, const morkBuf& inBuf, - mork_cscode inForm, morkAtomSpace* ioSpace, mork_aid inAid) + mork_cscode inForm, morkAtomSpace* ioSpace, mork_aid inAid, + morkZone* ioZone) // if inForm is zero, and inBuf.mBuf_Fill is less than 256, then a 'wee' // book atom will be created, and otherwise a 'big' book atom. { morkBookAtom* newAtom = 0; + mork_bool needBig = ( inForm || inBuf.mBuf_Fill > 255 ); mork_size size = ( needBig )? morkBigBookAtom::SizeForFill(inBuf.mBuf_Fill) : morkWeeBookAtom::SizeForFill(inBuf.mBuf_Fill); +#ifdef morkZone_CONFIG_ARENA + // a zone 'chip' remembers no size, and so cannot be deallocated: + newAtom = (morkBookAtom*) ioZone->ZoneNewChip(ev, size); +#else /*morkZone_CONFIG_ARENA*/ + MORK_USED_1(ioZone); mPool_Heap->Alloc(ev->AsMdbEnv(), size, (void**) &newAtom); +#endif /*morkZone_CONFIG_ARENA*/ if ( newAtom ) { if ( needBig ) @@ -350,12 +481,14 @@ morkPool::NewBookAtom(morkEnv* ev, const morkBuf& inBuf, } morkBookAtom* -morkPool::NewBookAtomCopy(morkEnv* ev, const morkBigBookAtom& inAtom) +morkPool::NewBookAtomCopy(morkEnv* ev, const morkBigBookAtom& inAtom, + morkZone* ioZone) // make the smallest kind of book atom that can hold content in inAtom. // The inAtom parameter is often expected to be a staged book atom in // the store, which was used to search an atom space for existing atoms. { morkBookAtom* newAtom = 0; + mork_cscode form = inAtom.mBigBookAtom_Form; mork_fill fill = inAtom.mBigBookAtom_Size; mork_bool needBig = ( form || fill > 255 ); @@ -363,7 +496,13 @@ morkPool::NewBookAtomCopy(morkEnv* ev, const morkBigBookAtom& inAtom) morkBigBookAtom::SizeForFill(fill) : morkWeeBookAtom::SizeForFill(fill); +#ifdef morkZone_CONFIG_ARENA + // a zone 'chip' remembers no size, and so cannot be deallocated: + newAtom = (morkBookAtom*) ioZone->ZoneNewChip(ev, size); +#else /*morkZone_CONFIG_ARENA*/ + MORK_USED_1(ioZone); mPool_Heap->Alloc(ev->AsMdbEnv(), size, (void**) &newAtom); +#endif /*morkZone_CONFIG_ARENA*/ if ( newAtom ) { morkBuf buf(inAtom.mBigBookAtom_Body, fill); diff --git a/db/mork/src/morkPool.h b/db/mork/src/morkPool.h index fb5eeaac2b3..291bfe2f637 100644 --- a/db/mork/src/morkPool.h +++ b/db/mork/src/morkPool.h @@ -68,6 +68,9 @@ public: // state is public because the entire Mork system is private // These two lists contain instances of morkHandleFrame: morkDeque mPool_UsedHandleFrames; // handle frames currently being used morkDeque mPool_FreeHandleFrames; // handle frames currently in free list + + mork_count mPool_UsedFramesCount; // length of mPool_UsedHandleFrames + mork_count mPool_FreeFramesCount; // length of mPool_UsedHandleFrames // { ===== begin morkNode interface ===== public: // morkNode virtual methods @@ -107,38 +110,38 @@ public: // morkNode memory management operators public: // other pool methods // alloc and free individual instances of handles (inside hand frames): - morkHandleFace* NewHandle(morkEnv* ev, mork_size inSize); + morkHandleFace* NewHandle(morkEnv* ev, mork_size inSize, morkZone* ioZone); void ZapHandle(morkEnv* ev, morkHandleFace* ioHandle); // alloc and free individual instances of rows: - morkRow* NewRow(morkEnv* ev); // allocate a new row instance - void ZapRow(morkEnv* ev, morkRow* ioRow); // free old row instance + morkRow* NewRow(morkEnv* ev, morkZone* ioZone); // alloc new row instance + void ZapRow(morkEnv* ev, morkRow* ioRow, morkZone* ioZone); // free old row instance // alloc and free entire vectors of cells (not just one cell at a time) - morkCell* NewCells(morkEnv* ev, mork_size inSize); - void ZapCells(morkEnv* ev, morkCell* ioVector, mork_size inSize); + morkCell* NewCells(morkEnv* ev, mork_size inSize, morkZone* ioZone); + void ZapCells(morkEnv* ev, morkCell* ioVector, mork_size inSize, morkZone* ioZone); // resize (grow or trim) cell vectors inside a containing row instance - mork_bool AddRowCells(morkEnv* ev, morkRow* ioRow, mork_size inNewSize); - mork_bool CutRowCells(morkEnv* ev, morkRow* ioRow, mork_size inNewSize); + mork_bool AddRowCells(morkEnv* ev, morkRow* ioRow, mork_size inNewSize, morkZone* ioZone); + mork_bool CutRowCells(morkEnv* ev, morkRow* ioRow, mork_size inNewSize, morkZone* ioZone); // alloc & free individual instances of atoms (lots of atom subclasses): - void ZapAtom(morkEnv* ev, morkAtom* ioAtom); // any subclass (by kind) + void ZapAtom(morkEnv* ev, morkAtom* ioAtom, morkZone* ioZone); // any subclass (by kind) - morkOidAtom* NewRowOidAtom(morkEnv* ev, const mdbOid& inOid); - morkOidAtom* NewTableOidAtom(morkEnv* ev, const mdbOid& inOid); + morkOidAtom* NewRowOidAtom(morkEnv* ev, const mdbOid& inOid, morkZone* ioZone); + morkOidAtom* NewTableOidAtom(morkEnv* ev, const mdbOid& inOid, morkZone* ioZone); morkAtom* NewAnonAtom(morkEnv* ev, const morkBuf& inBuf, - mork_cscode inForm); + mork_cscode inForm, morkZone* ioZone); // if inForm is zero, and inBuf.mBuf_Fill is less than 256, then a 'wee' // anon atom will be created, and otherwise a 'big' anon atom. morkBookAtom* NewBookAtom(morkEnv* ev, const morkBuf& inBuf, - mork_cscode inForm, morkAtomSpace* ioSpace, mork_aid inAid); + mork_cscode inForm, morkAtomSpace* ioSpace, mork_aid inAid, morkZone* ioZone); // if inForm is zero, and inBuf.mBuf_Fill is less than 256, then a 'wee' // book atom will be created, and otherwise a 'big' book atom. - morkBookAtom* NewBookAtomCopy(morkEnv* ev, const morkBigBookAtom& inAtom); + morkBookAtom* NewBookAtomCopy(morkEnv* ev, const morkBigBookAtom& inAtom, morkZone* ioZone); // make the smallest kind of book atom that can hold content in inAtom. // The inAtom parameter is often expected to be a staged book atom in // the store, which was used to search an atom space for existing atoms. diff --git a/db/mork/src/morkPortTableCursor.cpp b/db/mork/src/morkPortTableCursor.cpp index 3511a70f17a..2ae91c50483 100644 --- a/db/mork/src/morkPortTableCursor.cpp +++ b/db/mork/src/morkPortTableCursor.cpp @@ -286,6 +286,14 @@ morkPortTableCursor::NextTable(morkEnv* ev) if ( space ) // have a space remaining that might hold tables? { +#ifdef MORK_BEAD_OVER_NODE_MAPS + morkTableMapIter* ti = &mPortTableCursor_TableIter; + morkTable* table = ( mPortTableCursor_LastTable )? + ti->NextTable(ev) : ti->FirstTable(ev); + + for ( ; table && ev->Good(); table = ti->NextTable(ev) ) + +#else /*MORK_BEAD_OVER_NODE_MAPS*/ mork_tid* key = 0; // ignore keys in table map morkTable* table = 0; // old value table in the map morkTableMapIter* ti = &mPortTableCursor_TableIter; @@ -293,6 +301,7 @@ morkPortTableCursor::NextTable(morkEnv* ev) ti->NextTable(ev, key, &table) : ti->FirstTable(ev, key, &table); for ( ; c && ev->Good(); c = ti->NextTable(ev, key, &table) ) +#endif /*MORK_BEAD_OVER_NODE_MAPS*/ { if ( table && table->IsTable() ) { diff --git a/db/mork/src/morkRow.cpp b/db/mork/src/morkRow.cpp index 492e476bbd3..9b06491bafe 100644 --- a/db/mork/src/morkRow.cpp +++ b/db/mork/src/morkRow.cpp @@ -218,9 +218,11 @@ morkRow::InitRow(morkEnv* ev, const mdbOid* inOid, morkRowSpace* ioSpace, mRow_Pad = 0; mRow_Flags = 0; mRow_Tag = morkRow_kTag; + + morkZone* zone = &ioSpace->mSpace_Store->mStore_Zone; if ( inLength ) - mRow_Cells = ioPool->NewCells(ev, inLength); + mRow_Cells = ioPool->NewCells(ev, inLength, zone); if ( this->MaybeDirtySpaceStoreAndRow() ) // new row might dirty store { @@ -385,8 +387,9 @@ morkRow::TakeCells(morkEnv* ev, morkCell* ioVector, mork_fill inVecLength, if ( growth && ev->Good() ) // need to add any cells? { + morkZone* zone = &ioStore->mStore_Zone; morkPool* pool = ioStore->StorePool(); - if ( !pool->AddRowCells(ev, this, length + growth) ) + if ( !pool->AddRowCells(ev, this, length + growth, zone) ) ev->NewError("cannot take cells"); } if ( ev->Good() ) @@ -429,10 +432,11 @@ morkRow::NewCell(morkEnv* ev, mdb_column inColumn, mork_size length = (mork_size) mRow_Length; *outPos = (mork_pos) length; morkPool* pool = ioStore->StorePool(); + morkZone* zone = &ioStore->mStore_Zone; mork_bool canDirty = this->MaybeDirtySpaceStoreAndRow(); - if ( pool->AddRowCells(ev, this, length + 1) ) + if ( pool->AddRowCells(ev, this, length + 1, zone) ) { morkCell* cell = mRow_Cells + length; // next line equivalent to inline morkCell::SetCellDirty(): @@ -594,7 +598,7 @@ morkRow::CutAllColumns(morkEnv* ev) this->cut_all_index_entries(ev); morkPool* pool = store->StorePool(); - pool->CutRowCells(ev, this, /*newSize*/ 0); + pool->CutRowCells(ev, this, /*newSize*/ 0, &store->mStore_Zone); } } @@ -616,10 +620,10 @@ morkRow::SetRow(morkEnv* ev, const morkRow* inSourceRow) mork_bool sameStore = ( store == srcStore ); // identical stores? morkPool* pool = store->StorePool(); - if ( pool->CutRowCells(ev, this, /*newSize*/ 0) ) + if ( pool->CutRowCells(ev, this, /*newSize*/ 0, &store->mStore_Zone) ) { mork_fill fill = inSourceRow->mRow_Length; - if ( pool->AddRowCells(ev, this, fill) ) + if ( pool->AddRowCells(ev, this, fill, &store->mStore_Zone) ) { morkCell* dst = mRow_Cells; morkCell* dstEnd = dst + mRow_Length; @@ -784,7 +788,7 @@ void morkRow::CutColumn(morkEnv* ev, mdb_column inColumn) } if ( ev->Good() ) - pool->CutRowCells(ev, this, fill - 1); + pool->CutRowCells(ev, this, fill - 1, &store->mStore_Zone); } } } diff --git a/db/mork/src/morkRow.h b/db/mork/src/morkRow.h index 7ac752ad26d..3e927418502 100644 --- a/db/mork/src/morkRow.h +++ b/db/mork/src/morkRow.h @@ -46,7 +46,7 @@ class nsIMdbCell; class morkRow { // row of cells public: // state is public because the entire Mork system is private - morkRowSpace* mRow_Space; // mRow_Space->mSpace_Scope is the row scope + morkRowSpace* mRow_Space; // mRow_Space->SpaceScope() is the row scope morkRowObject* mRow_Object; // refcount & other state for object sharing morkCell* mRow_Cells; mdbOid mRow_Oid; diff --git a/db/mork/src/morkRowMap.cpp b/db/mork/src/morkRowMap.cpp index 99d08134e06..61499bd7135 100644 --- a/db/mork/src/morkRowMap.cpp +++ b/db/mork/src/morkRowMap.cpp @@ -170,4 +170,151 @@ morkRowMap::GetRow(morkEnv* ev, const morkRow* ioRow) } + +//3456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789 + +// ````` ````` ````` ````` ````` +// { ===== begin morkNode interface ===== + +/*public virtual*/ void +morkRowProbeMap::CloseMorkNode(morkEnv* ev) // CloseRowProbeMap() only if open +{ + if ( this->IsOpenNode() ) + { + this->MarkClosing(); + this->CloseRowProbeMap(ev); + this->MarkShut(); + } +} + +/*public virtual*/ +morkRowProbeMap::~morkRowProbeMap() // assert CloseRowProbeMap() executed earlier +{ + MORK_ASSERT(this->IsShutNode()); +} + +/*public non-poly*/ +morkRowProbeMap::morkRowProbeMap(morkEnv* ev, const morkUsage& inUsage, + nsIMdbHeap* ioHeap, nsIMdbHeap* ioSlotHeap, mork_size inSlots) +: morkProbeMap(ev, inUsage, ioHeap, + /*inKeySize*/ sizeof(morkRow*), /*inValSize*/ 0, + ioSlotHeap, inSlots, + /*inHoldChanges*/ morkBool_kTrue) +{ + if ( ev->Good() ) + mNode_Derived = morkDerived_kRowProbeMap; +} + +/*public non-poly*/ void +morkRowProbeMap::CloseRowProbeMap(morkEnv* ev) // called by CloseMorkNode(); +{ + if ( this ) + { + if ( this->IsNode() ) + { + this->CloseProbeMap(ev); + this->MarkShut(); + } + else + this->NonNodeError(ev); + } + else + ev->NilPointerError(); +} + +// } ===== end morkNode methods ===== +// ````` ````` ````` ````` ````` + +/*virtual*/ mork_test // hit(a,b) implies hash(a) == hash(b) +morkRowProbeMap::MapTest(morkEnv* ev, const void* inMapKey, + const void* inAppKey) const +{ + MORK_USED_1(ev); + const morkRow* key = *(const morkRow**) inMapKey; + if ( key ) + { + mork_bool hit = key->EqualRow(*(const morkRow**) inAppKey); + return ( hit ) ? morkTest_kHit : morkTest_kMiss; + } + else + return morkTest_kVoid; +} + +/*virtual*/ mork_u4 // hit(a,b) implies hash(a) == hash(b) +morkRowProbeMap::MapHash(morkEnv* ev, const void* inAppKey) const +{ + const morkRow* key = *(const morkRow**) inAppKey; + if ( key ) + return key->HashRow(); + else + { + ev->NilPointerWarning(); + return 0; + } +} + +/*virtual*/ mork_u4 +morkRowProbeMap::ProbeMapHashMapKey(morkEnv* ev, + const void* inMapKey) const +{ + const morkRow* key = *(const morkRow**) inMapKey; + if ( key ) + return key->HashRow(); + else + { + ev->NilPointerWarning(); + return 0; + } +} + +mork_bool +morkRowProbeMap::AddRow(morkEnv* ev, morkRow* ioRow) +{ + if ( ev->Good() ) + { + this->MapAtPut(ev, &ioRow, /*val*/ (void*) 0, + /*key*/ (void*) 0, /*val*/ (void*) 0); + } + return ev->Good(); +} + +morkRow* +morkRowProbeMap::CutOid(morkEnv* ev, const mdbOid* inOid) +{ + MORK_USED_1(inOid); + morkProbeMap::ProbeMapCutError(ev); + + return 0; +} + +morkRow* +morkRowProbeMap::CutRow(morkEnv* ev, const morkRow* ioRow) +{ + MORK_USED_1(ioRow); + morkProbeMap::ProbeMapCutError(ev); + + return 0; +} + +morkRow* +morkRowProbeMap::GetOid(morkEnv* ev, const mdbOid* inOid) +{ + morkRow row(inOid); + morkRow* key = &row; + morkRow* oldKey = 0; + this->MapAt(ev, &key, &oldKey, /*val*/ (void*) 0); + + return oldKey; +} + +morkRow* +morkRowProbeMap::GetRow(morkEnv* ev, const morkRow* ioRow) +{ + morkRow* oldKey = 0; + this->MapAt(ev, &ioRow, &oldKey, /*val*/ (void*) 0); + + return oldKey; +} + + //3456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789 diff --git a/db/mork/src/morkRowMap.h b/db/mork/src/morkRowMap.h index adff3c4539b..45ab56a8586 100644 --- a/db/mork/src/morkRowMap.h +++ b/db/mork/src/morkRowMap.h @@ -31,6 +31,10 @@ #include "morkMap.h" #endif +#ifndef _MORKPROBEMAP_ +#include "morkProbeMap.h" +#endif + //3456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789 #define morkDerived_kRowMap /*i*/ 0x724D /* ascii 'rM' */ @@ -84,11 +88,11 @@ public: // other map methods // note the rows are owned elsewhere, usuall by morkRowSpace public: // typesafe refcounting inlines calling inherited morkNode methods - static void SlotWeakRowMap(morkMap* me, + static void SlotWeakRowMap(morkRowMap* me, morkEnv* ev, morkRowMap** ioSlot) { morkNode::SlotWeakNode((morkNode*) me, ev, (morkNode**) ioSlot); } - static void SlotStrongRowMap(morkMap* me, + static void SlotStrongRowMap(morkRowMap* me, morkEnv* ev, morkRowMap** ioSlot) { morkNode::SlotStrongNode((morkNode*) me, ev, (morkNode**) ioSlot); } }; @@ -116,6 +120,105 @@ public: { return this->CutHere(ev, outRowPtr, /*val*/ (void*) 0); } }; + +//3456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789 + +#define morkDerived_kRowProbeMap /*i*/ 0x726D /* ascii 'rm' */ + +/*| morkRowProbeMap: maps a set of morkRow by contained Oid +|*/ +class morkRowProbeMap : public morkProbeMap { // for mapping row IDs to rows + +// { ===== begin morkNode interface ===== +public: // morkNode virtual methods + virtual void CloseMorkNode(morkEnv* ev); // CloseRowProbeMap() only if open + virtual ~morkRowProbeMap(); // assert CloseRowProbeMap() executed earlier + +public: // morkMap construction & destruction + morkRowProbeMap(morkEnv* ev, const morkUsage& inUsage, + nsIMdbHeap* ioHeap, nsIMdbHeap* ioSlotHeap, mork_size inSlots); + void CloseRowProbeMap(morkEnv* ev); // called by CloseMorkNode(); + +public: // dynamic type identification + mork_bool IsRowMap() const + { return IsNode() && mNode_Derived == morkDerived_kRowMap; } +// } ===== end morkNode methods ===== + + // { ===== begin morkProbeMap methods ===== + virtual mork_test // hit(a,b) implies hash(a) == hash(b) + MapTest(morkEnv* ev, const void* inMapKey, const void* inAppKey) const; + + virtual mork_u4 // hit(a,b) implies hash(a) == hash(b) + MapHash(morkEnv* ev, const void* inAppKey) const; + + virtual mork_u4 ProbeMapHashMapKey(morkEnv* ev, const void* inMapKey) const; + + // virtual mork_bool ProbeMapIsKeyNil(morkEnv* ev, void* ioMapKey); + + // virtual void ProbeMapClearKey(morkEnv* ev, // put 'nil' alls keys inside map + // void* ioMapKey, mork_count inKeyCount); // array of keys inside map + + // virtual void ProbeMapPushIn(morkEnv* ev, // move (key,val) into the map + // const void* inAppKey, const void* inAppVal, // (key,val) outside map + // void* outMapKey, void* outMapVal); // (key,val) inside map + + // virtual void ProbeMapPullOut(morkEnv* ev, // move (key,val) out from the map + // const void* inMapKey, const void* inMapVal, // (key,val) inside map + // void* outAppKey, void* outAppVal) const; // (key,val) outside map + // } ===== end morkProbeMap methods ===== + +public: // other map methods + + mork_bool AddRow(morkEnv* ev, morkRow* ioRow); + // AddRow() returns ev->Good() + + morkRow* CutOid(morkEnv* ev, const mdbOid* inOid); + // CutRid() returns the row removed equal to inRid, if there was one + + morkRow* CutRow(morkEnv* ev, const morkRow* ioRow); + // CutRow() returns the row removed equal to ioRow, if there was one + + morkRow* GetOid(morkEnv* ev, const mdbOid* inOid); + // GetOid() returns the row equal to inRid, or else nil + + morkRow* GetRow(morkEnv* ev, const morkRow* ioRow); + // GetRow() returns the row equal to ioRow, or else nil + + // note the rows are owned elsewhere, usuall by morkRowSpace + +public: // typesafe refcounting inlines calling inherited morkNode methods + static void SlotWeakRowProbeMap(morkRowProbeMap* me, + morkEnv* ev, morkRowProbeMap** ioSlot) + { morkNode::SlotWeakNode((morkNode*) me, ev, (morkNode**) ioSlot); } + + static void SlotStrongRowProbeMap(morkRowProbeMap* me, + morkEnv* ev, morkRowProbeMap** ioSlot) + { morkNode::SlotStrongNode((morkNode*) me, ev, (morkNode**) ioSlot); } +}; + +class morkRowProbeMapIter: public morkProbeMapIter{ // typesafe wrapper class + +public: + morkRowProbeMapIter(morkEnv* ev, morkRowProbeMap* ioMap) + : morkProbeMapIter(ev, ioMap) { } + + morkRowProbeMapIter( ) : morkProbeMapIter() { } + void InitRowMapIter(morkEnv* ev, morkRowProbeMap* ioMap) + { this->InitMapIter(ev, ioMap); } + + mork_change* FirstRow(morkEnv* ev, morkRow** outRowPtr) + { return this->First(ev, outRowPtr, /*val*/ (void*) 0); } + + mork_change* NextRow(morkEnv* ev, morkRow** outRowPtr) + { return this->Next(ev, outRowPtr, /*val*/ (void*) 0); } + + mork_change* HereRow(morkEnv* ev, morkRow** outRowPtr) + { return this->Here(ev, outRowPtr, /*val*/ (void*) 0); } + + mork_change* CutHereRow(morkEnv* ev, morkRow** outRowPtr) + { return this->CutHere(ev, outRowPtr, /*val*/ (void*) 0); } +}; + //3456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789 #endif /* _MORKROWMAP_ */ diff --git a/db/mork/src/morkRowObject.cpp b/db/mork/src/morkRowObject.cpp index 15e0b9ef8f1..15f12a564b7 100644 --- a/db/mork/src/morkRowObject.cpp +++ b/db/mork/src/morkRowObject.cpp @@ -70,7 +70,7 @@ morkRowObject::~morkRowObject() // assert CloseRowObject() executed earlier morkRowObject::morkRowObject(morkEnv* ev, const morkUsage& inUsage, nsIMdbHeap* ioHeap, morkRow* ioRow, morkStore* ioStore) -: morkObject(ev, inUsage, ioHeap, (morkHandle*) 0) +: morkObject(ev, inUsage, ioHeap, morkColor_kNone, (morkHandle*) 0) , mRowObject_Row( 0 ) , mRowObject_Store( 0 ) { diff --git a/db/mork/src/morkRowSpace.cpp b/db/mork/src/morkRowSpace.cpp index 4efbc98ec34..9fe0329d7d6 100644 --- a/db/mork/src/morkRowSpace.cpp +++ b/db/mork/src/morkRowSpace.cpp @@ -212,11 +212,23 @@ morkRowSpace::CutAllRows(morkEnv* ev, morkPool* ioPool) if ( this->IsRowSpaceClean() ) this->MaybeDirtyStoreAndSpace(); - mork_num outSlots = mRowSpace_Rows.mMap_Fill; + morkZone* zone = &mSpace_Store->mStore_Zone; + mork_num outSlots = mRowSpace_Rows.MapFill(); morkRow* r = 0; // old key row in the map mork_change* c = 0; + +#ifdef MORK_ENABLE_ZONE_ARENAS + MORK_USED_2(ev, ioPool); + return 0; +#else /*MORK_ENABLE_ZONE_ARENAS*/ + +#ifdef MORK_ENABLE_PROBE_MAPS + morkRowProbeMapIter i(ev, &mRowSpace_Rows); +#else /*MORK_ENABLE_PROBE_MAPS*/ morkRowMapIter i(ev, &mRowSpace_Rows); +#endif /*MORK_ENABLE_PROBE_MAPS*/ + for ( c = i.FirstRow(ev, &r); c && ev->Good(); c = i.NextRow(ev, &r) ) { @@ -229,7 +241,7 @@ morkRowSpace::CutAllRows(morkEnv* ev, morkPool* ioPool) morkRowObject::SlotWeakRowObject((morkRowObject*) 0, ev, &r->mRow_Object); } - ioPool->ZapRow(ev, r); + ioPool->ZapRow(ev, r, zone); } else r->NonRowTypeWarning(ev); @@ -237,18 +249,30 @@ morkRowSpace::CutAllRows(morkEnv* ev, morkPool* ioPool) else ev->NilPointerError(); +#ifdef MORK_ENABLE_PROBE_MAPS + // cut nothing from the map +#else /*MORK_ENABLE_PROBE_MAPS*/ i.CutHereRow(ev, /*key*/ (morkRow**) 0); +#endif /*MORK_ENABLE_PROBE_MAPS*/ } +#endif /*MORK_ENABLE_ZONE_ARENAS*/ + return outSlots; } - morkTable* morkRowSpace::FindTableByKind(morkEnv* ev, mork_kind inTableKind) { if ( inTableKind ) { +#ifdef MORK_BEAD_OVER_NODE_MAPS + + morkTableMapIter i(ev, &mRowSpace_Tables); + morkTable* table = i.FirstTable(ev); + for ( ; table && ev->Good(); table = i.NextTable(ev) ) + +#else /*MORK_BEAD_OVER_NODE_MAPS*/ mork_tid* key = 0; // nil pointer to suppress key access morkTable* table = 0; // old table in the map @@ -256,6 +280,7 @@ morkRowSpace::FindTableByKind(morkEnv* ev, mork_kind inTableKind) morkTableMapIter i(ev, &mRowSpace_Tables); for ( c = i.FirstTable(ev, key, &table); c && ev->Good(); c = i.NextTable(ev, key, &table) ) +#endif /*MORK_BEAD_OVER_NODE_MAPS*/ { if ( table->mTable_Kind == inTableKind ) return table; @@ -377,7 +402,7 @@ morkRowSpace::MakeNewRowId(morkEnv* ev) mork_rid id = mRowSpace_NextRowId; mork_num count = 9; // try up to eight times mdbOid oid; - oid.mOid_Scope = mSpace_Scope; + oid.mOid_Scope = this->SpaceScope(); while ( !outRid && --count ) // still trying to find an unused row ID? { @@ -409,7 +434,11 @@ morkRowSpace::make_index(morkEnv* ev, mork_column inCol) { if ( ev->Good() ) // no errors during construction? { +#ifdef MORK_ENABLE_PROBE_MAPS + morkRowProbeMapIter i(ev, &mRowSpace_Rows); +#else /*MORK_ENABLE_PROBE_MAPS*/ morkRowMapIter i(ev, &mRowSpace_Rows); +#endif /*MORK_ENABLE_PROBE_MAPS*/ mork_change* c = 0; morkRow* row = 0; mork_aid aidKey = 0; @@ -537,7 +566,7 @@ morkRowSpace::NewRowWithOid(morkEnv* ev, const mdbOid* inOid) if ( store ) { morkPool* pool = this->GetSpaceStorePool(); - morkRow* row = pool->NewRow(ev); + morkRow* row = pool->NewRow(ev, &store->mStore_Zone); if ( row ) { row->InitRow(ev, inOid, this, /*length*/ 0, pool); @@ -550,7 +579,7 @@ morkRowSpace::NewRowWithOid(morkEnv* ev, const mdbOid* inOid) mRowSpace_NextRowId = rid + 1; } else - pool->ZapRow(ev, row); + pool->ZapRow(ev, row, &store->mStore_Zone); if ( this->IsRowSpaceClean() && store->mStore_CanDirty ) this->MaybeDirtyStoreAndSpace(); // InitRow() does already @@ -575,10 +604,10 @@ morkRowSpace::NewRow(morkEnv* ev) if ( store ) { mdbOid oid; - oid.mOid_Scope = mSpace_Scope; + oid.mOid_Scope = this->SpaceScope(); oid.mOid_Id = id; morkPool* pool = this->GetSpaceStorePool(); - morkRow* row = pool->NewRow(ev); + morkRow* row = pool->NewRow(ev, &store->mStore_Zone); if ( row ) { row->InitRow(ev, &oid, this, /*length*/ 0, pool); @@ -586,7 +615,7 @@ morkRowSpace::NewRow(morkEnv* ev) if ( ev->Good() && mRowSpace_Rows.AddRow(ev, row) ) outRow = row; else - pool->ZapRow(ev, row); + pool->ZapRow(ev, row, &store->mStore_Zone); if ( this->IsRowSpaceClean() && store->mStore_CanDirty ) this->MaybeDirtyStoreAndSpace(); // InitRow() does already diff --git a/db/mork/src/morkRowSpace.h b/db/mork/src/morkRowSpace.h index 82d5c3606a5..a9352b1f552 100644 --- a/db/mork/src/morkRowSpace.h +++ b/db/mork/src/morkRowSpace.h @@ -55,7 +55,7 @@ #define morkDerived_kRowSpace /*i*/ 0x7253 /* ascii 'rS' */ -#define morkRowSpace_kStartRowMapSlotCount 512 +#define morkRowSpace_kStartRowMapSlotCount 11 #define morkRowSpace_kMaxIndexCount 8 /* no more indexes than this */ #define morkRowSpace_kPrimeCacheSize 17 /* should be prime number */ @@ -81,7 +81,6 @@ class morkRowSpace : public morkSpace { // // mork_refs mNode_Refs; // refcount for strong refs + weak refs // morkStore* mSpace_Store; // weak ref to containing store - // mork_scope mSpace_Scope; // the scope for this space // mork_bool mSpace_DoAutoIDs; // whether db should assign member IDs // mork_bool mSpace_HaveDoneAutoIDs; // whether actually auto assigned IDs @@ -91,7 +90,11 @@ public: // state is public because the entire Mork system is private nsIMdbHeap* mRowSpace_SlotHeap; +#ifdef MORK_ENABLE_PROBE_MAPS + morkRowProbeMap mRowSpace_Rows; // hash table of morkRow instances +#else /*MORK_ENABLE_PROBE_MAPS*/ morkRowMap mRowSpace_Rows; // hash table of morkRow instances +#endif /*MORK_ENABLE_PROBE_MAPS*/ morkTableMap mRowSpace_Tables; // all the tables in this row scope mork_tid mRowSpace_NextTableId; // for auto-assigning table IDs @@ -195,7 +198,7 @@ public: public: // other map methods mork_bool AddRowSpace(morkEnv* ev, morkRowSpace* ioRowSpace) - { return this->AddNode(ev, ioRowSpace->mSpace_Scope, ioRowSpace); } + { return this->AddNode(ev, ioRowSpace->SpaceScope(), ioRowSpace); } // the AddRowSpace() boolean return equals ev->Good(). mork_bool CutRowSpace(morkEnv* ev, mork_scope inScope) diff --git a/db/mork/src/morkSearchRowCursor.cpp b/db/mork/src/morkSearchRowCursor.cpp index 2caf1d51701..91f003c91b1 100644 --- a/db/mork/src/morkSearchRowCursor.cpp +++ b/db/mork/src/morkSearchRowCursor.cpp @@ -40,6 +40,9 @@ #include "morkSearchRowCursor.h" #endif +#ifndef _MORKUNIQROWCURSOR_ +#include "morkUniqRowCursor.h" +#endif #ifndef _ORKINTABLEROWCURSOR_ #include "orkinTableRowCursor.h" @@ -147,11 +150,11 @@ morkSearchRowCursor::AcquireUniqueRowCursorHandle(morkEnv* ev) { orkinTableRowCursor* outCursor = 0; -// morkUniqRowCursor* uniqCursor = this->MakeUniqCursor(ev); -// if ( uniqCursor ) + morkUniqRowCursor* uniqCursor = this->MakeUniqCursor(ev); + if ( uniqCursor ) { -// outCursor = uniqCursor->AcquireTableRowCursorHandle(ev); - //uniqCursor->CutStrongRef(ev); + outCursor = uniqCursor->AcquireTableRowCursorHandle(ev); + uniqCursor->CutStrongRef(ev); } return outCursor; } diff --git a/db/mork/src/morkSorting.cpp b/db/mork/src/morkSorting.cpp index f29444992d6..97de0cfaf7b 100644 --- a/db/mork/src/morkSorting.cpp +++ b/db/mork/src/morkSorting.cpp @@ -102,7 +102,7 @@ morkSorting::morkSorting(morkEnv* ev, const morkUsage& inUsage, nsIMdbHeap* ioNodeHeap, morkTable* ioTable, nsIMdbCompare* ioCompare, nsIMdbHeap* ioSlotHeap, mork_column inCol) -: morkObject(ev, inUsage, ioNodeHeap, (morkHandle*) 0) +: morkObject(ev, inUsage, ioNodeHeap, morkColor_kNone, (morkHandle*) 0) , mSorting_Table( 0 ) , mSorting_Compare( 0 ) diff --git a/db/mork/src/morkSorting.h b/db/mork/src/morkSorting.h index ef7b887814c..526ef04d710 100644 --- a/db/mork/src/morkSorting.h +++ b/db/mork/src/morkSorting.h @@ -74,7 +74,8 @@ class morkSorting : public morkObject { // mork_uses mNode_Uses; // refcount for strong refs // mork_refs mNode_Refs; // refcount for strong refs + weak refs - // morkHandle* mObject_Handle; // weak ref to handle for this object + // mork_color mBead_Color; // ID for this bead + // morkHandle* mObject_Handle; // weak ref to handle for this object public: // state is public because the entire Mork system is private diff --git a/db/mork/src/morkSpace.cpp b/db/mork/src/morkSpace.cpp index 616da781e50..74629bd4a37 100644 --- a/db/mork/src/morkSpace.cpp +++ b/db/mork/src/morkSpace.cpp @@ -67,7 +67,7 @@ morkSpace::CloseMorkNode(morkEnv* ev) // CloseSpace() only if open /*public virtual*/ morkSpace::~morkSpace() // assert CloseSpace() executed earlier { - MORK_ASSERT(mSpace_Scope==0); + MORK_ASSERT(SpaceScope()==0); MORK_ASSERT(mSpace_Store==0); MORK_ASSERT(this->IsShutNode()); } @@ -86,9 +86,8 @@ morkSpace::~morkSpace() // assert CloseSpace() executed earlier morkSpace::morkSpace(morkEnv* ev, const morkUsage& inUsage, mork_scope inScope, morkStore* ioStore, nsIMdbHeap* ioHeap, nsIMdbHeap* ioSlotHeap) -: morkNode(ev, inUsage, ioHeap) +: morkBead(ev, inUsage, ioHeap, inScope) , mSpace_Store( 0 ) -, mSpace_Scope( inScope ) , mSpace_DoAutoIDs( morkBool_kFalse ) , mSpace_HaveDoneAutoIDs( morkBool_kFalse ) , mSpace_CanDirty( morkBool_kFalse ) // only when store can be dirtied @@ -119,7 +118,7 @@ morkSpace::CloseSpace(morkEnv* ev) // called by CloseMorkNode(); if ( this->IsNode() ) { morkStore::SlotWeakStore((morkStore*) 0, ev, &mSpace_Store); - mSpace_Scope = 0; + mBead_Color = 0; // this->CloseBead(); this->MarkShut(); } else @@ -135,7 +134,7 @@ morkSpace::CloseSpace(morkEnv* ev) // called by CloseMorkNode(); /*static*/ void morkSpace::NonAsciiSpaceScopeName(morkEnv* ev) { - ev->NewError("mSpace_Scope > 0x7F"); + ev->NewError("SpaceScope() > 0x7F"); } /*static*/ void diff --git a/db/mork/src/morkSpace.h b/db/mork/src/morkSpace.h index e4cff1cc77e..3e6ff65ffd4 100644 --- a/db/mork/src/morkSpace.h +++ b/db/mork/src/morkSpace.h @@ -27,6 +27,10 @@ #include "morkNode.h" #endif +#ifndef _MORKBEAD_ +#include "morkBead.h" +#endif + #ifndef _MORKMAP_ #include "morkMap.h" #endif @@ -38,7 +42,7 @@ /*| morkSpace: |*/ -class morkSpace : public morkNode { // +class morkSpace : public morkBead { // // public: // slots inherited from morkNode (meant to inform only) // nsIMdbHeap* mNode_Heap; @@ -54,12 +58,17 @@ class morkSpace : public morkNode { // // mork_uses mNode_Uses; // refcount for strong refs // mork_refs mNode_Refs; // refcount for strong refs + weak refs + // mork_color mBead_Color; // ID for this bead + +public: // bead color setter & getter replace obsolete member mTable_Id: + + mork_tid SpaceScope() const { return mBead_Color; } + void SetSpaceScope(mork_scope inScope) { mBead_Color = inScope; } + public: // state is public because the entire Mork system is private morkStore* mSpace_Store; // weak ref to containing store - - mork_scope mSpace_Scope; // the scope for this space - + mork_bool mSpace_DoAutoIDs; // whether db should assign member IDs mork_bool mSpace_HaveDoneAutoIDs; // whether actually auto assigned IDs mork_bool mSpace_CanDirty; // changes imply the store becomes dirty? diff --git a/db/mork/src/morkStore.cpp b/db/mork/src/morkStore.cpp index c4cf6a36075..f5c0e064a71 100644 --- a/db/mork/src/morkStore.cpp +++ b/db/mork/src/morkStore.cpp @@ -126,7 +126,7 @@ morkPort::morkPort(morkEnv* ev, const morkUsage& inUsage, morkFactory* inFactory, // the factory for this nsIMdbHeap* ioPortHeap // the heap to hold all content in the port ) -: morkObject(ev, inUsage, ioNodeHeap, (morkHandle*) 0) +: morkObject(ev, inUsage, ioNodeHeap, morkColor_kNone, (morkHandle*) 0) , mPort_Env( ev ) , mPort_Factory( 0 ) , mPort_Heap( 0 ) @@ -220,6 +220,7 @@ morkStore::morkStore(morkEnv* ev, const morkUsage& inUsage, , mStore_RowSpaces(ev, morkUsage::kMember, (nsIMdbHeap*) 0, ioPortHeap) , mStore_AtomSpaces(ev, morkUsage::kMember, (nsIMdbHeap*) 0, ioPortHeap) +, mStore_Zone(ev, morkUsage::kMember, (nsIMdbHeap*) 0, ioPortHeap) , mStore_Pool(ev, morkUsage::kMember, (nsIMdbHeap*) 0, ioPortHeap) , mStore_CommitGroupIdentity( 0 ) @@ -246,9 +247,6 @@ morkStore::CloseStore(morkEnv* ev) // called by CloseMorkNode(); { if ( this->IsNode() ) { - // morkFile* file = mStore_File; - // if ( file && file->IsOpenNode() ) - // file->CloseMorkNode(ev); nsIMdbFile* file = mStore_File; if ( file ) @@ -264,7 +262,6 @@ morkStore::CloseStore(morkEnv* ev) // called by CloseMorkNode(); mStore_AtomSpaces.CloseMorkNode(ev); morkBuilder::SlotStrongBuilder((morkBuilder*) 0, ev, &mStore_Builder); - // morkFile::SlotStrongFile((morkFile*) 0, ev, &mStore_File); nsIMdbFile_SlotStrongFile((nsIMdbFile*) 0, ev, &mStore_File); @@ -272,6 +269,7 @@ morkStore::CloseStore(morkEnv* ev) // called by CloseMorkNode(); morkStream::SlotStrongStream((morkStream*) 0, ev, &mStore_OutStream); mStore_Pool.CloseMorkNode(ev); + mStore_Zone.CloseMorkNode(ev); this->ClosePort(ev); this->MarkShut(); } @@ -742,8 +740,9 @@ morkStore::YarnToAtom(morkEnv* ev, const mdbYarn* inYarn) } else if ( ev->Good() ) { - morkBuf buf(inYarn->mYarn_Buf, inYarn->mYarn_Fill); - outAtom = mStore_Pool.NewAnonAtom(ev, buf, inYarn->mYarn_Form); + morkBuf b(inYarn->mYarn_Buf, inYarn->mYarn_Fill); + morkZone* z = &mStore_Zone; + outAtom = mStore_Pool.NewAnonAtom(ev, b, inYarn->mYarn_Form, z); } } } diff --git a/db/mork/src/morkStore.h b/db/mork/src/morkStore.h index 04f93ab7dff..43a298ceff9 100644 --- a/db/mork/src/morkStore.h +++ b/db/mork/src/morkStore.h @@ -35,6 +35,10 @@ #include "morkPool.h" #endif +#ifndef _MORKZONE_ +#include "morkZone.h" +#endif + #ifndef _MORKATOM_ #include "morkAtom.h" #endif @@ -66,7 +70,8 @@ class morkPort : public morkObject { // private mork port // mork_uses mNode_Uses; // refcount for strong refs // mork_refs mNode_Refs; // refcount for strong refs + weak refs - // morkHandle* mObject_Handle; // weak ref to handle for this object + // mork_color mBead_Color; // ID for this bead + // morkHandle* mObject_Handle; // weak ref to handle for this object public: // state is public because the entire Mork system is private morkEnv* mPort_Env; // non-refcounted env which created port @@ -164,6 +169,8 @@ public: // state is public because the entire Mork system is private morkRowSpaceMap mStore_RowSpaces; // maps mork_scope -> morkSpace morkAtomSpaceMap mStore_AtomSpaces; // maps mork_scope -> morkSpace + morkZone mStore_Zone; + morkPool mStore_Pool; // we alloc a max size book atom to reuse space for atom map key searches: diff --git a/db/mork/src/morkTable.cpp b/db/mork/src/morkTable.cpp index 706e7a51c56..2e58422cdf7 100644 --- a/db/mork/src/morkTable.cpp +++ b/db/mork/src/morkTable.cpp @@ -94,7 +94,7 @@ morkTable::morkTable(morkEnv* ev, /*i*/ morkStore* ioStore, nsIMdbHeap* ioSlotHeap, morkRowSpace* ioRowSpace, const mdbOid* inOptionalMetaRowOid, // can be nil to avoid specifying mork_tid inTid, mork_kind inKind, mork_bool inMustBeUnique) -: morkObject(ev, inUsage, ioHeap, (morkHandle*) 0) +: morkObject(ev, inUsage, ioHeap, (mork_color) inTid, (morkHandle*) 0) , mTable_Store( 0 ) , mTable_RowSpace( 0 ) , mTable_MetaRow( 0 ) @@ -109,7 +109,6 @@ morkTable::morkTable(morkEnv* ev, /*i*/ , mTable_ChangesCount( 0 ) , mTable_ChangesMax( 3 ) // any very small number greater than zero -, mTable_Id( inTid ) , mTable_Kind( inKind ) , mTable_Flags( 0 ) @@ -402,8 +401,8 @@ morkTable::GetTableOid(morkEnv* ev, mdbOid* outOid) morkRowSpace* space = mTable_RowSpace; if ( space ) { - outOid->mOid_Scope = space->mSpace_Scope; - outOid->mOid_Id = mTable_Id; + outOid->mOid_Scope = space->SpaceScope(); + outOid->mOid_Id = this->TableId(); } else this->NilRowSpaceError(ev); @@ -813,7 +812,11 @@ morkTableMap::~morkTableMap() morkTableMap::morkTableMap(morkEnv* ev, const morkUsage& inUsage, nsIMdbHeap* ioHeap, nsIMdbHeap* ioSlotHeap) +#ifdef MORK_BEAD_OVER_NODE_MAPS + : morkBeadMap(ev, inUsage, ioHeap, ioSlotHeap) +#else /*MORK_BEAD_OVER_NODE_MAPS*/ : morkNodeMap(ev, inUsage, ioHeap, ioSlotHeap) +#endif /*MORK_BEAD_OVER_NODE_MAPS*/ { if ( ev->Good() ) mNode_Derived = morkDerived_kTableMap; diff --git a/db/mork/src/morkTable.h b/db/mork/src/morkTable.h index 25ce6309b39..26d41db2b67 100644 --- a/db/mork/src/morkTable.h +++ b/db/mork/src/morkTable.h @@ -47,6 +47,14 @@ #include "morkNodeMap.h" #endif +#ifndef _MORKPROBEMAP_ +#include "morkProbeMap.h" +#endif + +#ifndef _MORKBEAD_ +#include "morkBead.h" +#endif + //3456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789 class nsIMdbTable; @@ -97,13 +105,19 @@ class morkTable : public morkObject, public morkLink { // mork_uses mNode_Uses; // refcount for strong refs // mork_refs mNode_Refs; // refcount for strong refs + weak refs - // morkHandle* mObject_Handle; // weak ref to handle for this object + // mork_color mBead_Color; // ID for this bead + // morkHandle* mObject_Handle; // weak ref to handle for this object + +public: // bead color setter & getter replace obsolete member mTable_Id: + + mork_tid TableId() const { return mBead_Color; } + void SetTableId(mork_tid inTid) { mBead_Color = inTid; } public: // state is public because the entire Mork system is private morkStore* mTable_Store; // weak ref to port - // mTable_RowSpace->mSpace_Scope is row scope + // mTable_RowSpace->SpaceScope() is row scope morkRowSpace* mTable_RowSpace; // weak ref to containing space morkRow* mTable_MetaRow; // table's actual meta row @@ -116,7 +130,7 @@ public: // state is public because the entire Mork system is private mork_u2 mTable_ChangesCount; // length of changes list mork_u2 mTable_ChangesMax; // max list length before rewrite - mork_tid mTable_Id; + // mork_tid mTable_Id; mork_kind mTable_Kind; mork_u1 mTable_Flags; // bit flags @@ -316,7 +330,11 @@ public: /*| morkTableMap: maps mork_token -> morkTable |*/ +#ifdef MORK_BEAD_OVER_NODE_MAPS +class morkTableMap : public morkBeadMap { +#else /*MORK_BEAD_OVER_NODE_MAPS*/ class morkTableMap : public morkNodeMap { // for mapping tokens to tables +#endif /*MORK_BEAD_OVER_NODE_MAPS*/ public: @@ -326,8 +344,26 @@ public: public: // other map methods +#ifdef MORK_BEAD_OVER_NODE_MAPS mork_bool AddTable(morkEnv* ev, morkTable* ioTable) - { return this->AddNode(ev, ioTable->mTable_Id, ioTable); } + { return this->AddBead(ev, ioTable); } + // the AddTable() boolean return equals ev->Good(). + + mork_bool CutTable(morkEnv* ev, mork_tid inTid) + { return this->CutBead(ev, inTid); } + // The CutTable() boolean return indicates whether removal happened. + + morkTable* GetTable(morkEnv* ev, mork_tid inTid) + { return (morkTable*) this->GetBead(ev, inTid); } + // Note the returned table does NOT have an increase in refcount for this. + + mork_num CutAllTables(morkEnv* ev) + { return this->CutAllBeads(ev); } + // CutAllTables() releases all the referenced table values. + +#else /*MORK_BEAD_OVER_NODE_MAPS*/ + mork_bool AddTable(morkEnv* ev, morkTable* ioTable) + { return this->AddNode(ev, ioTable->TableId(), ioTable); } // the AddTable() boolean return equals ev->Good(). mork_bool CutTable(morkEnv* ev, mork_tid inTid) @@ -341,11 +377,37 @@ public: // other map methods mork_num CutAllTables(morkEnv* ev) { return this->CutAllNodes(ev); } // CutAllTables() releases all the referenced table values. +#endif /*MORK_BEAD_OVER_NODE_MAPS*/ + }; +#ifdef MORK_BEAD_OVER_NODE_MAPS +class morkTableMapIter: public morkBeadMapIter { +#else /*MORK_BEAD_OVER_NODE_MAPS*/ class morkTableMapIter: public morkMapIter{ // typesafe wrapper class +#endif /*MORK_BEAD_OVER_NODE_MAPS*/ public: + +#ifdef MORK_BEAD_OVER_NODE_MAPS + morkTableMapIter(morkEnv* ev, morkTableMap* ioMap) + : morkBeadMapIter(ev, ioMap) { } + + morkTableMapIter( ) : morkBeadMapIter() { } + void InitTableMapIter(morkEnv* ev, morkTableMap* ioMap) + { this->InitBeadMapIter(ev, ioMap); } + + morkTable* FirstTable(morkEnv* ev) + { return (morkTable*) this->FirstBead(ev); } + + morkTable* NextTable(morkEnv* ev) + { return (morkTable*) this->NextBead(ev); } + + morkTable* HereTable(morkEnv* ev) + { return (morkTable*) this->HereBead(ev); } + + +#else /*MORK_BEAD_OVER_NODE_MAPS*/ morkTableMapIter(morkEnv* ev, morkTableMap* ioMap) : morkMapIter(ev, ioMap) { } @@ -369,6 +431,7 @@ public: mork_change* CutHereTable(morkEnv* ev, mork_tid* outTid, morkTable** outTable) { return this->CutHere(ev, outTid, outTable); } +#endif /*MORK_BEAD_OVER_NODE_MAPS*/ }; //3456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789 diff --git a/db/mork/src/morkThumb.cpp b/db/mork/src/morkThumb.cpp index 4a5e7fc5eb7..a85f10283cf 100644 --- a/db/mork/src/morkThumb.cpp +++ b/db/mork/src/morkThumb.cpp @@ -88,7 +88,7 @@ morkThumb::~morkThumb() // assert CloseThumb() executed earlier morkThumb::morkThumb(morkEnv* ev, const morkUsage& inUsage, nsIMdbHeap* ioHeap, nsIMdbHeap* ioSlotHeap, mork_magic inMagic) -: morkObject(ev, inUsage, ioHeap, (morkHandle*) 0) +: morkObject(ev, inUsage, ioHeap, morkColor_kNone, (morkHandle*) 0) , mThumb_Magic( 0 ) , mThumb_Total( 0 ) , mThumb_Current( 0 ) diff --git a/db/mork/src/morkThumb.h b/db/mork/src/morkThumb.h index ba2cb5bbb64..2d24b6fe01d 100644 --- a/db/mork/src/morkThumb.h +++ b/db/mork/src/morkThumb.h @@ -68,7 +68,8 @@ class morkThumb : public morkObject { // mork_uses mNode_Uses; // refcount for strong refs // mork_refs mNode_Refs; // refcount for strong refs + weak refs - // morkHandle* mObject_Handle; // weak ref to handle for this object + // mork_color mBead_Color; // ID for this bead + // morkHandle* mObject_Handle; // weak ref to handle for this object public: // state is public because the entire Mork system is private // might as well include all the return values here: diff --git a/db/mork/src/morkWriter.cpp b/db/mork/src/morkWriter.cpp index f0158342f8b..72c09bbb2df 100644 --- a/db/mork/src/morkWriter.cpp +++ b/db/mork/src/morkWriter.cpp @@ -470,7 +470,7 @@ void morkWriter::WriteAtomSpaceAsDict(morkEnv* ev, morkAtomSpace* ioSpace) { morkStream* stream = mWriter_Stream; - mork_scope scope = ioSpace->mSpace_Scope; + mork_scope scope = ioSpace->SpaceScope(); if ( scope < 0x80 ) { if ( mWriter_LineSize ) @@ -622,7 +622,11 @@ morkWriter::DirtyAll(morkEnv* ev) space->SetRowSpaceDirty(); if ( ev->Good() ) { +#ifdef MORK_ENABLE_PROBE_MAPS + morkRowProbeMapIter* ri = &mWriter_RowSpaceRowsIter; +#else /*MORK_ENABLE_PROBE_MAPS*/ morkRowMapIter* ri = &mWriter_RowSpaceRowsIter; +#endif /*MORK_ENABLE_PROBE_MAPS*/ ri->InitRowMapIter(ev, &space->mRowSpace_Rows); morkRow* row = 0; // old key row in the map @@ -646,11 +650,17 @@ morkWriter::DirtyAll(morkEnv* ev) morkTableMapIter* ti = &mWriter_RowSpaceTablesIter; ti->InitTableMapIter(ev, &space->mRowSpace_Tables); +#ifdef MORK_BEAD_OVER_NODE_MAPS + morkTable* table = ti->FirstTable(ev); + + for ( ; table && ev->Good(); table = ti->NextTable(ev) ) +#else /*MORK_BEAD_OVER_NODE_MAPS*/ mork_tid* key = 0; // ignore keys in table map morkTable* table = 0; // old key row in the map for ( c = ti->FirstTable(ev, key, &table); c && ev->Good(); c = ti->NextTable(ev, key, &table) ) +#endif /*MORK_BEAD_OVER_NODE_MAPS*/ { if ( table && table->IsTable() ) { @@ -979,11 +989,17 @@ morkWriter::WriteAllStoreTables(morkEnv* ev) morkTableMapIter* ti = &mWriter_RowSpaceTablesIter; ti->InitTableMapIter(ev, &space->mRowSpace_Tables); +#ifdef MORK_BEAD_OVER_NODE_MAPS + morkTable* table = ti->FirstTable(ev); + + for ( ; table && ev->Good(); table = ti->NextTable(ev) ) +#else /*MORK_BEAD_OVER_NODE_MAPS*/ mork_tid* key2 = 0; // ignore keys in table map morkTable* table = 0; // old key row in the map for ( c = ti->FirstTable(ev, key2, &table); c && ev->Good(); c = ti->NextTable(ev, key2, &table) ) +#endif /*MORK_BEAD_OVER_NODE_MAPS*/ { if ( table && table->IsTable() ) { @@ -1008,7 +1024,11 @@ morkWriter::WriteAllStoreTables(morkEnv* ev) { mWriter_TableRowScope = 0; // ensure no table context now +#ifdef MORK_ENABLE_PROBE_MAPS + morkRowProbeMapIter* ri = &mWriter_RowSpaceRowsIter; +#else /*MORK_ENABLE_PROBE_MAPS*/ morkRowMapIter* ri = &mWriter_RowSpaceRowsIter; +#endif /*MORK_ENABLE_PROBE_MAPS*/ ri->InitRowMapIter(ev, &space->mRowSpace_Rows); morkRow* row = 0; // old row in the map @@ -1299,7 +1319,7 @@ mork_bool morkWriter::PutTableDict(morkEnv* ev, morkTable* ioTable) { morkRowSpace* space = ioTable->mTable_RowSpace; - mWriter_TableRowScope = space->mSpace_Scope; + mWriter_TableRowScope = space->SpaceScope(); mWriter_TableForm = 0; // (f=iso-8859-1) mWriter_TableAtomScope = 'v'; // (a=v) mWriter_TableKind = ioTable->mTable_Kind; diff --git a/db/mork/src/morkWriter.h b/db/mork/src/morkWriter.h index ad2a2f91474..264d3792bb1 100644 --- a/db/mork/src/morkWriter.h +++ b/db/mork/src/morkWriter.h @@ -191,7 +191,12 @@ public: // state is public because the entire Mork system is private morkRowSpaceMapIter mWriter_StoreRowSpacesIter; // for mStore_RowSpaces morkTableMapIter mWriter_RowSpaceTablesIter; // for mRowSpace_Tables + +#ifdef MORK_ENABLE_PROBE_MAPS + morkRowProbeMapIter mWriter_RowSpaceRowsIter; // for mRowSpace_Rows +#else /*MORK_ENABLE_PROBE_MAPS*/ morkRowMapIter mWriter_RowSpaceRowsIter; // for mRowSpace_Rows +#endif /*MORK_ENABLE_PROBE_MAPS*/ // { ===== begin morkNode interface ===== public: // morkNode virtual methods diff --git a/db/mork/src/orkinCell.h b/db/mork/src/orkinCell.h index 7c747f76d1f..0e8105d4b9d 100644 --- a/db/mork/src/orkinCell.h +++ b/db/mork/src/orkinCell.h @@ -67,8 +67,11 @@ private: // copying is not allowed // } ===== end morkNode methods ===== protected: // morkHandle memory management operators + void* operator new(size_t inSize, morkPool& ioPool, morkZone& ioZone, morkEnv* ev) + { return ioPool.NewHandle(ev, inSize, &ioZone); } + void* operator new(size_t inSize, morkPool& ioPool, morkEnv* ev) - { return ioPool.NewHandle(ev, inSize); } + { return ioPool.NewHandle(ev, inSize, (morkZone*) 0); } void* operator new(size_t inSize, morkHandleFace* ioFace) { MORK_USED_1(inSize); return ioFace; } diff --git a/db/mork/src/orkinEnv.cpp b/db/mork/src/orkinEnv.cpp index a02b1cf802d..7c25fdabc76 100644 --- a/db/mork/src/orkinEnv.cpp +++ b/db/mork/src/orkinEnv.cpp @@ -368,7 +368,7 @@ orkinEnv::GetHeap(nsIMdbHeap** acqHeap) if ( ev ) { nsIMdbHeap* heap = ev->mEnv_Heap; - if ( heap && heap->AddStrongRef(this) == 0 ) + if ( heap && heap->HeapAddStrongRef(this) == 0 ) outHeap = heap; } if ( acqHeap ) diff --git a/db/mork/src/orkinEnv.h b/db/mork/src/orkinEnv.h index 90c1cb63dab..633a2984d02 100644 --- a/db/mork/src/orkinEnv.h +++ b/db/mork/src/orkinEnv.h @@ -69,8 +69,11 @@ private: // copying is not allowed // } ===== end morkNode methods ===== protected: // morkHandle memory management operators + void* operator new(size_t inSize, morkPool& ioPool, morkZone& ioZone, morkEnv* ev) + { return ioPool.NewHandle(ev, inSize, &ioZone); } + void* operator new(size_t inSize, morkPool& ioPool, morkEnv* ev) - { return ioPool.NewHandle(ev, inSize); } + { return ioPool.NewHandle(ev, inSize, (morkZone*) 0); } void* operator new(size_t inSize, morkHandleFace* ioFace) { MORK_USED_1(inSize); return ioFace; } diff --git a/db/mork/src/orkinFactory.h b/db/mork/src/orkinFactory.h index 61781d24f4c..b4dacf48ba1 100644 --- a/db/mork/src/orkinFactory.h +++ b/db/mork/src/orkinFactory.h @@ -69,8 +69,11 @@ private: // copying is not allowed // } ===== end morkNode methods ===== protected: // morkHandle memory management operators + void* operator new(size_t inSize, morkPool& ioPool, morkZone& ioZone, morkEnv* ev) + { return ioPool.NewHandle(ev, inSize, &ioZone); } + void* operator new(size_t inSize, morkPool& ioPool, morkEnv* ev) - { return ioPool.NewHandle(ev, inSize); } + { return ioPool.NewHandle(ev, inSize, (morkZone*) 0); } void* operator new(size_t inSize, morkHandleFace* ioFace) { MORK_USED_1(inSize); return ioFace; } diff --git a/db/mork/src/orkinFile.h b/db/mork/src/orkinFile.h index 48e58531a71..6a28fc28780 100644 --- a/db/mork/src/orkinFile.h +++ b/db/mork/src/orkinFile.h @@ -69,8 +69,11 @@ private: // copying is not allowed // } ===== end morkNode methods ===== protected: // morkHandle memory management operators + void* operator new(size_t inSize, morkPool& ioPool, morkZone& ioZone, morkEnv* ev) + { return ioPool.NewHandle(ev, inSize, &ioZone); } + void* operator new(size_t inSize, morkPool& ioPool, morkEnv* ev) - { return ioPool.NewHandle(ev, inSize); } + { return ioPool.NewHandle(ev, inSize, (morkZone*) 0); } void* operator new(size_t inSize, morkHandleFace* ioFace) { MORK_USED_1(inSize); return ioFace; } diff --git a/db/mork/src/orkinHeap.cpp b/db/mork/src/orkinHeap.cpp index 3bc044be773..2d56526e780 100644 --- a/db/mork/src/orkinHeap.cpp +++ b/db/mork/src/orkinHeap.cpp @@ -36,6 +36,16 @@ orkinHeap::orkinHeap() // does nothing +#ifdef MORK_DEBUG_HEAP_STATS + : sHeap_AllocCount( 0 ) + , sHeap_FreeCount( 0 ) + , sHeap_BlockCount( 0 ) + + , sHeap_BlockVolume( 0 ) + , sHeap_HighWaterVolume( 0 ) + , sHeap_HighWaterTenKilo( 0 ) + , sHeap_HighWaterHundredKilo( 0 ) +#endif /*MORK_DEBUG_HEAP_STATS*/ { } @@ -46,15 +56,47 @@ orkinHeap::~orkinHeap() // does nothing // { ===== begin nsIMdbHeap methods ===== /*virtual*/ mdb_err -orkinHeap::Alloc(nsIMdbEnv* ev, // allocate a piece of memory +orkinHeap::Alloc(nsIMdbEnv* mev, // allocate a piece of memory mdb_size inSize, // requested size of new memory block void** outBlock) // memory block of inSize bytes, or nil { - MORK_USED_1(ev); +#ifdef MORK_DEBUG_HEAP_STATS + mdb_size realSize = inSize; + inSize += 8; // sizeof(mork_u4) * 2 + ++sHeap_AllocCount; +#endif /*MORK_DEBUG_HEAP_STATS*/ + + MORK_USED_1(mev); mdb_err outErr = 0; - void* block = new char[ inSize ]; + void* block = ::operator new(inSize); if ( !block ) outErr = morkEnv_kOutOfMemoryError; +#ifdef MORK_DEBUG_HEAP_STATS + else + { + mork_u4* array = (mork_u4*) block; + *array++ = realSize; + *array++ = orkinHeap_kTag; + block = array; + ++sHeap_BlockCount; + mork_num blockVol = sHeap_BlockVolume + realSize; + sHeap_BlockVolume = blockVol; + if ( blockVol > sHeap_HighWaterVolume ) + { + sHeap_HighWaterVolume = blockVol; + + mork_num tenKiloVol = blockVol / (10 * 1024); + if ( tenKiloVol > sHeap_HighWaterTenKilo ) + { + sHeap_HighWaterTenKilo = tenKiloVol; + + mork_num hundredKiloVol = blockVol / (100 * 1024); + if ( hundredKiloVol > sHeap_HighWaterHundredKilo ) + sHeap_HighWaterHundredKilo = hundredKiloVol; + } + } + } +#endif /*MORK_DEBUG_HEAP_STATS*/ MORK_ASSERT(outBlock); if ( outBlock ) @@ -63,26 +105,56 @@ orkinHeap::Alloc(nsIMdbEnv* ev, // allocate a piece of memory } /*virtual*/ mdb_err -orkinHeap::Free(nsIMdbEnv* ev, // free block allocated earlier by Alloc() +orkinHeap::Free(nsIMdbEnv* mev, // free block allocated earlier by Alloc() void* inBlock) { - MORK_USED_1(ev); +#ifdef MORK_DEBUG_HEAP_STATS + ++sHeap_FreeCount; +#endif /*MORK_DEBUG_HEAP_STATS*/ + + MORK_USED_1(mev); MORK_ASSERT(inBlock); if ( inBlock ) - delete [] (char *)inBlock; + { +#ifdef MORK_DEBUG_HEAP_STATS + morkEnv* ev = morkEnv::FromMdbEnv(mev); + mork_u4* array = (mork_u4*) inBlock; + if ( *--array != orkinHeap_kTag ) + { + if ( ev ) + ev->NewWarning("heap block tag not hEaP"); + } + mork_u4 realSize = *--array; + inBlock = array; + if ( sHeap_BlockCount ) + --sHeap_BlockCount; + else if ( ev ) + ev->NewWarning("sHeap_BlockCount underflow"); + + if ( sHeap_BlockVolume >= realSize ) + sHeap_BlockVolume -= realSize; + else if ( ev ) + { + sHeap_BlockVolume = 0; + ev->NewWarning("sHeap_BlockVolume underflow"); + } +#endif /*MORK_DEBUG_HEAP_STATS*/ + + ::operator delete(inBlock); + } return 0; } /*virtual*/ mdb_err -orkinHeap::AddStrongRef(nsIMdbEnv* ev) // does nothing +orkinHeap::HeapAddStrongRef(nsIMdbEnv* ev) // does nothing { MORK_USED_1(ev); return 0; } /*virtual*/ mdb_err -orkinHeap::CutStrongRef(nsIMdbEnv* ev) // does nothing +orkinHeap::HeapCutStrongRef(nsIMdbEnv* ev) // does nothing { MORK_USED_1(ev); return 0; diff --git a/db/mork/src/orkinHeap.h b/db/mork/src/orkinHeap.h index 479a2fc1599..ae49e6fe0d5 100644 --- a/db/mork/src/orkinHeap.h +++ b/db/mork/src/orkinHeap.h @@ -29,9 +29,31 @@ //3456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789 +#define orkinHeap_kTag 0x68456150 /* ascii 'hEaP' */ + /*| orkinHeap: |*/ class orkinHeap : public nsIMdbHeap { // + +#ifdef MORK_DEBUG_HEAP_STATS +protected: + mork_num sHeap_AllocCount; // number of times Alloc() is called + mork_num sHeap_FreeCount; // number of times Free() is called + mork_num sHeap_BlockCount; // number of outstanding blocks + + mork_num sHeap_BlockVolume; // sum of sizes for all outstanding blocks + mork_num sHeap_HighWaterVolume; // largest value of sHeap_BlockVolume seen + mork_num sHeap_HighWaterTenKilo; // HighWaterVolume in 10K granularity + mork_num sHeap_HighWaterHundredKilo; // HighWaterVolume in 100K granularity + +public: // getters + mork_num HeapAllocCount() const { return sHeap_AllocCount; } + mork_num HeapFreeCount() const { return sHeap_FreeCount; } + mork_num HeapBlockCount() const { return sHeap_AllocCount - sHeap_FreeCount; } + + mork_num HeapBlockVolume() const { return sHeap_BlockVolume; } + mork_num HeapHighWaterVolume() const { return sHeap_HighWaterVolume; } +#endif /*MORK_DEBUG_HEAP_STATS*/ public: orkinHeap(); // does nothing @@ -51,8 +73,8 @@ public: virtual mdb_err Free(nsIMdbEnv* ev, // free block allocated earlier by Alloc() void* inBlock); - virtual mdb_err AddStrongRef(nsIMdbEnv* ev); // does nothing - virtual mdb_err CutStrongRef(nsIMdbEnv* ev); // does nothing + virtual mdb_err HeapAddStrongRef(nsIMdbEnv* ev); // does nothing + virtual mdb_err HeapCutStrongRef(nsIMdbEnv* ev); // does nothing // } ===== end nsIMdbHeap methods ===== }; diff --git a/db/mork/src/orkinPortTableCursor.h b/db/mork/src/orkinPortTableCursor.h index 286f5b7b212..6f76a385a31 100644 --- a/db/mork/src/orkinPortTableCursor.h +++ b/db/mork/src/orkinPortTableCursor.h @@ -76,8 +76,11 @@ private: // copying is not allowed // } ===== end morkNode methods ===== protected: // morkHandle memory management operators + void* operator new(size_t inSize, morkPool& ioPool, morkZone& ioZone, morkEnv* ev) + { return ioPool.NewHandle(ev, inSize, &ioZone); } + void* operator new(size_t inSize, morkPool& ioPool, morkEnv* ev) - { return ioPool.NewHandle(ev, inSize); } + { return ioPool.NewHandle(ev, inSize, (morkZone*) 0); } void* operator new(size_t inSize, morkHandleFace* ioFace) { MORK_USED_1(inSize); return ioFace; } diff --git a/db/mork/src/orkinRow.h b/db/mork/src/orkinRow.h index af4382c5f0c..255f0851165 100644 --- a/db/mork/src/orkinRow.h +++ b/db/mork/src/orkinRow.h @@ -70,8 +70,11 @@ private: // copying is not allowed // } ===== end morkNode methods ===== protected: // morkHandle memory management operators + void* operator new(size_t inSize, morkPool& ioPool, morkZone& ioZone, morkEnv* ev) + { return ioPool.NewHandle(ev, inSize, &ioZone); } + void* operator new(size_t inSize, morkPool& ioPool, morkEnv* ev) - { return ioPool.NewHandle(ev, inSize); } + { return ioPool.NewHandle(ev, inSize, (morkZone*) 0); } void* operator new(size_t inSize, morkHandleFace* ioFace) { MORK_USED_1(inSize); return ioFace; } diff --git a/db/mork/src/orkinRowCellCursor.h b/db/mork/src/orkinRowCellCursor.h index 6454e0ad2b4..4940a41d746 100644 --- a/db/mork/src/orkinRowCellCursor.h +++ b/db/mork/src/orkinRowCellCursor.h @@ -77,8 +77,11 @@ private: // copying is not allowed // } ===== end morkNode methods ===== protected: // morkHandle memory management operators + void* operator new(size_t inSize, morkPool& ioPool, morkZone& ioZone, morkEnv* ev) + { return ioPool.NewHandle(ev, inSize, &ioZone); } + void* operator new(size_t inSize, morkPool& ioPool, morkEnv* ev) - { return ioPool.NewHandle(ev, inSize); } + { return ioPool.NewHandle(ev, inSize, (morkZone*) 0); } void* operator new(size_t inSize, morkHandleFace* ioFace) { MORK_USED_1(inSize); return ioFace; } diff --git a/db/mork/src/orkinSorting.h b/db/mork/src/orkinSorting.h index f000845d78f..a5ba8f33b73 100644 --- a/db/mork/src/orkinSorting.h +++ b/db/mork/src/orkinSorting.h @@ -69,8 +69,11 @@ private: // copying is not allowed // } ===== end morkNode methods ===== protected: // morkHandle memory management operators + void* operator new(size_t inSize, morkPool& ioPool, morkZone& ioZone, morkEnv* ev) + { return ioPool.NewHandle(ev, inSize, &ioZone); } + void* operator new(size_t inSize, morkPool& ioPool, morkEnv* ev) - { return ioPool.NewHandle(ev, inSize); } + { return ioPool.NewHandle(ev, inSize, (morkZone*) 0); } void* operator new(size_t inSize, morkHandleFace* ioFace) { MORK_USED_1(inSize); return ioFace; } diff --git a/db/mork/src/orkinStore.h b/db/mork/src/orkinStore.h index 6b2937e9de6..58e72481e07 100644 --- a/db/mork/src/orkinStore.h +++ b/db/mork/src/orkinStore.h @@ -69,8 +69,11 @@ private: // copying is not allowed // } ===== end morkNode methods ===== protected: // morkHandle memory management operators + void* operator new(size_t inSize, morkPool& ioPool, morkZone& ioZone, morkEnv* ev) + { return ioPool.NewHandle(ev, inSize, &ioZone); } + void* operator new(size_t inSize, morkPool& ioPool, morkEnv* ev) - { return ioPool.NewHandle(ev, inSize); } + { return ioPool.NewHandle(ev, inSize, (morkZone*) 0); } void* operator new(size_t inSize, morkHandleFace* ioFace) { MORK_USED_1(inSize); return ioFace; } diff --git a/db/mork/src/orkinTable.cpp b/db/mork/src/orkinTable.cpp index 1e56cf3ff5b..a640913c731 100644 --- a/db/mork/src/orkinTable.cpp +++ b/db/mork/src/orkinTable.cpp @@ -472,7 +472,7 @@ orkinTable::GetRowScope(nsIMdbEnv* mev, mdb_scope* outRowScope) morkTable* table = (morkTable*) mHandle_Object; morkRowSpace* space = table->mTable_RowSpace; if ( space ) - rowScope = space->mSpace_Scope; + rowScope = space->SpaceScope(); else table->NilRowSpaceError(ev); diff --git a/db/mork/src/orkinTable.h b/db/mork/src/orkinTable.h index f8da60e9055..954c164f51f 100644 --- a/db/mork/src/orkinTable.h +++ b/db/mork/src/orkinTable.h @@ -69,8 +69,11 @@ private: // copying is not allowed // } ===== end morkNode methods ===== protected: // morkHandle memory management operators + void* operator new(size_t inSize, morkPool& ioPool, morkZone& ioZone, morkEnv* ev) + { return ioPool.NewHandle(ev, inSize, &ioZone); } + void* operator new(size_t inSize, morkPool& ioPool, morkEnv* ev) - { return ioPool.NewHandle(ev, inSize); } + { return ioPool.NewHandle(ev, inSize, (morkZone*) 0); } void* operator new(size_t inSize, morkHandleFace* ioFace) { MORK_USED_1(inSize); return ioFace; } diff --git a/db/mork/src/orkinTableRowCursor.h b/db/mork/src/orkinTableRowCursor.h index e0ee48673b8..b4a9f900db6 100644 --- a/db/mork/src/orkinTableRowCursor.h +++ b/db/mork/src/orkinTableRowCursor.h @@ -71,8 +71,11 @@ private: // copying is not allowed // } ===== end morkNode methods ===== protected: // morkHandle memory management operators + void* operator new(size_t inSize, morkPool& ioPool, morkZone& ioZone, morkEnv* ev) + { return ioPool.NewHandle(ev, inSize, &ioZone); } + void* operator new(size_t inSize, morkPool& ioPool, morkEnv* ev) - { return ioPool.NewHandle(ev, inSize); } + { return ioPool.NewHandle(ev, inSize, (morkZone*) 0); } void* operator new(size_t inSize, morkHandleFace* ioFace) { MORK_USED_1(inSize); return ioFace; } diff --git a/db/mork/src/orkinThumb.h b/db/mork/src/orkinThumb.h index 9cfa35f6ba1..82fa7762f0a 100644 --- a/db/mork/src/orkinThumb.h +++ b/db/mork/src/orkinThumb.h @@ -69,8 +69,11 @@ private: // copying is not allowed // } ===== end morkNode methods ===== protected: // morkHandle memory management operators + void* operator new(size_t inSize, morkPool& ioPool, morkZone& ioZone, morkEnv* ev) + { return ioPool.NewHandle(ev, inSize, &ioZone); } + void* operator new(size_t inSize, morkPool& ioPool, morkEnv* ev) - { return ioPool.NewHandle(ev, inSize); } + { return ioPool.NewHandle(ev, inSize, (morkZone*) 0); } void* operator new(size_t inSize, morkHandleFace* ioFace) { MORK_USED_1(inSize); return ioFace; }