_init_kp_message140%

function

struct cmsghdr *

_init_kp_message(m, buf, bufsize)

kp_chfd100%

function

int

kp_chfd(kp, op, delta)

kp_chfl100%

function

int

kp_chfl(kp, op, delta)

kp_receive230%

function

int

kp_receive(kp, buf, size)

kp_transmit220%

function

int

kp_transmit(kp, buf, size)

kp_accept240%

function

int

kp_accept(kp, buf, size)

Regular socket accept from listening sockets.

kp_alloc_meta170%

function

int

kp_alloc_meta(kp, buf, size)

Allocate kport_t pairs capable of transmitting and receiving other kernel ports.

kp_alloc_bidirectional170%

function

int

kp_alloc_bidirectional(kp, buf, size)

kp_alloc_unidirectional170%

function

int

kp_alloc_unidirectional(kp, buf, size)

ev_type_name70%

function

const char *

ev_type_name(etyp)

ev_type_code20%

function

enum EventType

ev_type_code(n)

evs_type_name10%

function

int

evs_type_name(evs, typname)

evs_type_identifier10%

function

const char *

evs_type_identifier(evs)

ln_hash30%

function

Py_hash_t

ln_hash(ln)

ln_richcompare90%

function

PyObj

ln_richcompare(ln, operand, cmpop)

ln_call80%

function

PyObj

ln_call(ln, args, kw)

ln_clear70%

function

void

ln_clear(ln)

ln_traverse70%

function

int

ln_traverse(self, visit, arg)

ln_new90%

function

PyObj

ln_new(typ, args, kw)

ln_dealloc20%

function

void

ln_dealloc(ln)

Link_Create90%

function

PyObj

Link_Create(typ, ctx, ev, task)

kports_alloc110%

function

KPorts

kports_alloc(fill, length)

kports_create90%

function

KPorts

kports_create(data, length)

kp_close80%

function

PyObj

kp_close(self)

kernel.Ports.close

kp_configure210%

function

PyObj

kp_configure(self)

kp_allocate130%

function

PyObj

kp_allocate(subtype, length)

kernel.Ports.allocate

kports_richcompare340%

function

PyObj

kports_richcompare(self, x, op)

kports_length20%

function

Py_ssize_t

kports_length(self)

kernel.Ports.__len__

kports_concat140%

function

PyObj

kports_concat(self, x)

kernel.Ports.__concat__

kports_repeat120%

function

PyObj

kports_repeat(self, quantity)

kernel.Ports.__repeat__

kports_getitem70%

function

PyObj

kports_getitem(self, index)

kernel.Ports.__getitem__

kports_setitem120%

function

int

kports_setitem(self, index, val)

kernel.Ports.__setitem__

kports_subscript340%

function

PyObj

kports_subscript(self, item)

kernel.Ports.__getitem__

kports_getbuffer30%

function

int

kports_getbuffer(self, view, flags)

kports_new570%

function

PyObj

kports_new(subtype, args, kw)

kernel.Ports.__new__

kports_dealloc20%

function

void

kports_dealloc(self)

taskq_extend120%

function

int

taskq_extend(tq)

Append a memory allocation to the task queue.

taskq_insert10%

function

int

taskq_insert(tq, callable)

Insert task at the end of the queue. Presume available space.

taskq_enqueue70%

function

int

taskq_enqueue(tq, callable)

High-level append.

trap_execution_error320%

function

void

trap_execution_error(errctl, errctx, task)

Handle error cases using errctl and PyErr_WriteUnraisable when it or other critical operations fail.

taskq_continue100%

function

int

taskq_continue(tq)

Pop segments from TaskQueue.q_executing.

taskq_cycle60%

function

int

taskq_cycle(tq)

taskq_execute220%

function

int

taskq_execute(tq, errctl, errctx)

Execute the tasks in the TaskQueue.q_executing, and rotate TaskQueue.q_loading for the next cycle.

taskq_clear250%

function

void

taskq_clear(tq)

Release all objects held by the queue.

taskq_traverse260%

function

int

taskq_traverse(tq, visit, arg)

Container traversal for GC support.

taskq_initialize140%

function

int

taskq_initialize(tq)

Initialize the given, already allocated, task queue.

get_hostname

function

PyObj

get_hostname(mod)

get_uname80%

function

PyObj

get_uname(mod)

get_clock_ticks20%

function

PyObj

get_clock_ticks(mod)

set_process_title20%

function

PyObj

set_process_title(mod, title)

prepare10%

function

void

prepare()

_after_fork_parent60%

function

int

_after_fork_parent(pc_param)

Execute the process._after_fork_parent object from a pending call.

parent80%

function

void

parent()

_after_fork_child60%

function

int

_after_fork_child(pc_param)

Execute the process._after_fork_child object from a pending call.

child70%

function

void

child()

Synchronize with the parent process.

ltracefunc10%

function

int

ltracefunc(ob, f, event, arg)

trace10%

function

PyObj

trace(self, args)

Set the trace object on a set of threads. Only supports callable-object level. This is intended for debuggers.

_exit_by_signal50%

function

void

_exit_by_signal()

Executed in atexit in order to preserve the signal's exit code.

signalexit100%

function

PyObj

signalexit(mod, ob)

Register low-level atexit handler for exiting via a signal.

kport_clear_cloexec220%

function

PyObj

kport_clear_cloexec(mod, seq)

Ensure that the kport is preserved across process images. Used by system to hold on to listening sockets.

Generally, most file descriptors created by system will have the FD_CLOEXEC flag set.

kport_set_cloexec220%

function

PyObj

kport_set_cloexec(mod, seq)

k_initialize120%

function

PyObj

k_initialize(mod, ctx)

signal_string

function

const char *

signal_string(sig)

kernelq_clear

function

void

kernelq_clear(kq)

kernelq_traverse50%

function

int

kernelq_traverse(kq, visit, arg)

kernelq_reference_update100%

function

int

kernelq_reference_update(kq, ln, current)

Replace the link in the reference dictionary, but return the existing object if any.

kernelq_reference_delete100%

function

int

kernelq_reference_delete(kq, ev)

kernelq_cyclic_event190%

function

int

kernelq_cyclic_event(kq, cyclic, ln, kev)

Set or clear the cyclic flag on ln or raise an error if it's not acceptable for the given filter.

kernelq_transition390%

function

int

kernelq_transition(kq, tq)

kernelq_cancel330%

function

PyObj

kernelq_cancel(kq, ev)

inv_spawn810%

function

PyObj

inv_spawn(self, args, kw)

inv_new1280%

function

PyObj

inv_new(subtype, args, kw)

inv_dealloc180%

function

void

inv_dealloc(self)

ev_time_units

function

int

ev_time_units(ev, args, kw)

Initialize an event for scheduling a timer.

ev_pid_reference140%

function

int

ev_pid_reference(ev, args, kw)

Initialize an event with a process identifier and optional port.

ev_signal_reference150%

function

int

ev_signal_reference(ev, args, kw)

Initialize an event with a signal code and optional port.

ev_reference80%

function

int

ev_reference(ev, args, kw)

Initialize an event with an arbitrary reference.

ev_filesystem_reference200%

function

int

ev_filesystem_reference(ev, args, kw)

Initialize an event with a filesystem Path. Monitoring events(fs_delta, fs_void, fs_status).

ev_io_reference90%

function

int

ev_io_reference(ev, args, kw)

Initialize an event with a pair of kport_t.

ev_constructor440%

function

PyObj

ev_constructor(typ, typstring)

ev_get_type40%

function

PyObj

ev_get_type(ev, closure)

ev_get_port40%

function

PyObj

ev_get_port(ev, closure)

ev_get_source60%

function

PyObj

ev_get_source(ev, closure)

ev_hash360%

function

Py_hash_t

ev_hash(ev)

ev_richcompare710%

function

PyObj

ev_richcompare(ev, operand, cmpop)

ev_new280%

function

PyObj

ev_new(typ, args, kw)

Copy Event. Type specific constructors must be used to create new instances.

ev_release180%

function

void

ev_release(ev)

ev_clear60%

function

void

ev_clear(ev)

ev_traverse60%

function

int

ev_traverse(self, visit, arg)

ev_dealloc30%

function

void

ev_dealloc(ev)

interrupt_wait90%

function

int

interrupt_wait(ks)

Interrupt a running kernel.Scheduler.wait call.

ks_enqueue150%

function

PyObj

ks_enqueue(ks, callable)

kernel.Scheduler.enqueue

ks_execute260%

function

PyObj

ks_execute(self)

kernel.Scheduler.execute

ks_termination250%

function

int

ks_termination(ks, kq, tq)

ks_close190%

function

PyObj

ks_close(self)

kernel.Scheduler.close

ks_void30%

function

PyObj

ks_void(self)

kernel.Scheduler.void

ks_interrupt120%

function

PyObj

ks_interrupt(self)

kernel.Scheduler.interrupt

ks_dispatch320%

function

PyObj

ks_dispatch(self, args, kw)

kernel.Scheduler.dispatch

ks_cancel250%

function

PyObj

ks_cancel(self, ref)

kernel.Scheduler.cancel

ks_operations20%

function

PyObj

ks_operations(self)

kernel.Scheduler.operations

ks__set_waiting20%

function

PyObj

ks__set_waiting(self)

ks_wait250%

function

PyObj

ks_wait(self, args)

kernel.Scheduler.wait

ks_get_closed60%

function

PyObj

ks_get_closed(self, closure)

ks_get_has_tasks60%

function

PyObj

ks_get_has_tasks(self, closure)

ks_traverse110%

function

int

ks_traverse(self, visit, arg)

ks_clear40%

function

int

ks_clear(self)

ks_dealloc50%

function

void

ks_dealloc(self)

kernel.Scheduler.__del__

ks_new250%

function

PyObj

ks_new(subtype, args, kw)

kernel.Scheduler.__new__

fs_event_open40%

function

kport_t

fs_event_open(path, ev_type)

ev_type is ignored here as the subevent set is determined by kernelq_identify.

kernelq_delta360%

function

int

kernelq_delta(kq, ctl, kp, event)

kernelq_identify720%

function

int

kernelq_identify(kev, evs)

Interpret event_t for use with a kqueue filter.

kernelq_interrupt40%

function

int

kernelq_interrupt(kq)

Called by kernel.Scheduler.interrupt.

kernelq_interrupt_accept10%

function

int

kernelq_interrupt_accept(kq)

Nothing to do for kqueue.

kernelq_interrupt_setup60%

function

int

kernelq_interrupt_setup(kq)

kevent_set_timer60%

function

void

kevent_set_timer(kev, ns)

kernelq_schedule440%

function

int

kernelq_schedule(kq, cyclic, ln)

Establish the link with the kernel event.

kernelq_default_flags50%

function

int

kernelq_default_flags(kq)

kernelq_initialize190%

function

int

kernelq_initialize(kq)

kernelq_close70%

function

int

kernelq_close(kq)

Close the event queue kernel resources.

kernelq_receive180%

function

int

kernelq_receive(kq, seconds, ns)

Receive events from the kernel. Retry logic is not desired here as the event loop will naturally try again.

pkevent10%

function

void

pkevent(kev)