Hello,

I have Intel Parallel Studio XE 2015 Update 3 on my OS X computer.
I would like to uninstall it, how can it be done?

In Windows it is easy to do, bu what about OS X?

Thank You.

Hello,

New in using Intel C++ compiler here. I have an example C file listed below which illustrates the problem. There is no main function in the source by the way.
============================================
#include
struct abc {
int i,j;
} ia;

void f1(struct abc t) {
printf("%d %d\n", t.i, t.j);
}

void uf3(void)
{
f1(ia);
}
============================================

When the file is named as, for example, myfile.cpp,it compiles (cntrl+F7) fine. But when I called it myfile.c, then I have the following error
>>>>>
Error (active) argument of type "struct abc" is incompatible with parameter of type "struct abc" ..... ..... 12
>>>>>
Line 12 is f1(ia);

I am using Intel Parallel Studio XE Professional Edition for Fortran and C++ Windows 2016 together with Microsoft Visual Studio Community 2015.
Any help would be much appreciated. Thank you very much.

HCL

Hi - I was previously using Intel C++ 16.0 inside Windows Visual Studio 2012. Then I installed Visual Studio 2015, and all the Intel C++ compiler options have disappeared.

Is there some way of re-integrating Intel C++ into the new version of Visual Studio, or do I have to re-install Intel C++ from scratch?

John

I'm not sure if this is the right channel for this, but Intel® C++ Compiler 16.0 User and Reference Guide -> Compiler Reference -> Compiler Options -> Compiler Option Categories -> Language Options -> std, Qstd doesn't list  /Qstd=c++14 option, which is mentioned here: https://software.intel.com/en-us/articles/c14-features-supported-by-intel-c-compiler

Hi everyone,

When building my application with no optimisation flags in use, the application will run.

When building the application with any optimisation flags (such as /O1 or /O2 for example), the application will crash at startup.

This is a large codebase with thousands of commits, so it's hard to keep track of what changes have caused the use of optimisation flags to cause the whole application to crash. Does anyone have any advise on the best way to find out which files are generating bad output? I've tried debugging and stepping through (since it doesn't take long for the application to crash), but from what I can see all the data being processed is valid and the crash ends up in one of Microsoft's CRT library files.

I do apologise if this question isn't very coherent or lacking any in-depth information, if there's anything else I can include to help just let me know :-)

Using Intel C++ compiler 16 Update 1 on Windows 10 with Visual Studio 2013 Update 5.

I installed evaluation version of Intel® Parallel Studio XE 2016 Cluster Edition Update 1 on Windows 10 with Visual Studio 2015 Update 1 Community Edition. I'm getting compilation errors on Microsoft library files:

C:\Program Files\Microsoft Visual Studio 14.0\VC\include\limits(1120): error : identifier "__builtin_nanf" is undefined

I tried /Qstd=c++11 and /Qstd=c++14 compiler options to no effect.

my Mac was updated to OS X EI Capitan 10.11.2, and the Xcode update to 7.2 version, and I cannot find the Intel C++ 2016 compiler in Xcode now, so can I fix it, or just wait for the next version of intel C++ compiler?

I raised this issue in another forum (https://software.intel.com/en-us/forums/software-tuning-performance-opti...), but wanted to see if any of the compiler folks could explain to me why the compiler generates VGATHER-based code whenever I use an unsigned variable as an offset to an array index?

For a simple loop such as

for (int i=0; i<N; i++) {
      target[i] = scalar * source[i+offset];
}

the compiler will claim that the access is "indirect" if the "offset" variable is unsigned, but will generate reasonable vector code if the "offset" variable is signed.  The VGATHER-based code is typically slower (~1.5x) than the corresponding scalar code and 4x or more slower than the straightforward vector code (assuming both arrays are in the L1 data cache).

Is there something about the interpretation of unsigned variables that makes the gather function necessary, or is this an idiosyncrasy of the compilers?   (I have seen it with both icc 15.0.3 and with a 2016 version.)

Environment:  OS X 10.9 (Mavericks) and Xcode 5.0

Command line compilations/links fail with either:

"catastrophic error: cannot open source file "stdlib.h" OR with "ld: library not found for -lcrt1.10.6.o"

Affected compiler:  Intel Composer XE 2013 Update 1

Root cause:  Xcode 5.0 installation does not install all command line tools (include files, libraries, SDKs) need for the compiler to link user applications. 

FIX: Install the Xcode 5.0 "Command Line Tools".  Follow this Knowledge Base article for installation of this package:  http://software.intel.com/en-us/articles/installing-intel-compilers-for-os-x-pre-requisite-xcode-command-line-tools

Experimenting with vectorization I've come across some unexpected behavior. For example, the following demo gets 2x slower when #pragma simd is used.

// Vectorization simd slowdown demo
// #pragma simd makes this 2x slower on AVX2 (Haswell) CPU
// Build with: icl /nologo /Qstd=c++11 /Qcxx-features /Wall /QxHost /DNOMINMAX /DWIN32_LEAN_AND_MEAN -D__builtin_huge_val()=HUGE_VAL -D__builtin_huge_valf()=HUGE_VALF -D__builtin_nan=nan -D__builtin_nanf=nanf -D__builtin_nans=nan -D__builtin_nansf=nanf /DNDEBUG /Qansi-alias /O3 /fp:fast=2 /Qprec-div- /Qip /Qopt-report /Qopt-report-phase:vec simd_slowdown.cc

#include <ctime>
#include <iostream>
using namespace std;

// Length Squared
int
length_squared( int * a, int N )
{
	int length_sq( 0 );
#pragma simd // 2x slower with this!
#pragma vector aligned
	for ( int i = 0; i < N; ++i ) {
		length_sq += a[ i ] * a[ i ];
	}
	return length_sq;
}

int
main()
{
	int const N( 4096 ), R( 32*1024*1024 );
	alignas( 32 ) int a[ N ];
#pragma novector
	for ( int i = 0; i < N; ++i ) {
		a[ i ] = 1;
	}
	int s( 0 );
	double const time1 = (double)clock()/CLOCKS_PER_SEC;
#pragma novector
	for ( int r = 1; r <= R; ++r ) {
		s += length_squared( a, N );
	}
	double const time2 = (double)clock()/CLOCKS_PER_SEC;
	cout << time2 - time1 << " s  "<< s << endl;
}

This occurs with Intel C++ 2016 on a Haswell system using an AVX2 build. The vectorization reports are similar both ways. For another twist, if you change the array type to float then #pragma simd makes it run 40% faster. Is this just exposing weaknesses in the vectorization engine or is there a rational explanation for this.

Thanks!

This expression:

1/1'000.0

evaluates to inf instead of 0.001 with Intel® Parallel Studio XE 2016 Update 1 Composer Edition for C++ Windows* Integration for Microsoft* Visual Studio* 2015, Version 16.0.98.14. It works correctly with Microsoft C++ compiler.

I'm getting Cilk Plus keywords decorated with red squiggly lines in Visual Studio 2015 code editor. The code compiles just fine. I'm using Intel® Parallel Studio XE 2016 Update 1 Composer Edition for C++ Windows* Integration for Microsoft* Visual Studio* 2015, Version 16.0.98.14.

Hi,

With the Intel Compiler version 16.0.1 on OSX, the following code

#include <cstdio>
#include <cstdlib>
#include <new>
#include <type_traits>

template <typename T>
class Test {
 private:
  T* data_;

 public:
  Test(int n);
  ~Test();
};

template <typename T>
Test<T>::Test(int n) {
  if (std::is_pod<T>::value) {
    data_ = new T[n];
  } else {
    data_ = static_cast<T*>(::operator new(n * sizeof(T)));
    for (int i{0}; i < n; ++i) {
      new (data_ + i) T{};
    }
  }
};

template <typename T>
Test<T>::~Test() {
  if (std::is_pod<double>::value) {
    delete[] data_;
  } else {
    ::operator delete(data_);
  }
};

int main(int argc, const char* argv[]) {
  Test<double> x{10};

  return 0;
}

compiled with

icpc -std=c++11 -O3 -xHost -ansi-alias -fno-exceptions -DNDEBUG -opt-report=3 main.cpp -o main

produces an optimization report where it is clear that the call to ::operator new is still present in the optimization report although it is clear that at compile time, we now that this code is dead code.

INLINE REPORT: (main(int, const char **)) [1] main.cpp(37,40)
  -> INLINE (MANUAL): (38,18) Test<double>::Test(Test<double> *, int)
    -> EXTERN: (19,20) operator new[](size_t)
    -> INLINE (MANUAL): (23,12) operator new(size_t, void *)
  -> INLINE (MANUAL): (40,3) Test<double>::~Test(Test<double> *)
    -> EXTERN: (31,5) operator delete[](void *)

I suspect this is an optimization bug of the Intel compiler. But it seems that the assembly does not contain any code related to operator new.

Best regards,

Francois

The current version of Intel C++ compiler supports subset of C++14, which is enabled with  /Qstd:c++14 switch on Windows. Visual Studio 2015 Integration shows only Enable C++11 Support option in project properties, Enable C++14 Support is missing and has to be enabled by adding  /Qstd:c++14 to command line.

Hi,

I am using Intel C++ with Visual Studio Community 2015, When I compile C functions that call the open, read, lseek etc POSIX functions in Windows, I got messages saying 'warning #266 function "lseek" declared implicitly' for example.

I found from Microsoft's documentations that suggest using _open, _read, _lseek instead. Is this the only solution? Does Intel C++ come with its own C run time libraries that have the lseek etc functions?

HCL

I decided to created a new thread for a strange problem which is related to using #pragma prefetch on STL container std::vector. During the compilation phase ICC 14 disables #pragma prefetch directives which are declared on vector container. I must admit that in case of C-style array aferomentioned pragmas are "accepted" by the Compiler. Theoretically I could have relied more on HW Prefetch because of predictable linear access of vector elements, but I wanted to tune a little prefetch distance by manually inserting #pragma directives and run performance tests on various configuration values. I am not sure if OpenMP pragmas could be somehow responsible for disabling prefetch pragmas.

Few explanations related to design question and usage of STL vector instead of C-style arrays.

I based the design of  Radar Signals polymorphic classes on STL containers because I would like to minimize as much as possible the usage of raw pointers allocated by  operator new hence the choice of vector. In my case #pragma prefetch was inserted before single for loop with number of iterations known at compile time. Data access was linearly incremented without any dependencies on previous or next vector element. In my example vector is being read by its operator subscript so it behaves like plain array. 

Thanks in advance for any help.

Here is a code snippet which demonstrates this issue. #pragma prefetch directives are commented out.

 @Brief: Computes signal IQ Decomposition.
 @Params: _Inout_  vector to be initialized with IQ decomposed ExpChirpSignal , _In_  number of threads.

 @Returns:  by argument std::vector<std::pair<double,double>> IQ initialized with ExpChirpSignal IQ decomposition.
 @Throws: std::runtime_error when n_threads argument is <= 0, or when  or when vector<std::pair<double,double>> IQ is empty.
 */
      _Raises_SEH_exception_   void                      radiolocation::ExpChirpSignal::quadrature_components_extraction(_Inout_ std::vector<std::pair<double, double>> &IQ, _In_ const int n_threads)
 {
#if  defined _DEBUG
	 _ASSERTE(0 <= n_threads);
#else
		  if (n_threads <= 0)
			  BOOST_THROW_EXCEPTION(
			  invalid_value_arg() <<
			  boost::errinfo_api_function("ExpChirpSignal::quadrature_components_extraction") <<
			  boost::errinfo_errno(errno) <<
			  boost::errinfo_at_line(__LINE__));
#endif

		  if (!(IQ.empty()))
		  {

			  size_t a_samples = this->m_samples;
			  std::vector<double> a_cos_part(a_samples);
			  std::vector<double> a_sin_part(a_samples);
			  std::vector<double> a_phase(this->m_phase);
			  std::vector<std::pair<double, double>> a_chirp(this->m_chirp);
			  double a_efreq = this->m_efrequency;
			  double a_timestep = this->m_init_time;
			  double a_interval = this->m_interval;
			  size_t i;
			  double inv_samples{ 1.0 / static_cast<double>(a_samples) };
			  double delta{ 0.0 }; double t{ 0.0 };
			  omp_set_num_threads(n_threads);
#if defined OMP_TIMING

			  double start{ wrapp_omp_get_wtime() };
#endif
			  // Prefetching distances should be tested in order to find an optimal distance.
			  // ICC 14 upon compiling these pragma statements classifies them as a warning and disables them
			  // I suppose that the culprit is related to usage of std::vector.
			  /*#pragma prefetch a_cos_part:0:4
			  #pragma prefetch a_cos_part:1:32
			  #pragma prefetch a_sin_part:0:4
			  #pragma prefetch a_sin_part:1:32*/
#pragma omp parallel for default(shared) schedule(runtime) \
	private(i, delta, t) reduction(+:a_timestep)

			  for (i = 0; i < a_samples; ++i)
			  {
				  a_timestep += a_interval;
				  delta = static_cast<double>(i)* inv_samples;
				  t = a_timestep * delta;
				  a_cos_part.operator[](i) = 2.0 * ::cos((TWO_PI * a_efreq * t) + a_phase.operator[](i));
				  a_sin_part.operator[](i) = -2.0 * ::sin((TWO_PI * a_efreq * t) + a_phase.operator[](i));

				  IQ.operator[](i).operator=({ a_chirp.operator[](i).second * a_cos_part.operator[](i),
					  a_chirp.operator[](i).second * a_sin_part.operator[](i) });
			  }
#if defined OMP_TIMING
			  double end{ wrapp_omp_get_wtime() };
			  std::printf("ExpChirpSignal::quadrature_components_extraction executed in:%.15fseconds\n", end - start);
#endif
		  }
		  else BOOST_THROW_EXCEPTION(
			  empty_vector() <<
			  boost::errinfo_api_function("ExpChirpSignal::quadrature_components_exception") <<
			  boost::errinfo_errno(errno) <<
			  boost::errinfo_at_line(__LINE__));
 }

Hello, Thank you for reading my question.

I want to install a stm compiler in intel. But it is had to do.

I have a two question. 

At first. To install stm compiler, Do I need a intel c compiler(Intel® Parallel Studio XE Cluster Edition for Linux*) ?

I already have a parallel studio's serial number but It is not matched to stm compiler insaller.

Second, I don't know where is license file or serial number.

Thank you.

Hello,

For first, here is writed the Intel INDE Proffessional is free until January 2016, but the download link is broken https://software.intel.com/en-us/legacy-intel-inde. Why?

I have a Lenovo P90. I really dont like a Lenovo UI. Lenovo providing a source codes, so i cloned a Android 4.4.4. and copyied a Lenovo source files into it! But while building, the compiling failed becouse the ICC compilers missing in Prebuild/PRIVATE. I little searched about this and i found. I need the Android Intel C++ Compiler. So i searched where to get it! But sadly, it is contains only a Intel Studio, what is paid! But anyway, im a Student of "high-school", so i will obtain tools for a students package. But, there is a problem.. For first, i dont reach a 18 years (why lol). And then, for verify for im student i need a school email. We dont getting a School Emails, but for verifying for im student i using my International Student Identification Card.

So, my question is: its possible to get Android Intel C++ Compilers or how to get a student package with my ISIC card.

Thanks

P.S. If i writing to wrong category, sorry and delete it!

It's the same example as in 6.7.3.1 of C99 spec.

EXAMPLE 3 The function parameter declarations

void h(int n, int * restrict p, int * restrict q, int * restrict r)
{
    int i;
    for (i = 0; i < n; i++)
        p[i] = q[i] + r[i];
}

illustrate how an unmodified object can be aliased through two restricted pointers. In particular, if a and b are disjoint arrays, a call of the form h(100, a, b, b) has defined behavior, because array b is not modified within function h.

In short, it is explicitly mentioned it's defined behavior if b is not modified within function h. However, whether is it undefined behavior if a call of the form h(100, a, a, b)?

A little bit more backgrounds why I want to make it clear. There are some basic functions which we want to use in in-place or out-of-place manner. In order to reduce the effort, it is desired if we don't need to provide both h(int n, int * restrict p, int * restrict q, int * restrict r) and h_inplace(int n, int * restrict p, int * restrict q). From current observation, it seems icc and msvc can give correct result even if we call it as the form of h(100, a, a, b). However, we definitely don't want to have the risk if it is undefined behavior (which means it may be wrong from other compilers or future versions of icc and msvc). What do you think?

Dear board users,

I am trying to install Parallel Studio XE 2016 on a Linux Mint 17.3 machine.

I have seen that the installation process does not support LinuxMint, not even Ubuntu if I remember well. My first question is: Why? Linux Mint certainly is not a fringe system and may inherit the user base of Ubuntu as Ubuntu is getting more commercial and disrespects privacy at some points.

When will Linux Mint be supported? Even Ubuntu is based upon Debian, and Debian seems to be supported.

Second question:

I somehow moved through the installation process (we only need intel64 architecture) but compilervers.sh did not work. As I've used icpc 2013 on an older system before, I have copied and adapted older module files we had to mirror those settings with the new folders. I've put everything in ~/.bashrc. No, I can get icpc to respond:

icpc version 16.0.0 (gcc version 3.2.0 compatibility)

and I am able to compile a "helloworld" in C.

Why the "compatibility mode" with a gcc that I don't have (I do have g++ 4.8)? What does "compatibility mode" mean in this scenario?

I would not bother too much but it seems that I can't compile boost because of that.

Could you please point me to a precise list of all the dependencies and how to configure them myself if I can't use neither the installer nor compilervars.sh?

Thank you -

Andreas