README

mokomoking2501/lockwire/resource does not have a README file

#
Container

pub struct Container {
// private fields
}

#
Container::capacity

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

#
Container::get

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

#
Container::level

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

#
Container::name

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

#
Container::new

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

#
Container::put

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

#
PreemptiveResource

pub struct PreemptiveResource {
// private fields
}

#
PreemptiveResource::available

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

#
PreemptiveResource::capacity

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

#
PreemptiveResource::check_deadlines

#
PreemptiveResource::events

#
PreemptiveResource::in_use

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

#
PreemptiveResource::max_queue_length

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

#
PreemptiveResource::name

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

#
PreemptiveResource::new

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

#
PreemptiveResource::queue_length

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

#
PreemptiveResource::release

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

#
PreemptiveResource::report

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

#
PreemptiveResource::trace_log

#
PreemptiveResourceEvent

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

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

#
PreemptiveResourceEventKind

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

#
PreemptiveResourceEventKind::code

#
PreemptiveResourceEventKind::label

#
PreemptiveResourceReport

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

#
PreemptiveResourceReport::to_text

#
PriorityResource

pub struct PriorityResource {
// private fields
}

#
PriorityResource::new

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

#
PriorityResource::release

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

#
PriorityResource::report

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

#
PriorityResourceLease

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

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

#
PriorityResourceRequest::make

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

#
Resource

pub struct Resource {
// private fields
}

#
Resource::available

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

#
Resource::capacity

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

#
Resource::in_use

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

#
Resource::max_queue_length

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

#
Resource::name

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

#
Resource::new

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

#
Resource::preempt

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

#
Resource::preemption_count

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

#
Resource::queue_length

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

#
Resource::release

#
Resource::snapshot

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

#
ResourceLease

pub(all) struct ResourceLease {
resource_name : String
amount : Int
granted_at :
VTime

} derive(Eq,
Debug
)

#
ResourceSnapshot

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

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

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

#
Store::capacity

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

#
Store::get

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

#
Store::len

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

#
Store::name

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

#
Store::new

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

#
Store::put

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

#
package_id

fn package_id() -> String

#
preemptive_resource_contention_fixture

fn preemptive_resource_contention_fixture(seed? : Int) -> PreemptiveResourceReport