libxtc/api/evt__ext_8h_source.html

/* DO NOT EDIT: automatically built by dist/s_include. */

/* See M0_CLAIMS.md [T2]. */


#ifndef EVT_EXT_H

#define EVT_EXT_H


int  xtc_exec_get_eager_rebalance __P((xtc_exec_t *));

int  xtc_exec_get_service_mode __P((xtc_exec_t *));

int  xtc_exec_get_steal_backoff __P((xtc_exec_t *));

int __xtc_coro_preempt __P((void *));

int __xtc_coro_preempt_effective __P((void));

int __xtc_sim_active __P((void));

int __xtc_sim_io_corrupt_active __P((void));

int __xtc_sim_io_enospc __P((void));

int __xtc_sim_io_faults_active __P((void));

int __xtc_sim_io_flip_byte __P((int));

int __xtc_sim_io_should_fault __P((void));

int __xtc_sim_io_stale_read __P((int, uint64_t, void *, int));

int __xtc_sim_io_torn_prefix __P((int));

int __xtc_sim_partition_blocked __P((int, int));

int __xtc_sim_run_consistency_check __P((void));

int __xtc_sim_sched_pessimal_pct __P((void));

int __xtc_sim_swizzle_pct __P((void));

int __xtc_sim_vclock __P((int64_t *));

int __xtc_sim_vclock_observed __P((int64_t *));

int xtc_async __P((xtc_loop_t *, xtc_coro_fn, void *, xtc_task_t **));

int xtc_await __P((xtc_task_t *, intptr_t *));

int xtc_exec_async __P((xtc_exec_t *, xtc_coro_fn, void *, xtc_task_t **));

int xtc_exec_async_on __P((xtc_exec_t *, int, xtc_coro_fn, void *, xtc_task_t **));

int xtc_exec_class_create __P((xtc_loop_t *, int, int64_t, xtc_exec_class_t *));

int xtc_exec_class_shares __P((xtc_exec_class_t));

int xtc_exec_fini __P((xtc_exec_t *));

int xtc_exec_init __P((xtc_exec_t **, int));

int xtc_exec_loop_id __P((void));

int xtc_exec_loop_stats __P((xtc_exec_t *, int, xtc_loop_stats_t *));

int xtc_exec_n_loops __P((xtc_exec_t *));

int xtc_exec_run __P((xtc_exec_t *));

int xtc_exec_set_preempt __P((xtc_exec_t *, int64_t));

int xtc_exec_spawn __P((xtc_exec_t *, xtc_task_fn, void *, xtc_task_t **));

int xtc_exec_spawn_on __P((xtc_exec_t *, int, xtc_task_fn, void *, xtc_task_t **));

int xtc_exec_stop __P((xtc_exec_t *));

int xtc_loop_fini __P((xtc_loop_t *));

int xtc_loop_init __P((xtc_loop_t **));

int xtc_loop_run __P((xtc_loop_t *));

int xtc_loop_stop __P((xtc_loop_t *));

int xtc_loop_wake __P((xtc_loop_t *));

int xtc_shard_count __P((void));

int xtc_shard_id __P((void));

int xtc_sim_buggify __P((const char *));

int xtc_sim_buggify_active_count __P((void));

int xtc_sim_buggify_fault __P((unsigned));

int xtc_sim_buggify_reached_count __P((void));

int xtc_sim_buggify_site __P((int, char *, size_t, int *));

int xtc_sim_check __P((xtc_exec_t *));

int xtc_sim_exec_run __P((xtc_exec_t *, uint64_t, long));

int xtc_sim_fault __P((unsigned));

int xtc_sim_fault_point __P((const char *));

int xtc_sim_fault_points_seen __P((void));

int xtc_sim_nondeterminism_count __P((void));

int xtc_task_park_on_fd __P((xtc_task_t *, int, uint32_t));

int xtc_task_park_on_timer __P((xtc_task_t *, int64_t));

int xtc_task_spawn __P((xtc_loop_t *, xtc_task_fn, void *, xtc_task_t **));

int xtc_task_waker __P((xtc_task_t *, xtc_waker_t *));

int xtc_timer_cancel __P((xtc_timer_t *));

int xtc_timer_set __P((xtc_loop_t *, int64_t, xtc_timer_fn, void *, xtc_timer_t **));

int xtc_waker_wake __P((const xtc_waker_t *));

int xtc_yield_check __P((void));

int xtc_yield_if_due __P((void));

int64_t __xtc_sim_io_latency __P((void));

int64_t __xtc_sim_net_latency __P((void));

int64_t xtc_exec_class_latency __P((xtc_exec_class_t));

struct xtc_res *xtc_loop_res __P((xtc_loop_t *));

uint64_t __xtc_sim_rng __P((int));

uint64_t __xtc_sim_rng_range __P((int, uint64_t));

uint64_t xtc_exec_class_runs __P((xtc_exec_class_t));

uint64_t xtc_exec_class_vruntime __P((xtc_exec_class_t));

uint64_t xtc_loop_stall_count __P((const xtc_loop_t *));

uint64_t xtc_sim_fault_point_fires __P((const char *));

uint64_t xtc_sim_io_durable_end __P((int));

uint64_t xtc_sim_state_hash __P((xtc_exec_t *));

uint64_t xtc_yield_due_count __P((const xtc_loop_t *));

void __xtc_sim_io_stale_record __P((int, uint64_t, const void *, int));

void __xtc_sim_io_wb_synced __P((int));

void __xtc_sim_io_wb_wrote __P((int, uint64_t));

void __xtc_sim_nondeterminism __P((const char *));

void __xtc_task_free __P((xtc_task_t *));

void xtc_exec_set_eager_rebalance __P((xtc_exec_t *, int));

void xtc_exec_set_service_mode __P((xtc_exec_t *, int));

void xtc_exec_set_stall_budget __P((xtc_exec_t *, int64_t));

void xtc_exec_set_steal_backoff __P((xtc_exec_t *, int));

void xtc_loop_set_stall_budget __P((xtc_loop_t *, int64_t));

void xtc_loop_set_stall_cb __P((xtc_loop_t *, xtc_stall_cb, void *));

void xtc_sim_activate __P((uint64_t));

void xtc_sim_buggify_disable __P((void));

void xtc_sim_buggify_enable __P((unsigned));

void xtc_sim_clock_advance __P((int64_t));

void xtc_sim_clock_disable __P((void));

void xtc_sim_clock_enable __P((int64_t));

void xtc_sim_clock_set __P((int64_t));

void xtc_sim_clock_skew __P((int64_t, int));

void xtc_sim_deactivate __P((void));

void xtc_sim_fault_points_disable __P((void));

void xtc_sim_fault_points_enable __P((unsigned));

void xtc_sim_io_corrupt_disable __P((void));

void xtc_sim_io_corrupt_enable __P((unsigned));

void xtc_sim_io_enospc_enable __P((unsigned));

void xtc_sim_io_faults_disable __P((void));

void xtc_sim_io_faults_enable __P((int64_t, int64_t, unsigned));

void xtc_sim_io_stale_enable __P((unsigned));

void xtc_sim_io_wb_enable __P((int));

void xtc_sim_net_latency __P((int64_t, int64_t));

void xtc_sim_partition_clear __P((void));

void xtc_sim_partition_isolate __P((int));

void xtc_sim_partition_set __P((int, int, int));

void xtc_sim_sched_pessimal __P((unsigned));

void xtc_sim_set_consistency_check __P((xtc_sim_consistency_fn, void *));

void xtc_sim_strict __P((int));

void xtc_sim_swizzle_disable __P((void));

void xtc_sim_swizzle_enable __P((unsigned));

void xtc_yield __P((void));

void xtc_yield_set_budget __P((xtc_loop_t *, int64_t));

xtc_loop_t *xtc_exec_loop __P((xtc_exec_t *, int));


#endif /* EVT_EXT_H */

xtc_loop_stats_t
Definition xtc_exec.h:178

xtc_waker_t
Definition xtc_loop.h:44