Intel Parallel Studio XE 2016: New C / C ++ Compiler Features

__m128i x,y,z; x = y + z; 

• New keywords (as in C ++ 11) for alignment of _Alignas and _Alignof data , allowing to escape from compiler- dependent solutions:
  

   //  cacheline   64  _Alignas(64) char cacheline[64]; printf("Alignment of char = %d\n", _Alignof(char)); 

  
  I already wrote about the necessity and significance of data alignment earlier .
  
• Type-independent expressions using the _Generic keyword . This is a kind of "templates" from C ++. For example, the following macro for extracting the square root sqrt (x) is translated to sqrtl (x) , sqrt (x) or sqrtf (x) depending on the type of parameter x :
  

   #define sqrt(x) _Generic((x), long double: sqrtl, default: sqrt, float: sqrtf)(x) 

  
  But before it had to work hard to realize this handles yourself !
  
• The _Noreturn function specifier allows you to declare functions that never return to the calling code. This allows you to avoid warnings from the compiler for functions that do not have a return, as well as include a number of optimizations that can only be performed on “non-returnable” functions.
  

   _Noreturn void func (); // func never returns 

  
  
• New keyword _Static_assert , which allows to produce a compilation error in case the expression is zero. A simple example:
  

   //     static_assert(sizeof(int) < sizeof(char), "app requires sizeof(char) to be less than char"); error: static assertion failed with "app requires sizeof(char) to be less than char" 

  
  Unlike the #if and #error directives, you can catch errors that are difficult to find during preprocessing.
  
• Anonymous structures and associations. This is a non-profit society of anonymous alcoholics ... Just kidding, just checked your concentration. They are used for nesting structures and associations. For example:
  

   struct T // C11 { int m; union //  { char * index; int key; }; }; struct T t; t.key=1300; //     key 

  
  
• The peculiarity of the C11 standard is that it standardizes multithreading in the C language. Of course, developers have long since used the benefits of parallelism in C, but, nevertheless, through libraries and other language extensions. Now it is written in the standard.
  So, one of the new keywords supported by the Intel compiler is _Thread_local . With it, you can specify that the variable is not shared by the threads and each of them receives its local copy.
  

• Generalized lambda functions
• Capture expressions for lambda functions
• Separators
• Attribute [[deprecated]]
• Output type return for functions
• Aggregate class initialization with field initializers

 #if __cpp_binary_literals int const packed_zero_to_three = 0b00011011; #else int const packed_zero_to_three = 0x1B; #endif 

• A new omp target enter data directive has been added to map variables to the coprocessor (it is possible to set to and alloc for the map option). If the omp target directive mapil variables and executed the code on the device, then omp target data only deals with data. Accordingly, now there is also a omp target exit data directive for unmap variables (it is possible to specify from , release and delete for the map option).
• Improved capabilities for asynchronous code execution. The target region is now a task (task), so an asynchronous offload is possible using the existing task model and the nowait option for the omp task directive.
  
• The depend option for the omp task directive, which allows unloading with dependencies
  
• New always and delete modifiers for the map option
  

• If earlier it was impossible to pass through the pointer the field of the object to be unloaded to the coprocessor in the form of ptr-> field , now this restriction is removed. At the same time, it became possible to transfer structures whose fields are pointers. In this case, the structures themselves are transmitted bitwise, the pointers are copied, but the fields of the structures to which they point are not.
• It became possible to allocate memory only on the coprocessor, without allocating memory on the host, using the modifiers targetptr and preallocated .
  
• The concept of stream (and a new stream option for the pragma offload directive) appeared - a logical queue for unloading. With its help, you can now download several independent computations to Xeon Phi from one CPU thread. The work order is as follows:
  First, create a stream using the _Offload_stream_create API function:
  

   OFFLOAD_STREAM* handle = _Offload_stream_create( int device, // Intel MIC Architecture device number int number_of_cpus); // Threads allocated to the stream 

  
  And offload in the stream using the offload directive and the stream option, while indicating the signal value to identify the upload. This will help determine if a particular offense has been completed:
  

   // Issue offload to a stream and identify with signal value s1 #pragma offload … stream(handle) signal(s1) { … } … // Issue offload to a stream and identify with signal value s2 #pragma offload … stream(handle) signal(s2) { … } … // Check if offload with signal value s1 has completed if (_Offload_signaled(s1)) … 

  
  Much more details can be found in our documentation, which has been significantly expanded with the release of the new version.