Remove usage of unsafe from gkvlite

collection.go

 package gkvlite
 
 import (
         "encoding/json"
         "errors"
         "fmt"
         "math/rand"
         "sync"
-        "sync/atomic"
-        "unsafe"
 )
 
 // User-supplied key comparison func should return 0 if a == b,
 // -1 if a < b, and +1 if a > b.  For example: bytes.Compare()
 type KeyCompare func(a, b []byte) int
 
 // A persistable collection of ordered key-values (Item's).
 type Collection struct {
         name    string // May be "" for a private collection.
         store   *Store
         compare KeyCompare
 
         rootLock *sync.Mutex
         root     *rootNodeLoc // Protected by rootLock.
 
         allocStats AllocStats // User must serialize access (e.g., see locks in alloc.go).
 
-        AppData unsafe.Pointer // For app-specific data; atomic CAS recommended.
+        AppData interface{} // For app-specific data.
 }
 
 type rootNodeLoc struct {
         // The rootNodeLoc fields are protected by Collection.rootLock.
         refs int64 // Reference counter.
         root *nodeLoc
         next *rootNodeLoc // For free-list tracking.
 
         reclaimMark node // Address is used as a sentinel.
 
@@ skipping 92 matching lines @@
                 return errors.New("Item.Key/Val missing or too long")
         }
         if item.Priority < 0 {
                 return errors.New("Item.Priority must be non-negative")
         }
         rnl := t.rootAddRef()
         defer t.rootDecRef(rnl)
         root := rnl.root
         n := t.mkNode(nil, nil, nil, 1, uint64(len(item.Key))+uint64(item.NumValBytes(t)))
         t.store.ItemAddRef(t, item)
-        n.item.item = unsafe.Pointer(item) // Avoid garbage via separate init.
+        n.item.item = item // Avoid garbage via separate init.
         nloc := t.mkNodeLoc(n)
         defer t.freeNodeLoc(nloc)
         r, err := t.store.union(t, root, nloc, &rnl.reclaimMark)
         if err != nil {
                 return err
         }
         rnlNew := t.mkRootNodeLoc(r)
         // Can't reclaim n right now because r might point to n.
         rnlNew.reclaimLater[0] = t.reclaimMarkUpdate(nloc,
                 &rnl.reclaimMark, &rnlNew.reclaimMark)
@@ skipping 69 matching lines @@
 // Evict some clean items found by randomly walking a tree branch.
 // For concurrent users, only the single mutator thread should call
 // EvictSomeItems(), making it serialized with mutations.
 func (t *Collection) EvictSomeItems() (numEvicted uint64) {
         if t.store.readOnly {
                 return 0
         }
         i, err := t.store.walk(t, false, func(n *node) (*nodeLoc, bool) {
                 if !n.item.Loc().isEmpty() {
                         i := n.item.Item()
-                        if i != nil && atomic.CompareAndSwapPointer(&n.item.item,
-                                unsafe.Pointer(i), unsafe.Pointer(nil)) {
+                        if i != nil && n.item.casItem(i, nil) {
                                 t.store.ItemDecRef(t, i)
                                 numEvicted++
                         }
                 }
                 next := &n.left
                 if (rand.Int() & 0x01) == 0x01 {
                         next = &n.right
                 }
                 if next.isEmpty() {
                         return nil, false
@@ skipping 99 matching lines @@
 // Unmarshals JSON representation of root node file location.
 func (t *Collection) UnmarshalJSON(d []byte) error {
         p := ploc{}
         if err := json.Unmarshal(d, &p); err != nil {
                 return err
         }
         if t.rootLock == nil {
                 t.rootLock = &sync.Mutex{}
         }
         nloc := t.mkNodeLoc(nil)
-        nloc.loc = unsafe.Pointer(&p)
+        nloc.loc = &p
         if !t.rootCAS(nil, t.mkRootNodeLoc(nloc)) {
                 return errors.New("concurrent mutation during UnmarshalJSON().")
         }
         return nil
 }
 
 func (t *Collection) AllocStats() (res AllocStats) {
         withAllocLocks(func() { res = t.allocStats })
         return res
 }
@@ skipping 104 matching lines @@
         t.reclaimNodes_unlocked(r.root.Node(), &r.reclaimLater, &r.reclaimMark)
         for i := 0; i < len(r.reclaimLater); i++ {
                 if r.reclaimLater[i] != nil {
                         t.reclaimNodes_unlocked(r.reclaimLater[i], nil, &r.reclaimMark)
                         r.reclaimLater[i] = nil
                 }
         }
         t.freeNodeLoc(r.root)
         t.freeRootNodeLoc(r)
 }