template <class T>
using pointer = std::unique_ptr< T >
enum kernel_field: sys::u8
  • source = 1<<0
  • destination = 1<<1
  • source_application = 1<<2
  • target_application = 1<<3
  • node_filter = 1<<4
class sbn::kernel
Base classes
Derived classes
Types
  • using fields = kernel_field
  • using resource_expression_ptr = resources::expression_ptr
  • using resource_expression = resources::Expression
  • using weight_type = uint32_t
  • template <class T>
    using pointer = ::sbn::pointer< T >
  • using id_type = uint64_t
Enumerations
  • enum phases: sys::u8
Fields
  • size_t _pipeline_index
  • pipeline * _source_pipeline
  • kernel_ptr * _this_ptr
  • kernel_type::id_type _type_id
  • id_type _principal_id
  • kernel * _principal
  • id_type _parent_id
  • kernel * _parent
  • application * _target_application
  • application::id_type _target_application_id
  • application * _source_application
  • application::id_type _source_application_id
  • constexpr const auto max_weight
Methods
  • this_ptr() const -> const kernel_ptr &protected
  • this_ptr() -> kernel_ptr &protected
  • this_ptr(kernel_ptr * rhs) -> void
  • point_to_point(kernel::id_type id) -> void
  • point_to_point(kernel * k) -> void
  • return_to_parent() -> void
  • return_to_parent(exit_code ret) -> void

    New API.

  • pipeline_index(size_t rhs) -> void
  • pipeline_index() const -> size_t
  • mark_as_deleted(kernel_sack & result) -> voidvirtual

    Garbage-collect.

  • rollback() -> voidvirtual

    Undo the side effects caused by failed execution of the kernel.

  • react(kernel_ptr && child) -> voidvirtual

    Collects the output from the task from subordinate kernel child.

  • act() -> voidvirtual

    Performs the task or launches subordinate kernels to do so.

  • write(kernel_buffer & out) const -> voidvirtual
  • read(kernel_buffer & in) -> voidvirtual
  • hash() const -> size_t
  • parent_id(id_type rhs) -> void
  • parent_id() const -> id_type
  • parent(kernel * rhs) -> void
  • has_parent() const -> bool
  • parent() -> kernel *
  • parent() const -> const kernel *
  • principal_id(id_type id) -> void
  • principal_id() const -> id_type
  • principal(kernel * rhs) -> void
  • principal() -> kernel *
  • principal() const -> const kernel *
  • swap_header(kernel * k) -> void
  • read_header(kernel_buffer & in) -> void
  • write_header(kernel_buffer & out) const -> void
  • target_application(application * rhs) -> void
  • target_application() -> application *
  • target_application() const -> const application *
  • source_application(application * rhs) -> void
  • source_application() -> application *
  • source_application() const -> const application *
  • is_native() const -> boolvirtual
  • is_foreign() const -> bool
  • target_application_id(application::id_type rhs) -> void
  • target_application_id() const -> application::id_type
  • source_application_id(application::id_type rhs) -> void
  • source_application_id() const -> application::id_type
  • destination(const sys::socket_address & rhs) -> void
  • source(const sys::socket_address & rhs) -> void
  • destination() const -> const sys::socket_address &
  • source() const -> const sys::socket_address &
  • unique_id() const -> uint64_t
  • operator!=(const kernel & rhs) const -> bool
  • operator==(const kernel & rhs) const -> bool
  • node_filter(resource_expression_ptr && rhs) -> void
  • node_filter() const -> const resource_expression *
  • node_filter() -> resource_expression *
  • weights() const -> inline ::sbn::weight_array
  • weight(weight_type rhs) -> void
  • weight() const -> weight_type

    The total number of potentially parallel subordinate kernels. This number corresponds to the number of subordinate kernels that will be created and submitted to the local queue for parallel execution. The scheduler uses this number as a hint to spread the load equally between subordinate cluster nodes.

  • source_pipeline(pipeline * rhs) -> void
  • source_pipeline() const -> pipeline *
  • path(std::string && rhs) -> void
  • path(const std::string & rhs) -> void
  • path() const -> const std::string &
  • phase(phases rhs) -> void
  • phase() const -> phases
  • type_id(kernel_type::id_type rhs) -> void
  • type_id() const -> kernel_type::id_type
  • routed(bool rhs) -> void
  • routed() const -> bool
  • old_id(id_type rhs) -> void
  • old_id() const -> id_type
  • has_id() const -> bool
  • id(id_type rhs) -> void
  • id() const -> id_type
  • operator=(kernel &&) -> kernel &
  • kernel(kernel &&)
  • operator=(const kernel &) -> kernel &
  • kernel(const kernel &)
  • ~kernel()virtual
  • kernel()
Friends
  • operator<<
class sbn::service_kernel
Base classes
Derived classes
Methods
  • service_kernel()
template <class T, class ... Args>
make_pointer(Args &&... args) -> pointer< T >
operator<<(std::ostream & out, const kernel_ptr & rhs) -> std::ostream &
operator<<(std::ostream & out, const kernel & rhs) -> std::ostream &
UNISTDX_FLAGS(kernel_field)
operator<<(sbn::kernel_buffer & out, const kernel & rhs) -> sbn::kernel_buffer &
operator>>(sbn::kernel_buffer & in, kernel & rhs) -> sbn::kernel_buffer &
template <class B, class A>
pointer_static_cast(pointer< A > && ptr) -> auto
template <class B, class A>
pointer_dynamic_cast(pointer< A > && ptr) -> pointer< B >