HALDLS
vector_generator.h
Go to the documentation of this file.
1 #pragma once
2 #include <array>
3 #include <ostream>
4 
5 #include "halco/common/typed_array.h"
6 #include "halco/hicann-dls/vx/omnibus.h"
7 #include "halco/hicann-dls/vx/quad.h"
8 #include "halco/hicann-dls/vx/vector_generator.h"
9 
10 #include "haldls/cerealization.h"
11 #include "haldls/vx/genpybind.h"
12 #include "haldls/vx/padi.h"
13 #include "haldls/vx/traits.h"
14 #include "hate/visibility.h"
15 
16 namespace cereal {
17 class access;
18 } // namespace cereal
19 
20 namespace halco::hicann_dls::vx {
21 class OmnibusAddress;
22 struct PPUMemoryWordOnDLS;
23 } // namespace halco::hicann_dls::vx
24 
25 namespace haldls::vx GENPYBIND_TAG_HALDLS_VX {
26 
27 class GENPYBIND(visible) VectorGeneratorControl
28 {
29 public:
30  typedef halco::hicann_dls::vx::VectorGeneratorControlOnFPGA coordinate_type;
31  typedef std::true_type is_leaf_node;
32 
36  struct GENPYBIND(inline_base("*")) SourceCount
37  : public halco::common::detail::RantWrapper<SourceCount, uint_fast8_t, 2, 1>
38  {
39  constexpr explicit SourceCount(uintmax_t const val = 1) GENPYBIND(implicit_conversion) :
40  rant_t(val)
41  {}
42  };
43 
47  struct GENPYBIND(inline_base("*")) Wait
48  : public halco::common::detail::RantWrapper<Wait, uint_fast8_t, 15, 0>
49  {
50  constexpr explicit Wait(uintmax_t const val = 0) GENPYBIND(implicit_conversion) :
51  rant_t(val)
52  {}
53  };
54 
58  struct GENPYBIND(inline_base("*")) ResendCount
59  : public halco::common::detail::RantWrapper<ResendCount, uint_fast8_t, 15, 0>
60  {
61  constexpr explicit ResendCount(uintmax_t const val = 0) GENPYBIND(implicit_conversion) :
62  rant_t(val)
63  {}
64  };
65 
69  enum class GENPYBIND(visible) Source
70  {
71  omnibus,
72  external_0,
73  external_1,
74  external_2
75  };
76 
80  struct GENPYBIND(inline_base("*")) EventPack
81  : public halco::common::detail::RantWrapper<EventPack, uint_fast8_t, 3, 1>
82  {
83  constexpr explicit EventPack(uintmax_t const val = 1) GENPYBIND(implicit_conversion) :
84  rant_t(val)
85  {}
86  };
87 
91  enum class GENPYBIND(visible) Notification
92  {
93  omnibus,
94  gpio
95  };
96 
100  enum class GENPYBIND(visible) Trigger
101  {
102  omnibus,
103  gpio
104  };
105 
109  enum class GENPYBIND(visible) Signal
110  {
111  disabled,
112  notification,
113  trigger_and_notification
114  };
115 
116  VectorGeneratorControl() = default;
117 
122  GENPYBIND(getter_for(lookup_table_entry_start))
123  halco::hicann_dls::vx::VectorGeneratorLUTEntryOnVectorGeneratorLUT
124  get_lookup_table_entry_start() const SYMBOL_VISIBLE;
125 
130  GENPYBIND(setter_for(lookup_table_entry_start))
131  void set_lookup_table_entry_start(
132  halco::hicann_dls::vx::VectorGeneratorLUTEntryOnVectorGeneratorLUT value) SYMBOL_VISIBLE;
133 
134  GENPYBIND(getter_for(source_count))
135  SourceCount get_source_count() const SYMBOL_VISIBLE;
136  GENPYBIND(setter_for(source_count))
137  void set_source_count(SourceCount value) SYMBOL_VISIBLE;
138 
139  GENPYBIND(getter_for(resend_count))
140  ResendCount get_resend_count() const SYMBOL_VISIBLE;
141  GENPYBIND(setter_for(resend_count))
142  void set_resend_count(ResendCount value) SYMBOL_VISIBLE;
143 
144  typedef halco::common::typed_array<Wait, halco::hicann_dls::vx::SourceOnVectorGenerator>
145  SourceWaits GENPYBIND(opaque);
146  typedef halco::common::typed_array<Source, halco::hicann_dls::vx::SourceOnVectorGenerator>
147  Sources GENPYBIND(opaque);
148 
149  GENPYBIND(getter_for(source_waits))
150  SourceWaits get_source_waits() const SYMBOL_VISIBLE;
151  GENPYBIND(setter_for(source_waits))
152  void set_source_waits(SourceWaits value) SYMBOL_VISIBLE;
153 
154  GENPYBIND(getter_for(sources))
155  Sources get_sources() const SYMBOL_VISIBLE;
156  GENPYBIND(setter_for(sources))
157  void set_sources(Sources value) SYMBOL_VISIBLE;
158 
159  GENPYBIND(getter_for(event_pack))
160  EventPack get_event_pack() const SYMBOL_VISIBLE;
161  GENPYBIND(setter_for(event_pack))
162  void set_event_pack(EventPack value) SYMBOL_VISIBLE;
163 
168  GENPYBIND(getter_for(enable_ignore_zeros))
169  bool get_enable_ignore_zeros() const SYMBOL_VISIBLE;
170 
175  GENPYBIND(setter_for(enable_ignore_zeros))
176  void set_enable_ignore_zeros(bool value) SYMBOL_VISIBLE;
177 
178  GENPYBIND(getter_for(notification))
179  Notification get_notification() const SYMBOL_VISIBLE;
180  GENPYBIND(setter_for(notification))
181  void set_notification(Notification value) SYMBOL_VISIBLE;
182 
183  GENPYBIND(getter_for(trigger))
184  Trigger get_trigger() const SYMBOL_VISIBLE;
185  GENPYBIND(setter_for(trigger))
186  void set_trigger(Trigger value) SYMBOL_VISIBLE;
187 
188  GENPYBIND(getter_for(signal))
189  Signal get_signal() const SYMBOL_VISIBLE;
190  GENPYBIND(setter_for(signal))
191  void set_signal(Signal value) SYMBOL_VISIBLE;
192 
193  bool operator==(VectorGeneratorControl const& other) const SYMBOL_VISIBLE;
194  bool operator!=(VectorGeneratorControl const& other) const SYMBOL_VISIBLE;
195 
196  static size_t constexpr read_config_size_in_words GENPYBIND(hidden) = 0;
197  static size_t constexpr write_config_size_in_words GENPYBIND(hidden) = 1;
198  static std::array<halco::hicann_dls::vx::OmnibusAddress, read_config_size_in_words>
199  read_addresses(coordinate_type const& coord) SYMBOL_VISIBLE GENPYBIND(hidden);
200  static std::array<halco::hicann_dls::vx::OmnibusAddress, write_config_size_in_words>
201  write_addresses(coordinate_type const& coord) SYMBOL_VISIBLE GENPYBIND(hidden);
202  std::array<fisch::vx::word_access_type::Omnibus, write_config_size_in_words> encode() const
203  SYMBOL_VISIBLE GENPYBIND(hidden);
204  void decode(std::array<fisch::vx::word_access_type::Omnibus, read_config_size_in_words> const&
205  data) SYMBOL_VISIBLE GENPYBIND(hidden);
206 
207  GENPYBIND(stringstream)
208  friend std::ostream& operator<<(std::ostream& os, VectorGeneratorControl const& config)
209  SYMBOL_VISIBLE;
210 
211 private:
212  friend class cereal::access;
213  template <class Archive>
214  void serialize(Archive& ar, std::uint32_t const version) SYMBOL_VISIBLE;
215 
216  halco::hicann_dls::vx::VectorGeneratorLUTEntryOnVectorGeneratorLUT m_lookup_table_entry_start{};
217  SourceCount m_source_count{};
218  ResendCount m_resend_count{};
219  SourceWaits m_source_waits{Wait(), Wait()};
220  Sources m_sources{Source::omnibus, Source::omnibus};
221  EventPack m_event_pack;
222  bool m_enable_ignore_zeros{false};
223  Notification m_notification{};
224  Trigger m_trigger{};
225  Signal m_signal{};
226 };
227 
228 EXTERN_INSTANTIATE_CEREAL_SERIALIZE(VectorGeneratorControl)
229 
230 namespace detail {
231 
232 template <>
233 struct BackendContainerTrait<VectorGeneratorControl>
234  : public BackendContainerBase<VectorGeneratorControl, fisch::vx::word_access_type::Omnibus>
235 {};
236 
237 } // namespace detail
238 
239 std::ostream& operator<<(std::ostream& os, VectorGeneratorControl::Notification const& config)
240  SYMBOL_VISIBLE;
241 
242 std::ostream& operator<<(std::ostream& os, VectorGeneratorControl::Trigger const& config)
243  SYMBOL_VISIBLE;
244 
245 std::ostream& operator<<(std::ostream& os, VectorGeneratorControl::Signal const& config)
246  SYMBOL_VISIBLE;
247 
248 
252 class GENPYBIND(visible) VectorGeneratorLUTEntry
253 {
254 public:
255  typedef std::true_type is_leaf_node;
256  typedef halco::hicann_dls::vx::VectorGeneratorLUTEntryOnFPGA coordinate_type;
257 
261  struct GENPYBIND(inline_base("*")) Value
262  : public halco::common::detail::RantWrapper<Value, uint_fast16_t, 2047, 0>
263  {
264  constexpr explicit Value(uintmax_t const val = 0) GENPYBIND(implicit_conversion) :
265  rant_t(val)
266  {}
267  };
268 
270  VectorGeneratorLUTEntry() = default;
271 
276  GENPYBIND(getter_for(value))
277  Value get_value() const SYMBOL_VISIBLE;
278 
283  GENPYBIND(setter_for(value))
284  void set_value(Value value) SYMBOL_VISIBLE;
285 
286  bool operator==(VectorGeneratorLUTEntry const& other) const SYMBOL_VISIBLE;
287  bool operator!=(VectorGeneratorLUTEntry const& other) const SYMBOL_VISIBLE;
288 
289  GENPYBIND(stringstream)
290  friend std::ostream& operator<<(std::ostream& os, VectorGeneratorLUTEntry const& config)
291  SYMBOL_VISIBLE;
292 
293  static size_t constexpr config_size_in_words GENPYBIND(hidden) = 1;
294  static std::array<halco::hicann_dls::vx::OmnibusAddress, config_size_in_words> addresses(
295  coordinate_type const& coord) SYMBOL_VISIBLE GENPYBIND(hidden);
296  std::array<fisch::vx::word_access_type::Omnibus, config_size_in_words> encode() const
297  SYMBOL_VISIBLE GENPYBIND(hidden);
298  void decode(std::array<fisch::vx::word_access_type::Omnibus, config_size_in_words> const& data)
299  SYMBOL_VISIBLE GENPYBIND(hidden);
300 
301 private:
302  friend class cereal::access;
303  template <typename Archive>
304  void serialize(Archive& ar, std::uint32_t const version) SYMBOL_VISIBLE;
305 
306  Value m_value{};
307 };
308 
309 EXTERN_INSTANTIATE_CEREAL_SERIALIZE(VectorGeneratorLUTEntry)
310 
311 namespace detail {
312 
313 template <>
314 struct BackendContainerTrait<VectorGeneratorLUTEntry>
315  : public BackendContainerBase<VectorGeneratorLUTEntry, fisch::vx::word_access_type::Omnibus>
316 {};
317 
318 } // namespace detail
319 
320 
321 class GENPYBIND(visible) VectorGeneratorNotificationAddress
322 {
323 public:
324  typedef std::true_type is_leaf_node;
325  typedef halco::hicann_dls::vx::VectorGeneratorNotificationAddressOnFPGA coordinate_type;
326 
327  typedef halco::hicann_dls::vx::OmnibusAddress Value GENPYBIND(visible);
328 
330  VectorGeneratorNotificationAddress() = default;
331 
336  GENPYBIND(getter_for(value))
337  Value get_value() const SYMBOL_VISIBLE;
338 
343  GENPYBIND(setter_for(value))
344  void set_value(Value value) SYMBOL_VISIBLE;
345 
350  VectorGeneratorNotificationAddress(halco::hicann_dls::vx::PPUMemoryWordOnDLS const& word)
351  SYMBOL_VISIBLE;
352 
353  bool operator==(VectorGeneratorNotificationAddress const& other) const SYMBOL_VISIBLE;
354  bool operator!=(VectorGeneratorNotificationAddress const& other) const SYMBOL_VISIBLE;
355 
356  GENPYBIND(stringstream)
357  friend std::ostream& operator<<(
358  std::ostream& os, VectorGeneratorNotificationAddress const& config) SYMBOL_VISIBLE;
359 
360  static size_t constexpr config_size_in_words GENPYBIND(hidden) = 1;
361  static std::array<halco::hicann_dls::vx::OmnibusAddress, config_size_in_words> addresses(
362  coordinate_type const& coord) SYMBOL_VISIBLE GENPYBIND(hidden);
363  std::array<fisch::vx::word_access_type::Omnibus, config_size_in_words> encode() const
364  SYMBOL_VISIBLE GENPYBIND(hidden);
365  void decode(std::array<fisch::vx::word_access_type::Omnibus, config_size_in_words> const& data)
366  SYMBOL_VISIBLE GENPYBIND(hidden);
367 
368 private:
369  friend class cereal::access;
370  template <typename Archive>
371  void serialize(Archive& ar, std::uint32_t const version) SYMBOL_VISIBLE;
372 
373  Value m_value{};
374 };
375 
376 EXTERN_INSTANTIATE_CEREAL_SERIALIZE(VectorGeneratorNotificationAddress)
377 
378 namespace detail {
379 
380 template <>
381 struct BackendContainerTrait<VectorGeneratorNotificationAddress>
382  : public BackendContainerBase<
383  VectorGeneratorNotificationAddress,
384  fisch::vx::word_access_type::Omnibus>
385 {};
386 
387 } // namespace detail
388 
389 
390 class GENPYBIND(visible) VectorGeneratorTrigger
391 {
392 public:
393  typedef std::true_type is_leaf_node;
394  typedef halco::hicann_dls::vx::VectorGeneratorTriggerOnFPGA coordinate_type;
395 
397  VectorGeneratorTrigger() = default;
398 
399  bool operator==(VectorGeneratorTrigger const& other) const SYMBOL_VISIBLE;
400  bool operator!=(VectorGeneratorTrigger const& other) const SYMBOL_VISIBLE;
401 
402  GENPYBIND(stringstream)
403  friend std::ostream& operator<<(std::ostream& os, VectorGeneratorTrigger const& config)
404  SYMBOL_VISIBLE;
405 
406  static size_t constexpr write_config_size_in_words GENPYBIND(hidden) = 1;
407  static size_t constexpr read_config_size_in_words GENPYBIND(hidden) = 0;
408  static std::array<halco::hicann_dls::vx::OmnibusAddress, write_config_size_in_words>
409  write_addresses(coordinate_type const& coord) SYMBOL_VISIBLE GENPYBIND(hidden);
410  static std::array<halco::hicann_dls::vx::OmnibusAddress, read_config_size_in_words>
411  read_addresses(coordinate_type const& coord) SYMBOL_VISIBLE GENPYBIND(hidden);
412  std::array<fisch::vx::word_access_type::Omnibus, write_config_size_in_words> encode() const
413  SYMBOL_VISIBLE GENPYBIND(hidden);
414  void decode(std::array<fisch::vx::word_access_type::Omnibus, read_config_size_in_words> const&
415  data) SYMBOL_VISIBLE GENPYBIND(hidden);
416 
417 private:
418  friend class cereal::access;
419  template <typename Archive>
420  void serialize(Archive& ar, std::uint32_t const version) SYMBOL_VISIBLE;
421 };
422 
423 EXTERN_INSTANTIATE_CEREAL_SERIALIZE(VectorGeneratorTrigger)
424 
425 namespace detail {
426 
427 template <>
428 struct BackendContainerTrait<VectorGeneratorTrigger>
429  : public BackendContainerBase<VectorGeneratorTrigger, fisch::vx::word_access_type::Omnibus>
430 {};
431 
432 } // namespace detail
433 
434 
439 class GENPYBIND(visible) VectorGeneratorFIFOWord
440 {
441 public:
442  typedef std::true_type is_leaf_node;
443  typedef halco::hicann_dls::vx::VectorGeneratorFIFOWordOnFPGA coordinate_type;
444 
445  typedef PADIEvent::HagenActivation Value GENPYBIND(visible);
446 
447  typedef halco::common::typed_array<Value, halco::hicann_dls::vx::EntryOnQuad> Values
448  GENPYBIND(opaque);
449  typedef halco::common::typed_array<bool, halco::hicann_dls::vx::EntryOnQuad> Enables
450  GENPYBIND(opaque);
451 
453  VectorGeneratorFIFOWord() SYMBOL_VISIBLE;
454 
459  GENPYBIND(getter_for(values), return_value_policy(reference))
460  Values const& get_values() const SYMBOL_VISIBLE;
461 
466  GENPYBIND(setter_for(values))
467  void set_values(Values value) SYMBOL_VISIBLE;
468 
473  GENPYBIND(getter_for(last), return_value_policy(reference))
474  Enables const& get_last() const SYMBOL_VISIBLE;
475 
480  GENPYBIND(setter_for(last))
481  void set_last(Enables value) SYMBOL_VISIBLE;
482 
487  GENPYBIND(getter_for(enable), return_value_policy(reference))
488  Enables const& get_enable() const SYMBOL_VISIBLE;
489 
494  GENPYBIND(setter_for(enable))
495  void set_enable(Enables value) SYMBOL_VISIBLE;
496 
497  bool operator==(VectorGeneratorFIFOWord const& other) const SYMBOL_VISIBLE;
498  bool operator!=(VectorGeneratorFIFOWord const& other) const SYMBOL_VISIBLE;
499 
500  GENPYBIND(stringstream)
501  friend std::ostream& operator<<(std::ostream& os, VectorGeneratorFIFOWord const& config)
502  SYMBOL_VISIBLE;
503 
504  static size_t constexpr write_config_size_in_words GENPYBIND(hidden) = 1;
505  static size_t constexpr read_config_size_in_words GENPYBIND(hidden) = 0;
506  static std::array<halco::hicann_dls::vx::OmnibusAddress, write_config_size_in_words>
507  write_addresses(coordinate_type const& coord) SYMBOL_VISIBLE GENPYBIND(hidden);
508  static std::array<halco::hicann_dls::vx::OmnibusAddress, read_config_size_in_words>
509  read_addresses(coordinate_type const& coord) SYMBOL_VISIBLE GENPYBIND(hidden);
510  std::array<fisch::vx::word_access_type::Omnibus, write_config_size_in_words> encode() const
511  SYMBOL_VISIBLE GENPYBIND(hidden);
512  void decode(std::array<fisch::vx::word_access_type::Omnibus, read_config_size_in_words> const&
513  data) SYMBOL_VISIBLE GENPYBIND(hidden);
514 
515 private:
516  friend class cereal::access;
517  template <typename Archive>
518  void serialize(Archive& ar, std::uint32_t const version) SYMBOL_VISIBLE;
519 
520  Values m_values;
521  Enables m_last;
522  Enables m_enable;
523 };
524 
525 EXTERN_INSTANTIATE_CEREAL_SERIALIZE(VectorGeneratorFIFOWord)
526 
527 namespace detail {
528 
529 template <>
530 struct BackendContainerTrait<VectorGeneratorFIFOWord>
531  : public BackendContainerBase<VectorGeneratorFIFOWord, fisch::vx::word_access_type::Omnibus>
532 {};
533 
534 } // namespace detail
535 
536 } // namespace haldls::vx
haldls::vx::VectorGeneratorControl::coordinate_type
halco::hicann_dls::vx::VectorGeneratorControlOnFPGA coordinate_type
Definition: vector_generator.h:30
GENPYBIND_TAG_HALDLS_VX
#define GENPYBIND_TAG_HALDLS_VX
Definition: genpybind.h:4
halco::hicann_dls::vx
Definition: arq.h:13