Speedup open huge file

db.go

@@ -115,10 +115,11 @@ type DB struct {
 	batchMu sync.Mutex
 	batch   *batch
 
-	rwlock   sync.Mutex   // Allows only one writer at a time.
-	metalock sync.Mutex   // Protects meta page access.
-	mmaplock sync.RWMutex // Protects mmap access during remapping.
-	statlock sync.RWMutex // Protects stats access.
+	rwlock       sync.Mutex   // Allows only one writer at a time.
+	metalock     sync.Mutex   // Protects meta page access.
+	mmaplock     sync.RWMutex // Protects mmap access during remapping.
+	statlock     sync.RWMutex // Protects stats access.
+	freelistonce sync.Once    // Protects reading freelist from file.
 
 	ops struct {
 		writeAt func(b []byte, off int64) (n int, err error)
@@ -232,10 +233,6 @@ func Open(path string, mode os.FileMode, options *Options) (*DB, error) {
 		return nil, err
 	}
 
-	// Read in the freelist.
-	db.freelist = newFreelist()
-	db.freelist.read(db.page(db.meta().freelist))
-
 	// Mark the database as opened and return.
 	return db, nil
 }
@@ -439,6 +436,15 @@ func (db *DB) close() error {
 	return nil
 }
 
+func (db *DB) ensureFreelist() *freelist {
+	db.freelistonce.Do(func() {
+		fl := newFreelist()
+		fl.read(db.page(db.meta().freelist))
+		db.freelist = fl
+	})
+	return db.freelist
+}
+
 // Begin starts a new transaction.
 // Multiple read-only transactions can be used concurrently but only one
 // write transaction can be used at a time. Starting multiple write transactions
@@ -514,11 +520,11 @@ func (db *DB) beginRWTx() (*Tx, error) {
 	// Once we have the writer lock then we can lock the meta pages so that
 	// we can set up the transaction.
 	db.metalock.Lock()
-	defer db.metalock.Unlock()
 
 	// Exit if the database is not open yet.
 	if !db.opened {
 		db.rwlock.Unlock()
+		db.metalock.Unlock()
 		return nil, ErrDatabaseNotOpen
 	}
 
@@ -534,10 +540,14 @@ func (db *DB) beginRWTx() (*Tx, error) {
 			minid = t.meta.txid
 		}
 	}
+
+	// Release meta here cause ensureFreelist can take a long time
+	db.metalock.Unlock()
+
+	db.ensureFreelist()
 	if minid > 0 {
 		db.freelist.release(minid - 1)
 	}
-
 	return t, nil
 }
 

freelist.go

@@ -9,16 +9,16 @@ import (
 // freelist represents a list of all pages that are available for allocation.
 // It also tracks pages that have been freed but are still in use by open transactions.
 type freelist struct {
-	ids     []pgid          // all free and available free page ids.
-	pending map[txid][]pgid // mapping of soon-to-be free page ids by tx.
-	cache   map[pgid]bool   // fast lookup of all free and pending page ids.
+	ids     []pgid            // all free and available free page ids.
+	pending map[txid][]pgid   // mapping of soon-to-be free page ids by tx.
+	cache   map[pgid]struct{} // fast lookup of all free and pending page ids.
 }
 
 // newFreelist returns an empty, initialized freelist.
 func newFreelist() *freelist {
 	return &freelist{
 		pending: make(map[txid][]pgid),
-		cache:   make(map[pgid]bool),
+		cache:   make(map[pgid]struct{}),
 	}
 }
 
@@ -113,13 +113,13 @@ func (f *freelist) free(txid txid, p *page) {
 	var ids = f.pending[txid]
 	for id := p.id; id <= p.id+pgid(p.overflow); id++ {
 		// Verify that page is not already free.
-		if f.cache[id] {
+		if _, ok := f.cache[id]; ok {
 			panic(fmt.Sprintf("page %d already freed", id))
 		}
 
 		// Add to the freelist and cache.
 		ids = append(ids, id)
-		f.cache[id] = true
+		f.cache[id] = struct{}{}
 	}
 	f.pending[txid] = ids
 }
@@ -152,7 +152,8 @@ func (f *freelist) rollback(txid txid) {
 
 // freed returns whether a given page is in the free list.
 func (f *freelist) freed(pgid pgid) bool {
-	return f.cache[pgid]
+	_, ok := f.cache[pgid]
+	return ok
 }
 
 // read initializes the freelist from a freelist page.
@@ -174,7 +175,9 @@ func (f *freelist) read(p *page) {
 		copy(f.ids, ids)
 
 		// Make sure they're sorted.
-		sort.Sort(pgids(f.ids))
+		if !pgids(f.ids).isSorted() {
+			sort.Sort(pgids(f.ids))
+		}
 	}
 
 	// Rebuild the page cache.
@@ -212,18 +215,18 @@ func (f *freelist) reload(p *page) {
 	f.read(p)
 
 	// Build a cache of only pending pages.
-	pcache := make(map[pgid]bool)
+	pcache := make(map[pgid]struct{})
 	for _, pendingIDs := range f.pending {
 		for _, pendingID := range pendingIDs {
-			pcache[pendingID] = true
+			pcache[pendingID] = struct{}{}
 		}
 	}
 
 	// Check each page in the freelist and build a new available freelist
 	// with any pages not in the pending lists.
 	var a []pgid
 	for _, id := range f.ids {
-		if !pcache[id] {
+		if _, ok := pcache[id]; !ok {
 			a = append(a, id)
 		}
 	}
@@ -236,13 +239,13 @@ func (f *freelist) reload(p *page) {
 
 // reindex rebuilds the free cache based on available and pending free lists.
 func (f *freelist) reindex() {
-	f.cache = make(map[pgid]bool, len(f.ids))
+	f.cache = make(map[pgid]struct{}, len(f.ids))
 	for _, id := range f.ids {
-		f.cache[id] = true
+		f.cache[id] = struct{}{}
 	}
 	for _, pendingIDs := range f.pending {
 		for _, pendingID := range pendingIDs {
-			f.cache[pendingID] = true
+			f.cache[pendingID] = struct{}{}
 		}
 	}
 }

page.go

@@ -139,6 +139,14 @@ type pgids []pgid
 func (s pgids) Len() int           { return len(s) }
 func (s pgids) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
 func (s pgids) Less(i, j int) bool { return s[i] < s[j] }
+func (s pgids) isSorted() bool {
+	for i := len(s)-1; i > 0; i-- {
+		if s[i] < s[i-1] {
+			return false
+		}
+	}
+	return true
+}
 
 // merge returns the sorted union of a and b.
 func (a pgids) merge(b pgids) pgids {

tx.go

@@ -381,7 +381,7 @@ func (tx *Tx) Check() <-chan error {
 func (tx *Tx) check(ch chan error) {
 	// Check if any pages are double freed.
 	freed := make(map[pgid]bool)
-	for _, id := range tx.db.freelist.all() {
+	for _, id := range tx.db.ensureFreelist().all() {
 		if freed[id] {
 			ch <- fmt.Errorf("page %d: already freed", id)
 		}