All Classes and Interfaces
Classes
Class
Description
test NxN communication using all2all
testing farms connected using all2all
testing multi-input and multi-output on example 2
testing two all2all join with multi-output
testing join between 3 farms: farm w/o collector + all2all of two filters
testing collector replace and multioutput to a filter
testing multi in / out
feedback testing 2 stage all2all
Global settings for the bbflow package
Benchmark of two nodes connected each other
Benchmark of a farm with N workers
Sequential version of the computation did by the Farm benchmark (and also by the pipeline).
Benchmark of two nodes connected each other with a network channel (TCP)
Benchmark of a farm with a network channels (TCP)
Pipeline benchmark with N nodes
class keeping found position during SEARCH phase
the basic entity where all nodes are constructed onto it
if a new custom building block is created, all functions MUST be extended
Thread client of objectClient
this is our Collector, waiting result from ALL workers in case of SEARCH and waiting ONLY from node involved in case of LEARN.
Two combined workers as single one in ff_farm
Two combined workers as single one in ff_farm
Two combined workers as single one in ff_farm
Two combined workers as single one in ff_farm with different cardinalities
Two combined workers as single one in ff_farm with network feedback
Testing 2 farms with collector/emitter replaced and combined together
Single farm topology where the emitter and the collector are a composition of nodes
ff_farm test with an output node
output node of complete_farm_test
workers runJob of the example farm
custom time watch class to measure & print performance
default Collector of bbflow.ff_farm.
default Emitter of bbflow.ff_farm.
default Job extecuted by the bbflow.ff_node.
default worker extending default job
it should be extended doing nothing
Emitter receives commands from the external and send to workers what to do.
ff_farm test with an output node
All2All Building Block able to merge multiple farms
Combine two nodes (of type ff_node or ff_comb) in one.
Fundamental block modeling the Farm paradigm
Composed by one emitter (single input by default), n_workers workers and one collector
Worker must be implemented; the function runJob or runJobMulti contains the computation part.
Fundamental building block rapresenting a node
Implemented and used by other building blocks
Support multiple input and output channels
Single lock for all input channels and a single lock for all output channels
Pipeline building block allows auto-connection between all types of ff_blocks
Default class of the queues.
Queue extending ff_queue exploting a network channel.
Various tests used for the thesis
MSOM class creating emitter, collector and connect workers each others and with emitter/collector
a defaultJob used for the thesis
test of the network channels.
Thread running the job for ff_node building block
class to manage connection to server socket in order to send data through TCP channel
Auto-reconnection in case of fault is implemented
Server socket single threaded used to receive data from another node through TCP channel
Example of Ordered Farm using packets with label sorted on the collector side and emitted in the correct order by Filter1
Example of Ordered Farm using Emitter and Collector in ROUNDROBIN
example of pipeline usage with 2 stages
Stage1: a farm with n_workers
Stage2: a node receiving data from collector and printing to the output
Pipeline building block allows auto-connection between all types of ff_blocks
Two nodes connected each other with a network channel (TCP)
example of pipeline usage with 2 stages
Stage1: a farm with n_workers
Stage2: a node receiving data from collector and printing to the output
Class providing a static method used to invite JVM to preload main classes used in BBFlow.
Workers of the MSOM containing a part of the neural network and communicating with neighbours (TOP, LEFT, BOTTOM, RIGHT)
Receiving instructions from Emitter and sending results to Collector
Sequential version of the MSOM implementation.
packet containing instructions and data exchanged between all nodes
Reimplementation of ConcurrentLinkedQueue in Bounded manner
Taken inspiration from Hadoop class BoundedConcurrentLinkedQueue
Test class with a simple farm and sum of sequential numbers
test function of MSOM with some benchmark with different number of cores used
example of pipeline usage with 2 stages, timewatch added to measure performance.