jodavaho/distributed-leader-election

An implementation of GHS for distributed minimum spanning tree construction originally implemented at @nasajpl

distributed-leader-election's Issues

Update get_deps.sh, and create get_deps.sh for various platforms

There should be two classes of fetches in get_deps:

• System installs (like libnng-dev)
• Externals (like miniz from github)

And it could easily be extended to work on other systems, like alpine, which is especially useful for containers.

Create demo of time-based MST constructions

Create *cast functions somewhere other than GHS

reorg header files to reflect the various build targets

1. le/errno.h
2. le/seque*.h
3. le/ghs.h

etc.

Also:

1. src/lib/include/le/ghs.h instead of include/le/ghs.h
2. ...

Create demo of LE with middle strategy

factor out graph-related constructs into a graph class

In order to modularize the code and allow for leader election strategies and other MST-based algorithms, we should take all the Edge and peer (agent_t) information out of GhsState (including methods like set_edge and check_index_of), and create a "Graph" class that contains all that.

Add all CLI parameters to config file

implement code coverage tests suitable for CI

The tests executables are: tests/ghs-doctest and demo/ghs-demo-doctest

There are some flags in place to compile with --coverage, etc (see BUILD_COV=On in CMakeLists.txt), but none of it is instrumented appropriately for CI testing.

Create demo of LE with middle-weight strategy

Create Msg() constructors rather than to_msg

Create Dockerfile

In conjunction with #2 , create files required to make docker or other containers so that the demo code can easily be run on any system.

unify errno

Currently we define a lot of different error codes for no reason. it's overly general and confusing and requires translating lots of error codes and lots of duplication.

Just have one errno for the whole library.

Create system install / releases

Our highest priority is ubuntu (.deb), but any system could be targeted for release. Creating just the build steps steps in a make_dep.sh is fine.

Remove all `size_t`

It's not necessary to know the actual size, it's only necessary to be consistent with interfaces.

See #7

Document requirements

Some of the design decisions seem arbitrary. Document the forcing functions:

• No dynamic memory
• No dynamic types

etc etc

autodocs and gh-pages

automatically push doxygen build to github pages

Identify and guard all dependencies on std::, even if we haven't identified a nostd:: way of building yet

As prep for removing (or making optional) any dependency on std::, we should create a OptionalStd.h, in which we use #define and #ifdef to guard all the uses of std::

For example:

#ifdef USE_STD
#include <limit>
namespace whatever{
  const metric_t max_edge_metric = std::numeric_limits<metric_t>::max();
}
#else 
#include <something_else>
namespace whatever{
  const metric_t max_edge_metric = //some other semi-independent way of defining a max for metric_t that is tbd
}

Identify library targets that can be broken out into their own repos

For example:

• static_queue (req:none)
• GHS, ghs-demo (req: seque, graph)
• Leader elections (req: graph)