tiny file which shows this compiler error

gcc-bug.C (text/plain), 12.69 KB, created by Helmut Jarausch on 2017-11-07 12:32:14 UTC

#include <sstream>

typedef uint64_t kaapi_address_space_id_t;
typedef uint32_t kaapi_thread_id_t;
typedef uint64_t kaapi_ldid_t;
typedef uint64_t kaapi_ldset_t;

typedef enum kaapi_hws_levelid
{
  KAAPI_HWS_LEVELID_THREAD  = 0,
  KAAPI_HWS_LEVELID_CORE    = 1,
  KAAPI_HWS_LEVELID_NUMA    = 2,
  KAAPI_HWS_LEVELID_SOCKET  = 3,
  KAAPI_HWS_LEVELID_BOARD   = 4,
  KAAPI_HWS_LEVELID_MACHINE = 5,
  KAAPI_HWS_LEVELID_MAX
} kaapi_hws_levelid_t;


typedef enum kaapi_access_mode_t {
  KAAPI_ACCESS_MODE_VOID= 0,        /* 0000 0000 : */
  KAAPI_ACCESS_MODE_V   = 1,        /* 0000 0001 : */
  KAAPI_ACCESS_MODE_R   = 2,        /* 0000 0010 : */
  KAAPI_ACCESS_MODE_W   = 4,        /* 0000 0100 : */
  KAAPI_ACCESS_MODE_CW  = 8,        /* 0000 1000 : */
  KAAPI_ACCESS_MODE_S   = 16,       /* 0001 0000 : stack data */
  KAAPI_ACCESS_MODE_T   = 32,       /* 0010 0000 : for Quark support: scratch mode or temporary */
  KAAPI_ACCESS_MODE_P   = 64,       /* 0100 0000 : */
  KAAPI_ACCESS_MODE_IP  = 128,      /* 1000 0000 : in place, for CW only */

  KAAPI_ACCESS_MODE_RW  = KAAPI_ACCESS_MODE_R|KAAPI_ACCESS_MODE_W,
  KAAPI_ACCESS_MODE_STACK = KAAPI_ACCESS_MODE_S|KAAPI_ACCESS_MODE_RW,
  KAAPI_ACCESS_MODE_SCRATCH = KAAPI_ACCESS_MODE_T|KAAPI_ACCESS_MODE_V,
  KAAPI_ACCESS_MODE_CWP = KAAPI_ACCESS_MODE_P|KAAPI_ACCESS_MODE_CW,
  KAAPI_ACCESS_MODE_ICW = KAAPI_ACCESS_MODE_IP|KAAPI_ACCESS_MODE_CW
} kaapi_access_mode_t;


#define KAAPI_CACHE_LINE 64


typedef struct kaapi_thread_t {
  struct kaapi_task_t*   sp;
  char*                  sp_data;
} kaapi_thread_t;

typedef void (*kaapi_task_body_t)( struct kaapi_task_t* /* task */,
                                   kaapi_thread_t* /* thread */);

typedef int (*kaapi_isready_fnc_t)( void* );

typedef struct kaapi_atomic32_t {
  volatile int32_t _counter;
} kaapi_atomic32_t;
typedef kaapi_atomic32_t kaapi_atomic_t;


typedef struct kaapi_task_t {
  union {
    kaapi_task_body_t              steal;     /** !=0 iff steal */
    struct kaapi_frame_wrdlist_t* frame;     /** if DFG ==ok */
  } state;
  kaapi_task_body_t             body;      /** task body  */
  void*                         arg;       /** arg of the task */
  union { /* should be of size of uintptr */
    struct {
      uint8_t                   flag;      /** some flag as splittable, local... */
      uint8_t                   priority;  /** of the task */
      uint8_t                   site;      /** 1+preferred location */
      uint8_t                   mark;      /** to dump graph */
      uint32_t                  date;
      /* ... */                            /** some bits are available on 64bits LP machine */
    } s;
    uint64_t                    dummy;     /* to clear previous fields in one write */
  } u;
  kaapi_atomic_t                wc;
  const struct kaapi_format_t*  fmt;       /* cache if DFG built / frame_rd pointer */
  struct kaapi_task_t*          next;      /* when task pushed into list */
  struct kaapi_task_t*          prev;      /* to delete */
} kaapi_task_t  __attribute__((aligned(KAAPI_CACHE_LINE)));

typedef struct kaapi_access_t {
  void*    data;    /* global data */
  void*    version; /* used to set the data to access (R/W/RW/CW) if steal, used to store output after steal */

  // following fields are only valid if flag & DFG_OK is valid on the task
  kaapi_task_t*          task;    /* the owner task */
  kaapi_access_mode_t    mode;    /* */
  struct kaapi_access_t* next;    /* next access to the same data or 0 */
} kaapi_access_t;

typedef struct kaapi_memory_view_t {
  int           type;
  long          offset;
  unsigned long size[2];
  unsigned long lda;
  unsigned long wordsize;
} kaapi_memory_view_t;



typedef kaapi_access_t* (*kaapi_fmt_fnc_get_access_param)(
    const struct kaapi_format_t*, unsigned int, const void*
);

typedef int (*kaapi_adaptivetask_splitter_t)(
  struct kaapi_task_t*                 /* task to be used to get arguments */,
  struct kaapi_listrequest_iterator_t* /* iterator over the list*/
);

extern struct kaapi_request_t* kaapi_listrequest_iterator_get( 
  struct kaapi_listrequest_iterator_t* lrrange
);
extern struct kaapi_request_t* kaapi_listrequest_iterator_next( 
  struct kaapi_listrequest_iterator_t* lrrange 
);
extern int kaapi_listrequest_iterator_empty( 
  struct kaapi_listrequest_iterator_t* lrrange
);
/* may reclaims O(k) ops */
extern int kaapi_listrequest_iterator_count(
  struct kaapi_listrequest_iterator_t* lrrange
);

typedef int (*kaapi_request_replytask_fnc_t)
( 
  struct kaapi_request_t* request,
  int                     status
);
  

/** \ingroup WS
    Request emitted to get work.
    This data structure is pass in parameter of the splitter function.
    On return, the receiver that emits the request will retreive task(s) in the frame.
*/
typedef struct kaapi_request_t {
  kaapi_request_replytask_fnc_t reply;          /* function to reply */
  kaapi_ldid_t                  ident;          /* system wide id who is emetting the request */
  kaapi_atomic_t                status;         /* request status */
  kaapi_thread_t                thread;         /* where to store theft tasks/data */
  uintptr_t                     victim;         /* victim: used only to record trace */
  uintptr_t                     serial;         /* serial number: used only to record trace */
} kaapi_request_t;


/** \ingroup DFG
    Kaapi access, public
*/

#define kaapi_data(type, a)\
  ((type*)((kaapi_access_t*)(a))->data)



typedef void (*kaapi_fmt_fnc_get_name)(
  const struct kaapi_format_t*, const void*, char* buffer, int size
);

typedef void (*kaapi_fmt_fnc_get_name)(
  const struct kaapi_format_t*, const void*, char* buffer, int size
);


typedef size_t (*kaapi_fmt_fnc_get_size)(const struct kaapi_format_t*, const void*);

typedef void (*kaapi_fmt_fnc_task_copy)(const struct kaapi_format_t*, void*, const void*);

typedef unsigned int (*kaapi_fmt_fnc_get_count_params)(const struct kaapi_format_t*, const void*);

typedef kaapi_access_mode_t (*kaapi_fmt_fnc_get_mode_param)(
    const struct kaapi_format_t*, unsigned int, const void*
);

typedef void* (*kaapi_fmt_fnc_get_data_param)(
    const struct kaapi_format_t*, unsigned int, const void*
);
typedef void (*kaapi_fmt_fnc_set_access_param)(
    const struct kaapi_format_t*, unsigned int, void*, const kaapi_access_t*
);

typedef const struct kaapi_format_t*(*kaapi_fmt_fnc_get_fmt_param)(
    const struct kaapi_format_t*, unsigned int, const void*
);

typedef void (*kaapi_fmt_fnc_get_view_param)(
    const struct kaapi_format_t*, unsigned int, const void*, kaapi_memory_view_t* 
);

typedef void (*kaapi_fmt_fnc_set_view_param)(
    const struct kaapi_format_t*, unsigned int, void*, const kaapi_memory_view_t*);

typedef void (*kaapi_fmt_fnc_reducor)(
    const struct kaapi_format_t*, unsigned int, void*, const void*);

typedef void (*kaapi_fmt_fnc_redinit)(
    const struct kaapi_format_t*, unsigned int, const void* sp, void*);

typedef kaapi_adaptivetask_splitter_t	(*kaapi_fmt_fnc_get_splitter)(
    const struct kaapi_format_t*, const void*
);

#define KAAPI_MEMORY_VIEW_1D 1
#define KAAPI_MEMORY_VIEW_2D 2  /* assume row major */
#define KAAPI_MEMORY_VIEW_3D 3

static inline int kaapi_memory_view_iscontiguous( const kaapi_memory_view_t* const kmv )
{
  switch (kmv->type) {
    case KAAPI_MEMORY_VIEW_1D: return 1;
    case KAAPI_MEMORY_VIEW_2D: return  kmv->lda == kmv->size[1]; /* row major storage */
    default:
      break;
  } 
  return 0;
}

extern void kaapi_abort(unsigned long int line, const char* file, const char* msg);
#define kaapi_assert( cond ) if (!(cond)) kaapi_abort(__LINE__, __FILE__, 0);

static inline size_t kaapi_memory_view_size( const kaapi_memory_view_t* const kmv )
{
  switch (kmv->type) 
  {
    case KAAPI_MEMORY_VIEW_1D: return kmv->size[0]*kmv->wordsize;
    case KAAPI_MEMORY_VIEW_2D: return kmv->size[0]*kmv->size[1]*kmv->wordsize;
    default:
      kaapi_assert(0);
      break;
  }
  return 0;
}


  class Format {
  public:
    Format(
           const char* name = "empty",
           size_t size = 0,
           void (*cstor)( void* dest) = 0,
           void (*dstor)( void* dest) = 0,
           void (*cstorcopy)( void* dest, const void* src) = 0,
           void (*copy)( void* dest, const void* src) = 0,
           void (*assign)( void*, const kaapi_memory_view_t*, const void*, const kaapi_memory_view_t*) =0
           );
    struct kaapi_format_t* get_c_format();
    const struct kaapi_format_t* get_c_format() const;
  public:
    Format( kaapi_format_t* f );
    void reinit( kaapi_format_t* f ) const;
  protected:
    mutable struct kaapi_format_t* fmt;
  };
  class FormatUpdateFnc : public Format {
  public:
    FormatUpdateFnc(
                    const char* name,
                    int (*update_mb)(void* data, const struct kaapi_format_t* fmtdata,
                                     const void* value, const struct kaapi_format_t* fmtvalue )
                    );
  };
  class FormatTask : public Format {
  public:
    FormatTask(
              const char* name,
              kaapi_fmt_fnc_get_name get_name,
              kaapi_fmt_fnc_get_size get_size,
              kaapi_fmt_fnc_task_copy task_copy,
              kaapi_fmt_fnc_get_count_params get_count_params,
              kaapi_fmt_fnc_get_mode_param get_mode_param,
              kaapi_fmt_fnc_get_data_param get_data_param,
              kaapi_fmt_fnc_get_access_param get_access_param,
              kaapi_fmt_fnc_set_access_param set_access_param,
              kaapi_fmt_fnc_get_fmt_param get_fmt_param,
              kaapi_fmt_fnc_get_view_param get_view_param,
              kaapi_fmt_fnc_set_view_param set_view_param,
              kaapi_fmt_fnc_reducor reducor,
              kaapi_fmt_fnc_redinit redinit,
              kaapi_fmt_fnc_get_splitter get_splitter
    );
  };
  template <class T>
  class WrapperFormat : public Format {
    WrapperFormat(kaapi_format_t* f);
  public:
    WrapperFormat();
    static const WrapperFormat<T> format;
    static const Format* get_format();
    static const kaapi_format_t* get_c_format();
    static void cstor( void* dest) { new (dest) T; }
    static void dstor( void* dest) { T* d = (T*)dest; d->T::~T(); }
    static void cstorcopy( void* dest, const void* src) { T* s = (T*)src; new (dest) T(*s); }
    static void copy( void* dest, const void* src) { T* d = (T*)dest; T* s = (T*)src; *d = *s; }
    static void assign(
                       void* dest, const kaapi_memory_view_t* view_dest,
                       const void* src, const kaapi_memory_view_t* view_src)
    {
      T* d = (T*)dest; T* s = (T*)src;
      if (kaapi_memory_view_iscontiguous(view_dest) && kaapi_memory_view_iscontiguous(view_src))
      {
        size_t size = kaapi_memory_view_size(view_dest) / sizeof(T);
        for (size_t i=0; i < size; ++i)
          d[i] = s[i];
      }
      else if (view_src->type == 2)
      {
        size_t size_i = view_src->size[0];
        size_t size_j = view_src->size[1];
        for (size_t i=0; i < size_i; ++i)
        {
          for (size_t j=0; j < size_j; ++j)
            d[j] = s[j];
          d += view_dest->lda;
          s += view_src->lda;
        }
      }
      else {
        kaapi_abort(219, "/var/tmp/portage/sci-libs/xkaapi-9999/work/xkaapi-9999/api/kaapixx/kaapi++.h", "Format, bad assignment of unimplemented views");
      }
    }
    static void print( FILE* file, const void* src)
    {
      const T* data = (const T*)src;
      std::stringstream sstr;
      sstr << *data;
      fprintf(file, "%s", sstr.str().c_str());
    }
  };
  template <class UpdateFnc>
  class WrapperFormatUpdateFnc : public FormatUpdateFnc {
  protected:
    template<class UF, class T, class Y>
    static bool Caller( bool (UF::*)( T&, const Y& ), void* d, const void* v )
    {
      static UpdateFnc ufc;
      T* data = static_cast<T*>(d);
      const Y* value = static_cast<const Y*>(v);
      return ufc( *data, *value );
    }
  public:
    static int update_kaapi( void* data, const kaapi_format_t* fmtdata, const void* value, const kaapi_format_t* fmtvalue )
    {
      return Caller( &UpdateFnc::operator(), data, value ) ? 1 : 0;
    }
    static const FormatUpdateFnc format;
    static const FormatUpdateFnc* get_format();
  };
  template <class T>
  WrapperFormat<T>::WrapperFormat()
  : Format( typeid(T).name(),
           sizeof(T),
           WrapperFormat<T>::cstor,
           WrapperFormat<T>::dstor,
           WrapperFormat<T>::cstorcopy,
           WrapperFormat<T>::copy,
           WrapperFormat<T>::assign
           )
  {}
  template <class T>
  WrapperFormat<T>::WrapperFormat(kaapi_format_t* f)
  : Format( f )
  {}
  template <class T>
  const WrapperFormat<T> WrapperFormat<T>::format;
  template <class T>
  const Format* WrapperFormat<T>::get_format()
  {
    return &format;
  }
  template <class T>
  const kaapi_format_t* WrapperFormat<T>::get_c_format()
  {
    return format.Format::get_c_format();
  }