Way better performance when maintaining EdgeConnectionsPlus backing (…

…does dirtty sort + merge rather than global sort)

modules/engine/edgeconnplus.go

@@ -6,7 +6,6 @@ import (
  "sync/atomic"
  "unsafe"
 
- "github.com/jfcg/sorty/v2"
  "github.com/lkarlslund/adalanche/modules/ui"
 )
 
@@ -30,6 +29,10 @@ type Connection struct {
  edges EdgeBitmap
 }
 
+func init() {
+ // sorty.MaxGor = 1
+}
+
 func (e *EdgeConnectionsPlus) init() {
 
 }
@@ -100,6 +103,8 @@ func (e *EdgeConnectionsPlus) del(target *Object) {
  // }
  } else {
  ui.Debug().Msg("Trying to delete edge that is already deleted")
+ backing := e.getBacking()
+ _ = backing
  }
  } else {
  ui.Debug().Msg("Trying to delete edge that could not be found")
@@ -232,21 +237,29 @@ func (e *EdgeConnectionsPlus) insert(target *Object, eb EdgeBitmap) {
  backing := e.getBacking()
 
  for backing == nil || int(backing.maxTotal.Load()) == len(backing.data) {
- e.maintainBacking(false)
+ e.maintainBacking(Grow)
  backing = e.getBacking()
  }
 
  newMax := backing.maxTotal.Add(1)
  backing.data[int(newMax-1)] = newConnection
 }
 
-func (e *EdgeConnectionsPlus) Optimize() {
+func (e *EdgeConnectionsPlus) Minimize() {
  e.lock()
- e.maintainBacking(true)
+ e.maintainBacking(Minimize)
  e.unlock()
 }
 
-func (e *EdgeConnectionsPlus) maintainBacking(keepsize bool) {
+type sizeModifierFlag uint8
+
+const (
+ Grow sizeModifierFlag = iota
+ Same
+ Minimize
+)
+
+func (e *EdgeConnectionsPlus) maintainBacking(requestedModification sizeModifierFlag) {
  if !e.growing.CompareAndSwap(0, 1) {
  panic("growing twice")
  }
@@ -262,62 +275,95 @@ func (e *EdgeConnectionsPlus) maintainBacking(keepsize bool) {
  }
 
  oldMax := int(oldBacking.maxTotal.Load())
- var addLength int
- if !keepsize {
- addLength = len(oldBacking.data)
- if addLength > 8192 {
- addLength = 8192
+ oldClean := int(oldBacking.maxClean)
+ oldDeleted := int(oldBacking.deleted.Load())
+
+ var newLength int
+ switch requestedModification {
+ case Grow:
+ growSize := oldMax / 2
+ if growSize > 2048 {
+ growSize = 2048
  }
- }
- newLength := len(oldBacking.data) + addLength
-
- // Don't add, just keep this size
- if oldBacking.deleted.Load() > uint32(oldMax)/4 {
- addLength = 0
+ newLength = oldMax + growSize
+ case Same:
+ newLength = len(oldBacking.data)
+ case Minimize:
+ newLength = oldMax - oldDeleted
  }
 
- newData := make([]Connection, newLength)
- copy(newData, oldBacking.data)
-
- var deleted uint32
- searchData := newData[:oldMax]
- for i := range searchData { // BCE
- if atomic.LoadUint32(&searchData[i].alive) == 0 {
- searchData[i].target = (*Object)(unsafe.Pointer(^uintptr(0))) // Max pointer, sort will move it to the end
- deleted++
+ if newLength > 0 {
+ newData := make([]Connection, newLength)
+
+ // Place new non-deleted items at the end of the soon-to-be sorted part of the new slice
+ insertEnd := oldMax - oldDeleted
+ insertStart := insertEnd
+ oldDirtyData := oldBacking.data[int(oldBacking.maxClean):oldMax]
+ if oldDeleted == 0 {
+ // Nothing was deleted, so just bulk copy it
+ insertStart = insertEnd - (oldMax - oldClean)
+ copy(newData[insertStart:insertEnd], oldDirtyData)
+ } else {
+ // Pick non-deleted items one by one
+ for i := range oldDirtyData {
+ if oldDirtyData[i].alive == 0 {
+ continue
+ }
+ insertStart--
+ newData[insertStart] = oldDirtyData[i]
+ }
  }
- }
 
- // sort.Sort(ConnectionSliceSorter(newData[:oldMax]))
- sorty.MaxGor = 1
- sorty.Sort(oldMax, func(i, k, r, s int) bool {
- if uintptr(unsafe.Pointer(newData[i].target)) < uintptr(unsafe.Pointer(newData[k].target)) {
- if r != s {
- newData[r], newData[s] = newData[s], newData[r]
+ // Sort the new items
+ insertedData := newData[insertStart:insertEnd]
+
+ sort.Sort(ConnectionSliceSorter(insertedData))
+ // sorty.Sort(len(insertedData), func(i, k, r, s int) bool {
+ // if uintptr(unsafe.Pointer(insertedData[i].target)) < uintptr(unsafe.Pointer(insertedData[k].target)) {
+ // if r != s {
+ // insertedData[r], insertedData[s] = insertedData[s], insertedData[r]
+ // }
+ // return true
+ // }
+ // return false
+ // })
+
+ // sort.Slice(insertedData, func(i, j int) bool {
+ // return uintptr(unsafe.Pointer(insertedData[i].target)) < uintptr(unsafe.Pointer(insertedData[j].target))
+ // })
+
+ // Merge old and new
+ oldCleanData := oldBacking.data[:int(oldBacking.maxClean)]
+ fixData := newData[:insertEnd]
+ insertData := newData[insertStart:insertEnd]
+ for oc, f, i := 0, 0, 0; oc < len(oldCleanData); {
+ if oldCleanData[oc].alive == 0 {
+ oc++
+ continue
+ }
+ if i < len(insertedData) && uintptr(unsafe.Pointer(insertedData[i].target)) < uintptr(unsafe.Pointer(oldCleanData[oc].target)) {
+ fixData[f] = insertData[i]
+ i++
+ } else {
+ fixData[f] = oldCleanData[oc]
+ oc++
  }
- return true
+ f++
  }
- return false
- })
- // sort.Slice(newData[:oldMax], func(i, j int) bool {
- // return uintptr(unsafe.Pointer(newData[i].target)) < uintptr(unsafe.Pointer(newData[j].target))
- // })
-
- // if oldBacking.deleted.Load() > uint32(oldMax)/2 {
- // // More than half was deleted, lets shrink to a new slice
- // shrinkData := make([]Connection, oldMax/2)
- // copy(shrinkData, newData)
- // newData = shrinkData
- // }
-
- newBacking := Connections{
- data: newData,
- maxClean: uint32(oldMax) - deleted,
- }
- newBacking.maxTotal.Store(newBacking.maxClean)
 
- if !atomic.CompareAndSwapPointer(&e.backing, unsafe.Pointer(oldBacking), unsafe.Pointer(&newBacking)) {
- panic("Backing was changed behind my back")
+ newBacking := Connections{
+ data: newData,
+ maxClean: uint32(insertEnd),
+ }
+ newBacking.maxTotal.Store(newBacking.maxClean)
+
+ if !atomic.CompareAndSwapPointer(&e.backing, unsafe.Pointer(oldBacking), unsafe.Pointer(&newBacking)) {
+ panic("Backing was changed behind my back")
+ }
+ } else {
+ if !atomic.CompareAndSwapPointer(&e.backing, unsafe.Pointer(oldBacking), unsafe.Pointer(uintptr(0))) {
+ panic("Backing was changed behind my back")
+ }
  }
  e.growing.Store(0)
 }