baliuzeger / try_signalling Goto Github PK

benefit:

• avoid network communication between original data & running thread caused by the mechanism of Mutex.
• keep RunningSet::new simple (not adding more functions when having more run-modes), i.e. let the "body" (where the soul can go out & in) generate closure & insert into RunningSet.

Phase Respond should be removed for better performance.
It's no necessary for practical SNN operation. the signals are always timed.

Should deprecate Runnable to remove redundancy.

can try associated type.

pub trait PassiveConnection<S0: Send, S1: Send>
to
pub trait PassiveConnection {type S0; type S1;}

pub type ConnectionComponentS1<G, A> = ConnectionComponent<G, A, FwdPreS1, FwdPostS1>;
to
pub type ConnectionComponentS1<G, A> = ConnectionComponent<Generator<S0=FwdPreS1>, Acceptor<S1=FwdPostS1>>;

pub struct ConnectionComponent<G: Send + ?Sized, A: Send + ?Sized, R: Send, S: Send>
to
pub struct ConnectionComponent<G: Generator + Send + ?Sized, A: Acceptor + Send + ?Sizedd>

Reason: to run the loop in Supervisor for generating threads for all connections.

Ideas:
Pub Struct Model { oub_connection_populations: Vec<Vec<out_connection_population_of_some type>> }

let connection_population hold Arc of agent_populations to simplify the the system be managed based on populations.

synapses need to check the mode of pre & post synapse neuron to decide whether to run.
Therefore, if some neurons config_channels before synapses,
those neurons may get signal channels which the correspondent synapses won't run.

due to the need to access the Passive Agents, passive_sync_chs_sets may be locked by passive_running_populations.

Possible solutions:

1. let OutCoponents hold passive_sync_chs_sets when config_channels.
2. not use Mutex anymore; make a copy (like phantom) when run then merge back after running.
3. let passive_running_sets wait some time. (not really fix the problem.)
4. get sync_chs_sets by message passing.....!? seems don't work...

should ffw_accepted return Iter or Vec?

need functionality to add/remove agent/connection

Active_Multi_Out to Active_Multi_Out not implemented yet:
need modify Multi_In/Out_Component.

SingleOut to PassiveSingleOut not implemented yet:
need modify Single_In/Out_Component & passive_device run().

supervisor should use Weak to hold populations?

let a agent able to be owned by multi population,
and not cause problems when config_run from multi populations.

let everything know who & where it is.
by some String?
e.g. "Supervisor-0, LIF_population-1, #100."

Consider using actor model for performance / distributed run / avoiding complicated error handling when config.

in real situation, agents in a network may or may not be configured for running,
and running fore-agents should not send signals to the idle back-agents.

PreComponent should be:
{connections: Vec<(Arc<Mutex<Conn>>, DeviceMode<channels>)>}

passive running set of neurons should be separated by types of signals.
in case that a neuron can have different actions to types of acceptors when firing, this feature can avoid redundant message passing of confirm/report.

There should be a enum GeneratedSignal of types of signals a neuron has.
the running set of neurons should be hashtable of GeneratedSignal-acceptor_group,
device.evolve should return a vector/iterator of GeneratedSignal,
the device.run use it to decide which groups need Broadcast::FinishCycle.

candidates:

• message passing.
• fully reframed to actor model. #24

pub struct ComponentIdle<C, S0, S1> where C: PassiveConnection<S0, S1> + Send + ?Sized, { connections: Vec<Weak<Mutex<C>>>, }

to

Inlet<S0> & Outlet<S1>
respectively for post/pre components.

`{

code below
code below
code below

// here

fn run(&mut self, rx_confirm: CCReceiver, tx_report: CCSender) {
let mut running_connections = Vec::new();
for conn in &self.out_connections_1 {
let running_conn = conn.connection.upgrade().unwrap();
let (tx_conn_report, rx_conn_report) = crossbeam_channel::bounded(1);
let (tx_conn_confirm, rx_conn_confirm) = crossbeam_channel::bounded(1);
running_connections.push(RunningSet {
instance: thread::spawn(move || {running_conn.lock().unwrap()
.run_under_agent(rx_conn_confirm, tx_conn_report)}),
report: rx_conn_report,
confirm: tx_conn_confirm,
});
}
// failed to use a function of init_connections
for conn in &self.out_connections_2 {
let running_conn = conn.connection.upgrade().unwrap();
let (tx_conn_report, rx_conn_report) = crossbeam_channel::bounded(1);
let (tx_conn_confirm, rx_conn_confirm) = crossbeam_channel::bounded(1);
running_connections.push(RunningSet {
instance: thread::spawn(move || {running_conn.lock().unwrap()
.run_under_agent(rx_conn_confirm, tx_conn_report)}),
report: rx_conn_report,
confirm: tx_conn_confirm,
});
}`

neurons should also check whether it has any passive acceptors for Firing::N/Y.
If it connected to no passive acceptors, then even if it fires, it has to to nothing in FinishCycle phase.

supervisor's ownership to populations should be Weak.

1 is population level: show the relationships between populations,
e.g. neuron-population-0 all-to-all neuron-population-1.

1 is device level,
e.g. neuron-population-0, device # 1, connect to :
connection-population-0, device # 10,
recorder-population-0, device # 1,

to avoid writing Arc::clone(&some_agent) for convenience.