Some noted differences between Compaq VF6 and Intel VFC XE2011 - explain?

[kschmitt_dom]

I just attained trial copies of Intel Visual Fortran Composer XE 2011 and VS2010 in order to evaluate the compiler for use at my company on Windows 7 (32-bit). I am now testing existing code two different paradigms: 1) Intel Visual Fortran Composer XE 2011/VS2010 and 2) Compaq VF6/Developer's Studio. I have noted several differences that an expert might expound on. Thank you.

1. Intel 2011 seems to be harder on formatting for I/O commands. For instance, Compaq VF6 executables did not require quotes around text strings in order to execute a read statement. For a second instance, Compaq VF6 executables would allow integers to be written with an 'F' edit descriptor. This added enforcement is a good thing but is this a well-known difference?

2. In Intel 2011, the print command does not increment a line automatically between calls. For example, I have a command which will print the percent completion of a Monte Carlo experiment. The Compaq exe prints each readout on a new line while the Intel exe just replaces the first line. Is this a well-known difference? This subtle difference only worries me because it is hard to know if there are subtle differences which may affect the numerics of the exe.

3. Finally, the Intel exe is approximately 15% slower on my machine, for two different codes (though both have the same author). Obviously, this varies for the code but is reduced speed expected for Intel compiled exe as compared to Compaq?

Thank you.

[Steven_L_Intel1]

1. There should be no difference in these matters for correct programs. In the case of list-directed input, quotes are required if the text string contains certain delimiters. There may have been a bug fixed in this area in the last 7-8 years. Regarding integers and F format, both compilers behave the same for me. An example showing a difference would be appreciated.

2. There should be no difference in these matters for correct programs. An example showing otherwise would be appreciated.

3. The vast majority of applications run much faster with Intel Fortran than with CVF. Obviously there may be individual cases where this doesn't happen. Please provide an example for us so that we can take a look. Be sure that you are using comparable optimization levels (not comparing debug to non-debug, for example.)

[kschmitt_dom]

1. An example of F format differences. The following lines of code will compile and run inside a Fortran project with Compaq, but not with Intel (Compaq write the integers as real(4) outputs, Intel Breaks at the write command line)

!Assume the following has been initiated:
!iout=32
!path1='C:\USERS\kschmitt\DESKTOP'
!ierror=0
!nlk=1

open(unit=iout ,file=path1,share='DENYWR',iostat=ierror) !open report file

write(iout,100)'nlk',nlk !write integer

100 format(a,t25,12f12.5) !F format

2. The following script is used to print progress during a Monte Carlo loop where 'ntrial' (set ntrial to 1000 for best results) is the loop delimiter and itrial is the loop variable. Its messy code but I don't think that is incorrect.

if(real(itrial)-real(ntrial/100)*floor(real(itrial)
1 /real(ntrial/100)).eq.0.)then
print'(a,t2,f5.1,a)','+',
1 float(itrial*100)/float(ntrial),
2 '% of total number of trials analyzed'
endif

The Compaq VF6 exe writes the updates on different lines. The Intel exe substititutes the current update on the same line.

3. Both Compaq and Intel are compiling and running on the same optimization levels. This code is still in development and is proprietary.

If you can expound on 1 and 2, please do. Thank you!

[Steven_L_Intel1]

For #1, I see identical default behavior between the two compilers. If you compiled using the /check:format option, then both compilers would give an error similar to:

forrtl: severe (61): format/variable-type mismatch, unit 6, file CONOUT$

Which compile options are you using? I assume you are aware that both compilers will simply treat the integers as if they were floating bit patterns and not do conversions.

For #2, again, I see the same behavior between the two compilers. Whether or not the line is rewritten depends on whether or not Fortran carriage control is in effect. The default for both compilers is that this is off.

Please show me the command line options used for both compilers. I wonder if you are implicitly using Microsoft Fortran PowerStation compatibility for CVF. Are you using the "fl32" command there?

For #3, if you will show me the command options, I may be able to offer further advice.

[kschmitt_dom]

Compaq:
/check:bounds /compile_only /dbglibs /debug:full /nologo /traceback /warn:argument_checking /warn:nofileopt

Intel (default only):
/nologo /debug:full /Od /vms /f77rtl /intconstant /module:"Debug\" /object:"Debug\" /Fd"Debug\vc100.pdb" /traceback /check:bounds /libs:static /threads /dbglibs /c

1. If I add /check:format to Compaq, I get the error you described. Thank you.

2. Only commands in Compaq not in Intel are:
/compile_only
/warn:argument_checking
/warn:nofileopt

No fl32. Any ideas?

3. Any ideas?

4 (added): We will be using command line input file entry to run batch experiments. How come I can't change the Power Station Compatibility options in the VS menu? I can only change it from command line by entering the option "/fpscomp:filesfromcmd"


Thank you so much!

[Steven_L_Intel1]

Oh, you're using /vms and /f77rtl. Those have other effects, including the ones you're seeing. Why did you add those for Intel when you weren't using them with Compaq?

You are doing debug builds with bounds checking - it's the bounds checking that is probably responsible for the performance loss, as the Intel compiler does more of it. Please try a Release build with both compilers and compare.

You can change the PowerStation compatibility options in Visual Studio. Why do you think you can't?