🥮 mooncakes.io

    mokomoking2501/lockwire/resource does not have a README file

    Container

    source
    pub struct Container {
      // private fields
    }

    Container::capacity

    source
    fn Container::capacity(self : Container) -> Int

    Container::get

    source
    fn Container::get(self : Container, amount? : Int) -> Bool

    Container::level

    source
    fn Container::level(self : Container) -> Int

    Container::name

    source
    fn Container::name(self : Container) -> String

    Container::new

    source
    fn Container::new(name~ : String, capacity~ : Int, init~ : Int) -> Container

    Container::put

    source
    fn Container::put(self : Container, amount? : Int) -> Unit

    PreemptiveResource

    source
    pub struct PreemptiveResource {
      // private fields
    }

    PreemptiveResource::available

    source
    fn PreemptiveResource::available(self : PreemptiveResource) -> Int

    PreemptiveResource::capacity

    source
    fn PreemptiveResource::capacity(self : PreemptiveResource) -> Int

    PreemptiveResource::check_deadlines

    source

    PreemptiveResource::events

    source

    PreemptiveResource::in_use

    source
    fn PreemptiveResource::in_use(self : PreemptiveResource) -> Int

    PreemptiveResource::max_queue_length

    source
    fn PreemptiveResource::max_queue_length(self : PreemptiveResource) -> Int

    PreemptiveResource::name

    source
    fn PreemptiveResource::name(self : PreemptiveResource) -> String

    PreemptiveResource::new

    source
    fn PreemptiveResource::new(name~ : String, capacity~ : Int) -> PreemptiveResource

    PreemptiveResource::queue_length

    source
    fn PreemptiveResource::queue_length(self : PreemptiveResource) -> Int

    PreemptiveResource::release

    source
    fn PreemptiveResource::release(self : PreemptiveResource, owner_id~ : String, at~ : 
    VTime    ) -> Bool

    PreemptiveResource::report

    source
    fn PreemptiveResource::report(self : PreemptiveResource, scenario~ : String, seed~ : Int) -> PreemptiveResourceReport

    PreemptiveResource::request

    source

    PreemptiveResource::trace_log

    source

    PreemptiveResourceEvent

    source
    pub(all) struct PreemptiveResourceEvent {
      id : Int
      kind : PreemptiveResourceEventKind
      resource_name : String
      owner_id : String
      priority : Int
      amount : Int
      vtime : 
    VTime
      note : String
    } derive(Eq, 
    Debug    )

    PreemptiveResourceEvent::to_trace_event

    source
    fn PreemptiveResourceEvent::to_trace_event(self : PreemptiveResourceEvent, seed~ : Int, backend? : 
    BackendProfile    , clock_domain? : String, node_id? : String, medium_id? : String) -> 
    TraceEvent

    PreemptiveResourceEventKind

    source
    pub(all) enum PreemptiveResourceEventKind {
      Grant
      Queue
      Preempt
      Interrupt
      Cancel
      DeadlineOverrun
      ResourceExhaustion
      Release
    } derive(Eq, 
    Debug    )

    PreemptiveResourceEventKind::code

    source

    PreemptiveResourceEventKind::label

    source

    PreemptiveResourceReport

    source
    pub(all) struct PreemptiveResourceReport {
      scenario : String
      seed : Int
      resource_name : String
      capacity : Int
      grant_count : Int
      queue_count : Int
      preemption_count : Int
      interrupt_count : Int
      cancel_count : Int
      deadline_overrun_count : Int
      resource_exhaustion_count : Int
      max_queue_length : Int
      active_count : Int
      trace : 
    TraceLog
      digest : 
    SimDigest
      real_os_scheduler : Bool
    } derive(
    Debug    )

    PreemptiveResourceReport::passes

    source

    PreemptiveResourceReport::to_text

    source

    PriorityResource

    source
    pub struct PriorityResource {
      // private fields
    }

    PriorityResource::new

    source
    fn PriorityResource::new(name~ : String, capacity~ : Int) -> PriorityResource

    PriorityResource::release

    source
    fn PriorityResource::release(self : PriorityResource, owner_id~ : String, at~ : 
    VTime    ) -> Bool

    PriorityResource::report

    source
    fn PriorityResource::report(self : PriorityResource, scenario~ : String, seed~ : Int) -> PreemptiveResourceReport

    PriorityResource::request

    source

    PriorityResourceLease

    source
    pub(all) struct PriorityResourceLease {
      resource_name : String
      owner_id : String
      amount : Int
      priority : Int
      granted_at : 
    VTime
      deadline : 
    VTime    ?
      preemptible : Bool
    } derive(Eq, 
    Debug    )

    PriorityResourceRequest

    source
    pub(all) struct PriorityResourceRequest {
      owner_id : String
      priority : Int
      amount : Int
      deadline : 
    VTime    ?
      preemptible : Bool
    } derive(Eq, 
    Debug    )

    PriorityResourceRequest::make

    source
    fn PriorityResourceRequest::make(owner_id~ : String, priority~ : Int, amount? : Int, deadline? : 
    VTime    , preemptible? : Bool) -> PriorityResourceRequest

    Resource

    source
    pub struct Resource {
      // private fields
    }

    Resource::available

    source
    fn Resource::available(self : Resource) -> Int

    Resource::capacity

    source
    fn Resource::capacity(self : Resource) -> Int

    Resource::in_use

    source
    fn Resource::in_use(self : Resource) -> Int

    Resource::max_queue_length

    source
    fn Resource::max_queue_length(self : Resource) -> Int

    Resource::name

    source
    fn Resource::name(self : Resource) -> String

    Resource::new

    source
    fn Resource::new(name~ : String, capacity~ : Int) -> Resource

    Resource::preempt

    source
    fn Resource::preempt(self : Resource, env : 
    SimEnv    , amount? : Int) -> Unit

    Resource::preemption_count

    source
    fn Resource::preemption_count(self : Resource) -> Int

    Resource::queue_length

    source
    fn Resource::queue_length(self : Resource) -> Int

    Resource::release

    source

    Resource::request

    source

    Resource::snapshot

    source
    fn Resource::snapshot(self : Resource) -> ResourceSnapshot

    ResourceLease

    source
    pub(all) struct ResourceLease {
      resource_name : String
      amount : Int
      granted_at : 
    VTime
    } derive(Eq, 
    Debug    )

    ResourceSnapshot

    source
    pub(all) struct ResourceSnapshot {
      name : String
      capacity : Int
      in_use : Int
      queue_length : Int
      max_queue_length : Int
      preemption_count : Int
    } derive(Eq, 
    Debug    )

    ResourceSnapshot::to_trace_event

    source
    fn ResourceSnapshot::to_trace_event(self : ResourceSnapshot, event_id~ : Int, vtime~ : 
    VTime    , clock_domain~ : String, node_id~ : String, medium_id~ : String, seed~ : Int, rng_step~ : Int, backend~ : 
    BackendProfile    ) -> 
    TraceEvent

    Store

    source
    pub struct Store[T] {
      // private fields
    }

    Store::capacity

    source
    fn[T] Store::capacity(self : Store[T]) -> Int

    Store::get

    source
    fn[T] Store::get(self : Store[T]) -> T?

    Store::len

    source
    fn[T] Store::len(self : Store[T]) -> Int

    Store::name

    source
    fn[T] Store::name(self : Store[T]) -> String

    Store::new

    source
    fn[T] Store::new(name~ : String, capacity~ : Int) -> Store[T]

    Store::put

    source
    fn[T] Store::put(self : Store[T], item : T) -> Bool

    package_id

    source
    fn package_id() -> String

    preemptive_resource_contention_fixture

    source
    fn preemptive_resource_contention_fixture(seed? : Int) -> PreemptiveResourceReport

    Source Files

    Powered by MoonBit

    Site sourceReport issueModulesSkillsBuild queueStatistics

    © 2026 mooncakes.io