Pattern Properties

Property system for specification and deduction of pattern types. More...

Collaboration diagram for Pattern Properties:

Modules
	Pattern Layout Properties
	Pattern layout property category for specification and deduction of pattern types.
	Pattern Mapping Properties
	Pattern mapping property category for specification and deduction of pattern types.
	Pattern Partitioning Properties
	Pattern partitioning property category for specification and deduction of pattern types.

Classes
struct	dash::pattern_constraints< PartitioningConstraints, MappingConstraints, LayoutConstraints, PatternType >
	Traits for compile-time pattern constraints checking, suitable as a helper for template definitions employing SFINAE where no verbose error reporting is required. More...

Functions
template<typename PartitioningConstraints , typename MappingConstraints , typename LayoutConstraints , typename PatternType >
bool	dash::check_pattern_constraints (const PatternType &pattern)
	Traits for compile- and run-time pattern constraints checking, suitable for property checks where detailed error reporting is desired. More...

Detailed Description

Property system for specification and deduction of pattern types.

Description

The Pattern property system is based on type traits that provide a classification of pattern types by their properties.

All patterns realize a mapping of elements to addresses in physical memory in three stages:

• Partitioning: how elements are partitioned into blocks
• Mapping: how blocks are mapped to units
• Layout: how elements are arranged in the units' local memory

Semantics of a pattern type are fully described by its properties in these categories.

Function Documentation

check_pattern_constraints()

template<typename PartitioningConstraints , typename MappingConstraints , typename LayoutConstraints , typename PatternType >

bool dash::check_pattern_constraints

(

const PatternType &

pattern

)

#include </tmp/tmporruphar/dash/include/dash/pattern/PatternProperties.h>

Traits for compile- and run-time pattern constraints checking, suitable for property checks where detailed error reporting is desired.

{}

Definition at line 818 of file PatternProperties.h.

Referenced by dash::summa().

{
  // Pattern property traits of category Partitioning
  typedef typename dash::pattern_traits< PatternType >::partitioning
          partitioning_traits;
  // Pattern property traits of category Mapping
  typedef typename dash::pattern_traits< PatternType >::mapping
          mapping_traits;
  // Pattern property traits of category Layout
  typedef typename dash::pattern_traits< PatternType >::layout
          layout_traits;
  // Check compile-time invariants:

  // Partitioning properties:
  //
  static_assert(!PartitioningConstraints::rectangular ||
                partitioning_traits::rectangular,
                "Pattern does not implement rectangular partitioning");
  static_assert(!PartitioningConstraints::minimal ||
                partitioning_traits::minimal,
                "Pattern does not implement minimal partitioning");
  static_assert(!PartitioningConstraints::regular ||
                partitioning_traits::regular,
                "Pattern does not implement regular partitioning");
  static_assert(!PartitioningConstraints::balanced ||
                partitioning_traits::balanced,
                "Pattern does not implement balanced partitioning");
  static_assert(!PartitioningConstraints::unbalanced ||
                partitioning_traits::unbalanced,
                "Pattern does not implement unbalanced partitioning");
  // Mapping properties:
  //
  static_assert(!MappingConstraints::balanced ||
                mapping_traits::balanced,
                "Pattern does not implement balanced mapping");
  static_assert(!MappingConstraints::unbalanced ||
                mapping_traits::unbalanced,
                "Pattern does not implement unbalanced mapping");
  static_assert(!MappingConstraints::neighbor ||
                mapping_traits::neighbor,
                "Pattern does not implement neighbor mapping");
  static_assert(!MappingConstraints::shifted ||
                mapping_traits::shifted,
                "Pattern does not implement shifted mapping");
  static_assert(!MappingConstraints::diagonal ||
                mapping_traits::diagonal,
                "Pattern does not implement diagonal mapping");
  static_assert(!MappingConstraints::cyclic ||
                mapping_traits::cyclic,
                "Pattern does not implement cyclic mapping");
  // Layout properties:
  //
  static_assert(!LayoutConstraints::blocked ||
                layout_traits::blocked,
                "Pattern does not implement blocked layout");
  static_assert(!LayoutConstraints::canonical ||
                layout_traits::canonical,
                "Pattern does not implement canonical layout");
  static_assert(!LayoutConstraints::linear ||
                layout_traits::linear,
                "Pattern does not implement linear layout");
  return true;
}