HALDLS
neuron.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/neuron.h"
8 #include "haldls/vx/genpybind.h"
9 #include "haldls/vx/sram_controller.h"
10 #include "haldls/vx/traits.h"
11 #include "hate/visibility.h"
12 
13 #ifndef __ppu__
14 #include "haldls/cerealization.h"
15 #include "hxcomm/vx/target.h"
16 #endif
17 
18 namespace fisch::vx {
19 class OmnibusChipOverJTAG;
20 class Omnibus;
21 } // namespace fisch::vx
22 
23 namespace haldls {
24 namespace vx GENPYBIND_TAG_HALDLS_VX {
25 
26 
30 class GENPYBIND(visible) CommonNeuronBackendConfig : public DifferentialWriteTrait
31 {
32 public:
33  typedef halco::hicann_dls::vx::CommonNeuronBackendConfigOnDLS coordinate_type;
34  typedef std::true_type is_leaf_node;
35 
43  struct GENPYBIND(inline_base("*")) ClockScale
44  : public halco::common::detail::RantWrapper<ClockScale, uint_fast8_t, 15, 0>
45  {
46  constexpr explicit ClockScale(uintmax_t const val = 0) GENPYBIND(implicit_conversion) :
47  rant_t(val)
48  {}
49  };
50 
55  struct GENPYBIND(inline_base("*")) WaitGlobalPostPulse
56  : public halco::common::detail::RantWrapper<WaitGlobalPostPulse, uint_fast16_t, 255, 0>
57  {
58  constexpr explicit WaitGlobalPostPulse(uintmax_t const val = 1)
59  GENPYBIND(implicit_conversion) :
60  base_t(val)
61  {}
62  };
63 
67  struct GENPYBIND(inline_base("*")) WaitSpikeCounterReset
68  : public halco::common::detail::RantWrapper<WaitSpikeCounterReset, uint_fast16_t, 255, 0>
69  {
70  constexpr explicit WaitSpikeCounterReset(uintmax_t const val = 4)
71  GENPYBIND(implicit_conversion) :
72  base_t(val)
73  {}
74  };
75 
80  struct GENPYBIND(inline_base("*")) WaitSpikeCounterRead
81  : public halco::common::detail::RantWrapper<WaitSpikeCounterRead, uint_fast16_t, 255, 0>
82  {
83  constexpr explicit WaitSpikeCounterRead(uintmax_t const val = 112)
84  GENPYBIND(implicit_conversion) :
85  base_t(val)
86  {}
87  };
88 
92  struct GENPYBIND(inline_base("*")) WaitFireNeuron
93  : public halco::common::detail::RantWrapper<WaitFireNeuron, uint_fast16_t, 255, 0>
94  {
95  constexpr explicit WaitFireNeuron(uintmax_t const val = 4) GENPYBIND(implicit_conversion) :
96  base_t(val)
97  {}
98  };
99 
100  CommonNeuronBackendConfig() SYMBOL_VISIBLE;
101 
102  // accessors
103  GENPYBIND(getter_for(enable_event_registers))
104  bool get_enable_event_registers() const SYMBOL_VISIBLE;
105  GENPYBIND(setter_for(enable_event_registers))
106  void set_enable_event_registers(bool val) SYMBOL_VISIBLE;
107 
108  GENPYBIND(getter_for(force_reset))
109  bool get_force_reset() const SYMBOL_VISIBLE;
110  GENPYBIND(setter_for(force_reset))
111  void set_force_reset(bool val) SYMBOL_VISIBLE;
112 
113  GENPYBIND(getter_for(enable_clocks))
114  bool get_enable_clocks() const SYMBOL_VISIBLE;
115  GENPYBIND(setter_for(enable_clocks))
116  void set_enable_clocks(bool val) SYMBOL_VISIBLE;
117 
118  GENPYBIND(getter_for(clock_scale_slow))
119  ClockScale get_clock_scale_slow() const SYMBOL_VISIBLE;
120  GENPYBIND(setter_for(clock_scale_slow))
121  void set_clock_scale_slow(ClockScale const val) SYMBOL_VISIBLE;
122 
123  GENPYBIND(getter_for(clock_scale_fast))
124  ClockScale get_clock_scale_fast() const SYMBOL_VISIBLE;
125  GENPYBIND(setter_for(clock_scale_fast))
126  void set_clock_scale_fast(ClockScale const val) SYMBOL_VISIBLE;
127 
128  bool get_sample_positive_edge(
129  halco::hicann_dls::vx::NeuronEventOutputOnNeuronBackendBlock coord) const SYMBOL_VISIBLE;
130  void set_sample_positive_edge(
131  halco::hicann_dls::vx::NeuronEventOutputOnNeuronBackendBlock coord,
132  bool val) SYMBOL_VISIBLE;
133 
134  GENPYBIND(getter_for(clock_scale_adaptation_pulse))
135  ClockScale get_clock_scale_adaptation_pulse() const SYMBOL_VISIBLE;
136  GENPYBIND(setter_for(clock_scale_adaptation_pulse))
137  void set_clock_scale_adaptation_pulse(ClockScale const val) SYMBOL_VISIBLE;
138 
139  GENPYBIND(getter_for(clock_scale_post_pulse))
140  ClockScale get_clock_scale_post_pulse() const SYMBOL_VISIBLE;
141  GENPYBIND(setter_for(clock_scale_post_pulse))
142  void set_clock_scale_post_pulse(ClockScale const val) SYMBOL_VISIBLE;
143 
144  GENPYBIND(getter_for(wait_global_post_pulse))
145  WaitGlobalPostPulse get_wait_global_post_pulse() const SYMBOL_VISIBLE;
146  GENPYBIND(setter_for(wait_global_post_pulse))
147  void set_wait_global_post_pulse(WaitGlobalPostPulse const val) SYMBOL_VISIBLE;
148 
149  GENPYBIND(getter_for(wait_spike_counter_reset))
150  WaitSpikeCounterReset get_wait_spike_counter_reset() const SYMBOL_VISIBLE;
151  GENPYBIND(setter_for(wait_spike_counter_reset))
152  void set_wait_spike_counter_reset(WaitSpikeCounterReset const val) SYMBOL_VISIBLE;
153 
154  GENPYBIND(getter_for(wait_spike_counter_read))
155  WaitSpikeCounterRead get_wait_spike_counter_read() const SYMBOL_VISIBLE;
156  GENPYBIND(setter_for(wait_spike_counter_read))
157  void set_wait_spike_counter_read(WaitSpikeCounterRead const val) SYMBOL_VISIBLE;
158 
159  GENPYBIND(getter_for(wait_fire_neuron))
160  WaitFireNeuron get_wait_fire_neuron() const SYMBOL_VISIBLE;
161  GENPYBIND(setter_for(wait_fire_neuron))
162  void set_wait_fire_neuron(WaitFireNeuron const val) SYMBOL_VISIBLE;
163 
164  bool operator==(CommonNeuronBackendConfig const& other) const SYMBOL_VISIBLE;
165  bool operator!=(CommonNeuronBackendConfig const& other) const SYMBOL_VISIBLE;
166 
167  static size_t constexpr config_size_in_words GENPYBIND(hidden) = 2;
168  template <typename AddressT>
169  static std::array<AddressT, config_size_in_words> addresses(coordinate_type const& neuron)
170  SYMBOL_VISIBLE GENPYBIND(hidden);
171  template <typename WordT>
172  std::array<WordT, config_size_in_words> encode() const SYMBOL_VISIBLE GENPYBIND(hidden);
173  template <typename WordT>
174  void decode(std::array<WordT, config_size_in_words> const& data) SYMBOL_VISIBLE
175  GENPYBIND(hidden);
176 
177  GENPYBIND(stringstream)
178  friend std::ostream& operator<<(std::ostream& os, CommonNeuronBackendConfig const& config)
179  SYMBOL_VISIBLE;
180 
181 private:
182  friend class cereal::access;
183  template <class Archive>
184  void serialize(Archive& ar, std::uint32_t const version) SYMBOL_VISIBLE;
185 
186  bool m_en_event_regs;
187  bool m_force_reset;
188  bool m_en_clocks;
189  ClockScale m_clock_scale_slow;
190  ClockScale m_clock_scale_fast;
191  halco::common::typed_array<bool, halco::hicann_dls::vx::NeuronEventOutputOnNeuronBackendBlock>
192  m_sample_pos_edge;
193  ClockScale m_clock_scale_adapt_pulse;
194  ClockScale m_clock_scale_post_pulse;
195  WaitGlobalPostPulse m_wait_global_post_pulse;
196  WaitSpikeCounterReset m_wait_spike_counter_reset;
197  WaitSpikeCounterRead m_wait_spike_counter_read;
198  WaitFireNeuron m_wait_fire_neuron;
199 };
200 
201 #ifndef __ppu__
202 EXTERN_INSTANTIATE_CEREAL_SERIALIZE(CommonNeuronBackendConfig)
203 #endif
204 
208 struct GENPYBIND(inline_base("*")) NeuronBackendAddressOut
209  : public halco::common::detail::RantWrapper<NeuronBackendAddressOut, uint_fast16_t, 255, 0>
210 {
211  typedef halco::common::detail::RantWrapper<NeuronBackendAddressOut, uint_fast16_t, 255, 0>
212  rant_t;
213  constexpr explicit NeuronBackendAddressOut(uintmax_t const val = 0)
214  GENPYBIND(implicit_conversion) :
215  rant_t(val)
216  {}
217 };
218 
219 template <typename Coordinates>
220 class NeuronBackendConfig;
221 
229 template <typename Coordinates>
230 class NeuronBackendConfig : public DifferentialWriteTrait
231 {
232 public:
233  typedef typename Coordinates::NeuronBackendConfigOnDLS coordinate_type;
234  typedef std::true_type is_leaf_node;
235 #ifndef __ppu__
236  constexpr static auto unsupported_read_targets GENPYBIND(hidden) = {
237  hxcomm::vx::Target::simulation};
238 #endif
239 
240  typedef NeuronBackendAddressOut AddressOut GENPYBIND(visible);
241 
270  struct GENPYBIND(inline_base("*")) ResetHoldoff
271  : public halco::common::detail::RantWrapper<ResetHoldoff, uint_fast8_t, 15, 0>
272  {
273  typedef halco::common::detail::RantWrapper<ResetHoldoff, uint_fast8_t, 15, 0> rant_t;
274  constexpr explicit ResetHoldoff() : rant_t(15) {}
275  constexpr explicit ResetHoldoff(uintmax_t const val) GENPYBIND(implicit_conversion) :
276  rant_t(val)
277  {}
278  };
279 
298  struct GENPYBIND(inline_base("*")) RefractoryTime
299  : public halco::common::detail::RantWrapper<RefractoryTime, uint_fast16_t, 255, 0>
300  {
301  typedef halco::common::detail::RantWrapper<RefractoryTime, uint_fast16_t, 255, 0> rant_t;
302  constexpr explicit RefractoryTime() : rant_t(0) {}
303  constexpr explicit RefractoryTime(uintmax_t const val) GENPYBIND(implicit_conversion) :
304  rant_t(val)
305  {}
306  };
307 
312  struct GENPYBIND(inline_base("*")) InputClock
313  : public halco::common::detail::RantWrapper<InputClock, uint_fast8_t, 1, 0>
314  {
315  typedef halco::common::detail::RantWrapper<InputClock, uint_fast8_t, 1, 0> rant_t;
316  constexpr explicit InputClock() : rant_t(0) {}
317  constexpr explicit InputClock(uintmax_t const val) GENPYBIND(implicit_conversion) :
318  rant_t(val)
319  {}
320  };
321 
322  NeuronBackendConfig();
323 
324  // accessors
325  GENPYBIND(getter_for(address_out))
326  AddressOut get_address_out() const;
327  GENPYBIND(setter_for(address_out))
328  void set_address_out(AddressOut addr);
329 
330  GENPYBIND(getter_for(reset_holdoff))
331  ResetHoldoff get_reset_holdoff() const;
332  GENPYBIND(setter_for(reset_holdoff))
333  void set_reset_holdoff(ResetHoldoff val);
334 
335  GENPYBIND(getter_for(refractory_time))
336  RefractoryTime get_refractory_time() const;
337  GENPYBIND(setter_for(refractory_time))
338  void set_refractory_time(RefractoryTime val);
339 
340  GENPYBIND(getter_for(post_overwrite))
341  bool get_post_overwrite() const;
342  GENPYBIND(setter_for(post_overwrite))
343  void set_post_overwrite(bool val);
344 
345  GENPYBIND(getter_for(select_input_clock))
346  InputClock get_select_input_clock() const;
347  GENPYBIND(setter_for(select_input_clock))
348  void set_select_input_clock(InputClock src);
349 
350  GENPYBIND(getter_for(enable_adaptation_pulse))
351  bool get_enable_adaptation_pulse() const;
352  GENPYBIND(setter_for(enable_adaptation_pulse))
353  void set_enable_adaptation_pulse(bool val);
354 
355  GENPYBIND(getter_for(enable_bayesian_extension))
356  bool get_enable_bayesian_extension() const;
357  GENPYBIND(setter_for(enable_bayesian_extension))
358  void set_enable_bayesian_extension(bool val);
359 
360  GENPYBIND(getter_for(enable_neuron_slave))
361  bool get_enable_neuron_slave() const;
362  GENPYBIND(setter_for(enable_neuron_slave))
363  void set_enable_neuron_slave(bool val);
364 
365  GENPYBIND(getter_for(connect_fire_bottom))
366  bool get_connect_fire_bottom() const;
367  GENPYBIND(setter_for(connect_fire_bottom))
368  void set_connect_fire_bottom(bool val);
369 
370  GENPYBIND(getter_for(connect_fire_from_right))
371  bool get_connect_fire_from_right() const;
372  GENPYBIND(setter_for(connect_fire_from_right))
373  void set_connect_fire_from_right(bool val);
374 
375  GENPYBIND(getter_for(connect_fire_to_right))
376  bool get_connect_fire_to_right() const;
377  GENPYBIND(setter_for(connect_fire_to_right))
378  void set_connect_fire_to_right(bool val);
379 
380  GENPYBIND(getter_for(enable_spike_out))
381  bool get_enable_spike_out() const;
382  GENPYBIND(setter_for(enable_spike_out))
383  void set_enable_spike_out(bool val);
384 
391  GENPYBIND(getter_for(enable_neuron_master))
392  bool get_enable_neuron_master() const;
393  GENPYBIND(setter_for(enable_neuron_master))
394  void set_enable_neuron_master(bool val);
395 
396  GENPYBIND(getter_for(enable_bayesian_0))
397  bool get_enable_bayesian_0() const;
398  GENPYBIND(setter_for(enable_bayesian_0))
399  void set_enable_bayesian_0(bool val);
400 
401  GENPYBIND(getter_for(enable_bayesian_1))
402  bool get_enable_bayesian_1() const;
403  GENPYBIND(setter_for(enable_bayesian_1))
404  void set_enable_bayesian_1(bool val);
405 
406  bool operator==(NeuronBackendConfig const& other) const;
407  bool operator!=(NeuronBackendConfig const& other) const;
408 
409  static size_t constexpr config_size_in_words GENPYBIND(hidden) = 4;
410  template <typename AddressT>
411  static std::array<AddressT, config_size_in_words> addresses(coordinate_type const& neuron)
412  GENPYBIND(hidden);
413  template <typename WordT>
414  std::array<WordT, config_size_in_words> encode() const GENPYBIND(hidden);
415  template <typename WordT>
416  void decode(std::array<WordT, config_size_in_words> const& data) GENPYBIND(hidden);
417 
418  GENPYBIND(stringstream)
419  friend std::ostream& operator<<(
420  std::ostream& os, NeuronBackendConfig<Coordinates> const& config)
421  {
422  std::stringstream ss;
423  ss << "NeuronBackendConfig(\n" << std::boolalpha;
424  // clang-format off
425  ss << "\taddress_out: \t" << std::to_string(config.m_address_out) << "\n"
426  << "\treset_holdoff_config: \t" << std::to_string(config.m_reset_holdoff) << "\n"
427  << "\trefractory_time: \t" << std::to_string(config.m_refractory_time) << "\n"
428  << "\tpost_overwrite: \t" << config.m_post_overwrite << "\n"
429  << "\tselect_input_clock: \t" << config.m_select_input_clock << "\n"
430  << "\tenable_adaptation_pulse: \t" << config.m_en_adapt_pulse << "\n"
431  << "\tenable_bayesian_extension: \t" << config.m_en_baesian_extension << "\n"
432  << "\tenable_neuron_slave: \t" << config.m_en_neuron_slave << "\n"
433  << "\tconnect_fire_bottom: \t" << config.m_connect_fire_bottom << "\n"
434  << "\tconnect_fire_from_right: \t" << config.m_connect_fire_from_right << "\n"
435  << "\tconnect_fire_to_right: \t" << config.m_connect_fire_to_right << "\n"
436  << "\tenable_spike_out: \t" << config.m_en_spike_out << "\n"
437  << "\tenable_neuron_master: \t" << config.m_en_neuron_master << "\n"
438  << "\tenable_0_bayesian: \t" << config.m_en_0_baesian << "\n"
439  << "\tenable_1_bayesian: \t" << config.m_en_1_baesian << "\n)";
440  // clang-format on
441  return (os << ss.str());
442  }
443 
444 private:
445  friend class cereal::access;
446  template <class Archive>
447  void serialize(Archive& ar, std::uint32_t const version);
448 
449  AddressOut m_address_out;
450  ResetHoldoff m_reset_holdoff;
451  RefractoryTime m_refractory_time;
452  bool m_post_overwrite;
453  InputClock m_select_input_clock;
454  bool m_en_adapt_pulse;
455  bool m_en_baesian_extension;
456  bool m_en_neuron_slave;
457  bool m_connect_fire_bottom;
458  bool m_connect_fire_from_right;
459  bool m_connect_fire_to_right;
460  bool m_en_spike_out;
461  bool m_en_neuron_master;
462  bool m_en_0_baesian;
463  bool m_en_1_baesian;
464 };
465 
466 namespace detail {
467 
468 template <>
469 struct BackendContainerTrait<CommonNeuronBackendConfig>
470  : public BackendContainerBase<
471  CommonNeuronBackendConfig,
472  fisch::vx::word_access_type::Omnibus,
473  fisch::vx::word_access_type::OmnibusChipOverJTAG>
474 {};
475 
476 template <typename Coordinates>
477 struct BackendContainerTrait<NeuronBackendConfig<Coordinates>>
478  : public BackendContainerBase<
479  NeuronBackendConfig<Coordinates>,
480  fisch::vx::word_access_type::Omnibus,
481  fisch::vx::word_access_type::OmnibusChipOverJTAG>
482 {};
483 
484 } // namespace detail
485 
486 
490 class GENPYBIND(visible) NeuronReset
491 {
492 public:
493  typedef halco::hicann_dls::vx::NeuronResetOnDLS coordinate_type;
494  typedef std::true_type is_leaf_node;
495 
497  NeuronReset() SYMBOL_VISIBLE;
498 
499  bool operator==(NeuronReset const& other) const SYMBOL_VISIBLE;
500  bool operator!=(NeuronReset const& other) const SYMBOL_VISIBLE;
501 
502  static size_t constexpr write_config_size_in_words GENPYBIND(hidden) = 1;
503  static size_t constexpr read_config_size_in_words GENPYBIND(hidden) = 0;
504  template <typename AddressT>
505  static std::array<AddressT, read_config_size_in_words> read_addresses(
506  coordinate_type const& neuron) SYMBOL_VISIBLE GENPYBIND(hidden);
507  template <typename AddressT>
508  static std::array<AddressT, write_config_size_in_words> write_addresses(
509  coordinate_type const& neuron) SYMBOL_VISIBLE GENPYBIND(hidden);
510  template <typename WordT>
511  std::array<WordT, write_config_size_in_words> encode() const SYMBOL_VISIBLE GENPYBIND(hidden);
512  template <typename WordT>
513  void decode(std::array<WordT, read_config_size_in_words> const& data) SYMBOL_VISIBLE
514  GENPYBIND(hidden);
515 
516  GENPYBIND(stringstream)
517  friend std::ostream& operator<<(std::ostream& os, NeuronReset const& config) SYMBOL_VISIBLE;
518 
519 private:
520  friend class cereal::access;
521  template <class Archive>
522  void serialize(Archive& ar, std::uint32_t const version) SYMBOL_VISIBLE;
523 };
524 
525 #ifndef __ppu__
526 EXTERN_INSTANTIATE_CEREAL_SERIALIZE(NeuronReset)
527 #endif
528 
529 namespace detail {
530 
531 template <>
532 struct BackendContainerTrait<NeuronReset>
533  : public BackendContainerBase<
534  NeuronReset,
535  fisch::vx::word_access_type::Omnibus,
536  fisch::vx::word_access_type::OmnibusChipOverJTAG>
537 {};
538 
539 } // namespace detail
540 
541 
548 class GENPYBIND(visible) BlockPostPulse
549 {
550 public:
551  typedef halco::hicann_dls::vx::BlockPostPulseOnDLS coordinate_type;
552  typedef std::true_type is_leaf_node;
553 
555  BlockPostPulse() SYMBOL_VISIBLE;
556 
557  bool operator==(BlockPostPulse const& other) const SYMBOL_VISIBLE;
558  bool operator!=(BlockPostPulse const& other) const SYMBOL_VISIBLE;
559 
560  static size_t constexpr write_config_size_in_words GENPYBIND(hidden) = 1;
561  static size_t constexpr read_config_size_in_words GENPYBIND(hidden) = 0;
562  template <typename AddressT>
563  static std::array<AddressT, read_config_size_in_words> read_addresses(
564  coordinate_type const& block) SYMBOL_VISIBLE GENPYBIND(hidden);
565  template <typename AddressT>
566  static std::array<AddressT, write_config_size_in_words> write_addresses(
567  coordinate_type const& block) SYMBOL_VISIBLE GENPYBIND(hidden);
568  template <typename WordT>
569  std::array<WordT, write_config_size_in_words> encode() const SYMBOL_VISIBLE GENPYBIND(hidden);
570  template <typename WordT>
571  void decode(std::array<WordT, read_config_size_in_words> const& data) SYMBOL_VISIBLE
572  GENPYBIND(hidden);
573 
574  GENPYBIND(stringstream)
575  friend std::ostream& operator<<(std::ostream& os, BlockPostPulse const& config) SYMBOL_VISIBLE;
576 
577 private:
578  friend class cereal::access;
579  template <class Archive>
580  void serialize(Archive& ar, std::uint32_t const version) SYMBOL_VISIBLE;
581 };
582 
583 #ifndef __ppu__
584 EXTERN_INSTANTIATE_CEREAL_SERIALIZE(BlockPostPulse)
585 #endif
586 
587 namespace detail {
588 
589 template <>
590 struct BackendContainerTrait<BlockPostPulse>
591  : public BackendContainerBase<
592  BlockPostPulse,
593  fisch::vx::word_access_type::Omnibus,
594  fisch::vx::word_access_type::OmnibusChipOverJTAG>
595 {};
596 
597 } // namespace detail
598 
599 
603 class GENPYBIND(visible) SpikeCounterRead
604 {
605 public:
606  typedef halco::hicann_dls::vx::SpikeCounterReadOnDLS coordinate_type;
607  typedef std::true_type is_leaf_node;
608 
612  struct GENPYBIND(inline_base("*")) Count
613  : public halco::common::detail::RantWrapper<Count, uint_fast16_t, 255, 0>
614  {
615  constexpr explicit Count(uintmax_t const val = 0) GENPYBIND(implicit_conversion) :
616  rant_t(val)
617  {}
618  };
619 
621  SpikeCounterRead() SYMBOL_VISIBLE;
622 
627  GENPYBIND(getter_for(count))
628  Count get_count() const SYMBOL_VISIBLE;
629  GENPYBIND(setter_for(count))
630  void set_count(Count const cnt) SYMBOL_VISIBLE;
631 
632  // Overflow bit
633  GENPYBIND(getter_for(overflow))
634  bool get_overflow() const SYMBOL_VISIBLE;
635  GENPYBIND(setter_for(overflow))
636  void set_overflow(bool const ovrflw) SYMBOL_VISIBLE;
637 
638  bool operator==(SpikeCounterRead const& other) const SYMBOL_VISIBLE;
639  bool operator!=(SpikeCounterRead const& other) const SYMBOL_VISIBLE;
640 
641  static size_t constexpr write_config_size_in_words GENPYBIND(hidden) = 0;
642  static size_t constexpr read_config_size_in_words GENPYBIND(hidden) = 1;
643  template <typename AddressT>
644  static std::array<AddressT, read_config_size_in_words> read_addresses(
645  coordinate_type const& neuron) SYMBOL_VISIBLE GENPYBIND(hidden);
646  template <typename AddressT>
647  static std::array<AddressT, write_config_size_in_words> write_addresses(
648  coordinate_type const& neuron) SYMBOL_VISIBLE GENPYBIND(hidden);
649  template <typename WordT>
650  std::array<WordT, write_config_size_in_words> encode() const SYMBOL_VISIBLE GENPYBIND(hidden);
651  template <typename WordT>
652  void decode(std::array<WordT, read_config_size_in_words> const& data) SYMBOL_VISIBLE
653  GENPYBIND(hidden);
654 
655  GENPYBIND(stringstream)
656  friend std::ostream& operator<<(std::ostream& os, SpikeCounterRead const& config)
657  SYMBOL_VISIBLE;
658 
659 private:
660  friend class cereal::access;
661  template <class Archive>
662  void serialize(Archive& ar, std::uint32_t const version) SYMBOL_VISIBLE;
663 
664  Count m_count;
665  bool m_overflow;
666 };
667 
668 #ifndef __ppu__
669 EXTERN_INSTANTIATE_CEREAL_SERIALIZE(SpikeCounterRead)
670 #endif
671 
672 namespace detail {
673 
674 template <>
675 struct BackendContainerTrait<SpikeCounterRead>
676  : public BackendContainerBase<
677  SpikeCounterRead,
678  fisch::vx::word_access_type::Omnibus,
679  fisch::vx::word_access_type::OmnibusChipOverJTAG>
680 {};
681 
682 } // namespace detail
683 
684 
688 class GENPYBIND(visible) SpikeCounterReset
689 {
690 public:
691  typedef halco::hicann_dls::vx::SpikeCounterResetOnDLS coordinate_type;
692  typedef std::true_type is_leaf_node;
693 
695  SpikeCounterReset() SYMBOL_VISIBLE;
696 
697  bool operator==(SpikeCounterReset const& other) const SYMBOL_VISIBLE;
698  bool operator!=(SpikeCounterReset const& other) const SYMBOL_VISIBLE;
699 
700  static size_t constexpr write_config_size_in_words GENPYBIND(hidden) = 1;
701  static size_t constexpr read_config_size_in_words GENPYBIND(hidden) = 0;
702  template <typename AddressT>
703  static std::array<AddressT, read_config_size_in_words> read_addresses(
704  coordinate_type const& neuron) SYMBOL_VISIBLE GENPYBIND(hidden);
705  template <typename AddressT>
706  static std::array<AddressT, write_config_size_in_words> write_addresses(
707  coordinate_type const& neuron) SYMBOL_VISIBLE GENPYBIND(hidden);
708  template <typename WordT>
709  std::array<WordT, write_config_size_in_words> encode() const SYMBOL_VISIBLE GENPYBIND(hidden);
710  template <typename WordT>
711  void decode(std::array<WordT, read_config_size_in_words> const& data) SYMBOL_VISIBLE
712  GENPYBIND(hidden);
713 
714  GENPYBIND(stringstream)
715  friend std::ostream& operator<<(std::ostream& os, SpikeCounterReset const& config)
716  SYMBOL_VISIBLE;
717 
718 private:
719  friend class cereal::access;
720  template <class Archive>
721  void serialize(Archive& ar, std::uint32_t const version) SYMBOL_VISIBLE;
722 };
723 
724 #ifndef __ppu
725 EXTERN_INSTANTIATE_CEREAL_SERIALIZE(SpikeCounterReset)
726 #endif
727 
728 namespace detail {
729 
730 template <>
731 struct BackendContainerTrait<SpikeCounterReset>
732  : public BackendContainerBase<
733  SpikeCounterReset,
734  fisch::vx::word_access_type::Omnibus,
735  fisch::vx::word_access_type::OmnibusChipOverJTAG>
736 {};
737 
738 } // namespace detail
739 
740 
741 // TODO: Switch to CRTP pattern when https://github.com/kljohann/genpybind/issues/28 is solved
742 class GENPYBIND(visible) NeuronSRAMTimingConfig : public detail::SRAMTimingConfig
743 {
744 public:
745  typedef halco::hicann_dls::vx::NeuronSRAMTimingConfigOnDLS coordinate_type;
746 #ifndef __ppu__
747  constexpr static auto unsupported_read_targets GENPYBIND(hidden) = {
748  hxcomm::vx::Target::simulation};
749 #endif
750 
751  bool operator==(NeuronSRAMTimingConfig const& other) const SYMBOL_VISIBLE;
752  bool operator!=(NeuronSRAMTimingConfig const& other) const SYMBOL_VISIBLE;
753 
754  GENPYBIND(stringstream)
755  friend std::ostream& operator<<(std::ostream& os, NeuronSRAMTimingConfig const& config)
756  SYMBOL_VISIBLE;
757 
758  template <typename AddressT>
759  std::array<AddressT, config_size_in_words> addresses(coordinate_type const& word) const
760  SYMBOL_VISIBLE GENPYBIND(hidden);
761 
762 private:
763  friend class cereal::access;
764  template <typename Archive>
765  void serialize(Archive& ar, std::uint32_t);
766 };
767 
768 #ifndef __ppu__
769 EXTERN_INSTANTIATE_CEREAL_SERIALIZE(NeuronSRAMTimingConfig)
770 #endif
771 
772 namespace detail {
773 
774 template <>
775 struct BackendContainerTrait<NeuronSRAMTimingConfig>
776  : public BackendContainerBase<
777  NeuronSRAMTimingConfig,
778  fisch::vx::word_access_type::Omnibus,
779  fisch::vx::word_access_type::OmnibusChipOverJTAG>
780 {};
781 
782 } // namespace detail
783 
784 
785 // TODO: Switch to CRTP pattern when https://github.com/kljohann/genpybind/issues/28 is solved
786 class GENPYBIND(visible) NeuronBackendSRAMTimingConfig : public detail::SRAMTimingConfig
787 {
788 public:
789  typedef halco::hicann_dls::vx::NeuronBackendSRAMTimingConfigOnDLS coordinate_type;
790 #ifndef __ppu__
791  constexpr static auto unsupported_read_targets GENPYBIND(hidden) = {
792  hxcomm::vx::Target::simulation, hxcomm::vx::Target::hardware};
793 #endif
794 
795  bool operator==(NeuronBackendSRAMTimingConfig const& other) const SYMBOL_VISIBLE;
796  bool operator!=(NeuronBackendSRAMTimingConfig const& other) const SYMBOL_VISIBLE;
797 
798  GENPYBIND(stringstream)
799  friend std::ostream& operator<<(std::ostream& os, NeuronBackendSRAMTimingConfig const& config)
800  SYMBOL_VISIBLE;
801 
802  template <typename AddressT>
803  std::array<AddressT, config_size_in_words> addresses(coordinate_type const& word) const
804  SYMBOL_VISIBLE GENPYBIND(hidden);
805 
806 private:
807  friend class cereal::access;
808  template <typename Archive>
809  void serialize(Archive& ar, std::uint32_t);
810 };
811 
812 #ifndef __ppu__
813 EXTERN_INSTANTIATE_CEREAL_SERIALIZE(NeuronBackendSRAMTimingConfig)
814 #endif
815 
816 namespace detail {
817 
818 template <>
819 struct BackendContainerTrait<NeuronBackendSRAMTimingConfig>
820  : public BackendContainerBase<
821  NeuronBackendSRAMTimingConfig,
822  fisch::vx::word_access_type::Omnibus,
823  fisch::vx::word_access_type::OmnibusChipOverJTAG>
824 {};
825 
826 } // namespace detail
827 
828 #define NEURON_EXTERN_TEMPLATE(Coordinates) \
829  extern template class SYMBOL_VISIBLE NeuronBackendConfig<Coordinates>; \
830  \
831  extern template SYMBOL_VISIBLE std::array< \
832  halco::hicann_dls::vx::OmnibusChipOverJTAGAddress, \
833  NeuronBackendConfig<Coordinates>::config_size_in_words> \
834  NeuronBackendConfig<Coordinates>::addresses(coordinate_type const& coord); \
835  extern template SYMBOL_VISIBLE std::array< \
836  halco::hicann_dls::vx::OmnibusAddress, \
837  NeuronBackendConfig<Coordinates>::config_size_in_words> \
838  NeuronBackendConfig<Coordinates>::addresses(coordinate_type const& coord); \
839  \
840  extern template SYMBOL_VISIBLE std::array< \
841  fisch::vx::word_access_type::OmnibusChipOverJTAG, \
842  NeuronBackendConfig<Coordinates>::config_size_in_words> \
843  NeuronBackendConfig<Coordinates>::encode() const; \
844  extern template SYMBOL_VISIBLE std::array< \
845  fisch::vx::word_access_type::Omnibus, \
846  NeuronBackendConfig<Coordinates>::config_size_in_words> \
847  NeuronBackendConfig<Coordinates>::encode() const; \
848  \
849  extern template SYMBOL_VISIBLE void NeuronBackendConfig<Coordinates>::decode( \
850  std::array< \
851  fisch::vx::word_access_type::OmnibusChipOverJTAG, \
852  NeuronBackendConfig<Coordinates>::config_size_in_words> const& data); \
853  extern template SYMBOL_VISIBLE void NeuronBackendConfig<Coordinates>::decode( \
854  std::array< \
855  fisch::vx::word_access_type::Omnibus, \
856  NeuronBackendConfig<Coordinates>::config_size_in_words> const& data);
857 
858 } // namespace vx
859 } // namespace haldls
haldls::vx::CommonNeuronBackendConfig
Read/write access to common neuron parameters.
Definition: neuron.h:31
haldls::vx::CommonNeuronBackendConfig::coordinate_type
halco::hicann_dls::vx::CommonNeuronBackendConfigOnDLS coordinate_type
Definition: neuron.h:33
haldls::vx::DifferentialWriteTrait
Trait signalling derived-from container type support differential write operation.
Definition: traits.h:17
GENPYBIND_TAG_HALDLS_VX
#define GENPYBIND_TAG_HALDLS_VX
Definition: genpybind.h:4
haldls::vx::v3::NeuronBackendConfig
haldls::vx::NeuronBackendConfig< halco::hicann_dls::vx::v3::Coordinates > NeuronBackendConfig
Definition: neuron.h:24
sram_controller.h