synchronize renderwork. call notifyfn when we get new render work from an async context...

Author: sawka

tsunami/engine/clientimpl.go

@@ -26,6 +26,10 @@ const TsunamiListenAddrEnvVar = "TSUNAMI_LISTENADDR"
 const DefaultListenAddr = "localhost:0"
 const DefaultComponentName = "App"
 
+const NotifyMaxCadence = 10 * time.Millisecond
+const NotifyDebounceTime = 500 * time.Microsecond
+const NotifyMaxDebounceTime = 2 * time.Millisecond
+
 type ssEvent struct {
 	Event string
 	Data  []byte
@@ -218,6 +222,10 @@ func (c *ClientImpl) SendAsyncInitiation() error {
 	}
 }
 
+func (c *ClientImpl) notifyAsyncRenderWork() {
+	// TODO
+}
+
 func makeNullRendered() *rpctypes.RenderedElem {
 	return &rpctypes.RenderedElem{WaveId: uuid.New().String(), Tag: vdom.WaveNullTag}
 }

tsunami/engine/globalctx.go

@@ -10,6 +10,13 @@ import (
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
 )
 
+const (
+	GlobalContextType_async  = "async"
+	GlobalContextType_render = "render"
+	GlobalContextType_effect = "effect"
+	GlobalContextType_event  = "event"
+)
+
 // is set ONLY when we're in the render function of a component
 // used for hooks, and automatic dependency tracking
 var globalRenderContext *RenderContextImpl
@@ -123,3 +130,30 @@ func GetGlobalEffectContext() *EffectContextImpl {
 	}
 	return globalEffectContext
 }
+
+// inContextType returns the current global context type.
+// Returns one of:
+//   - GlobalContextType_render: when in a component render function
+//   - GlobalContextType_event: when in an event handler
+//   - GlobalContextType_effect: when in an effect function
+//   - GlobalContextType_async: when not in any specific context (default/async)
+func inContextType() string {
+	globalCtxMutex.Lock()
+	defer globalCtxMutex.Unlock()
+	
+	gid := goid.Get()
+	
+	if globalRenderContext != nil && gid == globalRenderGoId {
+		return GlobalContextType_render
+	}
+	
+	if globalEventContext != nil && gid == globalEventGoId {
+		return GlobalContextType_event
+	}
+	
+	if globalEffectContext != nil && gid == globalEffectGoId {
+		return GlobalContextType_effect
+	}
+	
+	return GlobalContextType_async
+}

tsunami/engine/hooks.go

@@ -125,14 +125,14 @@ func UseEffect(vc *RenderContextImpl, fn func() func(), deps []any) {
 		hookVal.Init = true
 		hookVal.Fn = fn
 		hookVal.Deps = deps
-		vc.Root.AddEffectWork(vc.GetCompWaveId(), hookVal.Idx, compTag)
+		vc.Root.addEffectWork(vc.GetCompWaveId(), hookVal.Idx, compTag)
 		return
 	}
 	// If deps is nil, always run (like React with no dependency array)
 	if deps == nil {
 		hookVal.Fn = fn
 		hookVal.Deps = deps
-		vc.Root.AddEffectWork(vc.GetCompWaveId(), hookVal.Idx, compTag)
+		vc.Root.addEffectWork(vc.GetCompWaveId(), hookVal.Idx, compTag)
 		return
 	}
 
@@ -141,7 +141,7 @@ func UseEffect(vc *RenderContextImpl, fn func() func(), deps []any) {
 	}
 	hookVal.Fn = fn
 	hookVal.Deps = deps
-	vc.Root.AddEffectWork(vc.GetCompWaveId(), hookVal.Idx, compTag)
+	vc.Root.addEffectWork(vc.GetCompWaveId(), hookVal.Idx, compTag)
 }
 
 func UseResync(vc *RenderContextImpl) bool {

tsunami/engine/rootelem.go

@@ -36,24 +36,50 @@ type RootElem struct {
 	Root            *ComponentImpl
 	RenderTs        int64
 	AppTitle        string
-	CFuncs          map[string]any
+	CFuncs          map[string]any            // component name => render function
 	CompMap         map[string]*ComponentImpl // component waveid -> component
 	EffectWorkQueue []*EffectWorkElem
-	NeedsRenderMap  map[string]bool
-	Atoms           map[string]genAtom
+	needsRenderMap  map[string]bool // key: waveid
+	needsRenderLock sync.Mutex
+	Atoms           map[string]genAtom // key: atomName
 	atomLock        sync.Mutex
 	RefOperations   []vdom.VDomRefOperation
 	Client          *ClientImpl
 }
 
-func (r *RootElem) AddRenderWork(id string) {
-	if r.NeedsRenderMap == nil {
-		r.NeedsRenderMap = make(map[string]bool)
+func (r *RootElem) addRenderWork(id string) {
+	defer func() {
+		if inContextType() == GlobalContextType_async {
+			r.Client.notifyAsyncRenderWork()
+		}
+	}()
+	
+	r.needsRenderLock.Lock()
+	defer r.needsRenderLock.Unlock()
+
+	if r.needsRenderMap == nil {
+		r.needsRenderMap = make(map[string]bool)
 	}
-	r.NeedsRenderMap[id] = true
+	r.needsRenderMap[id] = true
 }
 
-func (r *RootElem) AddEffectWork(id string, effectIndex int, compTag string) {
+func (r *RootElem) getAndClearRenderWork() []string {
+	r.needsRenderLock.Lock()
+	defer r.needsRenderLock.Unlock()
+
+	if len(r.needsRenderMap) == 0 {
+		return nil
+	}
+
+	ids := make([]string, 0, len(r.needsRenderMap))
+	for id := range r.needsRenderMap {
+		ids = append(ids, id)
+	}
+	r.needsRenderMap = nil
+	return ids
+}
+
+func (r *RootElem) addEffectWork(id string, effectIndex int, compTag string) {
 	r.EffectWorkQueue = append(r.EffectWorkQueue, &EffectWorkElem{WaveId: id, EffectIndex: effectIndex, CompTag: compTag})
 }
 
@@ -135,8 +161,12 @@ func (r *RootElem) AtomAddRenderWork(atomName string) {
 	if !ok {
 		return
 	}
-	for _, compId := range atom.GetUsedBy() {
-		r.AddRenderWork(compId)
+	usedBy := atom.GetUsedBy()
+	if len(usedBy) == 0 {
+		return
+	}
+	for _, compId := range usedBy {
+		r.addRenderWork(compId)
 	}
 }
 
@@ -356,8 +386,8 @@ func (r *RootElem) RunWork(opts *RenderOpts) {
 		r.runEffect(work, hook)
 	}
 	// now check if we need a render
-	if len(r.NeedsRenderMap) > 0 {
-		r.NeedsRenderMap = nil
+	renderIds := r.getAndClearRenderWork()
+	if len(renderIds) > 0 {
 		r.render(r.Root.Elem, &r.Root, "root", opts)
 	}
 }
@@ -392,7 +422,7 @@ func (r *RootElem) UpdateRef(updateRef rpctypes.VDomRefUpdate) {
 	}
 	ref.HasCurrent = updateRef.HasCurrent
 	ref.Position = updateRef.Position
-	r.AddRenderWork(waveId)
+	r.addRenderWork(waveId)
 }
 
 func (r *RootElem) QueueRefOp(op vdom.VDomRefOperation) {