I am using ICPC 2017
For some applications, I am receiving the remarks as displayed in the title.
However, the application in question does not even use OpenMP at all. For simplicity I enabled the -qopenmp flag for all executables in the same project. Some of them do use OpenMP. But the program in questions does not. Shall it -qopenmp has no effect, except linking an extra (useless and almost harmless) libiomp when the source does not have any #pragma omp?
In addition, this remark since to come when there are large functions to be inlined, or trying to inlining deep recursion of template functions. For example, an 16-iteration loop unrolled through meta programming, and each iteration itself unrolls a 4-iteration loop. It is difficult to provide a minimal example.
Add the -qoverride-limits option seems to disable the warning. However, it results in very long compile time and sometime excessive large memory usage.
Is there anyway simply to disable this warning? Usually remarks can be disabled with -disable-diag, but I cannot find the number of this remark anywhere in the reference manual.
Please see https://software.intel.com/en-us/articles/fdiag25464 for a short description of internal compiler limits and working around them. Deeply nested inlining can certainly increase both memory requirements and the complexity of other optimizations. -qopenmp has much less impact on code that doesn't contain OpenMP directives, but still has some.
Which compiler version are you using? The diagnostic messages in the above article should be disabled by -diag-disable=25464 etc. They occur in compiler version 15.0.1 and later. Similar remarks in older compilers that don't have a number can't be disabled in this way. If you see a remark in a recent compiler that doesn't have a number, please let us know and we'll try to get it fixed.
You should probably test whether run-time performance is significantly worse than when you compile with -qoverride-limits. If it is, you may want to inline more selectively to get a better balance between compile time, compiler memory usage and run-time performance.