v0.11.0

New Features
------------

* A new get_chip_info method has been added to MachineController which
  efficiently fetches the number of working cores, the set of working links,
  the quantity of SDRAM and SRAM free and the AppState of every core.

* A new get_system_info method has been added to MachineController which calls
  get_chip_info on every core in a machine (in a fault-tolerant manner)
  producing a SystemInfo object. SystemInfo objects are dictionaries containing
  the ChipInfo object for each chip in the system. They also contain a number
  of useful iterators for iterating over working/dead chips, links, and cores.
  This call is intended to replace the now-deprecated get_machine method (see
  notes later in the changelog for details) and provides a superset of the
  information previously provided in less time.

* A new rig.place_and_route.place_and_route_wrapper replaces the now-deprecated
  rig.place_and_route.wrapper which accepts SystemInfo objects instead of
  Machines. The new wrapper automatically reserves all non-idle cores,
  including monitors and other running applications, allowing Rig applications
  to peacefully coexist on the same machine. Further, the SDRAM and SRAM
  resources supplied to the place-and-route system now reflect the amount of
  free SDRAM and SRAM actually available on each chip.

* Two new place-and-route utility functions in rig.place_and_route.utils are
  provided, build_machine and build_core_constraints which translate a
  SystemInfo object into the standard place-and-route Machine and
  ReserveResourceConstraint data structures. These functions are used by the
  new place_and_route_wrapper function and are the preferred way of acquiring
  Machine objects and constraints for reserving monitor processors etc. for
  place and route in new code.

* The efficiency of the load_application method of MachineController has been
  improved for some cases.

API Deprecations
----------------

A number of minor API changes have been introduced in the name of more
appropriately dividing place-and-route and machine control parts of the API.
The deprecated APIs will remain for backwards compatibility but may be removed
in the future. Developers are strongly encouraged to update their code to use
the new APIs. Use of any deprecated API will produce a DeprecationWarning which
are displayed when running Python with the -Wd command line option.

* The rig.machine module has been deprecated and its contents moved to better
  reflect the uses of these structures:

  - rig.machine.Links -> rig.links.Links
  - rig.machine.Machine -> rig.place_and_route.Machine
  - rig.machine.Cores -> rig.place_and_route.Cores
  - rig.machine.SDRAM -> rig.place_and_route.SDRAM
  - rig.machine.SRAM -> rig.place_and_route.SRAM

* The get_machine method of MachineController has been deprecated since the
  structure it returns is designed primarily for use during place-and-route and
  is not a good fit for general system information gathering. Users should
  instead use the new get_system_info method which provides a superset of the
  information returned by get_machine. The new
  rig.place_and_route.utils.build_machine function is now the preferred way to
  construct a Machine object representing the state of a SpiNNaker machine for
  place-and-route.

  Further, with the arrival of the build_core_constraints utility it is now
  possible (and desirable) to automatically produce ReserveResourceConstraint
  which reserve all cores (including monitors) which are not idle. By using
  get_system_info in place of get_machine only one query needs to be sent to
  the system to generate a Machine and generate constraints.

* The rig.place_and_route.wrapper function has been deprecated in favour of
  rig.place_and_route.place_and_route_wrapper. This new wrapper function has an
  almost identical API to the old wrapper but accepts a SystemInfo object
  and internally derives a suitable Machine and set of
  ReserveResourceConstraints based on this. Unlike the old wrapper, this
  wrapper function will not use any cores which are already in use, not just
  the monitor processor. An additional benefit is that when this function is
  imported on its own its name is far more appropriate.

Bug-fixes
---------

* The new version of SC&MP included in this release now correctly frees all
  resources when the 'stop' signal is sent. Previous versions of SC&MP did not
  remove routing table entries or free SDRAM on chips where no applications had
  been loaded. As a result of this fix workaround code in Rig has been removed
  which means that sending the 'stop' signal should now be nearly instant
  compared with previous versions.

v0.10.1

New features
------------

* Added `write_across_link` and `read_across_link` methods to MachineController
  to allow low-level PEEK and POKE commands to be sent to chips for debug
  purposes.
* Added `discover_connections` method to MachineController which discovers
  other Ethernet connected chips in a machine and then uses them when
  communicating with chips on the same board as the Ethernet connection. This
  features offers only a mild performance improvement at present but is a step
  in the larger plan to introduce high-throughput parallel IO to rig's API.

Documentation improvements
--------------------------

* Add examples of sending and receiving SDP/SCP packets to a running
  application.
* Add links to source code on GitHub in Sphinx documentation.
* Add documentation for RouterDiagnostics
* Improve documentation for sdram_alloc{,_as_filelike}
* Improve documentation for MachineController exceptions.
* Numerous other minor documentation improvements.

v0.10.0

Breaking changes
----------------

* The `MachineController.boot()` method now only boots machines which are not
  already booted and ensures that the machine is responsive after booting. This
  change is considered 'breaking' since the command now (by default) results in
  SCP packets being sent to the machine and (by default) the method can now
  raise an exception on failure. The old behaviour can be achieved by setting
  the new `only_if_needed` and `check_booted` arguments to `False`.

Other Improvements
------------------

* The `SCPPacket` and `SDPPacket` constructors now have sensible default
  arguments which make their use for application sending/receiving simple
  SCP/SDP traffic much more straight-forward and boiler-plate free.
* The hilbert placement algorithm has been refactored and the underlying
  sequential placement algorithm, breadth-first vertex ordering heuristic and
  hilbert curve chip ordering have been split up.
* The hilbert algorithm now takes a `breadth_first` argument which if set to
  False will make the algorithm place vertices in the iteration order of
  `vertices_resources` making the algorithm run faster at the expense of
  (potentially) less sensible vertex ordering. This may be useful for
  applications whose communication needs are uniform random or extremely light.
* A new sequential placement algorithm is provided which by default does
  raster-scan placement but can be used as the basis for alternative sequential
  placement processes (e.g. it is now used by the hilbert placer and the new
  breadth_first placer).
* A new breadth_first placement algorithm is provided which fills the machine
  in a raster-scan fashion but placing vertices in a breadth-first traversal of
  the application graph. This may be used as-is or extended with a
  custom-chip-traversal order (as in the hilbert placer).
* Some minor typographical issues in the documentation have also been fixed.

v0.9.0

Breaking changes:

* Disallow repeated keys and masks in build_routing_tables. This prevents
  accidental creation of loops in certain cases.

Other changes:

* Fix documentation build requirements for Python 3.5+
* Minor documentation fixes

v0.8.2

* Add `fill` method to MachineController to allow memory blocks to initialised
  to a fixed value.
* Add `clear` argument to MachineController's sdram_alloc and related methods
  which zeros out newly allocated memory.
* Replaces a custom work-around in setup.py to ensure enum34 is not installed
  on Python >= 3.4 with a requirement on `enum-compat`, a virtual package which
  does achieves this goal.
* Fixes metadata in setup.py to denote Python 3.5 support.

v0.8.1

Python 3.5 support:

* Python 3.5 is now officially supported by Rig.
* Python 3.4 will remain officially supported for a short time as it is still
  widely used on various Linux distributions. Support will be dropped as soon
  as this is no longer the case.
* The enum34 backport library is no longer a dependency when installing on
  Python 3.4 and onwards.

Bug fixes:

* Fixes bug in the write buffering feature of the MachineControler. A side
  effect of this was noticing that nobody is actually using this feature and so
  it is now being considered for removal before Rig 1.0.

Other internal miscellany:

* Some dead code removed from the NER router.
* Minor changes to docstring utility module tests for 3.5 support.
* A slightly modified testing procedure is required as a workaround for issues
  with Pytest in Python 3.5. Travis and Tox will automatically use the new
  testing procedure, manual testers should see commit 7851cc5 for details. This
  workaround will be reverted as soon as the bug is fixed.

v0.8.0

* Adds SameChipConstraint to the place and route toolchain allowing vertices to
  be constrained to the same physical chip so that they can share on-chip
  resources.

v0.7.0

* Include (a minor derivative of) SCAMP 1.34. Previously included 1.33. These
  two releases *should* be binary compatible for applications... Apparently...
* Use "flood-fill core select packets" when loading applications. This makes
  use of a feature added in the included version of SCAMP which allows the
  application loading process to only send out each application binary once, no
  matter how many regions are required to enumerate all cores required. This
  yields substantial speedups in applications using large or irregular sets of
  cores.

v0.6.4

* Improve rig utility script documentation.

v0.6.3

* Fixes a bug requring write-access to APLX files to load.