Charm++ parallel programming system

[Jozsef Bakosi <jbakosi AT lanl.gov>]

Hi folks,

Building v6.9.0-rc3 using the intel compilers (18.0.2 20180210) and
intel mpi. Here is what I do:

export __INTEL_PRE_CFLAGS="-gcc-name=gcc-6 -gxx-name=g++-6 
-D__PURE_INTEL_C99_HEADERS__"

./build charm++ mpi-linux-x86_64 --enable-error-checking icc --build-shared 
--with-production -j36 
--incdir=/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 
-O3 -DNDEBUG

The error is:

/usr/include/math.h(155): error: invalid redeclaration of type name "float_t" 
(declared at line 267 of 
"/scratch2/opt/intel/compilers_and_libraries_2018.2.199/linux/compiler/include/math.h")
  typedef long double float_t;

I guess icpc is not picking up the correct gcc v6 headers, despite of
__INTEL_PRE_CFLAGS. I also tried passing it via the build script as

./build charm++ mpi-linux-x86_64 --enable-error-checking icc --build-shared 
--with-production -j36 
--incdir=/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 
-O3 -gxx-name=g++-6 -DNDEBUG

But that does not help.

Does anyone have a good idea how to proceed? I attach config.log and
charmconfig.out. Please let me know if you need more info.

Thanks,
Jozsef
Error checking is enabled
AMPI error checking is enabled
Statistics collection is disabled
Charm tracing is disabled
Charm tracing communication thread is disabled
Task Queue is disabled
Drone mode is disabled
CharmDebug is disabled
Charm record/replay is disabled
CCS is enabled
Charm control point is disabled
Charm LB user data is disabled
Lockless queue for PE local and node queue is disabled
Charm shrink expand is disabled
CharmPy support is disabled
Setting load balancing timer type as 'double'
### whether C++ compiler works
#include <stdio.h>
void foo(void) {
        printf("Hello, world!\n");
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
### whether linker works
#include <stdio.h>
int main() {
        printf("Hello, world!\n");
        return 0;
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
icpc -shared-intel -o testlink test.o
### whether compiler accept -fno-stack-protector
#include <stdio.h>
int main() {
        printf("Hello, world!\n");
        return 0;
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o -fno-stack-protector
icpc -shared-intel -o testlink test.o -fno-stack-protector
### whether C++ compiler supports C++11 without flags
// Check for Intel compiler incompatibility with the active g++/libstdc++ by
// including an arbitrary standard library header (cf bug #1560)
#include <map>

// Check for an excessively old g++/libstdc++ that can't handle features we 
use
#include <memory>
#include <vector>
std::unique_ptr<int> i;

class CkMigrateMessage;

struct base {
  base(void) { }
  base(CkMigrateMessage *) { }
};

template <class Parent>
struct CBaseT1 : Parent {
  std::vector<int> v; // check for C++11's shrink_to_fit()

  CBaseT1(void) :Parent()  { v.shrink_to_fit(); }
  CBaseT1(CkMigrateMessage *m) :Parent(m) { }
  CBaseT1(CBaseT1&& rhs) :Parent() { }

  template <typename... Args>
    CBaseT1(Args... args) : Parent(args...) { }
};

template struct CBaseT1<base>;
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
### whether native C++ compiler supports C++11 without flags
// Check for Intel compiler incompatibility with the active g++/libstdc++ by
// including an arbitrary standard library header (cf bug #1560)
#include <map>

// Check for an excessively old g++/libstdc++ that can't handle features we 
use
#include <memory>
#include <vector>
std::unique_ptr<int> i;

class CkMigrateMessage;

struct base {
  base(void) { }
  base(CkMigrateMessage *) { }
};

template <class Parent>
struct CBaseT1 : Parent {
  std::vector<int> v; // check for C++11's shrink_to_fit()

  CBaseT1(void) :Parent()  { v.shrink_to_fit(); }
  CBaseT1(CkMigrateMessage *m) :Parent(m) { }
  CBaseT1(CBaseT1&& rhs) :Parent() { }

  template <typename... Args>
    CBaseT1(Args... args) : Parent(args...) { }
};

template struct CBaseT1<base>;
g++ -fPIC -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
### whether C++ compiler accepts -fno-lifetime-dse
// Check for Intel compiler incompatibility with the active g++/libstdc++ by
// including an arbitrary standard library header (cf bug #1560)
#include <map>

// Check for an excessively old g++/libstdc++ that can't handle features we 
use
#include <memory>
#include <vector>
std::unique_ptr<int> i;

class CkMigrateMessage;

struct base {
  base(void) { }
  base(CkMigrateMessage *) { }
};

template <class Parent>
struct CBaseT1 : Parent {
  std::vector<int> v; // check for C++11's shrink_to_fit()

  CBaseT1(void) :Parent()  { v.shrink_to_fit(); }
  CBaseT1(CkMigrateMessage *m) :Parent(m) { }
  CBaseT1(CBaseT1&& rhs) :Parent() { }

  template <typename... Args>
    CBaseT1(Args... args) : Parent(args...) { }
};

template struct CBaseT1<base>;
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o -fno-lifetime-dse
icpc: command line warning #10006: ignoring unknown option '-fno-lifetime-dse'
Setting charm++ envelope refnum field to unsigned short
Configuring support for message priorities of arbitrary size (bitvectors)
### whether compiler generates code for 64-bit
#include <stdio.h>

int foo()
{
int x[(int)(sizeof(void *) - 7)]={0};
return x[0];
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
### whether compiler supports std::is_constructible
#include <type_traits>

struct s {
       s(int a) { }
};

bool foo()
{
  return std::is_constructible<s, int>::value;
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
### whether compiler supports std::alignment_of
#include <type_traits>

int foo()
{
  return std::alignment_of<int>::value;
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
### whether compiler implements regex
#include <regex>
void foo()
{
#if __cplusplus >= 201103L &&                                 
(!defined(__GLIBCXX__) || (__cplusplus >= 201402L) ||         
(defined(_GLIBCXX_REGEX_DFS_QUANTIFIERS_LIMIT) ||          
defined(_GLIBCXX_REGEX_STATE_LIMIT)           ||              
(defined(_GLIBCXX_RELEASE)                &&              _GLIBCXX_RELEASE > 
4)))
// compiler has regex support, continue
#else
// force compilation to fail
static_assert(false, "compiler has no regex implementation");
#endif
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
### whether has values.h 
#include <values.h>
int main() {
  double d = MAXDOUBLE;
  return 0;
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
### whether has stdint.h 
#include <stdint.h>
int main() {
  return 0;
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
### whether has malloc.h 
#include <malloc.h>
int main() {
  return 0;
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
### whether has alloca.h 
#include <alloca.h>
int main() {
  double *s=(double *)alloca(sizeof(double));
  *s=1.0;
  return 0;
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
### whether has regex.h 
#include <regex.h>
int main() {
  regex_t re;
  regcomp(&re, ".*MOD.*", REG_EXTENDED|REG_NOSUB);
  return 0;
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
### whether long long works
#include <stdlib.h>
long long foo(void) { return 17; }
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
### whether __int64 works
#include <stdlib.h>
__int64 foo(void) { return 17; }
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
### whether __int128 (128-bit integer) works
#include <stdlib.h>
int foo(void) {
  __int128   a;
  int x[(int)(sizeof(__int128) - 15)]={0};
  return x[0];
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
### whether __int128_t (128-bit integer) works
#include <stdlib.h>
int foo(void) {
  __int128_t   a;
  __uint128_t   b;
  a = a + a;
  int x[(int)(sizeof(__int128_t) - 15)]={0};
  return x[0];
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
### whether C++ library has <atomic> 
#include <atomic>
int main(int argc, char** argv) {
  return 0;
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
### whether long double works
#include <stdlib.h>
long double foo(void) { return 17.0; }
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
### whether ucontext has FPU pointer
#include <ucontext.h>
struct _libc_fpstate   fpstate;
fpregset_t *fp;
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
### whether ucontext uses uc_regs
#include <ucontext.h>

int main()
{
  ucontext_t context;
  context.uc_mcontext.uc_regs = 0;
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
test.cpp(6): error: class "mcontext_t" has no member "uc_regs"
    context.uc_mcontext.uc_regs = 0;
                        ^

compilation aborted for test.cpp (code 2)
### whether ucontext has pointer (v_regs) of vector type
#include <ucontext.h>
vrregset_t *v_regs;
ucontext_t  uc;

void foo()
{
  vrregset_t *ptr = uc.uc_mcontext.v_regs;
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
test.cpp(2): error: identifier "vrregset_t" is undefined
  vrregset_t *v_regs;
  ^

test.cpp(7): error: identifier "vrregset_t" is undefined
    vrregset_t *ptr = uc.uc_mcontext.v_regs;
    ^

test.cpp(7): error: identifier "ptr" is undefined
    vrregset_t *ptr = uc.uc_mcontext.v_regs;
                ^

test.cpp(7): error: class "mcontext_t" has no member "v_regs"
    vrregset_t *ptr = uc.uc_mcontext.v_regs;
                                     ^

compilation aborted for test.cpp (code 2)
### whether ibverbs ibv_port_attr has link_layer field
#include <infiniband/verbs.h>
void test()
{
    struct ibv_context    *context;
    int ibPort;
    struct ibv_port_attr attr;
    if (ibv_query_port(context, ibPort, &attr) != 0) return;
    if (attr.link_layer == IBV_LINK_LAYER_INFINIBAND)  return;
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
### whether inline works in C
inline static int foo()
{
  return 1;
}
icc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c test.c 
-o test.o
### whether C++ signed char and char differ
#include <stdlib.h>
class er {
 protected:
   void operator()(char &v,const char *desc=NULL) {};
   void operator()(signed char &v,const char *desc=NULL) {};
};
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
### whether typeinfo/typeid works
#include <typeinfo>
const char *foo(void) {
        int x;
        return typeid(x).name();
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
### whether std::iterator_traits is defined
#include <iterator>

template <typename T> // T models Input Iterator
typename std::iterator_traits<T>::value_type accumulate(T first, T last)
{
      typename std::iterator_traits<T>::value_type result = 0;
      while(first != last)
            result += *first++;
      return result;
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
### whether std::distance is defined
#include <vector>
#include <iterator>

int foo()
{
  std::vector<int> tree;
  return std::distance(tree.begin(), tree.end());
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
### whether std::inserter is defined
#include <list>
#include <iterator>

void foo()
{
  using namespace std;
  list<int> L;
  inserter ( L, L.end ( ) ) = 500;
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
### whether std::void_t is defined
#include <type_traits>

template<typename T, typename = std::void_t<>>
struct has_pup_member : std::false_type {};

icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
### whether operator delete can be overloaded in same class
class foo {
public:
  void operator delete(void*p){};
  void operator delete(void*p,int*){};
};
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
### whether offsetof is defined
#include <stddef.h>

struct FooType {
        int f1;
        int f2;
        double f3;
};

void foo()
{
  int off = offsetof(FooType, f2);
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
### whether GCC x86 assembly works
double foo(void)
{
  unsigned long long int v=0;
  int *lo=0+(int *)&v;
  int *hi=1+(int *)&v;
  __asm__ __volatile__(
      "rdtsc; movl %%edx,%0; movl %%eax,%1"
      : /* output  */ "=m" (*hi), "=m" (*lo)
      : /* input */
      : /* trashes */ "%edx", "%eax"
  );
  return v;
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
### whether GCC x86 assembly for atomic increment works
int foo(void)
{
  int x;
  asm("lock incl %0" :: "m" (x));
  asm("lock decl %0" :: "m" (x));
  return x;
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
### whether asm eieio assembly works
double foo(void)
{
        unsigned long long int x;
        asm volatile("eieio" ::: "memory");
        return x;
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
/tmp/icpcIgMi3Zas_.s: Assembler messages:
/tmp/icpcIgMi3Zas_.s:18: Error: no such instruction: `eieio'
### whether __thread (Thread Local Storage) is supported
__thread unsigned long long int x;
static __thread  int y;
void foo(void)
{
        x = 1;
        y = 1;
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
### whether synchronization primitives (__sync_add_and_fetch) works in C
#include <stdio.h>
int main()
{
  int t=1;
  __sync_add_and_fetch(&t, 1);
  return 1;
}
icc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c test.c 
-o test.o
icc -shared-intel -o testlink test.o
### whether synchronization primitives (__sync_synchronize) works in C
#include <stdio.h>
int main()
{
  __sync_synchronize();
}
icc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c test.c 
-o test.o
icc -shared-intel -o testlink test.o
### whether has __executable_start
extern int __executable_start;
int main()
{
  return __executable_start;
}
icc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c test.c 
-o test.o
icc -shared-intel -o testlink test.o
### whether switching TLS register (64-bit) is supported
#include <elf.h>
#include <stdlib.h>
#include <malloc.h>

void switchTLS() {
  Elf64_Addr m1, m2;
  asm volatile ("movq %%fs:0x0, %0\n\t"
                "movq %1, %%fs:0x0\n\t"
                : "=r"(m1)
                : "r"(m2));
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
### whether has dl_iterate_phdr
#ifndef _GNU_SOURCE
# define _GNU_SOURCE
#endif
#ifndef __USE_GNU
# define __USE_GNU
#endif
#include <link.h>
#include <stddef.h>
static int callback(struct dl_phdr_info* info, size_t size, void* data)
{
  return 0;
}
int main()
{
  dl_iterate_phdr(callback, NULL);
  return 0;
}
icc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c test.c 
-o test.o
icc -shared-intel -o testlink test.o
### whether has __malloc_hook
extern int __malloc_hook;
int main()
{
  return __malloc_hook;
}
icc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c test.c 
-o test.o
icc -shared-intel -o testlink test.o
### whether build on MPI
#include "mpi.h"
int main(int argc, char **argv)
{
  MPI_Init(&argc, &argv);
  return 0;
}
icc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c test.c 
-o test.o
### whether need to specify MPI library
#include "mpi.h"
int main(int argc, char **argv)
{
  MPI_Init(&argc, &argv);
  return 0;
}
icc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c test.c 
-o test.o
icc -shared-intel -o testlink test.o
/usr/bin/x86_64-linux-gnu-ld: test.o: in function `main':
test.c:(.text+0x3e): undefined reference to `MPI_Init'
### whether -lmpich
#include "mpi.h"
int main(int argc, char **argv)
{
  MPI_Init(&argc, &argv);
  return 0;
}
icc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c test.c 
-o test.o -lmpich
icc -shared-intel -o testlink test.o -lmpich
### whether MPI_Init_thread is supported
#include "mpi.h"
int main(int argc, char **argv)
{
  int thread_level, provided;
  thread_level = MPI_THREAD_FUNNELED;
  MPI_Init_thread(&argc, &argv, thread_level, &provided);
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
### whether macro conflicts occurs due to C++ MPI bindings
#include <stdio.h>
#include <mpi.h>

int main (int argc, char** argv) {
  return 0;
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
### whether getrusage accepts RUSAGE_THREAD
#ifndef _GNU_SOURCE
# define _GNU_SOURCE
#endif
#ifndef __USE_GNU
# define __USE_GNU
#endif
#include <sys/time.h>
#include <sys/resource.h>
int main() {
  struct rusage usage;
  getrusage(RUSAGE_THREAD, &usage);
  return 0;
}
icc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c test.c 
-o test.o
icc -shared-intel -o testlink test.o
### whether has asctime
#include <time.h>
int main() {
  struct tm *local;
  time_t t;
  t = time(NULL);
  local = localtime(&t);
  asctime(local);
  return 0;
}
icc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c test.c 
-o test.o
icc -shared-intel -o testlink test.o
### whether has log2
#include <math.h>
int main() {
  int i = log2(10);
  return 0;
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
icpc -shared-intel -o testlink test.o
### whether has sqrtf
#include <math.h>
int main() {
  float i = sqrtf((float)10.0);
  return 0;
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
icpc -shared-intel -o testlink test.o
### whether has fabsf
#include <math.h>
int main() {
  float i = fabsf((float)10.0);
  return 0;
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
icpc -shared-intel -o testlink test.o
### whether has mkstemp
#include <stdlib.h>
#include <string.h>
int main() {
  char fname[128];
  strcpy(fname, "/tmp/fdXXX.XXX");
  mkstemp(fname);
  return 0;
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
icpc -shared-intel -o testlink test.o
### whether has system
#include <stdlib.h>
int main() {
  system("/bin/ls");
  return 0;
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
icpc -shared-intel -o testlink test.o
### whether has sync()
#include <unistd.h>
int main() {
  sync();
  return 0;
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
icpc -shared-intel -o testlink test.o
### whether has fsync()
#include <unistd.h>
int main() {
  fsync(0);
  return 0;
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
icpc -shared-intel -o testlink test.o
### whether has fdatasync()
#include <unistd.h>
int main() {
  fdatasync(0);
  return 0;
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
icpc -shared-intel -o testlink test.o
### whether has sbrk
#include <unistd.h>
int main() {
  void *ptr  = sbrk(0);
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
icpc -shared-intel -o testlink test.o
### whether has _setjmp/_longjmp
#include <setjmp.h>
int main() {
  jmp_buf buf;
  _setjmp(buf);
  _longjmp(buf, 0);
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
icpc -shared-intel -o testlink test.o
### whether has mstats
#include <malloc.h>
int main() {
  struct mstats ms = mstats();
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
test.cpp(3): error: incomplete type is not allowed
    struct mstats ms = mstats();
                  ^

test.cpp(3): error: incomplete type is not allowed
    struct mstats ms = mstats();
                       ^

compilation aborted for test.cpp (code 2)
### whether has mallinfo
#include <malloc.h>
int main() {
  struct mallinfo mi = mallinfo();
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
icpc -shared-intel -o testlink test.o
### whether expects __morecore symbol
#include <cstddef>
int main() {
  extern void *(*__morecore)(ptrdiff_t);
  __morecore(0);
  return 0;
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
icpc -shared-intel -o testlink test.o
### whether has popen
#include <stdio.h>
int main() {
  FILE *p = popen("/bin/ps", "r");
  pclose(p);
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
icpc -shared-intel -o testlink test.o
### whether has poll
#include <poll.h>
void foo(void) {
  struct pollfd pos[3];
  poll(pos, 1, 1);
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
### whether has getpagesize
#include <unistd.h>

int main(int argc, char **argv) {
    int s = getpagesize();
}
icc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c test.c 
-o test.o
icc -shared-intel -o testlink test.o
### whether has getpid
#include <sys/types.h>
#include <unistd.h>

int main(int argc, char **argv) {
    pid_t pid = getpid();
}
icc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c test.c 
-o test.o
icc -shared-intel -o testlink test.o
### whether has kill
#include <sys/types.h>
#include <unistd.h>
#include <signal.h>

int main(int argc, char**argv)
{
    pid_t pid = getpid();
    kill(pid, 9);
}
icc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c test.c 
-o test.o
icc -shared-intel -o testlink test.o
### whether has setpriority
#include <sys/time.h>
#include <sys/resource.h>
void foo(void) {
  setpriority(PRIO_PROCESS, 0, 0);
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
### whether to use signal-safe system() 
#include "ckdll_system.C"
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
### whether sched_setaffinity call exists
#define _GNU_SOURCE
#include <sched.h>

int main()
{
  cpu_set_t cpuset;
  CPU_ZERO(&cpuset);
  CPU_SET(0, &cpuset);
  if (sched_setaffinity(0, sizeof(cpuset), &cpuset) < 0) {
    return -1;
  }
  return 0;
}
icc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c test.c 
-o test.o
icc -shared-intel -o testlink test.o
### whether pthread_setaffinity_np call exists
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>

int main()
{
  unsigned long mask = 0xffffffff;
  unsigned int len = sizeof(mask);

  if (pthread_setaffinity_np(pthread_self(), len, &mask) < 0) {
    return -1;
  }
  return 0;
}
icc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c test.c 
-o test.o -lpthread
icc -shared-intel -o testlink test.o -lpthread
test.c(11): warning #266: function "pthread_setaffinity_np" declared 
implicitly
    if (pthread_setaffinity_np(pthread_self(), len, &mask) < 0) {
        ^

### whether pthread_spin_lock exists
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>

int main()
{
  pthread_spinlock_t  lock;

  pthread_spin_init(&lock, 0);

  pthread_spin_lock(&lock);

  return 0;
}
icc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c test.c 
-o test.o -lpthread
icc -shared-intel -o testlink test.o -lpthread
### whether bindprocessor call exists
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>

#include <sys/processor.h>

int main()
{
  int retValue = 0;
  int pid;
  pid = getpid();
  if (bindprocessor(BINDPROCESS, pid, 0) == -1) return -1;
  return 0;
}
icc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c test.c 
-o test.o
test.c(5): catastrophic error: cannot open source file "sys/processor.h"
  #include <sys/processor.h>
                            ^

compilation aborted for test.c (code 4)
### whether dlopen links without -ldl
#include "ckdll_dlopen.C"
int main() {
        CkDll dll("foo.so");
        return 0;
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
icpc -shared-intel -o testlink test.o
### whether dlopen links with -ldl
#include "ckdll_dlopen.C"
int main() {
        CkDll dll("foo.so");
        return 0;
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o -ldl
icpc -shared-intel -o testlink test.o -ldl
### whether has RTLD_DEFAULT
#ifndef _GNU_SOURCE
# define _GNU_SOURCE
#endif
#ifndef __USE_GNU
# define __USE_GNU
#endif
#include <dlfcn.h>
#include <stddef.h>
int main()
{
  return dlsym(RTLD_DEFAULT, "main") != NULL;
}
icc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c test.c 
-o test.o
### whether has RTLD_NEXT
#ifndef _GNU_SOURCE
# define _GNU_SOURCE
#endif
#ifndef __USE_GNU
# define __USE_GNU
#endif
#include <dlfcn.h>
#include <stddef.h>
int main()
{
  return dlsym(RTLD_NEXT, "main") != NULL;
}
icc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c test.c 
-o test.o
### whether gethostname call exists
#ifdef _WIN32
#include <Winsock2.h>
#else
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#endif

int main()
{
  char hostname[1000];
  gethostname(hostname, 999);
  return 0;
}
icc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c test.c 
-o test.o
### whether getProcAddress works
#include "ckdll_win32.C"
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
In file included from test.cpp(1):
ckdll_win32.C(10): catastrophic error: cannot open source file "windows.h"
  #include <windows.h>
                      ^

compilation aborted for test.cpp (code 4)
### whether has socklen_t
#include <sys/types.h>
#include <sys/socket.h>

void foo(void) {
        int i;
        socklen_t s=sizeof(i);
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
### whether getifaddrs call exists
#include <netinet/in.h> /* for sockaddr_in */
#include <ifaddrs.h> /* for getifaddrs */
#include <net/if.h> /* for IFF_RUNNING */

int main()
{
  struct ifaddrs *interfaces=0;
  if( getifaddrs(&interfaces) == 0 ) {
        struct ifaddrs *interface;
        for( interface=interfaces; interface; interface=interface->ifa_next ) 
{
            if( (interface->ifa_flags & IFF_UP) && ! (interface->ifa_flags & 
IFF_LOOPBACK) ) {
                const struct sockaddr_in *addr = (const struct 
sockaddr_in*)interface->ifa_addr;
                if( addr && addr->sin_family==AF_INET ) {
                    break;
                }
            }
        }
        freeifaddrs(interfaces);
  }
}
icc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c test.c 
-o test.o
icc -shared-intel -o testlink test.o
### whether the mmap() syscall exists
#include <sys/types.h>
#include <sys/mman.h>

void *foo(void *a,int l,int fd) {
        return mmap((caddr_t)a,l,PROT_READ+PROT_WRITE,
                 MAP_FIXED+MAP_PRIVATE,fd,0);
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
### whether mmap() accepts MAP_ANON
#include <sys/types.h>
#include <sys/mman.h>

void *foo(void *a,int l) {
        return mmap((caddr_t)a,l,PROT_READ+PROT_WRITE,
                MAP_FIXED+MAP_PRIVATE+MAP_ANON,-1,0);
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
### whether mmap() accepts MAP_NORESERVE
#include <sys/types.h>
#include <sys/mman.h>

void *foo(void *a,int l) {
        return mmap((caddr_t)a,l,PROT_READ+PROT_WRITE,
                MAP_FIXED+MAP_PRIVATE+MAP_NORESERVE,-1,0);
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
### whether has get_myaddress
#include <rpc/rpc.h>

void foo(void *a) {
    get_myaddress((struct sockaddr_in*)a);
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
### whether has mprotect
#include <stdio.h>
#include <sys/mman.h>

void foo(void *a,int l,int fd) {
     void *pg = NULL;
     size_t pagesize = 4096;
     mprotect(pg, pagesize, PROT_READ | PROT_WRITE);
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
### whether has support for shm transport using Cross Memory Attach
#define _GNU_SOURCE
#include <sys/uio.h>
#include <errno.h>
int main() {
  pid_t pid;
  struct iovec *local, *remote;
  int nread = process_vm_readv(pid, local, 1, remote, 1, 0);
  nread = process_vm_writev(pid, local, 1, remote, 1, 0);
  return errno;
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
icpc -shared-intel -o testlink test.o
test.cpp(1): warning #47: incompatible redefinition of macro "_GNU_SOURCE"
  #define _GNU_SOURCE
          ^

### whether has -rdynamic
int main() {
  return 0;
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o -rdynamic
icpc -shared-intel -o testlink test.o -rdynamic
### whether glibc backtrace works
#include "cmibacktrace.c"

int main() {
        int nLevels=1;
        void *stack;
        CmiBacktraceRecord(&stack,0,&nLevels);
        return 0;
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o -DCMK_USE_BACKTRACE=1 -rdynamic
icpc -shared-intel -o testlink test.o -DCMK_USE_BACKTRACE=1 -rdynamic
### whether has sleep 
#include <unistd.h>
int main() {
  sleep(1);
  return 0;
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
### whether has usleep 
#include <unistd.h>
int main() {
  usleep(100);
  return 0;
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
### whether personality() and ADDR_NO_RANDOMIZE exist
#include <sys/personality.h>
int main() {
    int orig_persona = personality(0xffffffff);
    personality(orig_persona | ADDR_NO_RANDOMIZE);
    return 0;
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
### whether has zlib
#include <zlib.h>
int main() {
  gzFile f = gzopen("/tmp/x","r");
  gzprintf(f, "test...\n");
  gzclose(f);
  return 0;
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o -lz
icpc -shared-intel -o testlink test.o -lz
### whether has elf.h 
#include <elf.h>
typedef Elf32_Addr ELF_TYPE_Addr;
int main() {
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
### whether has Multiprocessing.h for Apple 
#include <Carbon/Carbon.h>
#include <Multiprocessing.h>
int main() {
  int a = MPProcessorsScheduled();
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o
test.cpp(1): catastrophic error: cannot open source file "Carbon/Carbon.h"
  #include <Carbon/Carbon.h>
                            ^

compilation aborted for test.cpp (code 4)
### whether ntohl is available
#include <netinet/in.h> /* for sockaddr_in */
#include <ifaddrs.h> /* for getifaddrs */
#include <net/if.h> /* for IFF_RUNNING */

int main()
{
  struct ifaddrs *interfaces=0;
  if( getifaddrs(&interfaces) == 0 ) {
        struct ifaddrs *interface;
        for( interface=interfaces; interface; interface=interface->ifa_next ) 
{
            if( (interface->ifa_flags & IFF_UP) && ! (interface->ifa_flags & 
IFF_LOOPBACK) ) {
                const struct sockaddr_in *addr = (const struct 
sockaddr_in*)interface->ifa_addr;
                if( addr && addr->sin_family==AF_INET ) {
                    break;
                }
            }
        }
        freeifaddrs(interfaces);
  }
}
icc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c test.c 
-o test.o
### whether has libjpeg
#include <stdio.h>
#include <stdlib.h>
#include "jpeglib.h"

int main()
{
  struct jpeg_compress_struct cinfo;
  jpeg_create_compress(&cinfo);
  return 0;
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o -ljpeg
icpc -shared-intel -o testlink test.o -ljpeg
### whether Python is installed
#include "python2.7/Python.h"
#include "python2.7/compile.h"
#include "python2.7/eval.h"
#include "python2.7/node.h"

int main() {
    Py_Initialize();
    PyEval_InitThreads();
    struct _node* programNode = PyParser_SimpleParseString("return 
1\n",Py_file_input);
    PyCodeObject *program = PyNode_Compile(programNode, "");
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c 
test.cpp -o test.o -lpython2.7 -lpthread -lutil -ldl
icpc -shared-intel -o testlink test.o -lpython2.7 -lpthread -lutil -ldl
whether can build shared library
#include "stdlib.h"
extern int foo();
int foo1() {
  void * t= malloc(2);
  foo();
  return 0;
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -fpic -c 
test.cpp -o test.o
icc -shared-intel -shared test.o -o testlink.so
whether can build shared library with MPI
#include "stdlib.h"
#include "mpi.h"
extern int foo();
int foo(int argc, char ** argv) {
  void * t= malloc(2);
  foo();
  MPI_Init(&argc, &argv);
  return 0;
}
icpc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -fpic -c 
test.cpp -o test.o
icc -shared-intel -shared test.o -o testlink.so
### whether the C++ linker succeeds with a Fortran entry point
      PROGRAM empty
      END PROGRAM
ifort -auto -fPIC -c conftest.f90 -o test.o
icpc -shared-intel -o testlink test.o 
-L/scratch2/opt/intel/compilers_and_libraries_2018.2.199/linux/bin/intel64/../../compiler/lib/intel64
 -lifcore -lifport -lifcore 
/scratch2/opt/intel/compilers_and_libraries_2018.2.199/linux/bin/intel64/../../compiler/lib/intel64/for_main.o
### whether OpenMP is supported
#include <stdio.h>
#include <omp.h>

int main(void)
{
  int iam = 0, np = 1;

  #pragma omp parallel default(shared) private(iam, np)
  {
    np = omp_get_num_threads();
    iam = omp_get_thread_num();
    printf("Hello from thread %d of %d\n", iam, np);
  }

  return 0;
}
icc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c test.c 
-o test.o -fopenmp
icc -shared-intel -o testlink test.o -fopenmp
### whether has lustre fs
#include <stdio.h>
#include <lustre/lustreapi.h>
#include <lustre/lustre_user.h>

int main() {
  llapi_printf(LLAPI_MSG_NORMAL, "Lustre FS is available");
  return 0;
}
icc -fpic -I../include -I. 
-I/opt/intel/compilers_and_libraries_2018.2.199/linux/mpi/include64 -c test.c 
-o test.o -llustreapi
test.c(2): catastrophic error: cannot open source file "lustre/lustreapi.h"
  #include <lustre/lustreapi.h>
                               ^

compilation aborted for test.c (code 4)

Attachment: config.log.gz
Description: application/gzip