HALDLS
routing_crossbar.h
Go to the documentation of this file.
1 #pragma once
2 #include <array>
3 #include <iosfwd>
4 
5 #include "halco/common/geometry.h"
6 #include "halco/common/typed_array.h"
7 #include "halco/hicann-dls/vx/event.h"
8 #include "halco/hicann-dls/vx/routing_crossbar.h"
9 #include "haldls/cerealization.h"
10 #include "haldls/vx/genpybind.h"
11 #include "haldls/vx/traits.h"
12 #include "hate/math.h"
13 #include "hate/visibility.h"
14 
15 #ifndef __ppu__
16 #include "hxcomm/vx/target.h"
17 #endif
18 
19 namespace fisch::vx {
20 class OmnibusChipOverJTAG;
21 class Omnibus;
22 } // namespace fisch::vx
23 
24 namespace haldls {
25 namespace vx GENPYBIND_TAG_HALDLS_VX {
26 
27 class GENPYBIND(visible) CrossbarOutputConfig
28 {
29 public:
30  typedef halco::hicann_dls::vx::CrossbarOutputConfigOnDLS coordinate_type;
31  typedef std::true_type is_leaf_node;
32 #ifndef __ppu__
33  constexpr static auto unsupported_read_targets GENPYBIND(hidden) = {
34  hxcomm::vx::Target::hardware};
35 #endif
36 
38  CrossbarOutputConfig() SYMBOL_VISIBLE;
39 
40  typedef halco::common::typed_array<bool, halco::hicann_dls::vx::CrossbarOutputOnDLS>
41  enable_event_counter_type GENPYBIND(opaque);
42  typedef halco::common::typed_array<bool, halco::hicann_dls::vx::CrossbarL2OutputOnDLS>
43  enable_slow_type GENPYBIND(opaque);
44 
49  GENPYBIND(getter_for(enable_event_counter), return_value_policy(reference_internal))
50  enable_event_counter_type const& get_enable_event_counter() const SYMBOL_VISIBLE;
51 
56  GENPYBIND(setter_for(enable_event_counter))
57  void set_enable_event_counter(enable_event_counter_type const& value) SYMBOL_VISIBLE;
58 
59  GENPYBIND(getter_for(enable_slow), return_value_policy(reference_internal))
60  enable_slow_type const& get_enable_slow() const SYMBOL_VISIBLE;
61 
62  GENPYBIND(setter_for(enable_slow))
63  void set_enable_slow(enable_slow_type const& value) SYMBOL_VISIBLE;
64 
65  bool operator==(CrossbarOutputConfig const& other) const SYMBOL_VISIBLE;
66  bool operator!=(CrossbarOutputConfig const& other) const SYMBOL_VISIBLE;
67 
68  static size_t constexpr config_size_in_words GENPYBIND(hidden) = 1;
69  template <typename AddressT>
70  static std::array<AddressT, config_size_in_words> addresses(coordinate_type const& neuron)
71  SYMBOL_VISIBLE GENPYBIND(hidden);
72  template <typename WordT>
73  std::array<WordT, config_size_in_words> encode() const SYMBOL_VISIBLE GENPYBIND(hidden);
74  template <typename WordT>
75  void decode(std::array<WordT, config_size_in_words> const& data) SYMBOL_VISIBLE
76  GENPYBIND(hidden);
77 
78  GENPYBIND(stringstream)
79  friend std::ostream& operator<<(std::ostream& os, CrossbarOutputConfig const& config)
80  SYMBOL_VISIBLE;
81 
82 private:
83  friend class cereal::access;
84  template <class Archive>
85  void serialize(Archive& ar, std::uint32_t const version) SYMBOL_VISIBLE;
86 
87  enable_event_counter_type m_enable_event_counter;
88  enable_slow_type m_enable_slow;
89 };
90 
91 EXTERN_INSTANTIATE_CEREAL_SERIALIZE(CrossbarOutputConfig)
92 
93 namespace detail {
94 
95 template <>
96 struct BackendContainerTrait<CrossbarOutputConfig>
97  : public BackendContainerBase<
98  CrossbarOutputConfig,
99  fisch::vx::word_access_type::Omnibus,
100  fisch::vx::word_access_type::OmnibusChipOverJTAG>
101 {};
102 
103 } // namespace detail
104 
105 
110 class GENPYBIND(visible) CrossbarInputDropCounter
111 {
112 public:
113  typedef halco::hicann_dls::vx::CrossbarInputOnDLS coordinate_type;
114  typedef std::true_type is_leaf_node;
115 
116  struct GENPYBIND(inline_base("*")) Value
117  : public halco::common::detail::
118  RantWrapper<Value, uint_fast32_t, hate::math::pow(2, 16) - 1, 0>
119  {
120  constexpr explicit Value(uintmax_t const val = 0) GENPYBIND(implicit_conversion) :
121  rant_t(val)
122  {}
123  };
124 
126  CrossbarInputDropCounter() SYMBOL_VISIBLE;
127 
132  CrossbarInputDropCounter(Value value) SYMBOL_VISIBLE;
133 
138  GENPYBIND(getter_for(value))
139  Value get_value() const SYMBOL_VISIBLE;
140 
145  GENPYBIND(setter_for(value))
146  void set_value(Value value) SYMBOL_VISIBLE;
147 
148  bool operator==(CrossbarInputDropCounter const& other) const SYMBOL_VISIBLE;
149  bool operator!=(CrossbarInputDropCounter const& other) const SYMBOL_VISIBLE;
150 
151  static size_t constexpr read_config_size_in_words GENPYBIND(hidden) = 1;
152  static size_t constexpr write_config_size_in_words GENPYBIND(hidden) = 0;
153  template <typename AddressT>
154  static std::array<AddressT, read_config_size_in_words> read_addresses(
155  coordinate_type const& coord) SYMBOL_VISIBLE GENPYBIND(hidden);
156  template <typename AddressT>
157  static std::array<AddressT, write_config_size_in_words> write_addresses(
158  coordinate_type const& coord) SYMBOL_VISIBLE GENPYBIND(hidden);
159  template <typename WordT>
160  std::array<WordT, write_config_size_in_words> encode() const SYMBOL_VISIBLE GENPYBIND(hidden);
161  template <typename WordT>
162  void decode(std::array<WordT, read_config_size_in_words> const& data) SYMBOL_VISIBLE
163  GENPYBIND(hidden);
164 
165  GENPYBIND(stringstream)
166  friend std::ostream& operator<<(std::ostream& os, CrossbarInputDropCounter const& config)
167  SYMBOL_VISIBLE;
168 
169 private:
170  friend class cereal::access;
171  template <class Archive>
172  void serialize(Archive& ar, std::uint32_t const version) SYMBOL_VISIBLE;
173 
174  Value m_value;
175 };
176 
177 EXTERN_INSTANTIATE_CEREAL_SERIALIZE(CrossbarInputDropCounter)
178 
179 namespace detail {
180 
181 template <>
182 struct BackendContainerTrait<CrossbarInputDropCounter>
183  : public BackendContainerBase<
184  CrossbarInputDropCounter,
185  fisch::vx::word_access_type::Omnibus,
186  fisch::vx::word_access_type::OmnibusChipOverJTAG>
187 {};
188 
189 } // namespace detail
190 
191 
195 class GENPYBIND(visible) CrossbarOutputEventCounter
196 {
197 public:
198  typedef halco::hicann_dls::vx::CrossbarOutputOnDLS coordinate_type;
199  typedef std::true_type is_leaf_node;
200 
201  struct GENPYBIND(inline_base("*")) Value
202  : public halco::common::detail::
203  RantWrapper<Value, uint_fast32_t, hate::math::pow(2, 24) - 1, 0>
204  {
205  constexpr explicit Value(uintmax_t const val = 0) GENPYBIND(implicit_conversion) :
206  rant_t(val)
207  {}
208  };
209 
211  CrossbarOutputEventCounter() SYMBOL_VISIBLE;
212 
217  CrossbarOutputEventCounter(Value value) SYMBOL_VISIBLE;
218 
223  GENPYBIND(getter_for(value))
224  Value get_value() const SYMBOL_VISIBLE;
225 
230  GENPYBIND(setter_for(value))
231  void set_value(Value value) SYMBOL_VISIBLE;
232 
233  bool operator==(CrossbarOutputEventCounter const& other) const SYMBOL_VISIBLE;
234  bool operator!=(CrossbarOutputEventCounter const& other) const SYMBOL_VISIBLE;
235 
236  static size_t constexpr read_config_size_in_words GENPYBIND(hidden) = 1;
237  static size_t constexpr write_config_size_in_words GENPYBIND(hidden) = 0;
238  template <typename AddressT>
239  static std::array<AddressT, read_config_size_in_words> read_addresses(
240  coordinate_type const& coord) SYMBOL_VISIBLE GENPYBIND(hidden);
241  template <typename AddressT>
242  static std::array<AddressT, write_config_size_in_words> write_addresses(
243  coordinate_type const& coord) SYMBOL_VISIBLE GENPYBIND(hidden);
244  template <typename WordT>
245  std::array<WordT, write_config_size_in_words> encode() const SYMBOL_VISIBLE GENPYBIND(hidden);
246  template <typename WordT>
247  void decode(std::array<WordT, read_config_size_in_words> const& data) SYMBOL_VISIBLE
248  GENPYBIND(hidden);
249 
250  GENPYBIND(stringstream)
251  friend std::ostream& operator<<(std::ostream& os, CrossbarOutputEventCounter const& config)
252  SYMBOL_VISIBLE;
253 
254 private:
255  friend class cereal::access;
256  template <class Archive>
257  void serialize(Archive& ar, std::uint32_t const version) SYMBOL_VISIBLE;
258 
259  Value m_value;
260 };
261 
262 EXTERN_INSTANTIATE_CEREAL_SERIALIZE(CrossbarOutputEventCounter)
263 
264 namespace detail {
265 
266 template <>
267 struct BackendContainerTrait<CrossbarOutputEventCounter>
268  : public BackendContainerBase<
269  CrossbarOutputEventCounter,
270  fisch::vx::word_access_type::Omnibus,
271  fisch::vx::word_access_type::OmnibusChipOverJTAG>
272 {};
273 
274 } // namespace detail
275 
276 
282 class GENPYBIND(visible) CrossbarNode
283 {
284 public:
285  typedef halco::hicann_dls::vx::CrossbarNodeOnDLS coordinate_type;
286  typedef std::true_type is_leaf_node;
287 #ifndef __ppu__
288  constexpr static auto unsupported_read_targets GENPYBIND(hidden) = {
289  hxcomm::vx::Target::hardware};
290 #endif
291 
292  typedef halco::hicann_dls::vx::NeuronLabel neuron_label_type;
293 
295  CrossbarNode() SYMBOL_VISIBLE;
296 
301  GENPYBIND(getter_for(mask))
302  neuron_label_type get_mask() const SYMBOL_VISIBLE;
303 
308  GENPYBIND(setter_for(mask))
309  void set_mask(neuron_label_type value) SYMBOL_VISIBLE;
310 
315  GENPYBIND(getter_for(target))
316  neuron_label_type get_target() const SYMBOL_VISIBLE;
317 
322  GENPYBIND(setter_for(target))
323  void set_target(neuron_label_type value) SYMBOL_VISIBLE;
324 
325  GENPYBIND(getter_for(enable_drop_counter))
326  bool get_enable_drop_counter() const SYMBOL_VISIBLE;
327 
328  GENPYBIND(setter_for(enable_drop_counter))
329  void set_enable_drop_counter(bool value) SYMBOL_VISIBLE;
330 
331  bool operator==(CrossbarNode const& other) const SYMBOL_VISIBLE;
332  bool operator!=(CrossbarNode const& other) const SYMBOL_VISIBLE;
333 
334  static const SYMBOL_VISIBLE CrossbarNode drop_all;
335 
336  static size_t constexpr config_size_in_words GENPYBIND(hidden) = 1;
337  template <typename AddressT>
338  static std::array<AddressT, config_size_in_words> addresses(coordinate_type const& neuron)
339  SYMBOL_VISIBLE GENPYBIND(hidden);
340  template <typename WordT>
341  std::array<WordT, config_size_in_words> encode() const SYMBOL_VISIBLE GENPYBIND(hidden);
342  template <typename WordT>
343  void decode(std::array<WordT, config_size_in_words> const& data) SYMBOL_VISIBLE
344  GENPYBIND(hidden);
345 
346  GENPYBIND(stringstream)
347  friend std::ostream& operator<<(std::ostream& os, CrossbarNode const& config) SYMBOL_VISIBLE;
348 
349 private:
350  friend class cereal::access;
351  template <class Archive>
352  void serialize(Archive& ar, std::uint32_t const version) SYMBOL_VISIBLE;
353 
354  neuron_label_type m_mask;
355  neuron_label_type m_target;
356  bool m_enable_drop_counter;
357 };
358 
359 EXTERN_INSTANTIATE_CEREAL_SERIALIZE(CrossbarNode)
360 
361 namespace detail {
362 
363 template <>
364 struct BackendContainerTrait<CrossbarNode>
365  : public BackendContainerBase<
366  CrossbarNode,
367  fisch::vx::word_access_type::Omnibus,
368  fisch::vx::word_access_type::OmnibusChipOverJTAG>
369 {};
370 
371 } // namespace detail
372 
373 } // namespace vx
374 } // namespace haldls
EXTERN_INSTANTIATE_CEREAL_SERIALIZE
#define EXTERN_INSTANTIATE_CEREAL_SERIALIZE(CLASS_NAME)
Definition: cerealization.h:75
haldls::vx::CrossbarInputDropCounter
Crossbar input drop counter accumulating drops at all outputs for which the drop counter accumulation...
Definition: routing_crossbar.h:111
haldls::vx::CrossbarInputDropCounter::coordinate_type
halco::hicann_dls::vx::CrossbarInputOnDLS coordinate_type
Definition: routing_crossbar.h:113
haldls::vx::CrossbarOutputConfig::enable_slow_type
halco::common::typed_array< bool, halco::hicann_dls::vx::CrossbarL2OutputOnDLS > enable_slow_type
Definition: routing_crossbar.h:43
haldls::vx::CrossbarOutputConfig::enable_event_counter_type
halco::common::typed_array< bool, halco::hicann_dls::vx::CrossbarOutputOnDLS > enable_event_counter_type
Definition: routing_crossbar.h:41
haldls::vx::CrossbarOutputConfig::CrossbarOutputConfig
CrossbarOutputConfig() SYMBOL_VISIBLE
Default constructor.
haldls::vx::CrossbarOutputConfig::coordinate_type
halco::hicann_dls::vx::CrossbarOutputConfigOnDLS coordinate_type
Definition: routing_crossbar.h:30
GENPYBIND_TAG_HALDLS_VX
#define GENPYBIND_TAG_HALDLS_VX
Definition: genpybind.h:4
halco
Definition: arq.h:13
haldls::vx::detail::BackendContainerBase
Backend container trait base.
Definition: traits.h:77