Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-prism

Source of release 0.6.1

0.6.1 / tests / compatibility / cache.lucb

from luce_prism import prism
import interop
import memory

struct Producer:
    var calls: usize
    var throws: bool
    var close_cache: prism.ValueCache*?

    pub func produce(key: prism.EvalKey) -> interop.Outcome[interop.Reference[prism.Value]]:
        self.calls += 1
        if let cache = self.close_cache:
            cache.close()
        if self.throws:
            return interop.Outcome[interop.Reference[prism.Value]].failure(prism.invalid, interop.Owned[str]("producer failed"))
        let result = prism.Value.number((f64)self.calls * 10.0) catch failure:
            return interop.Outcome[interop.Reference[prism.Value]].failure(failure.code, interop.Owned[str]("value allocation failed"))
        return interop.Outcome[interop.Reference[prism.Value]].success(interop.Owned[interop.Reference[prism.Value]](result, &result.owner.header))

    pub func close():
        self.close_cache = none

let producer_type = interop.Type[Producer]("Cache test producer", Producer.close, closeable = true)

func produce(producer: interop.Reference[Producer]) -> interop.Callback[prism.EvalKey, interop.Reference[prism.Value]]!:
    return try interop.Callback[prism.EvalKey, interop.Reference[prism.Value]].bind_mutating(producer, Producer.produce)

func number(cache: prism.ValueCache*, key: prism.EvalKey, producer: interop.Callback[prism.EvalKey, interop.Reference[prism.Value]]) -> f64!:
    let result = try cache.evaluate(key, producer)
    defer result.release()
    return try result.value().number_at()

func evalcache_hit_and_miss() -> !:
    let owner = try interop.Reference[Producer].adopt(try new Producer() in memory.heap, producer_type, memory.heap)
    defer owner.release()
    let callback = try produce(owner)
    defer callback.release()
    var cache = prism.ValueCache()
    defer cache.close()
    assert(try number(&cache, prism.EvalKey(1, 0.0), callback) == 10.0)
    assert(try number(&cache, prism.EvalKey(1, 0.0), callback) == 10.0 and owner.value().calls == 1)
    assert(cache.valid(prism.EvalKey(1, 0.0)))
    assert(try number(&cache, prism.EvalKey(2, 0.0), callback) == 20.0)
    assert(not cache.valid(prism.EvalKey(1, 0.0)))
    assert(try number(&cache, prism.EvalKey(2, 1.0), callback) == 30.0)
    cache.invalidate()
    assert(not cache.valid(prism.EvalKey(2, 1.0)))
    assert(try number(&cache, prism.EvalKey(2, 1.0), callback) == 40.0 and owner.value().calls == 4)

func evalcache_fresh_is_not_a_phantom_hit() -> !:
    let owner = try interop.Reference[Producer].adopt(try new Producer() in memory.heap, producer_type, memory.heap)
    defer owner.release()
    let callback = try produce(owner)
    defer callback.release()
    var cache = prism.ValueCache()
    defer cache.close()
    assert(not cache.valid(prism.EvalKey()))
    assert(try number(&cache, prism.EvalKey(), callback) == 10.0)
    assert(owner.value().calls == 1 and cache.valid(prism.EvalKey()))

func evalcache_throwing_producer_leaves_prior_entry_intact() -> !:
    let owner = try interop.Reference[Producer].adopt(try new Producer() in memory.heap, producer_type, memory.heap)
    defer owner.release()
    let callback = try produce(owner)
    defer callback.release()
    var cache = prism.ValueCache()
    defer cache.close()
    assert(try number(&cache, prism.EvalKey(1, 0.0), callback) == 10.0)
    owner.value().throws = true
    var failed = false
    _ = number(&cache, prism.EvalKey(2, 0.0), callback) catch failure:
        failed = true
        recover 0.0
    assert(failed and cache.valid(prism.EvalKey(1, 0.0)))
    assert(try number(&cache, prism.EvalKey(1, 0.0), callback) == 10.0)
    assert(owner.value().calls == 2)

pub func run() -> !:
    try evalcache_hit_and_miss()
    try evalcache_fresh_is_not_a_phantom_hit()
    try evalcache_throwing_producer_leaves_prior_entry_intact()
    try close_during_production()
    print("PASS 3 legacy evaluation-cache cases and owned callback result lifetime")

func close_during_production() -> !:
    let cache = try interop.Reference[prism.ValueCache].adopt(try new prism.ValueCache() in memory.heap, prism.value_cache_type, memory.heap)
    defer cache.release()
    let owner = try interop.Reference[Producer].adopt(try new Producer() in memory.heap, producer_type, memory.heap)
    defer owner.release()
    owner.value().close_cache = cache.value()
    let callback = try produce(owner)
    defer callback.release()
    assert(try number(cache.value(), prism.EvalKey(1, 0.0), callback) == 10.0)
    assert(not cache.value().valid(prism.EvalKey(1, 0.0)))

pub func allocation_case() -> !:
    try evalcache_hit_and_miss()
    try close_during_production()