@axpecter/lync 2.3.3 → 3.0.0

package/state/Sections.luau

@@ -0,0 +1,468 @@
+--!strict
+--!optimize 2
+-- The state sections: one partition's flush, as the bytes it becomes.
+
+local Bits = require (script.Parent.Parent.kernel.Bits)
+local Column = require (script.Parent.Parent.shape.emit.Column)
+local Compile = require (script.Parent.Parent.shape.Compile)
+local Fieldset = require (script.Parent.Fieldset)
+local Protocol = require (script.Parent.Parent.wire.Protocol)
+local Shape = require (script.Parent.Parent.shape)
+local Types = require (script.Parent.Parent.Types)
+local Varint = require (script.Parent.Parent.wire.Varint)
+
+local Sections = {}
+
+-- Constants -----------------------------------------------------------
+
+const KEYFRAME = Protocol.SECTION_KEYFRAME
+const DELTA = Protocol.SECTION_DELTA
+const REMOVAL = Protocol.SECTION_REMOVAL
+const CLEAR = Protocol.SECTION_CLEAR
+
+-- The bits a keyframe states a slot's generation in, which is what the modulus asks for.
+const GENS = Bits.width (Protocol.NEWEST_GENS - 1)
+
+-- The presence run's element, and the value of the flag that says a field covered every slot.
+const PRESENT = 1
+const COVERS = 1
+
+-- What a field's history has to be worth before a difference is taken against it.
+const CHEAPER = 8
+
+-- How wide an element a run packs, past which a column is a stride rather than a run.
+const RUNS = Protocol.BIT_CEILING
+
+-- What the widest varint spends, which is what a slot and an id are each bounded by.
+const WIDEST = Protocol.VARINT_GROUPS
+
+-- The least an entry of each kind can spend: a slot and an id, or a slot alone.
+const PAIRED = 2
+const LONE = 1
+
+const TOO_MANY = "a section naming more records than its own bytes could hold"
+const OUT_OF_ORDER = "a section naming its slots out of order"
+const GENERATIONS = "a generation run"
+const PRESENCE = "a presence run"
+
+-- Types ---------------------------------------------------------------
+
+-- One field's values across a partition's slots, and the last index each was sent at.
+export type Columns = { { [number]: any } }
+export type History = { { [number]: number }? }
+
+-- One section, as the caller fills it and as a reader fills it back.
+export type Frame = {
+    key: any,
+    count: number,
+    slots: { number },
+    ids: { number },
+    gens: { number },
+    chosen: Fieldset.Chosen,
+    present: { { number } },
+    under: { { number } },
+    covered: { number },
+    values: { { any } },
+    at: { { number } },
+}
+
+-- One set's sections, compiled: what each field's column is, and what a section of them costs.
+export type Layout = {
+    read def: Compile.Set,
+    read set: Fieldset.Fieldset,
+    read fields: { Field },
+    read generations: Field,
+    read presence: Field,
+    read frame: Frame,
+    read held: { number },
+    read spare: { number },
+    read opening: number,
+    read entry: number,
+    read each: { number },
+    read gained: { number },
+}
+
+-- What one field of a set becomes at both ends: whole always, and as a difference where it can.
+export type Field = {
+    read whole: Column.Write,
+    read back: Column.Read,
+    read gain: Column.Gain?,
+    read regain: Column.Regain?,
+}
+
+-- Private -------------------------------------------------------------
+
+-- A run of the section's own numbers, which is a field-shaped thing with no difference to take.
+local function run (width: number, said: string): Field
+    local whole, back = Column.bits (width, said)
+    return { whole = whole, back = back, gain = nil, regain = nil }
+end
+
+-- One field, as the pair or two that lay its column down.
+local function made (built: Shape.Built): Field
+    local grid = built.grid
+    local deltas = grid ~= nil and built.marker ~= "newest" and grid.width > CHEAPER
+
+    local whole: Column.Write, back: Column.Read
+    if grid == nil or grid.width > RUNS then
+        -- Stating its indices only where something will take a difference against them.
+        whole, back = Column.each (built.write, built.read, if deltas then grid else nil)
+    else
+        whole, back = Column.grid (built.tag, built.paths, built.expected, grid)
+    end
+
+    if not deltas then return { whole = whole, back = back, gain = nil, regain = nil } end
+
+    local gain, regain = Column.gain (
+        built.tag,
+        built.paths,
+        built.expected,
+        grid :: any,
+        built.marker ~= "monotonic"
+    )
+    return { whole = whole, back = back, gain = gain, regain = regain }
+end
+
+-- The slots a field covers and where its values sit, gathered where the column reads them.
+local function gathered (
+    of: Frame,
+    place: number,
+    field: number,
+    columns: Columns,
+    count: number
+): number
+    local under = of.under[place]
+    local values = of.values[field]
+    local held = columns[field]
+
+    if of.chosen.full[place] == COVERS then
+        for index = 1, count do
+            local slot = of.slots[index]
+            under[index] = slot
+            values[index] = held[slot]
+        end
+
+        of.covered[place] = count
+        return count
+    end
+
+    local present = of.present[place]
+    local reach = 0
+
+    for index = 1, count do
+        if present[index] == 0 then continue end
+
+        local slot = of.slots[index]
+        reach += 1
+        under[reach] = slot
+        values[reach] = held[slot]
+    end
+
+    of.covered[place] = reach
+    return reach
+end
+
+-- The same slots, without the values, which is what a reader has before a column has answered.
+local function covering (of: Frame, place: number, count: number): number
+    local under = of.under[place]
+
+    if of.chosen.full[place] == COVERS then
+        table.move (of.slots, 1, count, 1, under)
+        of.covered[place] = count
+        return count
+    end
+
+    local present = of.present[place]
+    local reach = 0
+
+    for index = 1, count do
+        if present[index] == 0 then continue end
+
+        reach += 1
+        under[reach] = of.slots[index]
+    end
+
+    of.covered[place] = reach
+    return reach
+end
+
+-- A count against the bytes left to hold it.
+local function counted (b: buffer, at: number, least: number): (number, number)
+    local count, after = Varint.read (b, at)
+    if count * least > buffer.len (b) - after then Fieldset.broken (TOO_MANY) end
+
+    return count, after
+end
+
+-- A slot list, ascending, which determinism asks for and one comparison holds it to.
+local function listed (of: Frame, b: buffer, at: number, count: number): number
+    local held = at
+    local last = 0
+
+    for index = 1, count do
+        local slot
+        slot, held = Varint.read (b, held)
+        if slot <= last then Fieldset.broken (OUT_OF_ORDER) end
+
+        of.slots[index] = slot
+        last = slot
+    end
+
+    return held
+end
+
+-- A section's header and the key of the partition it is about, which every kind opens with.
+local function opened (of: Layout, b: buffer, pos: number, kind: number): number
+    local def = of.def
+    of.held[2] = kind
+    def.head.write (b, pos, of.held)
+
+    local at = pos + def.head.bytes
+    local key = def.keyIndex
+    if key == nil then return at end
+
+    return def.fieldBuilt[key].write (b, at, of.frame.key)
+end
+
+-- The count and the slots under it, which three of the four kinds carry and one does not.
+local function spelled (of: Layout, b: buffer, at: number): number
+    local frame = of.frame
+    local held = Varint.write (b, at, frame.count)
+
+    for index = 1, frame.count do
+        held = Varint.write (b, held, frame.slots[index])
+    end
+    return held
+end
+
+-- Public --------------------------------------------------------------
+
+-- A set's sections, as the closures and the scratch one partition's flush is written through.
+function Sections.of (def: Compile.Set): Layout
+    local reach = def.fieldCount
+    local fields = table.create (reach) :: { Field }
+    local each = table.create (reach) :: { number }
+    local gained = table.create (reach) :: { number }
+
+    local values = table.create (reach) :: { { any } }
+    local at = table.create (reach) :: { { number } }
+    local present = table.create (reach) :: { { number } }
+    local under = table.create (reach) :: { { number } }
+
+    local entry = WIDEST * 2 + if #def.newestFields == 0 then 0 else 1
+
+    for index = 1, reach do
+        local built = def.fieldBuilt[index]
+        local one = made (built)
+
+        fields[index] = one
+        each[index] = built.maxBytes
+        gained[index] = if one.gain == nil then each[index] else WIDEST
+        entry += each[index]
+
+        values[index] = {}
+        at[index] = {}
+        present[index] = {}
+        under[index] = {}
+    end
+
+    local key = def.keyIndex
+    local set = Fieldset.of (reach)
+
+    return table.freeze ({
+        def = def,
+        set = set,
+        fields = table.freeze (fields),
+        generations = table.freeze (run (GENS, GENERATIONS)),
+        presence = table.freeze (run (PRESENT, PRESENCE)),
+        frame = {
+            key = nil,
+            count = 0,
+            slots = {},
+            ids = {},
+            gens = {},
+            chosen = Fieldset.chosen (),
+            present = present,
+            under = under,
+            covered = {},
+            values = values,
+            at = at,
+        },
+        held = { def.id, KEYFRAME },
+        spare = {},
+        opening = def.head.bytes + (if key == nil then 0 else def.fieldBuilt[key].maxBytes) + 1,
+        entry = entry,
+        each = table.freeze (each),
+        gained = table.freeze (gained),
+    })
+end
+
+--[[
+    A keyframe: the listed slots, the ids they are bound to, the generations they stand at, and
+    every field of every one of them.
+]]
+function Sections.keyframe (of: Layout, b: buffer, pos: number, columns: Columns): number
+    local frame = of.frame
+    local def = of.def
+    local count = frame.count
+
+    local at = spelled (of, b, opened (of, b, pos, KEYFRAME))
+    for index = 1, count do
+        at = Varint.writeSigned (b, at, frame.ids[index])
+    end
+
+    if #def.newestFields > 0 then
+        at = of.generations.whole (b, at, frame.gens :: any, of.spare, count)
+    end
+
+    for field = 1, def.fieldCount do
+        local values = frame.values[field]
+        local held = columns[field]
+
+        for index = 1, count do
+            values[index] = held[frame.slots[index] ]
+        end
+
+        at = of.fields[field].whole (b, at, values, frame.at[field], count)
+    end
+
+    return at
+end
+
+-- A delta: the fields that changed, the slots they changed on, and the differences.
+function Sections.delta (of: Layout, b: buffer, pos: number, columns: Columns, was: History): number
+    local frame = of.frame
+    local chosen = frame.chosen
+    local count = frame.count
+
+    local at = of.set.write (b, opened (of, b, pos, DELTA), chosen)
+    at = spelled (of, b, at)
+
+    for place = 1, chosen.count do
+        if chosen.full[place] ~= COVERS then
+            at = of.presence.whole (b, at, frame.present[place] :: any, of.spare, count)
+        end
+
+        local field = chosen.fields[place]
+        local covered = gathered (frame, place, field, columns, count)
+
+        local one = of.fields[field]
+        local gain = one.gain
+        local values, answered = frame.values[field], frame.at[field]
+
+        if gain == nil then
+            at = one.whole (b, at, values, answered, covered)
+            continue
+        end
+
+        local base = was[field] :: { [number]: number }
+        at = gain (b, at, values, frame.under[place], base, answered, covered)
+    end
+
+    return at
+end
+
+--[[
+    A removal: the slots and nothing else, deliberately, since a cause would announce a record past
+    the audience that was meant to be the only thing that knew of it.
+]]
+function Sections.removal (of: Layout, b: buffer, pos: number): number
+    return spelled (of, b, opened (of, b, pos, REMOVAL))
+end
+
+-- A clear: the partition and nothing about it, which is the whole of what emptying one says.
+function Sections.clear (of: Layout, b: buffer, pos: number): number
+    return opened (of, b, pos, CLEAR)
+end
+
+-- Which kind of section is at this position and which partition it is about, and nothing else.
+function Sections.about (
+    of: Layout,
+    b: buffer,
+    pos: number,
+    ctx: Types.ValidateContext
+): (number, any)
+    local def = of.def
+    local held = of.held
+
+    def.head.read (b, pos, held)
+
+    local key = def.keyIndex
+    if key == nil then return held[2], nil end
+local
+_, value =def.fieldBuilt[key].read (b, pos + def.head.bytes, ctx)
+    return held[2], value
+end
+
+-- Whatever section is at this position, as its kind and the byte past it.
+function Sections.taken (
+    of: Layout,
+    b: buffer,
+    pos: number,
+    was: History,
+    ctx: Types.ValidateContext
+): (number, number)
+    local frame = of.frame
+    local def = of.def
+    local held = of.held
+
+    def.head.read (b, pos, held)
+    local kind = held[2]
+    local at = pos + def.head.bytes
+
+    local key = def.keyIndex
+    if key ~= nil then
+        at, frame.key = def.fieldBuilt[key].read (b, at, ctx)
+    end
+    if kind == CLEAR then return kind, at end
+
+    local chosen = frame.chosen
+    if kind == DELTA then at = of.set.read (b, at, chosen) end
+
+    local count
+    count, at = counted (b, at, if kind == KEYFRAME then PAIRED else LONE)
+    frame.count = count
+    at = listed (frame, b, at, count)
+    if kind == REMOVAL then return kind, at end
+
+    if kind == KEYFRAME then
+        for index = 1, count do
+            frame.ids[index], at = Varint.readSigned (b, at)
+        end
+
+        if #def.newestFields > 0 then
+            at = of.generations.back (b, at, frame.gens :: any, of.spare, count, ctx)
+        end
+
+        for field = 1, def.fieldCount do
+            at = of.fields[field].back (b, at, frame.values[field], frame.at[field], count, ctx)
+        end
+
+        return kind, at
+    end
+
+    for place = 1, chosen.count do
+        if chosen.full[place] ~= COVERS then
+            at = of.presence.back (b, at, frame.present[place] :: any, of.spare, count, ctx)
+        end
+
+        local covered = covering (frame, place, count)
+        local field = chosen.fields[place]
+
+        local one = of.fields[field]
+        local regain = one.regain
+        local values, answered = frame.values[field], frame.at[field]
+
+        if regain == nil then
+            at = one.back (b, at, values, answered, covered, ctx)
+            continue
+        end
+
+        local base = was[field] :: { [number]: number }
+        at = regain (b, at, values, frame.under[place], base, answered, covered)
+    end
+
+    return kind, at
+end
+
+return table.freeze (Sections)

package/state/Store.luau

@@ -0,0 +1,188 @@
+--!strict
+--!optimize 2
+-- One partition's truth: a slot per record, the columns a wire reads and the rows a caller does.
+
+local Compile = require (script.Parent.Parent.shape.Compile)
+local Heap = require (script.Parent.Parent.kernel.Heap)
+local Protocol = require (script.Parent.Parent.wire.Protocol)
+
+local Store = {}
+
+-- Constants -----------------------------------------------------------
+
+-- How far a slot's generation counts before it comes round, which is what two wire bits hold.
+const GENS = Protocol.NEWEST_GENS
+
+-- What a field's marker has to be for the field to keep a last-sent index rather than a baseline.
+const LATEST: Compile.Marker = "newest"
+
+-- Types ---------------------------------------------------------------
+
+-- A record as a caller reads one, which is the same table the callbacks are handed.
+export type Record = { [string]: any }
+
+--[[
+    One partition, held twice. `columns` is the wire's truth, one field across every slot, which a
+    section writes as one lookup and then array reads. `rows` is the caller's, one record under its
+    id at one lookup. One write fills both, which is why they cannot come apart. A slot is the
+    lowest free one, and what that costs is the generation a receiver tells a rebind by.
+]]
+export type Store = {
+    read def: Compile.Set,
+    read fields: number,
+    read columns: { { [number]: any } },
+    read rows: { [number]: Record },
+    read ids: { [number]: number },
+    read slotOf: { [number]: number },
+    read prev: { { [number]: number }? },
+    read sent: { { [number]: any }? },
+    read gens: { [number]: number }?,
+    read free: Heap.Heap,
+    high: number,
+    count: number,
+}
+
+-- Private -------------------------------------------------------------
+
+-- A slot nobody holds, and whether it has been held before.
+local function taken (of: Store): number
+    local gens = of.gens
+local _, held =Heap.pop (of.free)
+
+    if held ~= nil then
+        local slot = held :: number
+        if gens ~= nil then gens[slot] = (gens[slot] + 1) % GENS end
+        return slot
+    end
+
+    local slot = of.high + 1
+    of.high = slot
+    if gens ~= nil then gens[slot] = 0 end
+    return slot
+end
+
+-- Public --------------------------------------------------------------
+
+-- A partition, empty.
+function Store.new (of: Compile.Set): Store
+    local fields = of.fieldCount
+    local columns = table.create (fields) :: { { [number]: any } }
+    local prev = table.create (fields) :: { { [number]: number }? }
+    local sent = table.create (fields) :: { { [number]: any }? }
+
+    for index = 1, fields do
+        local built = of.fieldBuilt[index]
+        local newest = built.cell.marker == LATEST
+
+        columns[index] = {}
+        prev[index] = if built.grid ~= nil and not newest then {} else nil
+        sent[index] = if newest then {} else nil
+    end
+
+    return {
+        def = of,
+        fields = fields,
+        columns = columns,
+        rows = {},
+        ids = {},
+        slotOf = {},
+        prev = prev,
+        sent = sent,
+        gens = if #of.newestFields == 0 then nil else {},
+        free = Heap.new (),
+        high = 0,
+        count = 0,
+    }
+end
+
+-- A record under an id, at the slot it will keep until it is removed.
+function Store.bind (of: Store, id: number): number
+    local slot = taken (of)
+
+    of.ids[slot] = id
+    of.slotOf[id] = slot
+    of.rows[id] = table.clone (of.def.template)
+    of.count += 1
+
+    return slot
+end
+
+-- A record at the slot the other machine chose for it.
+function Store.hold (of: Store, id: number, slot: number)
+    if of.ids[slot] == nil then
+        of.count += 1
+    end
+
+    of.ids[slot] = id
+    of.slotOf[id] = slot
+    of.rows[id] = table.clone (of.def.template)
+
+    if slot > of.high then of.high = slot end
+end
+
+-- A record gone, and the slot it held.
+function Store.unbind (of: Store, id: number): number?
+    local slot = of.slotOf[id]
+    if slot == nil then return nil end
+
+    of.slotOf[id] = nil
+    of.ids[slot] = nil
+    of.rows[id] = nil
+    of.count -= 1
+
+    return slot
+end
+
+-- A slot back where the allocator finds it, which only the machine that hands them out does.
+function Store.spare (of: Store, slot: number) Heap.push (of.free, slot, slot) end
+
+--[[
+    One field of one record, in both of the places it is held.
+
+    Both at once: the column and the row are one fact written twice, and they stay one fact only
+    because nothing can write either alone.
+]]
+function Store.write (of: Store, slot: number, field: number, value: any)
+    of.columns[field][slot] = value
+
+    local id = of.ids[slot]
+    local row = of.rows[id]
+--[[
+        A row a caller has been handed is frozen in a development build, so this writes a copy
+        rather than raising on it. What the caller holds stays what they were told it was: the
+        record as it read at the moment they took it, and borrowed rather than live.
+    ]]
+    
+
+
+
+
+
+row[of.def.fieldNames[field] ] = value
+end
+
+-- A partition emptied, and every slot it handed out back at the beginning.
+function Store.clear (of: Store)
+    for index = 1, of.fields do
+        table.clear (of.columns[index])
+
+        local baseline = of.prev[index]
+        if baseline ~= nil then table.clear (baseline) end
+
+        local last = of.sent[index]
+        if last ~= nil then table.clear (last) end
+    end
+
+    local gens = of.gens
+    if gens ~= nil then table.clear (gens) end
+
+    table.clear (of.rows)
+    table.clear (of.ids)
+    table.clear (of.slotOf)
+
+    of.free.count = 0
+    of.high = 0
+    of.count = 0
+end
+
+return table.freeze (Store)