Sam Yates authored 6 years ago and Benjamin Cumming committed 6 years ago

Global temperature for mechanisms.

* Make 'celsius' magic in modcc: now an indexed variable.
* Add a new temperature data source for indexed variables.
* Add support to printers for indexed variables that reference a scalar.
* Check that indexed variables aren't used in PROCEDURE blocks (this is a problem not just for 'celsius').
* Modify built-in mod files to pass celsius as a parameter to rates() procedures.
* Add global temperature to shared_state classes, and initialize through backend mechanism superclasses.
* Add some infrastructure for unit-test only mechanisms.
* Set modcc flags globally in top level CMakeLists.txt.
* Add test mechanism/module for checking celsius setting.
* Add unit test for multicore and gpu mechanism celsius setting.
* Make common mechanism private field data access helper for unit tests.
* Use helper in temperature, synapses tests.
* Fix warning in `distribued_context.hpp` about errant semicolon.
* Fix global scalar ref for SIMD printing.
* Use correct ARB_CXXOPT_ARCH instead of incorrect CXXOPT_ARCH in various CMakeLists.txt files.
* Add special case for no-non scalar indexed variables in API loop in SIMD printing.

Fixes #386

Two MacPorts/gcc7 issues:

std::uint64_t is unsigned long long on OS X, breaking an assumption about size_t in the distributed_context interface.
Problems with missing errno defines in the standard library headers.
With MacPorts gcc7, the installed c++config.h defines _GLIBCXX_HAVE_EOWNERDEAD and _GLIBCXX_HAVE_ENOTRECOVERABLE, but the corresponding errno defines are not provided by
sys/errno.h unless __DARWIN_C_SOURCE, which takes its value from _POSIX_C_SOURCE if defined, is greater than or equal to 200809L. Technically a MacPorts configuration bug? but easily worked around.

Use basic integral types for communication collectives interfaces.
Define _POSIX_C_SOURCE to be 200809L for glob.cpp.
Fixes #562.

* Remove dependency on memory library and range utils from `multi_event_stream.cu` source.

Fixes #545

noraabiakar authored 6 years ago and Sam Yates committed 6 years ago

* Replace distributed_contest with shared_ptr<distributed_context> in execution_context and pass around the shared pointer instead of a raw pointer.
* Fix construction of mpi_context
* Remove num_threads() from arb and arb::threading. Modify mpi_context so it also returns a shared_ptr. proc_allocation is initialized from execution context to determine available resources.
* Rename threading backend files. Delete useless files.
* Pass execution_context by const reference or value.
* Remove code duplication in thread_system constructors.

Sam Yates authored 6 years ago and Benjamin Cumming committed 6 years ago

* Update the install docs for architecture build options
* Update to reflect new install target

Reduce redundant functionality across event_generator, time_seq
and schedule by providing a low-heap overhead interface to schedule
and using that for time sequences in event_generator and specialized
cell groups.

* Have schedule return pair of pointers as view to generated times.
* Fix missing DEBUG/TRACE functionality.
* Use rate instead of mean_dt for Poisson schedule.
* Move merge_events() functionality to simulator.cpp.
* Migrate event_generator to event span interface.
* Migrate tourney_tree to event span interface.
* Only invoke tourney_tree merge if generators have events in the epoch.
* Use schedule for times in event_generator implementations.
* Replace seq_generator with explicit_generator that keeps a copy of events.
* Replace vector_backed_generator and poisson_generator with schedule_generator.
* Replace time_seq uses with schedule.
* Add default empty schedule.
* Move rounding error test for regular time sequence into schedule test.
* Update sampling API documentation for schedule.

noraabiakar authored 6 years ago and Benjamin Cumming committed 6 years ago

Use correct profiling and mpi flags.
Fix profiler doc

This small refactor simplifies the interface and implementation of the `tree` type.
* use `std::vector` instead of `memory::array` for internal storage in `arb::tree`
* return a `util::range` intstead of a view for `tree::children(int)`
* remove unused functionality for changing the root of a tree.

noraabiakar authored 6 years ago and Benjamin Cumming committed 6 years ago

Add initialize method to the profiler to set up the needed threading parameters given a simulation's task system.

noraabiakar authored 6 years ago and Benjamin Cumming committed 6 years ago

- Task system is no longer a single system private to the implementation of the threading backend and used everywhere. A separate task_system can be used (with a specified number of threads) for every simulation.
- arb::execution_context is the interface to task_system  and the previously defined distributed_context
- TBB and serial support has been removed. Cthreads is the only threading backend available. 

Fixes #139.

* Split colours and `pprintf(...)` into `io/pprintf.hpp` header.
* Remove generic `to_string()` function, replacing its very occasional usage with `pprintf`.
* Move block pretty printing into own .cpp file; this is the only place that the vector ostream printer was used.
* Remove `enum_hash`, as not needed with C++14.
* Move `is_in` utility function to `util.hpp`.
* Remove old SIMD printer backend code.

Sam Yates authored 6 years ago and Benjamin Cumming committed 6 years ago

* Perform device-to-device copy when device_reference is assigned a device_reference.

Better error message on missing file.

* Don't call a missing file an 'internal compiler error'.

noraabiakar authored 6 years ago and Sam Yates committed 6 years ago

Cthreads classes:
- Notification queue : Manages tasks: tries or forces popping and pushing tasks.  
- Task system : manages the notifications queues; controls which queue to pop from/push to; controls spinning on queues if necessary; manages creating/joining threads. Is a singleton.
- Task group : manages synchronization on a group of tasks. 

Operation: 
- Each thread has an associated queue
- Task system _tries to_ push tasks in one of the available queues. If it is unable to acquire a lock on a queue, it tries the next in a round robin fashion. After it loops all queues if it still hasn't successfully pushed the task, it spins on a single queue until lock is acquired and task is pushed. 
- Task system _tries to_ pop a task from the calling thread's queue. If it is unable to acquire the lock, it tries to steal the task from another thread's queue, in a round robin loop. If it is still unable to pop a task, it spins on its the calling thread's queue until the lock is acquired. 
- Task group keeps a counter for the number of tasks in the group which it increments/decrements when calling push/pop on the task system. The counter is used to know when all tasks in the group have been executed. 

Unit tests: 
- Basic tests to pop/push from notification_queue, task_system and task_group. 
- Simple tests for deadlock 
- Simple tests for correctness 

Benchmark: 
- Benchmarks performance for various task sizes

Sam Yates authored 6 years ago and Benjamin Cumming committed 6 years ago

All example code and validation tests no longer require access to private include directories. This provides the minimal requirement for an installable target

Note that it is still not possible to separately build mechanisms from NMODL with just the public includes, and there is not yet any package configuration file creation for use with CMake or pkg-config.

* Replace `hw::node_info` with `proc_allocation`, describing local resources for the purposes of domain decomposition.
* Group processor counting and gpu counting implementation under `node_info.cpp`.
* Remove `domain_decomposition` dependency from `cell_group_factory.hpp` so we can use the latter to test for backend support for a cell kind.
* Add `arb::cell_kind_implementation()` which performs the mapping from cell kind and backend kind to a `cell_group_ptr`-producing function (this will then become the site for custom cell group kind mapping support in future work).
* Move headers for aux library into `aux/include/aux`, so that there is less ambiguity in header location within test and example code.
* Simplify a little the affinity scanning code.
* Add `sysconf()` and `std::thread::hardware_concurrency()` fallbacks for processor count determination.
* Move `util::mask_stream`, `util::path`, `util::scope_exit` into aux header.
* Remove `util::nop`.
* Remove `io::exporter` and `io::exporter_spike_file`; replace with simpler interface in `aux::spike_emitter`.
* Move `load_balance.hpp`, `math.hpp`, `scwio.hpp` into public includes.
* Move path, glob and scope_exit utilities to aux lib.
* Move cell group size-based partitioning functionality into partition_load_balance, through the use of new `partition_hint` structure.
* Remove brunel example specific partitioner.
* Move brunel example option code out of `::arb` namespace.
* Move swc routines out of `arb::io` and into `arb::`.
* Specialize public swc-routines to take a vector of swc_record objects instead of an arbitrary sequence; place implementations into swcio.cpp.
* Remove dependency on `util/strprintf.hpp` from lmorpho.
* Remove `arb::math::min`, `arb::math::max`.
* Remove range utility dependence from validation tests: add piece-wise linear interpolator in test/validation/interpolate.hpp; remove `times` and `values` adaptors for simple trace data; add test/validation/util.hpp with generic size function and a `to_string` for `backend_kind`.
* Add `aux::open_or_throw` helper function to replicate no-overwrite spike output behaviour in example applications.
* Add `aux::strsub` simple string substitution function for use in examples, so as to avoid a `util::strprintf` or `util::pprintf` dependency.
* Remove arbor private header dependencies from examples and validation tests.

Sam Yates authored 6 years ago and Benjamin Cumming committed 6 years ago

Fixes #526.

Fixes issue #524.

Sam Yates authored 6 years ago and Benjamin Cumming committed 6 years ago

Fixes #182.

Sam Yates authored 6 years ago and Benjamin Cumming committed 6 years ago

Migrate source/build to c++14                                                                                                                    (#522)

* Update `CMakeLists.txt` for C++14 option.
* Update to gcc 6 minimum.
* Update travis CI from gcc-5 to gcc-6
* Use `std::..._t` style type traits, replacing `util::` aliases.
* Use `std::cbegin`, `std::cend`, and `std::make_unique`, replacing `util::` versions.
* Remove `DEDUCED_RETURN_TYPE` macros.
* Remove redundant return type specifications.
* Use correct ADL for `begin` and `end` in (almost all) the range utilities.
* Remove redundant `mechinfo` ctor (aggregate initialization suffices).
* Use lambda capture initializers where appropriate.
* Use generic `std::equal_to`.
* Use variable templates for `math::infinity` and `math::pi`.
* Remove `enum_hash` workaround.
* Use `""s` string literals where we were using our own `""_s` construction.
* Use generic lambda for recursive lambda instead of `std::function` wrapper.
* Use generic lambda for generic arithmetic tests.

Fixes #358.

Sam Yates authored 6 years ago and Benjamin Cumming committed 6 years ago

Who broke the build? Sam did!

Sam Yates authored 6 years ago and Benjamin Cumming committed 6 years ago

Fixes issue #517.

Deprecate the IBM xlC compiler.
xlC generates code that is an order of a magnitude slower than gcc, while generating spurious warnings, and requiring hacks and workarounds to pass all tests.
Supporting it makes no sense.

* Add test and fatal error for xlC detection in CheckCompilerXLC.cmake.
* Move xlC 13 misdetection work around to CheckCompilerXLC.cmake.
* Remove xlC-specific compatibility workarounds from code.

Sam Yates authored 6 years ago and Benjamin Cumming committed 6 years ago

This time we're moving `recipe.hpp` and `simulation.hpp`, plus the requirements they bring.

Code changes:
* Pimplize `simulation`.
* Consolidate arbor exceptions: all non-cell kind specific exceptions that might be expected to reach user code now have consistent messages and fit in an exception hierarchy based at `arb::arbor_exception`. Internal errors throw an `arb::arbor_internal_error` exception.
* Renamed `postsynaptic_spike_event` to `spike_event`. (Note: `pse_vector` name is unchanged.)
* Repurposed `pprintf` and moved it into `strprintf.h` — further consolidation is a TODO.
* Made a generic `util::to_string` to avoid redundancy of `operator<<` overloads and other `to_string` definitions. Defaults to ADL `to_string`, `std::to_string`, and finally tries using `operator<<`.

Sam Yates authored 6 years ago and Benjamin Cumming committed 6 years ago

Further work to public install target.

* Move SIMD classes, cell description classes, simple sampler to public include.
* Rename `cell` to `mc_cell`, `segment` to `mc_segment`, and remove `_description` from cell description class names and includes.
* Move `compartment_model` out of `mc_cell` interface and use only in `fvm_layout.cpp`.
* (Provisionally) remove area/volume methods on `mc_cell` and `mc_segment`.

Sam Yates authored 6 years ago and Benjamin Cumming committed 6 years ago

CMake and build refactoring

*   Use CUDA as first-class language (leading to CMake 3.9 minimum version requirement).

*   Use 'modern CMake' interface libraries for compiler options, include file and library dependency tracking. Interface library targets:
    * `arbor-deps`: compiler options and library requirements for the `libarbor.a` static library, as governed by configure-time options and environment.
    * `arbor-private-headers`: include path for non-installed headers, as required by unit tests and arbor itself.
    * `arbor-aux`: helper classes and utilities used across tests and examples.
    * `ext-json`, `ext-tclap`, `ext-tbb`, `ext-benchmark`, `ext-sphinx_rtd_theme`: externally maintained software that we include (directly or via submodule) in the `ext/` subdirectory.
 
*   Single static library `libarbor.a` includes all built-in modules and CUDA objects.

*   Simply configuration options:
    *  `ARB_WITH_TRACE`, `ARB_AUTORUN_MODCC_ON_CHA...

Add a new cell type, and corresponding cell_group implementation, for benchmarking the simulator library architecture.

Add an benchmark_cell_group, where each cell in the group

generates a spike train prescribed by a time_seq
takes a prescribed time interval per cell to perform the cell_group::advance method.
With this cell type, one can easily build arbitrary networks with prescribed spiking and cell update overheads.
A miniapp that uses this cell type to build a benchmark model is implemented in example/bench.

Fixes #493
Fixes #501

The built in profiler generates timings for state and current for individual multicore mechanisms.

Modcc generates and PE(advance_integrate_{state,current}_X) profiler calls (along with corresponding PL() for calls to multicore mechanism nrn_state and nrn_current API calls.

No timings are made for the gpu back end, which is not properly supported by the current profiling tools.

noraabiakar authored 6 years ago and Benjamin Cumming committed 6 years ago

Changes have been made to the simd implementation of mechansim functions: 

- The node_index array (array of indices that specifies for each mechanism the CVs where it is present), is now partitioned into 4 arrays according to the constraint on each simd_vector in node_index:
    1. contiguous array: contains the indices of all simd_vectors in node_index where the elements in simd_vector are contiguous
    2. constant array: contains the indices of all simd_vectors in node_index where the elements in simd_vector are identical
    3. independent array: contains the indices of all simd_vectors in node_index where the elements in simd_vector are independent (no repetitions) but not contiguous 
    4. none array: contains the indices of all simd_vectors in node_index where the none of the above constraints apply

    When mechanism functions are executed, they loop over each of the 4 arrays separately. This allows for optimizations in every category. 

- The modcc compiler was modified to generate code for the previous changes, including the optimizations per constraint:
    1. contiguous array: we use vector load/store and vector arithmetic. 
    2. constant array: we load only one element and broadcast it into a simd_vector; we use vector arithmetic; we reduce the result; we store one element.   
    3. indepndent array: we use vector scatter/gather and vector arithmetic. 
    4. none array: we cannot operate on the simd_vector in parallel, we loop over the elements to read, perform arithmetic and write back 

- Added a mechanism benchmark for pas, hh and expsyn

- Moved/modified some functions in simd.hpp to ensure that the correct implementation of a function is being called. 

Changes to libarbor
-------------------------

Time sequences were added in `src/time_sequence.hpp`:
- added new `time_seq` type that implements a type-erasure interface for the
  concept of a time sequence generator.
- added poisson, regular and vector-backed implementations of the time sequence
  concept.

Event generators:
- The poisson, regular and vector-backed implementations of the event generator
  concept were refactored to use the.

Cell groups:
- Removed the `dss_cell_group` and `rss_cell_group` and associated types.
- Added a generic spike source cell  that generates a sequence of spikes
  at time points specified by a `time_seq`. Using this approach, an
  additional `cell_group` specialization is not required for each type of
  sequence, and user-defined sequences can be used with minimal overhead.

Unit tests
------------

- Added unit tests for `time_seq`.
- Simplified `event_generator` unit tests, because much of the testing
  of the sequences was moved to the `time_seq` tests.
- Added unit tests for `spike_source_cell_group`.

Changes to miniapp
-------------------------

- simplified the miniapp by removing the command line options for using an input spike chain from file.
- updated the miniapp recipe to use `spike_source` cell group instead of `dss_cell_group`.

Benjamin Cumming authored 6 years ago and Sam Yates committed 6 years ago

Move from choosing the distributed communication model from a compile time choice (the old `arb::communication::communication_policy` type) to a run time decision.

* Add `arb::distributed_context` class that provides the required interface for distributed communication implementations, using type-erasure to provide value semantics.
* Add two implementations for the distributed context: `arb::mpi_context` and `arb::local_context`.
* Allow distribution over a user-supplied MPI communicator by providing it as an argument to `arb::mpi_context`.
* Add `mpi_error` exception type to wrap MPI errors.
* Move contents of the `arb::communication` namespace to the `arb` namespace.
* Add preprocessor for-each utility `ARB_PP_FOREACH`.
* Rewrite all examples and tests to use the new distributed context interface.
* Add documentation for distributed context class and semantics, and update documentation for load balancer and simulation classes accordingly.

Fixes #472

Sam Yates authored 6 years ago and Benjamin Cumming committed 6 years ago

Replace hard-coded index variable names in modcc cuda printer with ones derived from the external variable.

Uses `decode_indexed_variable`.

Benjamin Cumming authored 6 years ago and Sam Yates committed 6 years ago

* Use `sys/types.h` instead of `endian.h` for greater portability.
* Avoid use of constructor for `std::vector` in unit tests that is only available from C++14.

* Update SIMD developer docs to reflect newly merged mechanism refactor work.

Benjamin Cumming authored 6 years ago and Sam Yates committed 6 years ago

Completes CUDA printing in modcc.
* Add CudaPrinter visitor, overriding CPrinter.
* Add `ostream` `operator<<` overloads for `arb::gpu::shared_state` and `device_view` for debugging.
* Fix GPU back-end bugs.

First commit of two for mechanism refactor work (refer to PR #484 and PR #483).

FVM/mechanism code:
* Refactor mechanism data structures to decouple backend-specific implementations and mechanism metadata.
* Add mechanism catalogue for managing mechanism metadata and concrete implementation prototypes.
* Add fingerprint-checking to mechanism metadata and implementations to confirm they come from the same NMODL source (fingerprint is not yet computed, but tests are in place).
* Split FVM discretization work out from FVM integrator code.
* Use abstract base class over backend-templated FVM integrator class `fvm_lowered_cell_impl` to allow separate compilation of `mc_cell_group` and to remove the dummy backend code.
* Add a new FVM-specific scalar type `fvm_index_type` that is an alias for `int` to replace
`fvm_size_type` in fvm layouts and mechanisms. This was chosen as an alternative
to making `unsigned` versions of all our SIMD implementation classes.
* Extend `cable1d_neuron` global data to encompass: mechanism catalogue; default ion concentrations and charges; global temperature (only for Nernst); initial membrane potential.

Modcc:
* Collect printer sources in modcc under `printer/`.
* Move common functionality across printers into `printer/printerutil.{hpp,cpp}`.
* Add string to file I/O implemented in routines read_all and write_all in `io/bulkio.hpp`.
* Implement indent-friendly source code generation via a `std::streambuf` filter `io::prefixbuf` defined in `io/prefixbuf.hpp`, together with manipulators and a corresponding std::ostream-derived wrapper.
* Rewrite printers to use new infrastructure: cpu target incorporates SIMD printing options; CUDA printer at this point produces only stubs for CUDA kernel wrappers.
* Modify SIMD printing command line options for modcc: `-s` enables explicit vectorization using the SIMD classes;  `-S <N>` allows a specific data width to be prescribed.
* Fix problem in `test_ca.mod` with uninitialized ion current.
* Add infrastructure support to allow future pre-computation of SIMD index conflict cases for (hopefully) faster scatters and updates.
* Simplify `IndexedVariable` expressions in the AST, making data source explicit via a `sourceKind` enum, and leaving the indexing method and index names up to the printers.
* Allow state variables in the AST to 'shadow' an ion concentration — these are assigned in the
generated `write_ions` method.

SIMD classes:
* Add `simd_cast` operation between SIMD value types of the same width, and with `std::array`. (Note: this was tested and used in an early development version of the code, but not in this version. It was still a lacuna in the original SIMD wrappers, so it has been left in.)
* Restructure SIMD gather/scatter API to use a `simd::indirect` expression,  which encapsulates a pointer and SIMD offset.
* Add `simd::index_constraint` scoped enum to describe knowledge of contention in indirect indices, so that we can branch on this to the appropriate implementation.
* Add SIMD concrete implementation routines `reduce_add` for horizontal reduction and `element0` for access to first lane scalar value.
* Add SIMD value method `sum()` that exposes implementation `reduce_add`.
* Add SIMD concrete implementation routine `compound_indexed_add` that provides the implementation for `indirect(p, simd_indices) += simd_value` construction.
* Fix SIMD `implbase` bug where some static methods were using the `implbase` fall-back functions instead of the derived class specialized implementations.
* Move SIMD mathematical functions into friend routines of `simd_impl` in order to resolve implicit conversions from scalars in mixed SIMD-scalar operations.
* Use a templated `tag` class to dispatch on SIMD concrete implementation types, to avoid problems with incomplete types in method signatures.
* Remove old SIMD intrinsics.

CMake infrastructure:
* Downcase some variables in `CMakeLists.txt` files to  distinguish them visually from CMake keywords and variables.
* Split arbor modcc vectorization option (now `ARB_VECTORIZE`) and target-architecture optimization (now `ARB_ARCH`).
* For `arbor` and `arbormech` targets, and in particular not the `modcc` target, use `ARB_ARCH` to generate corresponding target-appropriate binaries, including, for example, appropriate SIMD support.
* Extend `CompilerOptions.cmake` to map as best as able between the various target architecture names (we use the gcc names) and the correct option to pass to the compiler based on the compiler and platform.
* Add work-around for misidentification by CMake of XL C as Clang.
* As a temporary work-around, include `arbormech` library twice on link line to resolve circular arbor–arbormech dependencies.

Unit tests:
* Extend repertoire of generic sequence equality/near equality testing support  in `common.hpp`.
* Add warning suppression for icc for the malloc instrumentation code.
* SIMD unit tests for indirect expressions, compound indirect add, reduction.
* Make some exact tests into floating point 'near' tests when comparing computed areas and lengths in swc and fvm layout tests, to account for compiler (e.g. icc) performing semantically inequivalent floating point operation reordering or fusion at `-O3`.
* Split out some of the CUDA tests into separate .cpp/.cu files for  separate-compilation purposes.

Other:
* The `padded_allocator` has been modified to propagate alignment/padding on move and copy (these semantics make their use much easier and safer in the multicore mechanism instantiation code).
* Map/table searching utilities in `util/maputil.hpp`.
* Fixes for correct sequence type categorization and `begin/end` ADL.
* Fixes for type guards for range methods that take universal references.
* Removal of some redundant code in range utilities through the use of universal references.
* Add new range view `reverse_view` for ranges delineated by bidirectional iterators.
* Add single argument form of `make_span` to count up from zero, and associated helper `count_along` that gives a span that indexes a supplied container.
* Moved `prefixbuf` to `modcc` source.
* Make sequence positive and negative tests in algorithms generic.
* Add `private`-subverting helper code/macro to `tests/unit/common.hpp` to reduce the number of public testing-only interfaces in the library code.
* Add virtual destructors for virtual base classes.
* Add new arb::math:: functions: `next_pow2` for unsigned integral types, `round_up` to round a number away from zero to next largest magnitude multiple.
* New `index_into` implementation that supports bidirectional access (moved to `util::` namespace).
* Fix problem in `test_ca.mod` with uninitialized ion current.
* Rework dangerous `memory::array(Iter, Iter)` constructor to be less dangerous (and do the expected thing).
* Allow ranges to be constructed from other ranges if the iterators are compatible.

Ben Cumming authored 7 years ago and Sam Yates committed 7 years ago

Add two new documentation pages for the C++ API

* Add domain decomposition page that covers `domain_decomposition`, `node_info` and `partition_load_balance`.
* Add simulation page that describes `arb::simulation` API interface.
* Fix some small typos elsewhere in the docs.
* Use `std::move` when adding spike callbacks to `arb::simulation` (useful if callbacks are stateful).

Ben Cumming authored 7 years ago and Sam Yates committed 7 years ago

Fixes issue #467 

* Add GPU synchronization points where required for Kepler to coordinate CPU access of managed memory.
* Use hand-rolled double precision atomic addition for Kelper targets.
* Replace `ARB_WITH_CUDA` build option with `ARB_GPU_MODEL` option that takes one of 'none', 'K20', 'K80' or 'P100', and set up source-code defines accoringly.
* Clean up of redundant compiler flags and defines no longer required now that the project uses separate compilation for CUDA sources.

Fix some typos in the SIMD documentation.

Ben Cumming authored 7 years ago and Sam Yates committed 7 years ago

Add some C++ API documentation.

* Create C++ API section in docs.
* Document `arb::recipe`: both a class reference along with more explanatory text and best practices guide.
* Add some class documentation of basic types required to understand recipe definition.
* Some in-code comment clean up.
* Change `arb::cell_kind` from a vanilla enum to a scoped enum.