Intel Software Network articles feed

Compile moblin 2.1 kernel sources with Intel Compiler

Wed, 18 Nov 2009 09:36:37 -0800

1. Prepare for build

a. su into root.

b. Create a ~/.rpmmacros file containing:

%_topdir %(echo $HOME)/rpmbuild

%_smp_mflags -j3

%__arch_install_post /usr/lib/rpm/check-rpaths /usr/lib/rpm/check-buildroot

%_default_patch_fuzz 2

#end of file

fuzz=2 is critical to allow the 915 patches to merge correctly.

_smp_mflags -jN, N should be set to the number of processor cores on your build system

2. Setup and do initial build. Download the kernel source from a source repository:

(Used http://repo.moblin.org/moblin/releases/2.1/source/kernel-2.6.31.5-10.1.moblin2.src.rpm)

a. Extract the rpm:

$ rpm -ivh kernel-2.6.31.5-10.1.moblin2.src.rpm

b. Prepare and do initial build to rpm:

$ cd rpmbuild/SPECS

c. Remove lines 762 & 763, 'BuildKernel %make_target %kernel_image menlow' & 'BuildKernel %make_target %kernel_image ivi'

$ rpmbuild -bc --target=i586 kernel.spec

The previous step ensures you have the components to build successfully.

3. Rebuild with gcc:

$ cd rpmbuild/BUILD/kernel-2.6.31/linux-2.6.31

$ make clean

$ make bzImage

$ make modules

$ make modules_install

$ make install

Test the image on your netbook by rebooting the system and selecting the kernel at the grub screen.

Rebuild with Intel Compiler

1. Perform step 1 in the previous section

2. Setup Intel Compiler environment:

a. Set the compiler environment:

$ source /opt/intel/Compiler/11.1/XXX/bin/ia32/iccvars_ia32.sh

where XXX is the particular version you are using.

3. Make source code modifications.

a. Modify include/linux/compiler-intel.h and add the following line at

the end of the file:

#undef __compiler_offsetof

b. Modify arch/x86/include/asm/xor_32.h at line 843, change

: "+r" (lines),

To:

: "+rm" (lines),

This change is required because the code is written to work with gcc's assumption that the stack is 16 byte aligned (contrary to the ABI) and thus there is one additional register available.

c. Add libirc_s.a to the link command by modifying Makefile at line 699. Change:

--start-group $(vmlinux-main) --end-group

to:

--start-group $(vmlinux-main) /opt/intel/Compiler/11.1/XXX/lib/ia32/libirc_s.a

--end-group

d. Modify arch/x86/include/asm/delay.h and remove the references to __bad_udelay and replace the calls to it with 0.

e. Modify include/linux/log2.h and remove the references to ____ilog2_NaN() and replace the calls to it with 0.

f. Modify line 47 of arch/x86/kernel/acpi/realmode/Makefile adding a reference to libirc_s.a as follows:
WAKEUP_OBJS = $(addprefix $(obj)/,$(wakeup-y)) /opt/intel/Compiler/11.1/053/lib/ia32/libirc_s.a

g. Modify line 89 of arch/x86/boot/Makefile adding a reference to libirc_s.a as follows:
SETUP_OBJS = $(addprefix $(obj)/,$(setup-y)) /opt/intel/Compiler/11.1/053/lib/ia32/libirc_s.a

h. Modify kernel/trace/trace_events.c by adding the following line of code (line 915) at the start of event_create_dir():
if (call->system==NULL) return -1;
This change is due to a kernel issue where the source code makes alignment assumptions that are not enforced in the kernel source code. This change is merely a workaround, not a fix for the real issue.

        i. Modify the intelwrapper file documented at www.linuxdna.com and make the following changes:
          - Enable script to replace -march=i686 | -mtune=pentium3 | -mtune=generic with ‘'
          - Enable script to replace -O2 | -Os with ‘-O3 -ip -xSSE3_ATOM'
            Performance BKM: The goal of this option change is to enable higher performance.  Note that the default kernel options uses things such as -mnosse and -fno-omit-frame-pointer which can override the higher optimizations in some places.
          - Enable script to call gcc to compile drivers/net/wimax/i2400m/fw.c | lib/libcrc32c* | crypto/testmgr* - this is required because 11.1 does not yet support some instances of variable length arrays
          - Enable script to call gcc to compile arch/x86/boot/compressed/misc.c - issue with PIC in icc
          - Enable script to call gcc to compile drivers/block/spectra/ffsport.c - inline asm issue

4. Start the build:

$ cd /rpmbuild/BUILD/kernel-2.6.31/linux-2.6.31

$ make clean

$ make HOSTCC=intelwrapper CC=intelwrapper CONFIG_DEBUG_SECTION_MISMATCH=y KBUILD_MODPOST_WARN=n bzImage

$ make HOSTCC=intelwrapper CC=intelwrapper CONFIG_DEBUG_SECTION_MISMATCH=y KBUILD_MODPOST_WARN=n modules

$ make HOSTCC=intelwrapper CC=intelwrapper CONFIG_DEBUG_SECTION_MISMATCH=y KBUILD_MODPOST_WARN=n modules_install

$ make HOSTCC=intelwrapper CC=intelwrapper CONFIG_DEBUG_SECTION_MISMATCH=y KBUILD_MODPOST_WARN=n install

The make install step will install the kernel and modify grub so that the kernel can be selected upon bootup.

To build with other configurations, such as the mrst config:
cp configs/kernel-mrst.config .config and go to step 4.

Build ffmpeg/ffmpeg-mt using Intel compiler on linux

Mon, 28 Sep 2009 02:31:21 -0700

Introduction :
FFmpeg is a complete, cross-platform solution to record, convert and stream audio and video. FFmpeg-mt is the multithreaded version of FFmpeg. Visit http://ffmpeg.org for more information.

Version :
I use the latest source from FFMPEG git and Intel C++ compiler 11.1.046 for linux.

Obtaining Source Code :
Get the ffmpeg source:
git clone git://git.ffmpeg.org/ffmpeg
cd ffmpeg
git clone git://git.ffmpeg.org/libswscale

Get the ffmpeg-mt source:
git clone git://git.gitorious.org/ffmpeg/ffmpeg-mt
cd ffmpeg-mt
git clone git://git.mplayerhq.hu/libswscale

Build the application:
The build process for ffmpeg and ffmpeg-mt is similar.

1. go to the source code folder.

2. configure the build. Please use ./configure --help for more options.

./configure --prefix=/usr --enable-shared

3. Build with gcc compiler by default.

make & make install

4. To build with Intel compiler, use the following command after step 2.

source /opt/intel/Compiler/11.1/046/bin/iccvars.sh ia32

make CC=icc LD=icc

make install

5. To build with more advanced options like "-ipo" using Intel compiler, we can use a wrapper to change build option. For example:

1) make a new file with name intelwrapper, input the followings in the file:

ICCFLAGS="$@ -ipo"

echo "icc $ICCFLAGS"

icc $ICCFLAGS

2) add execution attribute for intelwrapper

chmod 755 intelwrapper

3) make CC=/bin/intelwrapper AR=xiar LD=icc
4) make install

Using Intel Compilers for Linux with Caos Linux

Fri, 28 Aug 2009 13:49:34 -0700

Using Intel(R) Compilers under Caos NSA 1.0 Linux

These notes apply to a Caos NSA 1.0 Linux Desktop installation. Other installation types (server, base, etc) but should be similar but may require the installation of additional packages.

In order to use Intel(R) Compilers ( Fortran or C++ ) under Caos Linux you will need the latest 11.1 version of the Intel compiler(s). Older 10.0 and 9.1 versions of the compilers may not work properly and have not been tested. Keep in mind that Caos NSA Linux installations are not OFFICIALLY supported by the Intel Compilers. Please see your ReleaseNotes document with your compiler version for a list of officially supported distributions and versions.

If you have active support for your compiler, you can download the latest Intel compiler version from
https://registrationcenter.intel.com

Follow the directions below after your network connection is configured. Also, it is recommended that you first update your system to the latest version of Caos. Open a terminal window as the root user. Enter the following command to update your Caos installation:

smart update
smart upgrade

BEFORE YOU INSTALL Intel(R) Fortran for Linux or Intel(R) C++ for Linux on your fresh Caos NSA Desktop installation, you will first need to install several packages to prepare the system to serve as a development platform:

Check that gcc and g++ are installed. By default. Check this with:

gcc --version
g++ --version

By default you may not have these packages installed.

To prepare the system for the Intel Compilers, add the gcc-c++ and glibc-devel packages. Open a terminal window as the root user. Use 'smart' to install the following packages:

smart install gcc-c++
smart install glibc-devel

If you are in a 32bit, also known as "CAOS NSA 1.0 for i386" system, you may proceed with the installation of the Intel compilers (see below). 'uname -m' will return "i686" for this configuration.

For x86-64 architecture, you will also need another package to supply 32bit libraries needed for developing 32bit applications in addition to 64bit applications. First, determine the version of the 64bit version of glibc-devel that is installed:

smart query glibc-devel

the output should show both the 64bit and 32bit packages and their version. For example:

glibc-devel-2.8-13.nsa1@i686
glibc-devel-2.8-13.nsa1$x86_64

Note that the versions you see may not match "2.8-13". You may have a newer or older version available. Find the 'i686' version and use smart install to fetch and install that package:

smart install glibc-devel-2.8-13.nsa1@i686

for example. Use the correct version returned by 'smart query' above, "2.8-13" is just an example to give you the idea.

Finally, there is an optional package to consider: The 11.0 version of the Intel Compiler for Linux has a graphical
debugger, a new graphical interface for the IDB debugger. If you want to use this debugger, please make sure to install the Java JRE version 1.5 or greater. This can be done at anytime after the installation of the compiler. However, you will get a warning message about 'missing prerequisite' for the JRE - simply ignore that message and proceed with the installation. OR to avoid that message and enable the graphical IDE, get the latest JRE from:

http://java.com/en/download/manual.jsp

Once installation of prerequisites is complete, you are ready to start the Intel compiler(s) installation. During the installation, you may get a message "Detected operating system (generic) is not supported", followed by
----------------------------------------------------------------- ---------------
Missing optional pre-requisite
-- operating system type is not supported.
-- system glibc or kernel version not supported or not detectable
-- binutils version not supported or not detectable
----------------------------------------------------------------- ---------------
"Would you like to perform an unsupported install of this product [yes/no] (no)?"

enter "yes"

This will complete the installation. Keep in mind, you will get this warning from the compiler installer until such time as this particular OS and version are supported. Once installed, you can read the ReadMe notes in ...installdir.../Documentation directory which has a list of the supported Linux distributions and versions.

Memory allocation results in segmentation violation

Thu, 27 Aug 2009 23:40:59 -0700

Problem :

I observe that when I compiled the following test case using default flag, its working properly. When I disabled optimization using flag -O0, it working for array size 10000, but unfortunately its giving segmentation fault error for size 100000.

$ cat mytest1.c
// mytest1.c

#include
#include
#include

#define SIZE 1024 // Size = 1G
int main(int argc, char *argv[])
{
     float *a; //DB Init

     long i,size=0,j;
     float sum=0;
     int k=0;
     int return_value;

     sscanf(argv[1], "%ld", &size);
     printf("\n Size before Allocation = %ld\n",size);
     a=(float *) malloc (sizeof(float)* (size+128));

     printf("Value of return from malloc = %d",return_value);

     if (a == NULL){
         printf("\n\n ERROR: Memory Allocation not possible\n\n");
         exit(-1);
     }
     else
     {
         printf("Value of return pointer after memory allocation = %ld",a);
         printf("\n\n probing a[0]\n");
         a[0] = 0.;
         printf("probing a[%ld]\n", size-1);
         a[size-1] = 0.;
         printf("probing succeeded\n");
         return 0;
    }

    for(i=0;i< size; i++){
        sum+=a[i];
    }
    printf("\n Addition Complete, # of Element= %ld\n", size);
    free((void *)a);
    return 0;
}

$ icc -O0 mytest1.c
$ ./a.out 100000

Size before Allocation = 100000
Value of return pointer after memory allocation = -1788305392

probing a[0]
Segmentation fault

$ icc mytest1.c
$ ./a.out 100000

Size before Allocation = 100000
Value of return pointer after memory allocation = 182895288336

probing a[0]
probing a[99999]
probing succeeded

Environment :

Intel C++ compiler, Linux x86_64

Root Cause :

Implicitly declared malloc() returns improper address pointer and the application crashes. The compiler must know the function signature to handle it properly.

Resolution :

Implicitly declared malloc() returns improper address pointer. The malloc() declaration in stdlib.h is as given below:

void * malloc ( size_t size );

The compiler must know the function signature to handle it properly. If we do not provide declaration to compiler, the compiler assumes that the value returned by the function is integer. This is called implicit declaration.

The implicit declaration will force void pointer returned from malloc() to integer, the integer is converted again to float pointer. These conversions results in improper value for returned memory address and the application crashes.

Icc and variable length arrays

Mon, 24 Aug 2009 03:38:26 -0700

Problem :

I am having a compilation issue with icc that seems related with checking the C language standard.

I am getting the following error message with icc :

error: a field declaration cannot have a type involving a variable length array

I get this error with icc whether I am using -std=c99 or nothing (ie default -std=gnu98).

When using gcc (4.1.2 and 4.3.3) I get slightly different results:

gcc -std=c89 -pedandtic (same with -std=gnu89)
warning: ISO C90 forbids variable length array ‘bounds’
warning: a member of a structure or union cannot have a variably modified type

gcc -std=c99 -pedantic
warning: a member of a structure or union cannot have a variably modified type
(no C90 forbids...)

gcc without -pedantic: no warnings, no errors

So I guess that this is a language standard issue

Environment :

Intel C++ compiler 11.0 and older, Linux.

Resolution :

You may use latest Intel C++ compiler 11.1 to resolve this issue. I can compile the varaible length arrays test case with icc 11.1.038.

$ cat varLenArray.c

// varLenArray.c

void func(int sz)
{
int arr[sz]; // sz ins't const; allowed only in C99
}

int main()
{
int size;
printf("enter array's size : ");
scanf("%d", &size);
func(size);
return 0;
}

$ icc -c varLenArray.c
$ uname -a
Linux maya8 2.6.23.1-42.fc8 #1 SMP Tue Oct 30 13:18:33 EDT 2007 x86_64 x86_64 x86_64 GNU/Linux

Intel thread affinity environment variable for OpenMP*

Mon, 24 Aug 2009 02:31:41 -0700

Problem :

I am using the Intel® compiler and openMP* to parallelize some work as follows:

#pragma omp parallel num_threads(4)
{
DoWork();
}

I would d like to experiment with Intel's thread affinity feature for OpenMP but I a unsure of exactly how to use the environment variable (for example, where do I place the environment statement in my code?).

Could you give a little example showing proper usage and where to place the statement ?

Environment :
Intel C++ compiler, Linux*, Mac OS* X, Windows*

Resolution :

Intel thread affinity environment variable KMP_AFFINITY for openMP is explained in Compiler Intel® compiler user guide topic “Thread Affinity Interface (Linux* and Windows*)”. You may review the topic for detailed information.

There are many ways to set the thread affinity using KMP_AFFINITY. I am providing an example below. In the example I am mapping OpenMP threads 0, 1, 2 and 3 to OS processor 3, 2, 1 and 0 respectively.

$ cat tstcase.cpp
// tstcase.cpp
// Thread afinity interface
//


#include 
#include 
using namespace std;

#define N 1000

int main ()
{
cout << "Starting openmp test." << endl;

int i;
float a[N], b[N], c[N], d[N];

/* Some initializations */
for (i=0; i < N; i++)
{
a[i] = i * 1.5;
b[i] = i + 22.35;
}

#pragma omp parallel shared(a,b,c,d) private(i)
{

#pragma omp sections nowait
{

// Section #1
//
#pragma omp section
{
cout << "Section #1." << endl;
for (i=0; i < N; i++)
c[i] = a[i] + b[i]; // End of section #1
a[0] = 3.45;
}

// Section #2
//
#pragma omp section
{
cout << "Section #2." << endl;
for (i=0; i < N; i++)
d[i] = a[i] * b[i]; // End of section #2
a[1] = 5.67;
}

} // End of sections

} // End of parallel

cout << "Exiting openmp test." << endl;
return 0;
}

$ icc -openmp tstcase.cpp
$ export KMP_AFFINITY="verbose,proclist=[3,2,1,0]"
$ ./a.out
OMP: Warning #63: KMP_AFFINITY: proclist specified, setting affinity type to "explicit".
Starting openmp test.
OMP: Info #149: KMP_AFFINITY: Affinity capable, using global cpuid instr info
OMP: Info #154: KMP_AFFINITY: Initial OS proc set respected: {0,1,2,3}
OMP: Info #156: KMP_AFFINITY: 4 available OS procs
OMP: Info #157: KMP_AFFINITY: Uniform topology
OMP: Info #159: KMP_AFFINITY: 2 packages x 2 cores/pkg x 1 threads/core (4 total cores)
OMP: Info #160: KMP_AFFINITY: OS proc to physical thread map ([] => level not in map):
OMP: Info #168: KMP_AFFINITY: OS proc 0 maps to package 0 core 0 [thread 0]
OMP: Info #168: KMP_AFFINITY: OS proc 2 maps to package 0 core 1 [thread 0]
OMP: Info #168: KMP_AFFINITY: OS proc 1 maps to package 3 core 0 [thread 0]
OMP: Info #168: KMP_AFFINITY: OS proc 3 maps to package 3 core 1 [thread 0]
OMP: Info #147: KMP_AFFINITY: Internal thread 0 bound to OS proc set {3}
OMP: Info #147: KMP_AFFINITY: Internal thread 1 bound to OS proc set {2}
OMP: Info #147: KMP_AFFINITY: Internal thread 2 bound to OS proc set {1}
OMP: Info #147: KMP_AFFINITY: Internal thread 3 bound to OS proc set {0}
Section #1.
Section #2.
Exiting openmp test.

Effect of wrong value returned by time() system call

Mon, 24 Aug 2009 01:45:13 -0700

Problem :
There is system call failure reported that are related with time function.
If x86 base system used TSC(Time Stamp Counter) for clock source (It's default)
and RedHat Kernel is older than 2.6.18-92.1.6.el5, then gettimeofday(2) system
call returns current time + 4398 sec.

This link has an example: http://www.unix.com/high-level-programming/75447-problem-gettimeofday.html.

Two other links with additional information:

http://lkml.org/lkml/2007/8/23/96
https://bugzilla.redhat.com/show_bug.cgi?id=452185

The following are the questions for Intel C++ compiler for Linux*:

(1) Does icc use the following system calls ?
- gettimeofday(2), time(2), ftime(3) ?
- clock_gettime(3) with CLOCK_REALTIME or CLOCK_MINOTONIC as 1st parameter?
- getdata(3) or getdate_r(3), because it calls time(2) function when parameter do not have hour/min/sec?
- pthead_cond_timedwait(3), pthread_rwlock_timedrdlock(3), pthread_wrlock_timedwrlock(3) or pthread_mutex_timedlock(3)?
- aio_suspend(3)

(2) If above system calls are failed, then icc carry out unjust operation ?

Environment :

Linux*, Intel C++ compiler

Resolution :

The time() is being used in the pgopti runtime library to create the name of the .dyn file, and to get start and end time stamps for the .dyn file. These start and end time stamps are used in the merging process (profmerge) to compute the duration of the run, which is used in the weighted profile feature. This feature allows users to assign weights to the profiles, rather than having longer runs automatically get greater weight.

So, if time() can’t be trusted, neither can this feature. On the plus side, it’s a relatively new feature. On the minus side, we put it in there because IBM DB2 wanted it. We can find out what platform they are using to see if they personally would be affected.

As for other uses of time()-like functions in PGO:

(1) clock() is used in interval based profiling to tell when another interval is set.

(2) As for merging of files, the time is determined by the ‘mtime’ variable in the structure returned by a stat() call.

Other than PGO, the time is used for in the compiler for date stamping objects, for implementing __TIME__ macro expansion, ...

So we don't think it will be used for anything that will cause "bad"
code except for getting incorrect values for these sorts of things. You could argue that this isn't really bad code in the sense that it agrees with what the system told the compiler.

Intel® C++ Compiler for Linux* - Building ACE+TAO with Intel® C++ Compiler for Linux*

Tue, 04 Aug 2009 02:50:07 -0700

Introduction

This document explains how to configure and build ACE+TAO. From the ACE+TAO web site:

ACE† is an open-source framework that provides many components and patterns† for developing high-performance, distributed real-time and embedded systems. ACE provides powerful, yet efficient abstractions for sockets, demultiplexing loops, threads, synchronization primitives.
TAO† (The ACE ORB) is an open-source implementation of a CORBA† Object Request Broker (ORB) built using components and patterns in the ACE framework.
Several companies provide commercial support for ACE+TAO, see http://www.cs.wustl.edu/~schmidt/commercial-support.html† for information. Remedy IT, http://www.theaceorb.nl† , provides support for building ACE+TAO with the Intel® C++ Compiler.
Version Information
The version of ACE+TAO used in this document is ACE version 5.5.8.
Obtaining the Source Code
The ACE+TAO source code was downloaded from http://software.intel.com/file/7247† .
Obtaining the latest version of Intel® C++ Compiler
See http://www3.intel.com/cd/software/products/asmo-na/eng/compilers/clin/277618.htm for details.
Prerequisites
None.

Configuration and Set-up Information

$ tar zxvf ACE+TAO-src.tar.gz 

$ cd ACE_wrappers/

$ export ACE_ROOT=`pwd`

# create configuration file

$ echo 'zlib=1

inline=0

boost=0

CFLAGS+=-Wp64

include $(ACE_ROOT)/include/makeinclude/platform_linux_icc.GNU' >
 $ACE_ROOT/include/makeinclude/platform_macros.GNU

# create configuration file

$ echo '#include "ace/config-linux.h"' > $ACE_ROOT/ace/config.h

$ cd $ACE_ROOT

$ export LD_LIBRARY_PATH=$ACE_ROOT/lib:$LD_LIBRARY_PATH

$ gmake >& gmake.log

TAO Configuration and Set-up Information

$ export TAO_ROOT=$ACE_ROOT/TAO

$ cd $TAO_ROOT 

$ gmake >& gmake.log 

$

Source Code Changes
None required.
Building and Running Applications
One can test the TAO build is correctly configured by following the instructions on how to run the various examples in $TAO_ROOT/tests.
Verifying Correctness
Run the various examples in $TAO_ROOT/tests and compare with the ACE+TAO scorecard, which lists the status of the ACE+TAO build. The ACE+TAO scorecard for the Intel ^® C++ Compiler builds are performed by Remedy IT† can be found at http://www.dre.vanderbilt.edu/~remedynl/† .
Related topics
http://software.intel.com/en-us/articles/building-acetao-with-intelr-c-compiler-for-linux/
Known Issues and Limitations
None. Contact Intel® Premier Support website if you encounter problems or want to provide feedback.

^† This link will take you off of the Intel Web site. Intel does not control the content of the destination Web Site.

Installing Intel Compilers on OpenSUSE

Wed, 22 Jul 2009 09:36:56 -0700

Problem : I am having trouble installing my Intel Compiler Pro v11.1 on OpenSUSE

Environment : This article was written for OpenSUSE 11.2 and 11.1 but should apply to 11.0 installations as well. This guide applies ONLY to the Intel Compilers Profession Version 11.1 and greater. If you have an older Intel compiler, please upgrade to 11.1. Compatibility of OpenSUSE 11.2 with anything other than Intel Compiler Pro 11.1 is not guaranteed to work - consider getting an older OpenSUSE 10.x or older version to work with your older Intel compiler.

Root Cause : As of this writing OpenSUSE 11.2 is not officially supported by the Intel Compiler Professional edition. The procedures herein are intended to assist the user configure OpenSUSE to support installation of the Intel Compiler Professional Edition. However, this is not a supported configuration. Please see your Release Notes document for a list of officially supported Linux distributions and versions.

The default OpenSUSE installation may not have all the packages needed to support software development (gcc, g++, and binutils packages along with header files). Also, the Intel compiler released versions are targeted and built for distributions available 12-16 months before the compiler is actually released to customers. Thus, by the time development is completed for a particular compiler version, many Linux distributions have progressed forward one or two versions. Intel tries to stay current with Linux distributions, but it often takes us many months after a distribution release to add support. See your Release Notes from the compiler documentation to determine supported distributions and versions.

Resolution : Add several packages to your OpenSUSE installation PRIOR to installation of the compiler.

Procedure:

00) Remove any previous failed installations:
If you have an installation of the Intel Compiler Pro v11.1 on your system from a failed attempt, uninstall it.
/opt/intel/Compiler/11.1/046/bin/[ia32 | intel64]/uninstall_cpro[c | f].sh

substitute your version for "046" above if you have another version besides 11.1.046

0) First determine whether you have installed a 32bit or 64bit version of OpenSUSE. Do this with the uname -a command:

uname -m

which will return:
x86_64   if you have a 64bit installation
i686 if you have a 32bit installation

Based on whether you have a 32bit or 64bit installation, choose one of the 2 procedures below.

1) i686 32bit Installation

a) login as root or super user.
If you do not have the root password or priviledge, check if you have SUDO priviledges.
If you do not have either root/admin or SUDO priviledges STOP. You will be unable to install the Intel compilers on this installation until you are able to add system-wide packages as a root or admin user.
If you use SUDO to gain access, open a root window with this command:
sudo bash

b) Add Base Development and C/C++ Development
start Yast2 in interactive mode. From the root window:   yast2
When the graphical admin tool Yast2 opens, there is a button (lower right) for "Software Manager".
Click Software Manager button to open the Software Manager tool.
On this Software Manager window, find the "Filter" pull-down. Set Filter to "Patterns" to display groups of packages in the left-hand list of package groups. Scroll down in this list to find the group named "Development".
Under the "Development" group, select the following package sets to install:
"Base Development"
"C/C++ Development"

in addition, if you are installing the Intel C++ compiler and wish to use Eclipse integration, also install the "Integrated Development Environments"/"Eclipse" package set.

Once these package sets are select, select "Install" to install the developer packages on your system.

c) Install 32bit gcc and g++ 3.3 and make the default
From the terminal window, as root:

zypper install gcc33-32bit
zypper install libstdc++33-32bit

Try the installation of the Intel Compiler at this point. If this does not work, consider doing the following:
rm /usr/bin/gcc
ln -s /usr/bin/gcc-3.3 /usr/bin/gcc

You may now proceed with an installation of the Intel Compilers.

2) x86_64 64bit OS Installation

a) login as root or super user.
If you do not have the root password or priviledge, check if you have SUDO priviledges.
If you do not have either root/admin or SUDO priviledges STOP. You will be unable to install the Intel compilers on this installation until you are able to add system-wide packages as a root or admin user.
If you use SUDO to gain access, open a root window with this command:
sudo bash

b) Add Base Development and C/C++ Development
start Yast2 in interactive mode. From the root window:   yast2
When the graphical admin tool Yast2 opens, there is a button (lower right) for "Software Manager".
Click Software Manager button to open the Software Manager tool.
On this Software Manager window, find the "Filter" pull-down. Set Filter to "Patterns" to display groups of packages in the left-hand list of package groups. Scroll down in this list to find the group named "Development".
Under the "Development" group, select the following package sets to install:
"Base Development"
"C/C++ Development"

in addition, if you are installing the Intel C++ compiler and wish to use Eclipse integration, also install the "Integrated Development Environments"/"Eclipse" package set.

Once these package sets are select, select "Install" to install the developer packages on your system.

c) Install gcc and g++ 3.3
From the terminal window, as root:

zypper install gcc33
zypper install libstdc++33
zypper install libstdc++33-32bit

At this point you are ready to install the 64bit versions of the Intel Compiler. But before you do, read below:

d) Determine if you want or need to develop 32bit applications
Up to this point you have everything you need to install the 64bit Intel compilers and develop 64bit applications. If this is all you need, locate the Intel compiler tarball named *_intel64.tgz, for example, l_cprof_p_11.1.046_intel64.tgz and install.
IF you want to be able to create 32bit applications AND 64bit applications:

zypper install gcc33-32bit

You may now proceed with an installation of the Intel Compilers. Use the combined IA-32 and Intel64 package, for example l_cprof_p_11.1.046.tgz.

Finishing up: Usage

Once the compilers are installed, it is necessary to source the ifortvars.sh or ifortvars.csh file to properly set the user environment to use the Intel compilers. This (these) commands can be placed in a user's ~/.bashrc or other system login file (fortran 11.1.046 example shown below, bash user):

64bit compiler selection:
source /opt/intel/Compiler/11.1/046/bin/ifortvars.sh intel64

32bit compiler selection:
source /opt/intel/Compiler/11.1/046/bin/ifortvars.sh ia32

C/C++ users: substitute "iccvars" for "ifortvars" above.

Other versions: substitute your actual minor version for "046" above.
Also, if you are a CSH or TCSH user, use ifortvars.csh or iccvars.csh as appropriate.

It is hoped this guide proves helpful for installing the Intel Compilers Professional Edition on an OpenSUSE installation. Please add comments to this article if you have suggestions or tips to improve this guide.

How to Compile for Intel® AVX

Thu, 16 Jul 2009 16:34:04 -0700

Intel® AVX (Intel® Advanced Vector Extensions) is a 256 bit instruction set extension to Intel® SSE (Intel® Streaming SIMD Extensions) that was first announced in 2008. Further information about Intel AVX is available at http://software.intel.com/en-us/avx/ .

The Intel C/C++ and Fortran Compilers, version 11.1, support the building of applications for Intel AVX. On Windows*, use the command line switch /QxAVX. On Linux*, use –xavx. The switches /QaxAVX (Windows) and –axavx (Linux) may be used to build applications that will take advantage of AVX instructions on Intel systems that support these, but will use only SSE instructions on other systems.

Both C/C++ and Fortran compilers support automatic vectorization of floating-point loops using AVX instructions. The C/C++ compiler also supports AVX-based intrinsics (via the header file immintrin.h) and inline assembly. Intel AVX allows the vectorization of a wider variety of floating point loops than Intel SSE, with a greater potential performance gain due to the greater width of the SIMD registers. The vectorizer is enabled automatically by the switches listed above. To see which loops have been vectorized, use the switch /Qvec-report1 (windows) or –vec-report1 (Linux).

Pending availability of processors supporting Intel AVX, the Intel® Software Development Emulator (Intel® SDE) is available for testing programs built for Intel AVX. See http://software.intel.com/en-us/articles/intel-software-development-emulator/ .
Further general information about the Intel Compilers for C/C++ and Fortran is available at http://software.intel.com/en-us/intel-compilers/ . Further information about compiler support for Intel AVX may be found in the Intel C++ Compiler User and Reference Guides, for example in the section 'Intrinsics for Advanced Vector Extensions', accessible online at http://software.intel.com/sites/products/documentation/hpc/compilerpro/en-us/cpp/win/compiler_c/index.htm .