Struct FedAvg 

pub struct FedAvg<B: Backend> { /* private fields */ }

FedAvg aggregator: weighted average where weights are num_samples / total_samples. Generic over B: Backend so the reduction composes from the backend’s Mul + Add primitives without bumping the 30-op floor.

The buffer is a BTreeMap<PeerId, (B::Tensor, u64)> so the reduction walk has a deterministic iteration order (lexical by peer id). The engine’s dispatch_atomic(&mut self, ...) contract gives the aggregator exclusive access for the duration of each call. The buffer is #[serde(skip)] because snapshot captures the aggregator’s structural identity, not the per-round transient contribution state.

Trait Implementations

impl<B> Aggregator for FedAvg<B>

where B: 'static + Backend, B::Tensor: Tensor,

type Element = <B as Backend>::Tensor

Storage element type for the tensors this aggregator operates on. Most f32-native aggregators declare type Element = [f32].

type Error = OpError

Library-maker-defined error type.

type Metadata = FedAvgMeta

Impl-defined metadata that travels alongside the tensor. Carried as a typed slot value; serde fires only when the value crosses a wire boundary.

fn contribute( &mut self, _ctx: &mut RuntimeResourceRef<'_>, src: PeerId, tensor: &Self::Element, metadata: FedAvgMeta, _completion: CompletionHandle<(), Self::Error>, ) -> ContractResponse<(), Self::Error>

Contribute one peer’s update to the in-progress aggregation. ctx is the per-dispatch runtime surface; impls reach their declared #[depends(...)] siblings through RuntimeResourceRef::dependency. tensor is a reference to the element (e.g. &[f32] for Element = [f32]). metadata is the typed accompanying data (sample counts for FedAvg, weights for weighted sum, round ids, …). Default-constructed Metadata is valid for impls that don’t have a real metadata channel.

fn aggregate( &mut self, ctx: &mut RuntimeResourceRef<'_>, _completion: CompletionHandle<(Box<Self::Element>, FedAvgMeta), Self::Error>, ) -> ContractResponse<(Box<Self::Element>, FedAvgMeta), Self::Error>

Reduce the accumulated contributions and return the result. ctx carries the runtime surface so the aggregator’s reduction can resolve #[depends(...)] siblings (e.g. the Backend that supplies the composed weighted-sum). Output is (params, metadata):

impl<B> AggregatorRuntime for FedAvg<B>

where B: Backend + 'static + Default, B::Tensor: Tensor,

type Error = OpError

Aggregator-impl-specific error type.

fn atomic_opset(&self) -> AtomicOpsetDecl

Atomic-op opset this impl owns.

fn dispatch_atomic( &mut self, op_type: &str, inputs: &[(&str, &dyn SlotValue)], ctx: &mut RuntimeResourceRef<'_>, ) -> Result<DispatchResult, Self::Error>

Rust-dispatch entry point for atomic ops.

impl<B: Backend + 'static> AnyComponent for FedAvg<B>

fn as_any(&self) -> &dyn Any

Downcast view - immutable.

fn as_any_mut(&mut self) -> &mut dyn Any

Downcast view - mutable.

impl<B: Backend> Clone for FedAvg<B>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<B> ConcreteComponent for FedAvg<B>

where B: 'static + Default + Backend,

const TYPE_NAME: &'static str = "FedAvg"

Stable identifier. Convention: <crate>::<TypeName>.

const PACKAGE: ComponentPackage = ComponentPackage::Framework

Origin tag; defaults to Application.

const DEPENDENCIES: &'static [DependencyDecl]

Sibling components this depends on. Populated by the bb::Concrete derive from #[bb::depends(...)].

type Config = ()

Per-deployment config. Use () for stateless concretes.

type Error = Infallible

Error from Self::new; use Infallible if construction can’t fail.

fn new(_: &Self::Config) -> Result<Self, Self::Error>

Construct from &Self::Config. Install calls this once per slot.

fn serialize(&self) -> Vec<u8>

Serialize state to bytes, including config-derived fields.

fn restore(bytes: &[u8]) -> Result<Self, RestoreError>

Reconstruct from serialize output.

impl<B: Debug + Backend> Debug for FedAvg<B>

where B::Tensor: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<B: Backend> Default for FedAvg<B>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, B: Backend> Deserialize<'de> for FedAvg<B>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<B: Backend> Serialize for FedAvg<B>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.