legion_c_util.h File Reference

#include "legion.h"
#include "legion/legion_c.h"
#include "legion/legion_mapping.h"
#include "mappers/mapping_utilities.h"
#include <stdlib.h>
#include <string.h>
#include <algorithm>

Go to the source code of this file.

Classes
struct	Legion::ColoredPoints
class	Legion::CObjectWrapper
struct	Legion::CObjectWrapper::Blockify< DIM >
class	Legion::CContext
class	Legion::TaskMut

Namespaces
namespace	Legion

Macros
#define	ARRAY_ACCESSOR(DIM)
#define	RECT_ITERATOR(DIM)    typedef RectInDomainIterator<DIM,coord_t> RectInDomainIterator##DIM##D;
#define	BUFFER_CHAR(DIM)    typedef DeferredBuffer<char,DIM> DeferredBufferChar##DIM##D;
#define	NEW_OPAQUE_WRAPPER(T_, T)
#define	RECT_ITERATOR(DIM)    NEW_OPAQUE_WRAPPER(legion_rect_in_domain_iterator_##DIM##d_t, RectInDomainIterator##DIM##D *);
#define	BUFFER_CHAR(DIM)    NEW_OPAQUE_WRAPPER(legion_deferred_buffer_char_##DIM##d_t, DeferredBufferChar##DIM##D *);
#define	ACCESSOR_ARRAY(DIM)    NEW_OPAQUE_WRAPPER(legion_accessor_array_##DIM##d_t, ArrayAccessor##DIM##D *);
#define	NEW_POINT_WRAPPER(DIM)
#define	NEW_RECT_WRAPPER(DIM)
#define	NEW_BLOCKIFY_WRAPPER(DIM)
#define	NEW_TRANSFORM_WRAPPER(D1, D2)
#define	NEW_AFFINE_TRANSFORM_WRAPPER(D1, D2)

Typedefs
typedef std::map< Color, ColoredPoints >	Legion::Coloring
typedef std::map< Color, Domain >	Legion::DomainColoring
typedef std::map< DomainPoint, ColoredPoints >	Legion::PointColoring
typedef std::map< DomainPoint, Domain >	Legion::DomainPointColoring
typedef std::map< DomainPoint, std::set< Domain > >	Legion::MultiDomainPointColoring

Functions
static bool	operator< (const legion_ptr_t &lhs, const legion_ptr_t &rhs)

Detailed Description

Legion C API: C++ Conversion Utilities

Macro Definition Documentation

ARRAY_ACCESSOR

#define ARRAY_ACCESSOR

(

DIM

)

Value:

      typedef Legion::UnsafeFieldAccessor<char,DIM,coord_t, \
                Realm::AffineAccessor<char,DIM,coord_t> >   ArrayAccessor##DIM##D;

NEW_AFFINE_TRANSFORM_WRAPPER

#define NEW_AFFINE_TRANSFORM_WRAPPER	(		D1,
			D2
	)

Value:

    typedef AffineTransform<D1,D2,coord_t> AffineTransform##D1##x##D2;                      \
    static legion_affine_transform_##D1##x##D2##_t wrap(AffineTransform##D1##x##D2 t) {     \
      legion_affine_transform_##D1##x##D2##_t t_;                                           \
      t_.transform = wrap(t.transform);                                                     \
      t_.offset = wrap(t.offset);                                                           \
      return t_;                                                                            \
    }                                                                                       \
    static AffineTransform##D1##x##D2 unwrap(legion_affine_transform_##D1##x##D2##_t t_) {  \
      AffineTransform##D1##x##D2 t;                                                         \
      t.transform = unwrap(t_.transform);                                                   \
      t.offset = unwrap(t_.offset);                                                         \
      return t;                                                                             \
    }

NEW_BLOCKIFY_WRAPPER

#define NEW_BLOCKIFY_WRAPPER

(

DIM

)

Value:

      static Blockify<DIM> unwrap(legion_blockify_##DIM##d_t t_) {  \
        Blockify<DIM> t(unwrap(t_.block_size), unwrap(t_.offset));  \
        return t;                                                   \
      }

NEW_OPAQUE_WRAPPER

#define NEW_OPAQUE_WRAPPER	(		T_,
			T
	)

Value:

      static T_ wrap(T t) {                                             \
        T_ t_;                                                          \
        t_.impl = static_cast<void *>(t);                               \
        return t_;                                                      \
      }                                                                 \
      static const T_ wrap_const(const T t) {                           \
        T_ t_;                                                          \
        t_.impl = const_cast<void *>(static_cast<const void *>(t));     \
        return t_;                                                      \
      }                                                                 \
      static T unwrap(T_ t_) {                                          \
        return static_cast<T>(t_.impl);                                 \
      }                                                                 \
      static const T unwrap_const(const T_ t_) {                        \
        return static_cast<const T>(t_.impl);                           \
      }

NEW_POINT_WRAPPER

#define NEW_POINT_WRAPPER

(

DIM

)

Value:

      typedef Point<DIM,coord_t> Point##DIM##D;                 \
      static legion_point_##DIM##d_t wrap(Point##DIM##D t) {    \
        legion_point_##DIM##d_t t_;                             \
        for (int i = 0; i < DIM; i++)                           \
          t_.x[i] = t[i];                                       \
        return t_;                                              \
      }                                                         \
      static Point##DIM##D unwrap(legion_point_##DIM##d_t t_) { \
        Point##DIM##D t;                                        \
        for (int i = 0; i < DIM; i++)                           \
          t[i] = t_.x[i];                                       \
        return t;                                               \
      }

NEW_RECT_WRAPPER

#define NEW_RECT_WRAPPER

(

DIM

)

Value:

      typedef Rect<DIM,coord_t> Rect##DIM##D;                   \
      static legion_rect_##DIM##d_t wrap(Rect##DIM##D t) {      \
        legion_rect_##DIM##d_t t_;                              \
        t_.lo = wrap(Point##DIM##D(t.lo));                      \
        t_.hi = wrap(Point##DIM##D(t.hi));                      \
        return t_;                                              \
      }                                                         \
      static Rect##DIM##D unwrap(legion_rect_##DIM##d_t t_) {   \
        Rect##DIM##D t(unwrap(t_.lo), unwrap(t_.hi));           \
        return t;                                               \
      }

NEW_TRANSFORM_WRAPPER

#define NEW_TRANSFORM_WRAPPER	(		D1,
			D2
	)

Value:

      typedef Transform<D1,D2,coord_t> Transform##D1##x##D2;                    \
      static legion_transform_##D1##x##D2##_t wrap(Transform##D1##x##D2 t) {    \
        legion_transform_##D1##x##D2##_t t_;                                    \
        for (int i = 0; i < D1; i++)                                            \
          for (int j = 0; j < D2; j++)                                          \
            t_.trans[i][j] = t[i][j];                                           \
        return t_;                                                              \
      }                                                                         \
      static Transform##D1##x##D2 unwrap(legion_transform_##D1##x##D2##_t t_) { \
        Transform##D1##x##D2 t;                                                 \
        for (int i = 0; i < D1; i++)                                            \
          for (int j = 0; j < D2; j++)                                          \
            t[i][j] = t_.trans[i][j];                                           \
        return t;                                                               \
      }