
An implementation of the Speculative Paxos protocol - drkp
https://github.com/UWSysLab/specpaxos
======
RijilV
Le sigh, multicast. A great example where software engineering crosses over to
the physical realms.

When a router receives a packet destined for a multicast group and that router
has multiple destinations for that pocket, it must store that packet in memory
until the last interface associated with that group can be written to. On
networks which aren't heavily used that's not problem. Once you start
utiziling your network however, the routers will be busy storing packets and
their sensible-for-simple-cases buffers will become overwhelmed and you've got
a multicast storm on your hands.

Great on paper, even works in test setups. Call me when you're running your
kit to the limits, and I'll let you know you have a multicast problem.

~~~
robryk
Why is it worse than sending a separate packet to each of the participants? If
we're using multicast router can send packets to all participants in any order
(when links become available) while storing one copy of it. If we're sending
separate packets, either router has to store multiple copies of it in memory
or it sends the packet to different participants in a constrained order.

------
blopeur
Interesting concept but relies on multicast. SDN might help solve the inherent
multicast drawbacks by creating topologies, distribution trees, etc.. ahead of
time. But practically, how often do you see multicast deployed and enabled in
modern datacenters ?

------
erichocean
This would go very nicely with Aeron.

[https://github.com/real-logic/Aeron](https://github.com/real-logic/Aeron)

------
alexnewman
I like this as a niche (sub 100 node) solution to an interesting problem. I
wonder how well this works over a MAN.

------
GauntletWizard
Use Raft. Rather than speculating, learn, do, and guarantee you're doing the
correct thing by electing once, distributing, achieving quorum and continuing.
This is spitshine on a turd - PAXOS is a great protocol, but not a speedy one.
It's an important building block, not something to be running constantly.

~~~
Randgalt
More appropriately, don't implement these incredibly difficult protocols
yourself - unless it's an exercise. Use one of the well maintained, widely
used implementations.

~~~
bitL
If you took edX's Reliable Distributed Algorithms 1, you'd have implemented it
in a few lines in Scala.

~~~
sethammons
Well, in a few lines built atop kompics which is a simulation framework.
(Multi) Paxos in particular is considered so hard to get right that no
organization actually implements it to my understanding. They instead have
their own flavor based on paxos. See zookeeper.

~~~
bitcrusher
That's not really true at all. Basho (makers of Riak) have a multi-paxos
implementation that is used in Riak.
Riak_Ensemble:([https://github.com/basho/riak_ensemble](https://github.com/basho/riak_ensemble))

