Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2023-03-17 10:51:25 

0001 #ifndef DataFormats_SoATemplate_interface_SoAView_h
0002 #define DataFormats_SoATemplate_interface_SoAView_h
0003 
0004 /*
0005  * Structure-of-Arrays templates allowing access to a selection of scalars and columns from one
0006  * or multiple SoA layouts or views.
0007  * This template generator will allow handling subsets of columns from one or multiple SoA views or layouts.
0008  */
0009 
0010 #include "SoACommon.h"
0011 
0012 #define SOA_VIEW_LAYOUT(TYPE, NAME) (TYPE, NAME)
0013 
0014 #define SOA_VIEW_LAYOUT_LIST(...) __VA_ARGS__
0015 
0016 #define SOA_VIEW_VALUE(LAYOUT_NAME, LAYOUT_MEMBER) (LAYOUT_NAME, LAYOUT_MEMBER, LAYOUT_MEMBER)
0017 
0018 #define SOA_VIEW_VALUE_RENAME(LAYOUT_NAME, LAYOUT_MEMBER, LOCAL_NAME) (LAYOUT_NAME, LAYOUT_MEMBER, LOCAL_NAME)
0019 
0020 #define SOA_VIEW_VALUE_LIST(...) __VA_ARGS__
0021 
0022 /*
0023  * A macro defining a SoA view (collection of columns from multiple layouts or views.)
0024  *
0025  * Usage:
0026  * GENERATE_SOA_VIEW(PixelXYConstView, PixelXYView,
0027  *   SOA_VIEW_LAYOUT_LIST(
0028  *     SOA_VIEW_LAYOUT(PixelDigis,         pixelDigis),
0029  *     SOA_VIEW_LAYOUT(PixelRecHitsLayout, pixelsRecHit)
0030  *   ),
0031  *   SOA_VIEW_VALUE_LIST(
0032  *     SOA_VIEW_VALUE_RENAME(pixelDigis,   x,   digisX),
0033  *     SOA_VIEW_VALUE_RENAME(pixelDigis,   y,   digisY),
0034  *     SOA_VIEW_VALUE_RENAME(pixelsRecHit, x, recHitsX),
0035  *     SOA_VIEW_VALUE_RENAME(pixelsRecHit, y, recHitsY)
0036  *   )
0037  * );
0038  *
0039  */
0040 
0041 namespace cms::soa {
0042 
0043   /* Traits for the different column type scenarios */
0044   /* Value traits passes the class as is in the case of column type and return
0045    * an empty class with functions returning non-scalar as accessors. */
0046   template <class C, SoAColumnType COLUMN_TYPE>
0047   struct ConstValueTraits : public C {
0048     using C::C;
0049   };
0050 
0051   template <class C>
0052   struct ConstValueTraits<C, SoAColumnType::scalar> {
0053     // Just take to SoAValue type to generate the right constructor.
0054     SOA_HOST_DEVICE SOA_INLINE ConstValueTraits(size_type, const typename C::valueType*) {}
0055     SOA_HOST_DEVICE SOA_INLINE ConstValueTraits(size_type, const typename C::Params&) {}
0056     SOA_HOST_DEVICE SOA_INLINE ConstValueTraits(size_type, const typename C::ConstParams&) {}
0057     // Any attempt to do anything with the "scalar" value a const element will fail.
0058   };
0059 
0060 }  // namespace cms::soa
0061 
0062 /*
0063  * Members definitions macros for views
0064  */
0065 
0066 /**
0067  * Layout templates parametrization
0068  */
0069 #define _DECLARE_VIEW_LAYOUT_PARAMETRIZED_TEMPLATE_IMPL(TYPE, NAME)                            \
0070   (using BOOST_PP_CAT(TYPE, _default) = BOOST_PP_CAT(TYPE, _StagedTemplates) < VIEW_ALIGNMENT, \
0071    VIEW_ALIGNMENT_ENFORCEMENT > ;)
0072 
0073 #define _DECLARE_VIEW_LAYOUT_PARAMETRIZED_TEMPLATE(R, DATA, TYPE_NAME) \
0074   BOOST_PP_EXPAND(_DECLARE_VIEW_LAYOUT_PARAMETRIZED_TEMPLATE_IMPL TYPE_NAME)
0075 
0076 /**
0077  * Layout types aliasing for referencing by name
0078  */
0079 #define _DECLARE_VIEW_LAYOUT_TYPE_ALIAS_IMPL(TYPE, NAME) using BOOST_PP_CAT(TypeOf_, NAME) = TYPE;
0080 
0081 #define _DECLARE_VIEW_LAYOUT_TYPE_ALIAS(R, DATA, TYPE_NAME) \
0082   BOOST_PP_EXPAND(_DECLARE_VIEW_LAYOUT_TYPE_ALIAS_IMPL TYPE_NAME)
0083 
0084 /**
0085  * Member types aliasing for referencing by name
0086  */
0087 // clang-format off
0088 #define _DECLARE_VIEW_MEMBER_TYPE_ALIAS_IMPL(LAYOUT_NAME, LAYOUT_MEMBER, LOCAL_NAME, CAST)                             \
0089   using BOOST_PP_CAT(TypeOf_, LOCAL_NAME) =                                                                            \
0090       typename BOOST_PP_CAT(TypeOf_, LAYOUT_NAME)::Metadata::BOOST_PP_CAT(TypeOf_, LAYOUT_MEMBER);                     \
0091   using BOOST_PP_CAT(ParametersTypeOf_, LOCAL_NAME) =                                                                  \
0092       typename BOOST_PP_CAT(TypeOf_, LAYOUT_NAME)::Metadata::BOOST_PP_CAT(ParametersTypeOf_, LAYOUT_MEMBER);           \
0093   constexpr static cms::soa::SoAColumnType BOOST_PP_CAT(ColumnTypeOf_, LOCAL_NAME) =                                   \
0094       BOOST_PP_CAT(TypeOf_, LAYOUT_NAME)::Metadata::BOOST_PP_CAT(ColumnTypeOf_, LAYOUT_MEMBER);                        \
0095   using BOOST_PP_CAT(ConstAccessorOf_, LOCAL_NAME) =                                                                   \
0096     typename cms::soa::SoAAccessors<typename BOOST_PP_CAT(Metadata::TypeOf_, LOCAL_NAME)>::                            \
0097         template ColumnType<BOOST_PP_CAT(ColumnTypeOf_, LOCAL_NAME)>::template AccessType<                             \
0098             cms::soa::SoAAccessType::constAccess>::template Alignment<conditionalAlignment>::                          \
0099                 template RestrictQualifier<restrictQualify> ;                                                          \
0100   using BOOST_PP_CAT(MutableAccessorOf_, LOCAL_NAME) =                                                                 \
0101     typename cms::soa::SoAAccessors<typename BOOST_PP_CAT(Metadata::TypeOf_, LOCAL_NAME)>::                            \
0102         template ColumnType<BOOST_PP_CAT(ColumnTypeOf_, LOCAL_NAME)>::template AccessType<                             \
0103             cms::soa::SoAAccessType::mutableAccess>::template Alignment<conditionalAlignment>::                        \
0104                 template RestrictQualifier<restrictQualify> ;                                                          \
0105   SOA_HOST_DEVICE SOA_INLINE                                                                                           \
0106   const auto BOOST_PP_CAT(parametersOf_, LOCAL_NAME)() const {                                                         \
0107     return CAST(parent_.BOOST_PP_CAT(LOCAL_NAME, Parameters_));                                                        \
0108   };
0109 // clang-format on
0110 
0111 // DATA should be a function used to convert
0112 //   parent_.LOCAL_NAME ## Parameters_
0113 // to
0114 //   ParametersTypeOf_ ## LOCAL_NAME                (for a View)
0115 // or
0116 //   ParametersTypeOf_ ## LOCAL_NAME :: ConstType   (for a ConstView)
0117 // or empty, if no conversion is necessary.
0118 #define _DECLARE_VIEW_MEMBER_TYPE_ALIAS(R, DATA, LAYOUT_MEMBER_NAME) \
0119   BOOST_PP_EXPAND(_DECLARE_VIEW_MEMBER_TYPE_ALIAS_IMPL BOOST_PP_TUPLE_PUSH_BACK(LAYOUT_MEMBER_NAME, DATA))
0120 
0121 /**
0122  * Member type pointers for referencing by name
0123  */
0124 // clang-format off
0125 #define _DECLARE_VIEW_MEMBER_POINTERS_IMPL(LAYOUT_NAME, LAYOUT_MEMBER, LOCAL_NAME)                                     \
0126   SOA_HOST_DEVICE SOA_INLINE auto* BOOST_PP_CAT(addressOf_, LOCAL_NAME)() {                                            \
0127     return BOOST_PP_CAT(parametersOf_, LOCAL_NAME)().addr_;                                                            \
0128   };
0129 // clang-format on
0130 
0131 #define _DECLARE_VIEW_MEMBER_POINTERS(R, DATA, LAYOUT_MEMBER_NAME) \
0132   BOOST_PP_EXPAND(_DECLARE_VIEW_MEMBER_POINTERS_IMPL LAYOUT_MEMBER_NAME)
0133 
0134 /**
0135  * Member type const pointers for referencing by name
0136  */
0137 // clang-format off
0138 #define _DECLARE_VIEW_MEMBER_CONST_POINTERS_IMPL(LAYOUT_NAME, LAYOUT_MEMBER, LOCAL_NAME)                               \
0139   SOA_HOST_DEVICE SOA_INLINE auto const* BOOST_PP_CAT(addressOf_, LOCAL_NAME)() const {                                \
0140     return BOOST_PP_CAT(parametersOf_, LOCAL_NAME)().addr_;                                                            \
0141   };
0142 // clang-format on
0143 
0144 #define _DECLARE_VIEW_MEMBER_CONST_POINTERS(R, DATA, LAYOUT_MEMBER_NAME) \
0145   BOOST_PP_EXPAND(_DECLARE_VIEW_MEMBER_CONST_POINTERS_IMPL LAYOUT_MEMBER_NAME)
0146 
0147 /**
0148  * Generator of parameters (layouts/views) for constructor by layouts/views.
0149  */
0150 #define _DECLARE_VIEW_CONSTRUCTION_PARAMETERS_IMPL(LAYOUT_TYPE, LAYOUT_NAME, DATA) (DATA LAYOUT_TYPE & LAYOUT_NAME)
0151 
0152 #define _DECLARE_VIEW_CONSTRUCTION_PARAMETERS(R, DATA, TYPE_NAME) \
0153   BOOST_PP_EXPAND(_DECLARE_VIEW_CONSTRUCTION_PARAMETERS_IMPL BOOST_PP_TUPLE_PUSH_BACK(TYPE_NAME, DATA))
0154 
0155 /**
0156  * Generator of parameters for constructor by column.
0157  */
0158 #define _DECLARE_VIEW_CONSTRUCTION_BYCOLUMN_PARAMETERS_IMPL(LAYOUT_NAME, LAYOUT_MEMBER, LOCAL_NAME, DATA) \
0159   (DATA typename BOOST_PP_CAT(Metadata::ParametersTypeOf_, LOCAL_NAME)::TupleOrPointerType LOCAL_NAME)
0160 
0161 #define _DECLARE_VIEW_CONSTRUCTION_BYCOLUMN_PARAMETERS(R, DATA, LAYOUT_MEMBER_NAME) \
0162   BOOST_PP_EXPAND(                                                                  \
0163       _DECLARE_VIEW_CONSTRUCTION_BYCOLUMN_PARAMETERS_IMPL BOOST_PP_TUPLE_PUSH_BACK(LAYOUT_MEMBER_NAME, DATA))
0164 
0165 /**
0166  * Generator of member initialization from constructor.
0167  * We use a lambda with auto return type to handle multiple possible return types.
0168  */
0169 // clang-format off
0170 #define _DECLARE_VIEW_MEMBER_INITIALIZERS_IMPL(LAYOUT, MEMBER, NAME)                                                   \
0171   (BOOST_PP_CAT(NAME, Parameters_)([&]() -> auto {                                                                     \
0172     auto params = LAYOUT.metadata().BOOST_PP_CAT(parametersOf_, MEMBER)();                                             \
0173     if constexpr (alignmentEnforcement == AlignmentEnforcement::enforced)                                              \
0174       if (reinterpret_cast<intptr_t>(params.addr_) % alignment)                                                        \
0175         throw std::runtime_error("In constructor by layout: misaligned column: " #NAME);                               \
0176     return params;                                                                                                     \
0177   }()))
0178 // clang-format on
0179 
0180 #define _DECLARE_VIEW_MEMBER_INITIALIZERS(R, DATA, LAYOUT_MEMBER_NAME) \
0181   BOOST_PP_EXPAND(_DECLARE_VIEW_MEMBER_INITIALIZERS_IMPL LAYOUT_MEMBER_NAME)
0182 
0183 /**
0184  * Generator of size computation for constructor.
0185  * This is the per-layout part of the lambda checking they all have the same size.
0186  */
0187 // clang-format off
0188 #define _UPDATE_SIZE_OF_VIEW_IMPL(LAYOUT_TYPE, LAYOUT_NAME)                                                            \
0189   if (set) {                                                                                                           \
0190     if (ret != LAYOUT_NAME.metadata().size())                                                                          \
0191       throw std::runtime_error("In constructor by layout: different sizes from layouts.");                             \
0192   } else {                                                                                                             \
0193     ret = LAYOUT_NAME.metadata().size();                                                                               \
0194     set = true;                                                                                                        \
0195   }
0196 // clang-format on
0197 
0198 #define _UPDATE_SIZE_OF_VIEW(R, DATA, TYPE_NAME) BOOST_PP_EXPAND(_UPDATE_SIZE_OF_VIEW_IMPL TYPE_NAME)
0199 
0200 /**
0201  * Generator of member initialization from constructor.
0202  * We use a lambda with auto return type to handle multiple possible return types.
0203  */
0204 // clang-format off
0205 #define _DECLARE_VIEW_MEMBER_INITIALIZERS_BYCOLUMN_IMPL(LAYOUT, MEMBER, NAME)                                          \
0206   (                                                                                                                    \
0207     BOOST_PP_CAT(NAME, Parameters_)([&]() -> auto {                                                                    \
0208       if constexpr (alignmentEnforcement == AlignmentEnforcement::enforced)                                            \
0209         if (Metadata:: BOOST_PP_CAT(ParametersTypeOf_, NAME)::checkAlignment(NAME, alignment))                         \
0210           throw std::runtime_error("In constructor by column: misaligned column: " #NAME);                             \
0211       return NAME;                                                                                                     \
0212     }())                                                                                                               \
0213   )
0214 // clang-format on
0215 
0216 #define _DECLARE_VIEW_MEMBER_INITIALIZERS_BYCOLUMN(R, DATA, LAYOUT_MEMBER_NAME) \
0217   BOOST_PP_EXPAND(_DECLARE_VIEW_MEMBER_INITIALIZERS_BYCOLUMN_IMPL LAYOUT_MEMBER_NAME)
0218 
0219 /**
0220  * Generator of layout list.
0221  */
0222 #define _DECLARE_LAYOUT_LIST_IMPL(LAYOUT, NAME) (NAME)
0223 
0224 #define _DECLARE_LAYOUT_LIST(R, DATA, LAYOUT_MEMBER_NAME) BOOST_PP_EXPAND(_DECLARE_LAYOUT_LIST_IMPL LAYOUT_MEMBER_NAME)
0225 
0226 /**
0227  * Generator of view member list.
0228  */
0229 #define _DECLARE_VIEW_MEMBER_LIST_IMPL(LAYOUT, MEMBER, NAME) (NAME)
0230 
0231 #define _DECLARE_VIEW_MEMBER_LIST(R, DATA, LAYOUT_MEMBER_NAME) \
0232   BOOST_PP_EXPAND(_DECLARE_VIEW_MEMBER_LIST_IMPL LAYOUT_MEMBER_NAME)
0233 
0234 /**
0235  * Generator of member initializer for copy constructor.
0236  */
0237 #define _DECLARE_VIEW_MEMBER_INITIALIZERS_FROM_OTHER_IMPL(LAYOUT, MEMBER, LOCAL_NAME, DATA) \
0238   (BOOST_PP_CAT(MEMBER, Parameters_){DATA.BOOST_PP_CAT(MEMBER, Parameters_)})
0239 
0240 #define _DECLARE_VIEW_MEMBER_INITIALIZERS_FROM_OTHER(R, DATA, LAYOUT_MEMBER_NAME) \
0241   BOOST_PP_EXPAND(_DECLARE_VIEW_MEMBER_INITIALIZERS_FROM_OTHER_IMPL BOOST_PP_TUPLE_PUSH_BACK(LAYOUT_MEMBER_NAME, DATA))
0242 
0243 /**
0244  * Generator of member assignment for assignment operator.
0245  */
0246 #define _DECLARE_VIEW_MEMBER_ASSIGNMENT_FROM_OTHER_IMPL(LAYOUT, MEMBER, LOCAL_NAME, DATA) \
0247   BOOST_PP_CAT(MEMBER, Parameters_) = DATA.BOOST_PP_CAT(MEMBER, Parameters_);
0248 
0249 #define _DECLARE_VIEW_MEMBER_ASSIGNMENT_FROM_OTHER(R, DATA, LAYOUT_MEMBER_NAME) \
0250   BOOST_PP_EXPAND(_DECLARE_VIEW_MEMBER_ASSIGNMENT_FROM_OTHER_IMPL BOOST_PP_TUPLE_PUSH_BACK(LAYOUT_MEMBER_NAME, DATA))
0251 
0252 /**
0253  * Generator of element members initializer.
0254  */
0255 #define _DECLARE_VIEW_ELEM_MEMBER_INIT_IMPL(LAYOUT, MEMBER, LOCAL_NAME, DATA) (LOCAL_NAME(DATA, LOCAL_NAME))
0256 
0257 #define _DECLARE_VIEW_ELEM_MEMBER_INIT(R, DATA, LAYOUT_MEMBER_NAME) \
0258   BOOST_PP_EXPAND(_DECLARE_VIEW_ELEM_MEMBER_INIT_IMPL BOOST_PP_TUPLE_PUSH_BACK(LAYOUT_MEMBER_NAME, DATA))
0259 
0260 /**
0261  * Helper macro extracting the data type from metadata of a layout or view
0262  */
0263 #define _COLUMN_TYPE(LAYOUT_NAME, LAYOUT_MEMBER) \
0264   typename std::remove_pointer<decltype(BOOST_PP_CAT(LAYOUT_NAME, Type)()::LAYOUT_MEMBER())>::type
0265 
0266 /**
0267  * Generator of parameters for (non-const) element subclass (expanded comma separated).
0268  */
0269 #define _DECLARE_VIEW_ELEMENT_VALUE_ARG_IMPL(LAYOUT_NAME, LAYOUT_MEMBER, LOCAL_NAME, DATA) \
0270   (DATA typename BOOST_PP_CAT(Metadata::ParametersTypeOf_, LOCAL_NAME) LOCAL_NAME)
0271 
0272 #define _DECLARE_VIEW_ELEMENT_VALUE_ARG(R, DATA, LAYOUT_MEMBER_NAME) \
0273   _DECLARE_VIEW_ELEMENT_VALUE_ARG_IMPL BOOST_PP_TUPLE_PUSH_BACK(LAYOUT_MEMBER_NAME, DATA)
0274 
0275 /**
0276  * Generator of parameters for (const) element subclass (expanded comma separated).
0277  */
0278 #define _DECLARE_CONST_VIEW_ELEMENT_VALUE_ARG_IMPL(LAYOUT_NAME, LAYOUT_MEMBER, LOCAL_NAME, DATA) \
0279   (DATA typename BOOST_PP_CAT(Metadata::ParametersTypeOf_, LOCAL_NAME)::ConstType LOCAL_NAME)
0280 
0281 #define _DECLARE_CONST_VIEW_ELEMENT_VALUE_ARG(R, DATA, LAYOUT_MEMBER_NAME) \
0282   _DECLARE_CONST_VIEW_ELEMENT_VALUE_ARG_IMPL BOOST_PP_TUPLE_PUSH_BACK(LAYOUT_MEMBER_NAME, DATA)
0283 
0284 /**
0285  * Generator of member initialization for constructor of element subclass
0286  */
0287 #define _DECLARE_VIEW_CONST_ELEM_MEMBER_INIT_IMPL(LAYOUT_NAME, LAYOUT_MEMBER, LOCAL_NAME, DATA) \
0288   (BOOST_PP_CAT(LOCAL_NAME, _)(DATA, LOCAL_NAME))
0289 
0290 /* declare AoS-like element value args for contructor; these should expand,for columns only */
0291 #define _DECLARE_VIEW_CONST_ELEM_MEMBER_INIT(R, DATA, LAYOUT_MEMBER_NAME) \
0292   BOOST_PP_EXPAND(_DECLARE_VIEW_CONST_ELEM_MEMBER_INIT_IMPL BOOST_PP_TUPLE_PUSH_BACK(LAYOUT_MEMBER_NAME, DATA))
0293 
0294 /**
0295  * Declaration of the members accessors of the const element subclass
0296  */
0297 // clang-format off
0298 #define _DECLARE_VIEW_CONST_ELEMENT_ACCESSOR_IMPL(LAYOUT_NAME, LAYOUT_MEMBER, LOCAL_NAME)                              \
0299   SOA_HOST_DEVICE SOA_INLINE                                                                                           \
0300       const typename SoAConstValueWithConf<BOOST_PP_CAT(Metadata::ColumnTypeOf_, LOCAL_NAME),                          \
0301       const typename BOOST_PP_CAT(Metadata::TypeOf_, LOCAL_NAME)>::RefToConst                                          \
0302       LOCAL_NAME() const {                                                                                             \
0303     return BOOST_PP_CAT(LOCAL_NAME, _)();                                                                              \
0304   }
0305 // clang-format on
0306 
0307 #define _DECLARE_VIEW_CONST_ELEMENT_ACCESSOR(R, DATA, LAYOUT_MEMBER_NAME) \
0308   _DECLARE_VIEW_CONST_ELEMENT_ACCESSOR_IMPL LAYOUT_MEMBER_NAME
0309 
0310 /**
0311  * Declaration of the private members of the const element subclass
0312  */
0313 // clang-format off
0314 #define _DECLARE_VIEW_CONST_ELEMENT_VALUE_MEMBER_IMPL(LAYOUT_NAME, LAYOUT_MEMBER, LOCAL_NAME)                          \
0315   const cms::soa::ConstValueTraits<SoAConstValueWithConf<BOOST_PP_CAT(Metadata::ColumnTypeOf_, LOCAL_NAME),            \
0316                                                          typename BOOST_PP_CAT(Metadata::TypeOf_, LOCAL_NAME)>,        \
0317                                    BOOST_PP_CAT(Metadata::ColumnTypeOf_, LOCAL_NAME)>                                  \
0318       BOOST_PP_CAT(LOCAL_NAME, _);
0319 // clang-format on
0320 
0321 #define _DECLARE_VIEW_CONST_ELEMENT_VALUE_MEMBER(R, DATA, LAYOUT_MEMBER_NAME) \
0322   _DECLARE_VIEW_CONST_ELEMENT_VALUE_MEMBER_IMPL LAYOUT_MEMBER_NAME
0323 
0324 /**
0325  * Generator of the member-by-member copy operator of the element subclass.
0326  */
0327 #define _DECLARE_VIEW_ELEMENT_VALUE_COPY_IMPL(LAYOUT_NAME, LAYOUT_MEMBER, LOCAL_NAME)                 \
0328   if constexpr (Metadata::BOOST_PP_CAT(ColumnTypeOf_, LOCAL_NAME) != cms::soa::SoAColumnType::scalar) \
0329     LOCAL_NAME() = other.LOCAL_NAME();
0330 
0331 #define _DECLARE_VIEW_ELEMENT_VALUE_COPY(R, DATA, LAYOUT_MEMBER_NAME) \
0332   BOOST_PP_EXPAND(_DECLARE_VIEW_ELEMENT_VALUE_COPY_IMPL LAYOUT_MEMBER_NAME)
0333 
0334 /**
0335  * Declaration of the private members of the const element subclass
0336  */
0337 // clang-format off
0338 #define _DECLARE_VIEW_ELEMENT_VALUE_MEMBER_IMPL(LAYOUT_NAME, LAYOUT_MEMBER, LOCAL_NAME)                                \
0339   SoAValueWithConf<BOOST_PP_CAT(Metadata::ColumnTypeOf_, LOCAL_NAME),                                                  \
0340                    typename BOOST_PP_CAT(Metadata::TypeOf_, LOCAL_NAME)>                                               \
0341       LOCAL_NAME;
0342 // clang-format on
0343 
0344 #define _DECLARE_VIEW_ELEMENT_VALUE_MEMBER(R, DATA, LAYOUT_MEMBER_NAME) \
0345   _DECLARE_VIEW_ELEMENT_VALUE_MEMBER_IMPL LAYOUT_MEMBER_NAME
0346 
0347 /**
0348  * Parameters passed to const element subclass constructor in operator[]
0349  */
0350 #define _DECLARE_VIEW_CONST_ELEMENT_CONSTR_CALL_IMPL(LAYOUT_NAME, LAYOUT_MEMBER, LOCAL_NAME) \
0351   (BOOST_PP_CAT(LOCAL_NAME, Parameters_))
0352 
0353 #define _DECLARE_VIEW_CONST_ELEMENT_CONSTR_CALL(R, DATA, LAYOUT_MEMBER_NAME) \
0354   BOOST_PP_EXPAND(_DECLARE_VIEW_CONST_ELEMENT_CONSTR_CALL_IMPL LAYOUT_MEMBER_NAME)
0355 
0356 /**
0357  * Parameters passed to element subclass constructor in operator[]
0358  *
0359  * The use of const_cast (inside const_cast_SoAParametersImpl) is safe because the constructor of a View binds only to
0360  * non-const arguments.
0361  */
0362 #define _DECLARE_VIEW_ELEMENT_CONSTR_CALL_IMPL(LAYOUT_NAME, LAYOUT_MEMBER, LOCAL_NAME) \
0363   (const_cast_SoAParametersImpl(base_type::BOOST_PP_CAT(LOCAL_NAME, Parameters_)))
0364 
0365 #define _DECLARE_VIEW_ELEMENT_CONSTR_CALL(R, DATA, LAYOUT_MEMBER_NAME) \
0366   BOOST_PP_EXPAND(_DECLARE_VIEW_ELEMENT_CONSTR_CALL_IMPL LAYOUT_MEMBER_NAME)
0367 
0368 /**
0369  * Direct access to column pointer and indexed access
0370  */
0371 // clang-format off
0372 #define _DECLARE_VIEW_SOA_ACCESSOR_IMPL(LAYOUT_NAME, LAYOUT_MEMBER, LOCAL_NAME)                                        \
0373   /* Column or scalar */                                                                                               \
0374   SOA_HOST_DEVICE SOA_INLINE                                                                                           \
0375   typename cms::soa::SoAAccessors<typename BOOST_PP_CAT(Metadata::TypeOf_, LOCAL_NAME)>::                              \
0376         template ColumnType<BOOST_PP_CAT(Metadata::ColumnTypeOf_, LOCAL_NAME)>::template AccessType<                   \
0377             cms::soa::SoAAccessType::mutableAccess>::template Alignment<conditionalAlignment>::                        \
0378                  template RestrictQualifier<restrictQualify>::NoParamReturnType                                        \
0379   LOCAL_NAME() {                                                                                                       \
0380     return typename cms::soa::SoAAccessors<typename BOOST_PP_CAT(Metadata::TypeOf_, LOCAL_NAME)>::                     \
0381         template ColumnType<BOOST_PP_CAT(Metadata::ColumnTypeOf_, LOCAL_NAME)>::template AccessType<                   \
0382             cms::soa::SoAAccessType::mutableAccess>::template Alignment<conditionalAlignment>::                        \
0383                 template RestrictQualifier<restrictQualify>(const_cast_SoAParametersImpl(                              \
0384                     base_type:: BOOST_PP_CAT(LOCAL_NAME, Parameters_)))();                                             \
0385   }                                                                                                                    \
0386   SOA_HOST_DEVICE SOA_INLINE                                                                                           \
0387   typename cms::soa::SoAAccessors<typename BOOST_PP_CAT(Metadata::TypeOf_, LOCAL_NAME)>::                              \
0388         template ColumnType<BOOST_PP_CAT(Metadata::ColumnTypeOf_, LOCAL_NAME)>::template AccessType<                   \
0389             cms::soa::SoAAccessType::mutableAccess>::template Alignment<conditionalAlignment>::                        \
0390                  template RestrictQualifier<restrictQualify>::ParamReturnType                                          \
0391   LOCAL_NAME(size_type index) {                                                                                        \
0392     if constexpr (rangeChecking == cms::soa::RangeChecking::enabled) {                                                 \
0393       if (index >= base_type::elements_)                                                                               \
0394         SOA_THROW_OUT_OF_RANGE("Out of range index in mutable " #LOCAL_NAME "(size_type index)")                       \
0395     }                                                                                                                  \
0396     return typename cms::soa::SoAAccessors<typename BOOST_PP_CAT(Metadata::TypeOf_, LOCAL_NAME)>::                     \
0397         template ColumnType<BOOST_PP_CAT(Metadata::ColumnTypeOf_, LOCAL_NAME)>::template AccessType<                   \
0398             cms::soa::SoAAccessType::mutableAccess>::template Alignment<conditionalAlignment>::                        \
0399                 template RestrictQualifier<restrictQualify>(const_cast_SoAParametersImpl(                              \
0400                     base_type:: BOOST_PP_CAT(LOCAL_NAME, Parameters_)))(index);                                        \
0401   }
0402 // clang-format on
0403 
0404 #define _DECLARE_VIEW_SOA_ACCESSOR(R, DATA, LAYOUT_MEMBER_NAME) \
0405   BOOST_PP_EXPAND(_DECLARE_VIEW_SOA_ACCESSOR_IMPL LAYOUT_MEMBER_NAME)
0406 
0407 /**
0408  * Direct access to column pointer (const) and indexed access.
0409  */
0410 // clang-format off
0411 #define _DECLARE_VIEW_SOA_CONST_ACCESSOR_IMPL(LAYOUT_NAME, LAYOUT_MEMBER, LOCAL_NAME)                                  \
0412   /* Column or scalar */                                                                                               \
0413   SOA_HOST_DEVICE SOA_INLINE                                                                                           \
0414   typename cms::soa::SoAAccessors<typename BOOST_PP_CAT(Metadata::TypeOf_, LOCAL_NAME)>::                              \
0415         template ColumnType<BOOST_PP_CAT(Metadata::ColumnTypeOf_, LOCAL_NAME)>::template AccessType<                   \
0416             cms::soa::SoAAccessType::constAccess>::template Alignment<conditionalAlignment>::                          \
0417                 template RestrictQualifier<restrictQualify>::NoParamReturnType                                         \
0418   LOCAL_NAME() const {                                                                                                 \
0419     return typename cms::soa::SoAAccessors<typename BOOST_PP_CAT(Metadata::TypeOf_, LOCAL_NAME)>::                     \
0420         template ColumnType<BOOST_PP_CAT(Metadata::ColumnTypeOf_, LOCAL_NAME)>::template AccessType<                   \
0421             cms::soa::SoAAccessType::constAccess>::template Alignment<conditionalAlignment>::                          \
0422                 template RestrictQualifier<restrictQualify>(BOOST_PP_CAT(LOCAL_NAME, Parameters_))();                  \
0423   }                                                                                                                    \
0424   SOA_HOST_DEVICE SOA_INLINE                                                                                           \
0425   typename cms::soa::SoAAccessors<typename BOOST_PP_CAT(Metadata::TypeOf_, LOCAL_NAME)>::                              \
0426         template ColumnType<BOOST_PP_CAT(Metadata::ColumnTypeOf_, LOCAL_NAME)>::template AccessType<                   \
0427             cms::soa::SoAAccessType::constAccess>::template Alignment<conditionalAlignment>::                          \
0428                 template RestrictQualifier<restrictQualify>::ParamReturnType                                           \
0429   LOCAL_NAME(size_type index) const {                                                                                  \
0430     if constexpr (rangeChecking == cms::soa::RangeChecking::enabled) {                                                 \
0431       if (index >= elements_)                                                                                          \
0432         SOA_THROW_OUT_OF_RANGE("Out of range index in const " #LOCAL_NAME "(size_type index)")                         \
0433     }                                                                                                                  \
0434     return typename cms::soa::SoAAccessors<typename BOOST_PP_CAT(Metadata::TypeOf_, LOCAL_NAME)>::                     \
0435         template ColumnType<BOOST_PP_CAT(Metadata::ColumnTypeOf_, LOCAL_NAME)>::template AccessType<                   \
0436             cms::soa::SoAAccessType::constAccess>::template Alignment<conditionalAlignment>::                          \
0437                 template RestrictQualifier<restrictQualify>(BOOST_PP_CAT(LOCAL_NAME, Parameters_))(index);             \
0438   }
0439 // clang-format on
0440 
0441 #define _DECLARE_VIEW_SOA_CONST_ACCESSOR(R, DATA, LAYOUT_MEMBER_NAME) \
0442   BOOST_PP_EXPAND(_DECLARE_VIEW_SOA_CONST_ACCESSOR_IMPL LAYOUT_MEMBER_NAME)
0443 
0444 /**
0445  * SoA class member declaration (column pointers and parameters).
0446  */
0447 #define _DECLARE_VIEW_SOA_MEMBER_IMPL(LAYOUT_NAME, LAYOUT_MEMBER, LOCAL_NAME, DATA) \
0448   typename BOOST_PP_CAT(Metadata::ParametersTypeOf_, LOCAL_NAME) BOOST_PP_CAT(LOCAL_NAME, Parameters_);
0449 
0450 #define _DECLARE_VIEW_SOA_MEMBER(R, DATA, LAYOUT_MEMBER_NAME) \
0451   BOOST_PP_EXPAND(_DECLARE_VIEW_SOA_MEMBER_IMPL BOOST_PP_TUPLE_PUSH_BACK(LAYOUT_MEMBER_NAME, DATA))
0452 
0453 /**
0454  * Const SoA class member declaration (column pointers and parameters).
0455  */
0456 #define _DECLARE_CONST_VIEW_SOA_MEMBER_IMPL(LAYOUT_NAME, LAYOUT_MEMBER, LOCAL_NAME, DATA) \
0457   typename BOOST_PP_CAT(Metadata::ParametersTypeOf_, LOCAL_NAME)::ConstType BOOST_PP_CAT(LOCAL_NAME, Parameters_);
0458 
0459 #define _DECLARE_CONST_VIEW_SOA_MEMBER(R, DATA, LAYOUT_MEMBER_NAME) \
0460   BOOST_PP_EXPAND(_DECLARE_CONST_VIEW_SOA_MEMBER_IMPL BOOST_PP_TUPLE_PUSH_BACK(LAYOUT_MEMBER_NAME, DATA))
0461 
0462 /**
0463  * Assign the value of the view from the values in the value_element.
0464  */
0465 
0466 // clang-format off
0467 #define _TRIVIAL_VIEW_ASSIGN_VALUE_ELEMENT_IMPL(VALUE_TYPE, CPP_TYPE, NAME)                                            \
0468   _SWITCH_ON_TYPE(VALUE_TYPE,                                                                                          \
0469       /* Scalar (empty) */                                                                                             \
0470       ,                                                                                                                \
0471       /* Column */                                                                                                     \
0472       NAME() = value.NAME;                                                                                             \
0473       ,                                                                                                                \
0474       /* Eigen column */                                                                                               \
0475       NAME() = value.NAME;                                                                                             \
0476 )
0477 // clang-format on
0478 
0479 #define _TRIVIAL_VIEW_ASSIGN_VALUE_ELEMENT(R, DATA, TYPE_NAME) _TRIVIAL_VIEW_ASSIGN_VALUE_ELEMENT_IMPL TYPE_NAME
0480 
0481 /* ---- MUTABLE VIEW ------------------------------------------------------------------------------------------------ */
0482 // clang-format off
0483 #define _GENERATE_SOA_VIEW_PART_0(CONST_VIEW, VIEW, LAYOUTS_LIST, VALUE_LIST)                                          \
0484   template <CMS_SOA_BYTE_SIZE_TYPE VIEW_ALIGNMENT = cms::soa::CacheLineSize::defaultSize,                              \
0485             bool VIEW_ALIGNMENT_ENFORCEMENT = cms::soa::AlignmentEnforcement::relaxed,                                 \
0486             bool RESTRICT_QUALIFY = cms::soa::RestrictQualify::enabled,                                                \
0487             bool RANGE_CHECKING = cms::soa::RangeChecking::disabled>                                                   \
0488   struct VIEW : public CONST_VIEW<VIEW_ALIGNMENT, VIEW_ALIGNMENT_ENFORCEMENT, RESTRICT_QUALIFY, RANGE_CHECKING> {      \
0489     /* Declare the parametrized layouts as the default */                                                              \
0490     /*BOOST_PP_SEQ_CAT(_ITERATE_ON_ALL(_DECLARE_VIEW_LAYOUT_PARAMETRIZED_TEMPLATE, ~, LAYOUTS_LIST))   */              \
0491     /* these could be moved to an external type trait to free up the symbol names */                                   \
0492     using self_type = VIEW;                                                                                            \
0493     using base_type = CONST_VIEW<VIEW_ALIGNMENT, VIEW_ALIGNMENT_ENFORCEMENT, RESTRICT_QUALIFY, RANGE_CHECKING>;
0494 // clang-format on
0495 
0496 // clang-format off
0497 #define _GENERATE_SOA_VIEW_PART_0_NO_DEFAULTS(CONST_VIEW, VIEW, LAYOUTS_LIST, VALUE_LIST)                              \
0498   template <CMS_SOA_BYTE_SIZE_TYPE VIEW_ALIGNMENT,                                                                     \
0499             bool VIEW_ALIGNMENT_ENFORCEMENT,                                                                           \
0500             bool RESTRICT_QUALIFY,                                                                                     \
0501             bool RANGE_CHECKING>                                                                                       \
0502   struct VIEW : public CONST_VIEW<VIEW_ALIGNMENT, VIEW_ALIGNMENT_ENFORCEMENT, RESTRICT_QUALIFY, RANGE_CHECKING> {      \
0503     /* Declare the parametrized layouts as the default */                                                              \
0504     /*BOOST_PP_SEQ_CAT(_ITERATE_ON_ALL(_DECLARE_VIEW_LAYOUT_PARAMETRIZED_TEMPLATE, ~, LAYOUTS_LIST))   */              \
0505     /* these could be moved to an external type trait to free up the symbol names */                                   \
0506     using self_type = VIEW;                                                                                            \
0507     using base_type = CONST_VIEW<VIEW_ALIGNMENT, VIEW_ALIGNMENT_ENFORCEMENT, RESTRICT_QUALIFY, RANGE_CHECKING>;
0508 // clang-format on
0509 
0510 /**
0511  * Split of the const view definition where the parametrized template alias for the layout is defined for layout trivial view.
0512  */
0513 
0514 // clang-format off
0515 #define _GENERATE_SOA_VIEW_PART_1(CONST_VIEW, VIEW, LAYOUTS_LIST, VALUE_LIST)                                          \
0516     using size_type = cms::soa::size_type;                                                                             \
0517     using byte_size_type = cms::soa::byte_size_type;                                                                   \
0518     using AlignmentEnforcement = cms::soa::AlignmentEnforcement;                                                       \
0519                                                                                                                        \
0520     /* For CUDA applications, we align to the 128 bytes of the cache lines.                                            \
0521      * See https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#global-memory-3-0 this is still valid      \
0522      * up to compute capability 8.X.                                                                                   \
0523      */                                                                                                                \
0524     constexpr static byte_size_type defaultAlignment = cms::soa::CacheLineSize::defaultSize;                           \
0525     constexpr static byte_size_type alignment = VIEW_ALIGNMENT;                                                        \
0526     constexpr static bool alignmentEnforcement = VIEW_ALIGNMENT_ENFORCEMENT;                                           \
0527     constexpr static byte_size_type conditionalAlignment =                                                             \
0528         alignmentEnforcement == AlignmentEnforcement::enforced ? alignment : 0;                                        \
0529     constexpr static bool restrictQualify = RESTRICT_QUALIFY;                                                          \
0530     constexpr static bool rangeChecking = RANGE_CHECKING;                                                              \
0531     /* Those typedefs avoid having commas in macros (which is problematic) */                                          \
0532     template <cms::soa::SoAColumnType COLUMN_TYPE, class C>                                                            \
0533     using SoAValueWithConf = cms::soa::SoAValue<COLUMN_TYPE, C, conditionalAlignment, restrictQualify>;                \
0534                                                                                                                        \
0535     template <cms::soa::SoAColumnType COLUMN_TYPE, class C>                                                            \
0536     using SoAConstValueWithConf = cms::soa::SoAConstValue<COLUMN_TYPE, C, conditionalAlignment, restrictQualify>;      \
0537                                                                                                                        \
0538     /**                                                                                                                \
0539      * Helper/friend class allowing SoA introspection.                                                                 \
0540      */                                                                                                                \
0541     struct Metadata {                                                                                                  \
0542       friend VIEW;                                                                                                     \
0543       SOA_HOST_DEVICE SOA_INLINE size_type size() const { return parent_.elements_; }                                  \
0544       /* Alias layout or view types to name-derived identifyer to allow simpler definitions */                         \
0545       _ITERATE_ON_ALL(_DECLARE_VIEW_LAYOUT_TYPE_ALIAS, ~, LAYOUTS_LIST)                                                \
0546                                                                                                                        \
0547       /* Alias member types to name-derived identifyer to allow simpler definitions */                                 \
0548       _ITERATE_ON_ALL(_DECLARE_VIEW_MEMBER_TYPE_ALIAS, const_cast_SoAParametersImpl, VALUE_LIST)                       \
0549       _ITERATE_ON_ALL(_DECLARE_VIEW_MEMBER_POINTERS, ~, VALUE_LIST)                                                    \
0550       _ITERATE_ON_ALL(_DECLARE_VIEW_MEMBER_CONST_POINTERS, ~, VALUE_LIST)                                              \
0551                                                                                                                        \
0552       /* Forbid copying to avoid const correctness evasion */                                                          \
0553       Metadata& operator=(const Metadata&) = delete;                                                                   \
0554       Metadata(const Metadata&) = delete;                                                                              \
0555                                                                                                                        \
0556     private:                                                                                                           \
0557       SOA_HOST_DEVICE SOA_INLINE Metadata(const VIEW& parent) : parent_(parent) {}                                     \
0558       const VIEW& parent_;                                                                                             \
0559     };                                                                                                                 \
0560                                                                                                                        \
0561     friend Metadata;                                                                                                   \
0562     SOA_HOST_DEVICE SOA_INLINE const Metadata metadata() const { return Metadata(*this); }                             \
0563     SOA_HOST_DEVICE SOA_INLINE Metadata metadata() { return Metadata(*this); }                                         \
0564                                                                                                                        \
0565     /* Trivial constuctor */                                                                                           \
0566     VIEW() = default;                                                                                                  \
0567                                                                                                                        \
0568     /* Constructor relying on user provided layouts or views */                                                        \
0569     SOA_HOST_ONLY VIEW(_ITERATE_ON_ALL_COMMA(_DECLARE_VIEW_CONSTRUCTION_PARAMETERS, BOOST_PP_EMPTY(), LAYOUTS_LIST))   \
0570         : base_type{_ITERATE_ON_ALL_COMMA(_DECLARE_LAYOUT_LIST, BOOST_PP_EMPTY(), LAYOUTS_LIST)} {}                    \
0571                                                                                                                        \
0572     /* Constructor relying on individually provided column addresses */                                                \
0573     SOA_HOST_ONLY VIEW(size_type elements,                                                                             \
0574                         _ITERATE_ON_ALL_COMMA(_DECLARE_VIEW_CONSTRUCTION_BYCOLUMN_PARAMETERS,                          \
0575                                               BOOST_PP_EMPTY(),                                                        \
0576                                               VALUE_LIST))                                                             \
0577         : base_type{elements, _ITERATE_ON_ALL_COMMA(_DECLARE_VIEW_MEMBER_LIST, BOOST_PP_EMPTY(), VALUE_LIST)} {}       \
0578                                                                                                                        \
0579     /* Copiable */                                                                                                     \
0580     VIEW(VIEW const&) = default;                                                                                       \
0581     VIEW& operator=(VIEW const&) = default;                                                                            \
0582                                                                                                                        \
0583     /* Movable */                                                                                                      \
0584     VIEW(VIEW &&) = default;                                                                                           \
0585     VIEW& operator=(VIEW &&) = default;                                                                                \
0586                                                                                                                        \
0587     /* Trivial destuctor */                                                                                            \
0588     ~VIEW() = default;                                                                                                 \
0589                                                                                                                        \
0590     /* AoS-like accessor (const) */                                                                                    \
0591     using const_element = typename base_type::const_element;                                                           \
0592                                                                                                                        \
0593     using base_type::operator[];                                                                                       \
0594                                                                                                                        \
0595     /* AoS-like accessor (mutable) */                                                                                  \
0596     struct element {                                                                                                   \
0597       SOA_HOST_DEVICE SOA_INLINE                                                                                       \
0598       element(size_type index, /* Declare parameters */                                                                \
0599               _ITERATE_ON_ALL_COMMA(_DECLARE_VIEW_ELEMENT_VALUE_ARG, BOOST_PP_EMPTY(), VALUE_LIST))                    \
0600           : _ITERATE_ON_ALL_COMMA(_DECLARE_VIEW_ELEM_MEMBER_INIT, index, VALUE_LIST) {}                                \
0601       SOA_HOST_DEVICE SOA_INLINE                                                                                       \
0602       element& operator=(const element& other) {                                                                       \
0603         _ITERATE_ON_ALL(_DECLARE_VIEW_ELEMENT_VALUE_COPY, ~, VALUE_LIST)                                               \
0604         return *this;                                                                                                  \
0605       }
0606 // clang-format on
0607 
0608 // clang-format off
0609 #define _GENERATE_SOA_VIEW_PART_2(CONST_VIEW, VIEW, LAYOUTS_LIST, VALUE_LIST)                                          \
0610       _ITERATE_ON_ALL(_DECLARE_VIEW_ELEMENT_VALUE_MEMBER, ~, VALUE_LIST)                                               \
0611     };                                                                                                                 \
0612                                                                                                                        \
0613     SOA_HOST_DEVICE SOA_INLINE                                                                                         \
0614     element operator[](size_type index) {                                                                              \
0615       if constexpr (rangeChecking == cms::soa::RangeChecking::enabled) {                                               \
0616         if (index >= base_type::elements_)                                                                             \
0617           SOA_THROW_OUT_OF_RANGE("Out of range index in " #VIEW "::operator[]")                                        \
0618       }                                                                                                                \
0619       return element{index, _ITERATE_ON_ALL_COMMA(_DECLARE_VIEW_ELEMENT_CONSTR_CALL, ~, VALUE_LIST)};                  \
0620     }                                                                                                                  \
0621                                                                                                                        \
0622     /* inherit const accessors from ConstView */                                                                       \
0623                                                                                                                        \
0624     /* non-const accessors */                                                                                          \
0625     _ITERATE_ON_ALL(_DECLARE_VIEW_SOA_ACCESSOR, ~, VALUE_LIST)                                                         \
0626                                                                                                                        \
0627     /* dump the SoA internal structure */                                                                              \
0628     template <typename T>                                                                                              \
0629     SOA_HOST_ONLY friend void dump();                                                                                  \
0630   };
0631 // clang-format on
0632 
0633 /* ---- CONST VIEW -------------------------------------------------------------------------------------------------- */
0634 // clang-format off
0635 #define _GENERATE_SOA_CONST_VIEW_PART_0(CONST_VIEW, VIEW, LAYOUTS_LIST, VALUE_LIST)                                    \
0636   template <CMS_SOA_BYTE_SIZE_TYPE VIEW_ALIGNMENT = cms::soa::CacheLineSize::defaultSize,                              \
0637             bool VIEW_ALIGNMENT_ENFORCEMENT = cms::soa::AlignmentEnforcement::relaxed,                                 \
0638             bool RESTRICT_QUALIFY = cms::soa::RestrictQualify::enabled,                                                \
0639             bool RANGE_CHECKING = cms::soa::RangeChecking::disabled>                                                   \
0640   struct CONST_VIEW {                                                                                                  \
0641     /* these could be moved to an external type trait to free up the symbol names */                                   \
0642     using self_type = CONST_VIEW;
0643 // clang-format on
0644 
0645 // clang-format off
0646 #define _GENERATE_SOA_CONST_VIEW_PART_0_NO_DEFAULTS(CONST_VIEW, VIEW, LAYOUTS_LIST, VALUE_LIST)                        \
0647   template <CMS_SOA_BYTE_SIZE_TYPE VIEW_ALIGNMENT,                                                                     \
0648             bool VIEW_ALIGNMENT_ENFORCEMENT,                                                                           \
0649             bool RESTRICT_QUALIFY,                                                                                     \
0650             bool RANGE_CHECKING>                                                                                       \
0651   struct CONST_VIEW {                                                                                                  \
0652     /* these could be moved to an external type trait to free up the symbol names */                                   \
0653     using self_type = CONST_VIEW;
0654 // clang-format on
0655 
0656 /**
0657  * Split of the const view definition where the parametrized template alias for the layout is defined for layout trivial view.
0658  */
0659 
0660 // clang-format off
0661 #define _GENERATE_SOA_CONST_VIEW_PART_1(CONST_VIEW, VIEW, LAYOUTS_LIST, VALUE_LIST)                                    \
0662     using size_type = cms::soa::size_type;                                                                             \
0663     using byte_size_type = cms::soa::byte_size_type;                                                                   \
0664     using AlignmentEnforcement = cms::soa::AlignmentEnforcement;                                                       \
0665                                                                                                                        \
0666     template <CMS_SOA_BYTE_SIZE_TYPE, bool, bool, bool>                                                                \
0667     friend struct VIEW;                                                                                                \
0668                                                                                                                        \
0669     /* For CUDA applications, we align to the 128 bytes of the cache lines.                                            \
0670      * See https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#global-memory-3-0 this is still valid      \
0671      * up to compute capability 8.X.                                                                                   \
0672      */                                                                                                                \
0673     constexpr static byte_size_type defaultAlignment = cms::soa::CacheLineSize::defaultSize;                           \
0674     constexpr static byte_size_type alignment = VIEW_ALIGNMENT;                                                        \
0675     constexpr static bool alignmentEnforcement = VIEW_ALIGNMENT_ENFORCEMENT;                                           \
0676     constexpr static byte_size_type conditionalAlignment =                                                             \
0677         alignmentEnforcement == AlignmentEnforcement::enforced ? alignment : 0;                                        \
0678     constexpr static bool restrictQualify = RESTRICT_QUALIFY;                                                          \
0679     constexpr static bool rangeChecking = RANGE_CHECKING;                                                              \
0680     /* Those typedefs avoid having commas in macros (which is problematic) */                                          \
0681     template <cms::soa::SoAColumnType COLUMN_TYPE, class C>                                                            \
0682     using SoAValueWithConf = cms::soa::SoAValue<COLUMN_TYPE, C, conditionalAlignment, restrictQualify>;                \
0683                                                                                                                        \
0684     template <cms::soa::SoAColumnType COLUMN_TYPE, class C>                                                            \
0685     using SoAConstValueWithConf = cms::soa::SoAConstValue<COLUMN_TYPE, C, conditionalAlignment, restrictQualify>;      \
0686                                                                                                                        \
0687     /**                                                                                                                \
0688      * Helper/friend class allowing SoA introspection.                                                                 \
0689      */                                                                                                                \
0690     struct Metadata {                                                                                                  \
0691       friend CONST_VIEW;                                                                                               \
0692       SOA_HOST_DEVICE SOA_INLINE size_type size() const { return parent_.elements_; }                                  \
0693       /* Alias layout or view types to name-derived identifyer to allow simpler definitions */                         \
0694       _ITERATE_ON_ALL(_DECLARE_VIEW_LAYOUT_TYPE_ALIAS, ~, LAYOUTS_LIST)                                                \
0695                                                                                                                        \
0696       /* Alias member types to name-derived identifyer to allow simpler definitions */                                 \
0697       _ITERATE_ON_ALL(_DECLARE_VIEW_MEMBER_TYPE_ALIAS, BOOST_PP_EMPTY(), VALUE_LIST)                                   \
0698       _ITERATE_ON_ALL(_DECLARE_VIEW_MEMBER_CONST_POINTERS, ~, VALUE_LIST)                                              \
0699                                                                                                                        \
0700       /* Forbid copying to avoid const correctness evasion */                                                          \
0701       Metadata& operator=(const Metadata&) = delete;                                                                   \
0702       Metadata(const Metadata&) = delete;                                                                              \
0703                                                                                                                        \
0704     private:                                                                                                           \
0705       SOA_HOST_DEVICE SOA_INLINE Metadata(const CONST_VIEW& parent) : parent_(parent) {}                               \
0706       const CONST_VIEW& parent_;                                                                                       \
0707     };                                                                                                                 \
0708                                                                                                                        \
0709     friend Metadata;                                                                                                   \
0710     SOA_HOST_DEVICE SOA_INLINE const Metadata metadata() const { return Metadata(*this); }                             \
0711                                                                                                                        \
0712     /* Trivial constuctor */                                                                                           \
0713     CONST_VIEW() = default;                                                                                            \
0714                                                                                                                        \
0715     /* Constructor relying on user provided layouts or views */                                                        \
0716     SOA_HOST_ONLY CONST_VIEW(_ITERATE_ON_ALL_COMMA(_DECLARE_VIEW_CONSTRUCTION_PARAMETERS, const, LAYOUTS_LIST))        \
0717         : elements_([&]() -> size_type {                                                                               \
0718             bool set = false;                                                                                          \
0719             size_type ret = 0;                                                                                         \
0720             _ITERATE_ON_ALL(_UPDATE_SIZE_OF_VIEW, BOOST_PP_EMPTY(), LAYOUTS_LIST)                                      \
0721             return ret;                                                                                                \
0722           }()),                                                                                                        \
0723           _ITERATE_ON_ALL_COMMA(_DECLARE_VIEW_MEMBER_INITIALIZERS, ~, VALUE_LIST) {}                                   \
0724                                                                                                                        \
0725     /* Constructor relying on individually provided column addresses */                                                \
0726     SOA_HOST_ONLY CONST_VIEW(size_type elements,                                                                       \
0727                         _ITERATE_ON_ALL_COMMA(_DECLARE_VIEW_CONSTRUCTION_BYCOLUMN_PARAMETERS, const, VALUE_LIST))      \
0728         : elements_(elements), _ITERATE_ON_ALL_COMMA(_DECLARE_VIEW_MEMBER_INITIALIZERS_BYCOLUMN, ~, VALUE_LIST) {}     \
0729                                                                                                                        \
0730     /* Copiable */                                                                                                     \
0731     CONST_VIEW(CONST_VIEW const&) = default;                                                                           \
0732     CONST_VIEW& operator=(CONST_VIEW const&) = default;                                                                \
0733                                                                                                                        \
0734     /* Movable */                                                                                                      \
0735     CONST_VIEW(CONST_VIEW &&) = default;                                                                               \
0736     CONST_VIEW& operator=(CONST_VIEW &&) = default;                                                                    \
0737                                                                                                                        \
0738     /* Trivial destuctor */                                                                                            \
0739     ~CONST_VIEW() = default;                                                                                           \
0740                                                                                                                        \
0741     /* AoS-like accessor (const) */                                                                                    \
0742     struct const_element {                                                                                             \
0743       SOA_HOST_DEVICE SOA_INLINE                                                                                       \
0744       const_element(size_type index, /* Declare parameters */                                                          \
0745                     _ITERATE_ON_ALL_COMMA(_DECLARE_CONST_VIEW_ELEMENT_VALUE_ARG, const, VALUE_LIST))                   \
0746           : _ITERATE_ON_ALL_COMMA(_DECLARE_VIEW_CONST_ELEM_MEMBER_INIT, index, VALUE_LIST) {}                          \
0747       _ITERATE_ON_ALL(_DECLARE_VIEW_CONST_ELEMENT_ACCESSOR, ~, VALUE_LIST)                                             \
0748                                                                                                                        \
0749     private:                                                                                                           \
0750       _ITERATE_ON_ALL(_DECLARE_VIEW_CONST_ELEMENT_VALUE_MEMBER, ~, VALUE_LIST)                                         \
0751     };                                                                                                                 \
0752                                                                                                                        \
0753     SOA_HOST_DEVICE SOA_INLINE                                                                                         \
0754     const_element operator[](size_type index) const {                                                                  \
0755       if constexpr (rangeChecking == cms::soa::RangeChecking::enabled) {                                               \
0756         if (index >= elements_)                                                                                        \
0757           SOA_THROW_OUT_OF_RANGE("Out of range index in " #CONST_VIEW "::operator[]")                                  \
0758       }                                                                                                                \
0759       return const_element{index, _ITERATE_ON_ALL_COMMA(_DECLARE_VIEW_CONST_ELEMENT_CONSTR_CALL, ~, VALUE_LIST)};      \
0760     }                                                                                                                  \
0761                                                                                                                        \
0762     /* const accessors */                                                                                              \
0763     _ITERATE_ON_ALL(_DECLARE_VIEW_SOA_CONST_ACCESSOR, ~, VALUE_LIST)                                                   \
0764                                                                                                                        \
0765     /* dump the SoA internal structure */                                                                              \
0766     template <typename T>                                                                                              \
0767     SOA_HOST_ONLY friend void dump();                                                                                  \
0768                                                                                                                        \
0769   private:                                                                                                             \
0770     size_type elements_ = 0;                                                                                           \
0771     _ITERATE_ON_ALL(_DECLARE_CONST_VIEW_SOA_MEMBER, const, VALUE_LIST)                                                 \
0772 };
0773 // clang-format on
0774 
0775 // clang-format off
0776 // MAJOR caveat: in order to propagate the LAYOUTS_LIST and VALUE_LIST
0777 #define _GENERATE_SOA_CONST_VIEW(CONST_VIEW, VIEW, LAYOUTS_LIST, VALUE_LIST)                                           \
0778    _GENERATE_SOA_CONST_VIEW_PART_0(CONST_VIEW, VIEW,                                                                   \
0779      SOA_VIEW_LAYOUT_LIST(LAYOUTS_LIST), SOA_VIEW_VALUE_LIST(VALUE_LIST))                                              \
0780    _GENERATE_SOA_CONST_VIEW_PART_1(CONST_VIEW, VIEW,                                                                   \
0781      SOA_VIEW_LAYOUT_LIST(LAYOUTS_LIST), SOA_VIEW_VALUE_LIST(VALUE_LIST))
0782 
0783 #define GENERATE_SOA_CONST_VIEW(CONST_VIEW, VIEW, LAYOUTS_LIST, VALUE_LIST)                                            \
0784    _GENERATE_SOA_CONST_VIEW(CONST_VIEW, BOOST_PP_CAT(CONST_VIEW, Unused_),                                             \
0785      SOA_VIEW_LAYOUT_LIST(LAYOUTS_LIST), SOA_VIEW_VALUE_LIST(VALUE_LIST))
0786 
0787 #define _GENERATE_SOA_TRIVIAL_CONST_VIEW(CLASS, LAYOUTS_LIST, VALUE_LIST)                                              \
0788    _GENERATE_SOA_CONST_VIEW_PART_0_NO_DEFAULTS(ConstViewTemplateFreeParams, ViewTemplateFreeParams,                    \
0789      SOA_VIEW_LAYOUT_LIST(LAYOUTS_LIST), SOA_VIEW_VALUE_LIST(VALUE_LIST))                                              \
0790    using BOOST_PP_CAT(CLASS, _parametrized) = CLASS<VIEW_ALIGNMENT, VIEW_ALIGNMENT_ENFORCEMENT>;                       \
0791    _GENERATE_SOA_CONST_VIEW_PART_1(ConstViewTemplateFreeParams, ViewTemplateFreeParams,                                \
0792      SOA_VIEW_LAYOUT_LIST(LAYOUTS_LIST), SOA_VIEW_VALUE_LIST(VALUE_LIST))
0793 
0794 #define _GENERATE_SOA_VIEW(CONST_VIEW, VIEW, LAYOUTS_LIST, VALUE_LIST)                                                 \
0795    _GENERATE_SOA_VIEW_PART_0(CONST_VIEW, VIEW, SOA_VIEW_LAYOUT_LIST(LAYOUTS_LIST), SOA_VIEW_VALUE_LIST(VALUE_LIST))    \
0796    _GENERATE_SOA_VIEW_PART_1(CONST_VIEW, VIEW, SOA_VIEW_LAYOUT_LIST(LAYOUTS_LIST), SOA_VIEW_VALUE_LIST(VALUE_LIST))    \
0797    _GENERATE_SOA_VIEW_PART_2(CONST_VIEW, VIEW, SOA_VIEW_LAYOUT_LIST(LAYOUTS_LIST), SOA_VIEW_VALUE_LIST(VALUE_LIST))
0798 
0799 #define GENERATE_SOA_VIEW(CONST_VIEW, VIEW, LAYOUTS_LIST, VALUE_LIST)                                                  \
0800    _GENERATE_SOA_CONST_VIEW(CONST_VIEW, VIEW, SOA_VIEW_LAYOUT_LIST(LAYOUTS_LIST), SOA_VIEW_VALUE_LIST(VALUE_LIST))     \
0801    _GENERATE_SOA_VIEW(CONST_VIEW, VIEW, SOA_VIEW_LAYOUT_LIST(LAYOUTS_LIST), SOA_VIEW_VALUE_LIST(VALUE_LIST))
0802 
0803 #define _GENERATE_SOA_TRIVIAL_VIEW(CLASS, LAYOUTS_LIST, VALUE_LIST, ...)                                               \
0804    _GENERATE_SOA_VIEW_PART_0_NO_DEFAULTS(ConstViewTemplateFreeParams, ViewTemplateFreeParams,                          \
0805      SOA_VIEW_LAYOUT_LIST(LAYOUTS_LIST), SOA_VIEW_VALUE_LIST(VALUE_LIST))                                              \
0806    using BOOST_PP_CAT(CLASS, _parametrized) = CLASS<VIEW_ALIGNMENT, VIEW_ALIGNMENT_ENFORCEMENT>;                       \
0807    _GENERATE_SOA_VIEW_PART_1(ConstViewTemplateFreeParams, ViewTemplateFreeParams,                                      \
0808      SOA_VIEW_LAYOUT_LIST(LAYOUTS_LIST), SOA_VIEW_VALUE_LIST(VALUE_LIST))                                              \
0809                                                                                                                        \
0810    /* Extra operator=() for mutable element to emulate the aggregate initialisation syntax */                          \
0811    SOA_HOST_DEVICE SOA_INLINE constexpr element & operator=(const typename                                             \
0812        BOOST_PP_CAT(CLASS, _parametrized)::Metadata::value_element value) {                                            \
0813      _ITERATE_ON_ALL(_TRIVIAL_VIEW_ASSIGN_VALUE_ELEMENT, ~, __VA_ARGS__)                                               \
0814      return *this;                                                                                                     \
0815    }                                                                                                                   \
0816                                                                                                                        \
0817    _GENERATE_SOA_VIEW_PART_2(ConstViewTemplateFreeParams, ViewTemplateFreeParams,                                      \
0818      SOA_VIEW_LAYOUT_LIST(LAYOUTS_LIST), SOA_VIEW_VALUE_LIST(VALUE_LIST))
0819 // clang-format on
0820 
0821 /**
0822  * Helper macro turning layout field declaration into view field declaration.
0823  */
0824 #define _VIEW_FIELD_FROM_LAYOUT_IMPL(VALUE_TYPE, CPP_TYPE, NAME, DATA) (DATA, NAME, NAME)
0825 
0826 #define _VIEW_FIELD_FROM_LAYOUT(R, DATA, VALUE_TYPE_NAME) \
0827   BOOST_PP_EXPAND((_VIEW_FIELD_FROM_LAYOUT_IMPL BOOST_PP_TUPLE_PUSH_BACK(VALUE_TYPE_NAME, DATA)))
0828 
0829 #endif  // DataFormats_SoATemplate_interface_SoAView_h
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.2.1 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!