Fix race in item too.

item.go

 package gkvlite
 
 import (
         "encoding/binary"
         "errors"
         "fmt"
         "sync"
         "sync/atomic"
 )
 
 // A persistable item.
 type Item struct {
         Transient interface{} // For any ephemeral data.
         Key, Val  []byte      // Val may be nil if not fetched into memory yet.
         Priority  int32       // Use rand.Int31() for probabilistic balancing.
 }
 
+var itemLocGL = sync.RWMutex{}
+
 // A persistable item and its persistence location.
 type itemLoc struct {
-        m sync.Mutex
-
         loc  *ploc // can be nil if item is dirty (not yet persisted).
         item *Item // can be nil if item is not fetched into memory yet.
 }
 
 var empty_itemLoc = &itemLoc{}
 
 // Number of Key bytes plus number of Val bytes.
 func (i *Item) NumBytes(c *Collection) int {
         return len(i.Key) + i.NumValBytes(c)
 }
@@ skipping 10 matching lines @@
 func (i *Item) Copy() *Item {
         return &Item{
                 Key:       i.Key,
                 Val:       i.Val,
                 Priority:  i.Priority,
                 Transient: i.Transient,
         }
 }
 
 func (i *itemLoc) Loc() *ploc {
-        i.m.Lock()
-        defer i.m.Unlock()
+        itemLocGL.RLock()
+        defer itemLocGL.RUnlock()
         return i.loc
 }
 
 func (i *itemLoc) setLoc(n *ploc) {
-        i.m.Lock()
-        defer i.m.Unlock()
+        itemLocGL.Lock()
+        defer itemLocGL.Unlock()
         i.loc = n
 }
 
 func (i *itemLoc) Item() *Item {
-        i.m.Lock()
-        defer i.m.Unlock()
+        itemLocGL.RLock()
+        defer itemLocGL.RUnlock()
         return i.item
 }
 
 func (i *itemLoc) casItem(o, n *Item) bool {
-        i.m.Lock()
-        defer i.m.Unlock()
+        itemLocGL.Lock()
+        defer itemLocGL.Unlock()
         if i.item == o {
                 i.item = n
                 return true
         }
         return false
 }
 
 func (i *itemLoc) Copy(src *itemLoc) {
         if src == nil {
                 i.Copy(empty_itemLoc)
                 return
         }
-        newloc := src.Loc()
-        newitem := src.Item()
 
-        i.m.Lock()
-        defer i.m.Unlock()
-        i.loc = newloc
-        i.item = newitem
+        itemLocGL.Lock()
+        defer itemLocGL.Unlock()
+        // NOTE: This trick only works because of the global lock. No reason to lock
+        // src independently of i.
+        i.loc = src.loc
+        i.item = src.item
 }
 
 const itemLoc_hdrLength int = 4 + 4 + 4 + 4
 
 func (i *itemLoc) write(c *Collection) (err error) {
         if i.Loc().isEmpty() {
                 iItem := i.Item()
                 if iItem == nil {
                         return errors.New("itemLoc.write with nil item")
                 }
@@ skipping 111 matching lines @@
         loc := iloc.Loc()
         if loc.isEmpty() {
                 i := iloc.Item()
                 if i == nil {
                         return 0
                 }
                 return i.NumBytes(c)
         }
         return int(loc.Length) - itemLoc_hdrLength
 }