enum connection_flags: sys::u32
  • save_upstream_kernels = 1<<0
  • save_downstream_kernels = 1<<1
  • write_transaction_log = 1<<2
class sbn::connection
Derived classes
Types
  • using connection_ptr = std::shared_ptr< connection >
  • using time_point = clock_type::time_point
  • using duration = clock_type::duration
  • using clock_type = std::chrono::system_clock
  • using flag = connection_flags
Enumerations
  • enum states
Structs
  • struct sbn::connection::flush_guard
Fields
Methods
  • ensure_has_id(kernel * k) -> voidprotected
  • generate_new_id(kernel * k) -> voidprotected
  • template <class ... Args>
    log(const Args &... args) const -> voidprotected
  • template <class Source>
    fill(Source & source) -> voidprotected
  • template <class Sink>
    flush(Sink & sink) -> voidprotected
  • read_kernel() -> kernel_ptrprotectedvirtual
  • write_kernel(const kernel * k) -> voidprotectedvirtual
  • receive_foreign_kernel(kernel_ptr && fk) -> voidprotectedvirtual
  • receive_kernel(kernel_ptr && k) -> voidprotectedvirtual
  • recover_kernels(bool downstream) -> voidprotected
  • do_forward(kernel_ptr k) -> kernel_ptrprotected
  • write(std::ostream & out) const -> voidvirtual
  • load() -> weight_array &
  • load() const -> const weight_array &

    The first element is the number of kernels with maximum weight. These kernels use all threads of the cluster node. The second element is the number of kernels that were sent to the client, but have not returned yet.

  • min_output_buffer_size(size_t rhs) -> void
  • min_input_buffer_size(size_t rhs) -> void
  • downstream() const -> const kernel_queue &
  • upstream() const -> const kernel_queue &
  • state(states rhs) -> void
  • state() const -> states
  • name(const char * rhs) -> void
  • name() const -> const char *
  • attempts() const -> sys::u32
  • types(kernel_type_registry * rhs) -> void
  • flags() const -> flag
  • flags(flag rhs) -> void
  • isset(flag rhs) -> bool
  • unsetf(flag rhs) -> void
  • setf(flag rhs) -> void
  • socket_address(const sys::socket_address & rhs) -> void
  • socket_address() const -> const sys::socket_address &
  • parent(basic_socket_pipeline * rhs) -> void
  • parent() const -> basic_socket_pipeline *
  • has_start_time_point() const -> bool
  • start_time_point(time_point rhs) -> void
  • start_time_point() const -> time_point
  • stop() -> voidvirtual
  • flush() -> voidvirtual
  • activate(const connection_ptr & self) -> voidvirtual
  • deactivate(const connection_ptr & self) -> voidvirtual
  • retry(const connection_ptr & self) -> voidvirtual
  • remove(const connection_ptr & self) -> voidvirtual
  • add(const connection_ptr & self) -> voidvirtual
  • handle(const sys::epoll_event & event) -> voidvirtual
  • receive_kernels() -> void
  • clear(kernel_sack & sack) -> void
  • forward(kernel_ptr k) -> void
  • send(kernel_ptr & k) -> void

    The kernel is deleted if it goes downstream and does not carry its parent.

  • operator=(connection &&) -> connection &
  • connection(connection &&)
  • operator=(const connection &) -> connection &
  • connection(const connection &)
  • ~connection()virtual
  • connection()
operator<<(std::ostream & out, connection::states rhs) -> std::ostream &
to_string(connection::states rhs) -> const char *
operator<<(std::ostream & out, const connection::connection_ptr & rhs) -> std::ostream &
operator<<(std::ostream & out, const connection * rhs) -> std::ostream &
template <class Queue>
find_kernel(const sbn::kernel * a, const Queue & queue) -> Queue::const_iterator
operator<<(std::ostream & out, const connection & rhs) -> std::ostream &