High-Performance Data Orchestration in Roku OS 15.0

Source: Dev.to

MoveIntoField and MoveFromField

Traditionally, an assignment like node.field = myAA performed a deep copy. In Roku OS 15.0, MoveIntoField() and MoveFromField() literally transfer ownership. The data moves into the node, and your local variable becomes empty.

' --- BEFORE (The Blocking Copy) ---
' ...do some work
' m.top.content = hugeAA 
' 1. Task thread stops.
' 2. Render thread stops.
' 3. Both wait for a deep copy to finish. 
' 4. Breakpointing here kills the app because 
'    the Render thread is "stuck" waiting.

' --- AFTER (The Non-Blocking Move) ---
sub finishTask(hugeAA)
    ' ...do some work
    ' MoveIntoField transfers the memory pointer instantly.
    m.top.MoveIntoField("content", hugeAA)

    ' hugeAA is now empty. The Task can exit or move on without 
    ' holding a redundant copy in memory.
    ? "Task complete. hugeAA is now empty: " ; hugeAA.IsEmpty()
end sub

Render Thread References: SetRef and GetRef

Sometimes you don’t want to move or copy data—you just want the Render thread to look at a single instance of an object. This is now possible via the Reference APIs, which are strictly limited to the Render Thread.

• SetRef(): Assigns an AA to a field by reference (no copy).
• GetRef(): Retrieves that reference for use.
• CanGetRef(): Safety check to see if a reference exists.

Note: Field observers are not notified when you use SetRef(). This makes it perfect for high‑frequency data (e.g., coordinate tracking) where you want to avoid the overhead of observer notifications.

' --- BEFORE (Memory Inefficiency) ---
' m.childA.data = m.top.content ' Copy 1
' m.childB.data = m.top.content ' Copy 2 (Memory usage doubled)

' --- AFTER (Robust Reference Sharing) ---
' This must happen on the Render Thread (e.g., in an observer or queue handler)
sub shareTaskData()
    if m.top.CanGetRef("content")
        ref = m.top.GetRef("content")

        ' Pass the pointer to children. No deep copies are made.
        m.childA.SetRef("sharedContent", ref)
        m.childB.SetRef("sharedContent", ref)
    end if
end sub

The roRenderThreadQueue

The roRenderThreadQueue API solves the “SceneGraph Hole” by allowing Task threads to send data to the UI thread without triggering a Rendezvous (a synchronous lock that freezes the UI). Think of it as a thread‑safe mailbox: the Task thread drops a message and continues; the Render thread processes messages between frames.

Core APIs

• roRenderThreadQueue – Manager node. Initialize it on both the Render thread (to listen) and the Task thread (to send).
• AddMessageHandler(message_id, handler_name) – Registers a function to run when a message with a matching ID arrives. Multiple handlers can be attached to one ID; they execute in registration order.
• PostMessage(message_id, data) – Moves the data (high‑performance).
• CopyMessage(message_id, data) – Performs a deep copy before sending.

' --- BEFORE (Rendezvous Dependency) ---
' m.top.updateData = hugeAA 
' Scene.brs has an observer on task.updateData.
' The moment this assignment happens, the threads are "locked."

' --- AFTER (Decoupled Messaging) ---
' [Inside Task Thread]
sub runTask()
    hugeAA = loadMassiveJson()

    queue = CreateObject("roRenderThreadQueue")
    queue.PostMessage("FEED_UPDATE", hugeAA)
end sub

' [Inside Component/Scene .brs]
sub init()
    m.queue = CreateObject("roRenderThreadQueue")
    m.queue.AddMessageHandler("FEED_UPDATE", "onFeedUpdate")
end sub

sub onFeedUpdate(data as Object, info as Object)
    ' data is the moved AA. No Rendezvous ever occurred.
    m.myGrid.content = data
end sub

Conclusion

This architectural shift is arguably the most important change in Roku development since SceneGraph itself. The new APIs let you stop copying large data structures and simply point to them, delivering several tangible benefits:

• Low‑End Device Salvation: On devices with limited RAM (e.g., Roku Express), memory spikes from deep copies are eliminated, allowing massive JSON payloads to be handled on cheap hardware.
• The End of “Jank”: Micro‑stutters in RowList or other UI components disappear because MoveIntoField and PostMessage are O(1) operations, keeping the Render thread responsive.

Relevant Links

• Data Transfer APIs – Roku Developer Guide
• Performance Overview Video