Intel Software Network - Main Articles Feed

BIND(C) does not work for COMPLEX

Fri, 20 Nov 2009 13:00:50 -0800

Reference Number : dpd200049725

Version : 10.0,10.1,11.0,11.1

Product : Intel Fortran Compiler, Professional Edition

Operating System : Linux

Problem Description :
The Intel Fortran compiler uses an additional, hidden argument to return the result of a function of type COMPLEX. Adding the BIND(C) attribute to the function declaration should cause the result to be returned by value, in accordance with the x64 ABI, so that the function becomes interoperable with the Intel and GNU C compilers. Currently, it does not.

Resolution Status : This may be fixed in a future version of the Intel compiler

[DISCLAIMER: The information on this web site is intended for hardware system manufacturers and software developers. Intel does not warrant the accuracy, completeness or utility of any information on this site. Intel may make changes to the information or the site at any time without notice. Intel makes no commitment to update the information at this site. ALL INFORMATION PROVIDED ON THIS WEBSITE IS PROVIDED "as is" without any express, implied, or statutory warranty of any kind including but not limited to warranties of merchantability, non-infringement of intellectual property, or fitness for any particular purpose. Independent companies manufacture the third-party products that are mentioned on this site. Intel is not responsible for the quality or performance of third-party products and makes no representation or warranty regarding such products. The third-party supplier remains solely responsible for the design, manufacture, sale and functionality of its products. Intel and the Intel logo are trademarks or registered trademarks of Intel Corporation or its subsidiaries in the United States and other countries. *Other names and brands may be claimed as the property of others.]

Interview with Anatoliy Kuznetsov, the author of BitMagic C++ Library

Fri, 20 Nov 2009 03:30:48 -0800

Abstract

In this article, Anatoliy Kuznetsov answers the questions and tells us about the open BitMagic C++ Library.

Introduction

In my regular browsing through 64-bit programming related websites, I often came across references to BitMagic C++ Library and realized that it had benefited a lot from using 64-bits. I decided to contact the author asking him to give us an interview about his research and developments.

Questions are asked by: Andrey Karpov - in-house developer at OOO "Program Verification Systems currently" working on PVS-Studio tool designed for verification modern C++ applications.

The answers are given by: Anatoliy Kuznetsov - chief software engineer at NCBI; developer of the open source BitMagic C++ Library.

Anatoliy, please tell us a few words about yourself. What projects are you involved in?

I am a chief software engineer, at present I am working for the bio-molecular data discovery and visualization team at NCBI (National Center for Biotechnology Information). Apart from my primary job, I am the chief developer and architect of the open-source BitMagic C++ Library.

I am a planning engineer by education, a graduate of the Lobachevskiy University of Nizhniy Novgorod.

What is BitMagic?

BitMagic has been developed as a universal template library for processing compressed bit vectors. The library solves several tasks:

It provides a bit container which is really compatible with STL in terms of ideology. It means that such container must support iterators, memory allocators and interact with algorithms and other STL containers.

The library can efficiently operate on very long and sparse vectors.

It enables the serialization vectors for further writing to a database or sending them over a network.

A developer is provided with a set of algorithms to implement set-theory operations and calculate distances and similarity metrics in multidimensional binary spaces.

Much consideration is given to optimization for popular fast calculation systems such as SSE.

What tasks addressed by BitMagic make it so attractive for developers?

The library turned out to be fairly a one-stop solution and apparently it won’t be easy to list all its possible applications. At present, the library offers more compelling results in the following spheres:

Bit and inverted indexes building for full-text search systems, acceleration of relational algebra operations (AND, OR, JOIN etc).

Development of non-standard extensions and indexes for existing databases (Oracle Cartridges, MS SQL extended stored procedures). Generally, such extensions help integrate scientific, geographic and other non-standard data into the database.

Data mining algorithms development.

In-memory indexes and databases development.

Development of precise access isolation systems with a large number of objects (security enhanced databases with the isolation of access to specific fields and columns).

Task management systems (for the computation cluster), real-time task state tracking systems, and the storage of task states described as Finite State Machines.

Tasks related to the representation and storage of strongly connected graphs.

What can you tell about the history of BitMagic development? What motivated you to create it?

For a long time my colleagues and I had worked on tasks related to large databases, analysis and visualization systems. The initial working version demonstrating bit-vector capabilities was produced by Maxim Shemanaryov (he is the developer of Antigrain Geometry, a wonderful 2D vector graphics library: http://www.antigrain.com). Then, some ideas for an equivalent representation of data sets were described by Koen Van Damm, an engineer from Europe, who worked on programming language parsers for the verification of complex systems. There were other sources as well. I decided to bring them all together in the form of a library suitable for repeated use in various projects.

What license BitMagic is distributed under? Where I can download it?

The library is free for commercial and non-commercial use and is available in the form of source texts. The only limitation is the the requirement to give credit to the library and its authors if you are using it in a released product.

You can check out all the materials here: http://bmagic.sourceforge.net.

Am I right saying that BitMagic has significant advantage if compiled as a 64-bit version?

Yes indeed, the library uses a series of optimization methods to accelerate processing in 64-bit systems or SIMD-enabled systems (128-bit SSE2).

Here are some factors leading to a faster execution of algorithms:

a wide machine word (logical operations are performed over a wide word);

the programmer (and the compiler) has access to additional registers and the lack of registers is not so critical (this an inherited disadvantage of x86 architecture);

memory alignment often makes the operation faster (128-bit alignment of addresses provides good results);

and of course it’s possible to place more objects and data for processing in a program’s memory. That’s a great benefit of the 64-bit version, which is clear to everyone.

At the moment the fastest method is to use 128-bit SSE2 optimizations with a 64-bit program. This mode combines the double number of x86 registers with a wide machine word to perform logical operations.

64-bit systems and programs are going through a real Renaissance. The migration to 64-bits will be faster than the move from 16 to 32. The launch of 64-bit Windows versions in the mainstream market and the availability of related tools (like the one your company is developing) will stimulate this process. In the environment of increasingly complex systems and larger amounts of code, such tools as PVS-Studio will be of great practical utility as they help reduce labor costs and the time to market.

Please tell us about the compression methods used in BitMagic.

The current 3.6.0 version of the library uses several compression methods.

"Bitvectors" in memory are split into blocks. When a block is not occupied or is occupied fully, it won’t be allocated. That is, the programmer can set bits in a wide range very far from zero. Thus setting a 100,000,000 bit won’t result in an exploded memory use which is often common to vectors with a two-dimensional linear model.

Blocks in memory can have an equivalent representation in the form of areas – the so-called gaps. Actually that’s a sort of RLE coding. Unlike RLE, our library doesn't lose the capability to execute logical operations or access random bits.

When serializing "bitvectors", a set of different methods is used: conversion to lists of integer numbers (representing nulls or ones) and list coding by the Elias Gamma Coding method. When implementing these methods, we do lose the random bit access capability but it is not so critical for disk writes if compared with reduced storage and input-output overheads.

Could you give some code examples demonstrating possible uses of BitMagic?

The first example simply creates 2 vectors, initializes them and performs the logical operation AND. Further, the enumerator class is used for the iteration and printing of values saved in the vector.

#include <iostream>
#include "bm.h"
using namespace std;
int main(void)
{
    bm::bvector<>   bv;    
    bv[10] = true; bv[100] = true; bv[10000] = true;
    bm::bvector<>   bv2(bv);    
    bv2[10000] = false;
    bv &= bv2;
    bm::bvector<>::enumerator en = bv.first();
    bm::bvector<>::enumerator en_end = bv.end();
    for (; en < en_end; ++en) {
        cout << *en << endl;
    }
    return 0;
}

The next example demonstrates vector serialization and the use of compression.

#include <stdlib.h>
#include <iostream>
#include "bm.h"
#include "bmserial.h"
using namespace std;
// This procedure creates very dense bitvector.
// The resulting set will consists mostly from ON (1) bits
// interrupted with small gaps of 0 bits.
//
void fill_bvector(bm::bvector<>* bv)
{
    for (unsigned i = 0; i < MAX_VALUE; ++i) {
        if (rand() % 2500) {
            bv->set_bit(i);
        }
    }
}
void print_statistics(const bm::bvector<>& bv)
{
    bm::bvector<>::statistics st;
    bv.calc_stat(&st);
    cout << "Bits count:" << bv.count() << endl;
    cout << "Bit blocks:" << st.bit_blocks << endl;
    cout << "GAP blocks:" << st.gap_blocks << endl;
    cout << "Memory used:"<< st.memory_used << endl;
    cout << "Max.serialize mem.:" << 
            st.max_serialize_mem << endl << endl;;
}
unsigned char* serialize_bvector(
  bm::serializer<bm::bvector<> >& bvs, 
  bm::bvector<>& bv)
{
    // It is reccomended to optimize 
    // vector before serialization.
    bv.optimize();  
    bm::bvector<>::statistics st;
    bv.calc_stat(&st);
    cout << "Bits count:" << bv.count() << endl;
    cout << "Bit blocks:" << st.bit_blocks << endl;
    cout << "GAP blocks:" << st.gap_blocks << endl;
    cout << "Memory used:"<< st.memory_used << endl;
    cout << "Max.serialize mem.:" << 
             st.max_serialize_mem << endl;
    // Allocate serialization buffer.
    unsigned char*  buf = 
        new unsigned char[st.max_serialize_mem];
    // Serialization to memory.
    unsigned len = bvs.serialize(bv, buf, 0);
    cout << "Serialized size:" << len << endl << endl;
    return buf;
}
int main(void)
{
    bm::bvector<>   bv1;    
    bm::bvector<>   bv2;
   //  set DGAP compression mode ON
    bv2.set_new_blocks_strat(bm::BM_GAP);  
    fill_bvector(&bv1);
    fill_bvector(&bv2);
    // Prepare a serializer class 
    // for best performance it is best 
    // to create serilizer once and reuse it
    // (saves a lot of memory allocations)
    //
    bm::serializer<bm::bvector<> > bvs;
    // next settings provide lowest serilized size 
    bvs.byte_order_serialization(false);
    bvs.gap_length_serialization(false);
    bvs.set_compression_level(4);
    unsigned char* buf1 = serialize_bvector(bvs, bv1);
    unsigned char* buf2 = serialize_bvector(bvs, bv2);
    // Serialized bvectors (buf1 and buf2) now ready to be
    // saved to a database, file or send over a network.
    // ...
    // Deserialization.
    bm::bvector<>  bv3;
    // As a result of desrialization bv3 
    // will contain all bits from
    // bv1 and bv3:
    //   bv3 = bv1 OR bv2
    bm::deserialize(bv3, buf1);
    bm::deserialize(bv3, buf2);
    print_statistics(bv3);
    // After a complex operation 
    // we can try to optimize bv3.
    bv3.optimize();
    print_statistics(bv3);
    delete [] buf1;
    delete [] buf2;
    return 0;
}

What are your plans for BitMagic further development?

We want to implement some new vector compression methods with parallel data procession capability.

In view of the mass expansion of Intel Core i5-i7-i9, it would be reasonable to release a SSE 4.2 version of the library. Intel has added some interesting features that can be used very efficiently. The most promising feature is hardware support for bit number calculation (Population Count).

We are experimenting with nVidia CUDA and other GPGPUs. Today graphic cards enable you to perform integer and logical operations - and their resources can be harnessed for algorithms working on data sets and compression.

References

Elias Gamma encoding of bit-vector Delta gaps (D-Gaps). http://bmagic.sourceforge.net/dGap-gamma.html
Hierarchical Compression. http://bmagic.sourceforge.net/hCompression.html
D-Gap Compression. http://bmagic.sourceforge.net/dGap.html
64-bit Programming And Optimization. http://bmagic.sourceforge.net/bm64opt.html
Optimization of memory allocations. http://bmagic.sourceforge.net/memalloc.html
Bitvector as a container. http://bmagic.sourceforge.net/enum.html
128-bit SSE2 optimization. http://bmagic.sourceforge.net/bmsse2opt.html
Using BM library in memory saving mode. http://bmagic.sourceforge.net/memsave.html
Efficient distance metrics. http://bmagic.sourceforge.net/distopt.html

Intel Software Network at SuperComputing SC09

Thu, 19 Nov 2009 08:00:53 -0800

Intel Software Network at Supercomputing 09! Visit Intel at Booth #1935, and the Intel Academic Program in the SC Education Booth (Lobby C).

Please Join Intel and the Intel Academic Community at Supercomputing 09 in Portland Oregon. We are sponsoring keynotes, talks, and sessions. Many of our events will be available live and on line, see below, and of course, if you are attending, please visit us in person.

Intel Academic Community Sponsored Talks

Tuesday, November 17 5:00-6:30 PM Room C124	Friday, November 20 10:30 AM-12:00PM Room PB252
*Teach Parallel: Developing a Curriculum for Parallelism, Moderator: Tom Murphy* (Contra Costa College) Dr. John Gustafson (Intel Labs) Robert Chesebrough (Intel) Dr. Jim Larus (Microsoft) Dr. Bill Dally (NVIDIA) Dr. Simon McIntosh-Smith (Bristol University)	*Preparing the World for Ubiquitous Parallelism* Moderator: Dr. Matthew Wolf (Georgia Institute of Technology) Dr. Benedict Gaster (AMD) Kevin Goldsmith (Adobe Systems Inc.) Dr. Charlie Peck (Earlham College) Dr. Steven Parker (NVIDIA) Dr. Michael Wrinn (Intel Corporation) Dr. Evan Smyth (DreamWorks)

Intel Software Network TV

Intel Software Network TV will stream many of the keynotes and invited talks live as well as conversations with key attendees. When not streamling live, you will see encore presentations of past episodes - see the Schedules below (all times Pacific). All events can be seen live below, on Intel Software Network TV, or on the Supercomputing Education Website.

Teach Parallel! - Intel Academic Community & Supercomputing Education

Join us live in Person - All broadcasts will take place in Supercomputing Education Booth (Lobby C).
Teach Parallel is a cooperative production of Supercomputing Education and the Intel Academic Community
Questions and discussion from the audience will be encouraged.

Time	Tuesday, November 17	Wednesday, November 18	Thursday, November 19
Teach Parallel! - with Paul steinberg & Professor Tom Murphy All major manufactures of CPUs, GPUs and ASICs have moved to a many core design, yet universities and colleges are not training engineers in the parallel and concurrent disciplines needed to efficiently program on such systems. What can be done to bring parallelism into the mainstream? Join Paul & Tom and the experts below as they discuss Paralleism, Technology and Education.
1:00 PM	Dr. Wilf Pinfold, General Chair, Super Computing Conference 09	Dr Evan Smyth, Principal Software Engineer, DreamWorks Animation	Dr. Daniel Ernst, University of Wisconsin, Eau-Claire
1:30 PM	Dr. Joel Adams, Department of Computer Science Calvin College	Dr. Charlie Peck, Earlham College	Laura McGinnis, Supercomputing Education Chair, 2010
2:00 PM	Dr. Tim Mattson, Intel Principal Engineer.	Jason Arviso, Navajo Technical College, Internet to the Hogan	Dr. John Gustafson, He's not just a scientist, he's a law!
2:30 PM	Dr. Dan Reed, Microsoft, Director of Multicore Research.	Dr. David O'Hallaron, Director, Intel Labs Pittsburgh. Professor, Computer Science, Carnegie Mellon University	Parallel Octave
3:00	Prize drawing! Prize drawing! Prize drawing!
3:05 PM	Dr. Jesse Bemley, former National BDPA(Black Data Processing Associates) Education Chairperson. Developer the High School Computer competition (HSCC) program	Dr. Matt Wolf, Research Scientist CERCS Center for Experimental Research in Computer Systems.	Todd Rosenquist, Senior Technical Consulting Engineer, Intel Math Kernel Library
3:30 PM	Dr. James Reinders, Intel Chief Software Evangelist.	Dr. Charlie Peck, Earlham College	Dr. Paul McKenney, Distinguished Engineer at IBM Linux Technology Center
4:00 PM	Dr. Robert M. Panoff, founder and Executive Director of The Shodor Education	Werner Krotz-Vogel, Technical Marketing Engineer at Intel for Intel® Cluster Tools	Dr. Rebecca Hartman- Baker
4:30 PM

Intel Booth Theater Presentations:

Join us in our in-booth theater (booth #1935) at Supercomputing to hear free presentations throughout the show!
Download the Theater Schedule PDF (427 KB)

_______________________________________________________________________________________________
Here are a few of our scheduled sessions:

PANEL: Preparing the World for Ubiquitous Parallelism
Moderator: Matthew Wolf (Georgia Institute of Technology)
Panelists: Benedict Gaster (AMD), Kevin Goldsmith (Adobe Systems Inc.), Tom Murphy (Contra Costa College), Steven Parker (NVIDIA), Michael Wrinn (Intel Corporation)
Friday, 10:30AM - 12:00PM
Room PB252

The complete list of Intel panels, talks, BOFs and events can be downloaded: Download the Intel talk schedule, PDF (427 KB)

Our latest Intel @ Supercomputing 09 blogs:

In the Company of Friends, by Tom Murphy. (Your invitation to the Panel Discussion, November 17th, 5:30pm, room C124)

Subscribe to the Intel Academic Community blog RSS feed

Intel Software Network Attendees at Supercomputing 2009 (partial list):

Paul Steinberg, Academic Community Manager (Pauls' blog, @psteinb on Twitter)

Aaron Tersteeg, Parallel Programming Community Manager (Aaron's blog, @Tersteeg on Twitter)

Arti Gupta, Visual Computing Community Manager (Arti's blog, @artigupta on Twitter)

James Reinders, Director Marketing and Business, Software Development Products (James' blog, @JamesReinders on Twitter)

Michael Wrinn, Manager, Innovative Software Education (Michael's blog)

Scott Apeland, Director, Developer Network Organization (Scott's blog)

Michael McCool, Software Architect (Michael's blog, @michaelmccool on Twitter)

Bob Chesebrough, Technical Course Architect, (Bob's blog)

Jennifer Teal, Marketing Manager (Jen's blog, @jenvteal on Twitter)

Bev Bachmayer, Intel Academic Community Europe Region (Bev's blog)

Zander Sprague, Intel Academic Community, Americas Region (Zander's blog, @ztsprague on Twitter)

Jerry Baugh, Technical Content Manager

Josh Bancroft, Intel Software Network TV (Josh's blog, @jabancroft on Twitter)

Maryann Iannitti, Manager, Marketing Programs (Maryann's blog)

Bill Pearson, Manager, Intel Software Network (Bill's blog, @billpearson on Twitter)

Amy Barton, New Media Communications (Amy's blog, YouTube, @amybarton on Twitter)

Intel Academic Community Black Belts at Supercomputing 2009:

Matthew Wolf, Georgia Tech University (Dr. Wolf's blog)

Tom Murphy, Contra Costa College (Dr. Murphy's blog, @wolfmurphy on Twitter)

Additional Links:

Diagnostic 269: invalid format string conversion

Wed, 18 Nov 2009 16:36:31 -0800

Casue:

This warning is triggered by a printf or scanf format specifier that is not appropriate for the type of the variable being printed.

Example:

#include <stdio.h>

int main() {
   long int li = 0;
   printf("%l\n",li);     // %l is the size specifier; the type specifer is missing
   printf("%ld\n",li); // OK
   return 0;
}

> icl -c /W4 diag269.cpp
Intel(R) C++ Compiler Professional for applications running on IA-32, Version 11.1 Build 20090511 Package ID: w_cproc_p_11.1.035
Copyright (C) 1985-2009 Intel Corporation. All rights reserved.

diag269.cpp
diag269.cpp(5): warning #269: invalid format string conversion
printf("%l\n",li);
^

Resolution :

Use proper type specifier.

Diagnostic 181: argument is incompatible with corresponding format string conversion

Wed, 18 Nov 2009 16:23:47 -0800

Cause:

This warning is triggered by a printf or scanf format specifier that is not appropriate for the type of the variable being printed.

Example:

#include <stdio.h>

int main() {
   unsigned int ui = 0;
   printf("%f\n",ui); // %f is for a double type, not an unsigned integer type
   printf("%u\n",ui); // OK
   return 0;
}
> icl -c /W4 diag181.cpp
Intel(R) C++ Compiler Professional for applications running on IA-32, Version 11.1    Build 20090511 Package ID: w_cproc_p_11.1.035
Copyright (C) 1985-2009 Intel Corporation. All rights reserved.

diag181.cpp
diag181.cpp(5): warning #181: argument is incompatible with corresponding format string conversion
printf("%f\n",ui);
^

Resolution :

Use the proper type specifier.

Diagnostic 319: name followed by "::" must be a class or namespace

Wed, 18 Nov 2009 15:24:43 -0800

Cause:

This diagnostic occurs when a qualifier is not preceded by a class or namespace name.

Example:

class C {
static int i;
};

typedef int Foo;

int Foo::i; // error -- Foo is not a class or namespace

> icl -c diag319.cpp
Intel(R) C++ Compiler Professional for applications running on IA-32, Version 11.1 Build 20090511 Package ID: w_cproc_p_11.1.035
Copyright (C) 1985-2009 Intel Corporation. All rights reserved.

diag319.cpp
diag319.cpp(7): error: name followed by "::" must be a class or namespace name
int Foo::i;
^

Resolution:

Quality the name correctly. For example:

int C::i; // ok, C is a class name

Diagnostic 109: expression must have (pointer-to-) function type

Wed, 18 Nov 2009 15:13:47 -0800

Cause:

This error is reported when the compiler sees a function call but the identifier in the
function call is not a function name or function pointer.

Example:

void foo(void* p) {
p(); // p is being called as if it were a function but it is not a function

}

> icl -c diag109.cpp
Intel(R) C++ Compiler Professional for applications running on IA-32, Version 11.1 Build 20090511 Package ID: w_cproc_p_11.1.035
Copyright (C) 1985-2009 Intel Corporation. All rights reserved.

diag109.cpp
diag109.cpp(2): error: expression must have (pointer-to-) function type
p();
^

Resolution :
Ensure there is no syntax error and the function prototype exists.

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 <build path>/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.

error 409 when building boost libraries 1.40.0 with Intel compiler

Tue, 17 Nov 2009 19:21:42 -0800

Problem :
When building boost libraries version 1.40.0 with Intel compiler 11.1.046, the compiler report error #409 like below:

./boost/wave/cpplexer/re2clex/cpp_re2c_lexer.hpp(119): error #409: "boost::wave::cpplexer::re2clex::lexer<IteratorT, PositionT>::lexer(const IteratorT &, const IteratorT &, const PositionT &, boost::wave::language_support)" provides no initializer for:
const member "boost::wave::cpplexer::re2clex::lexer<IteratorT, PositionT>::cache"
{
^
detected during:
instantiation of "boost::wave::cpplexer::re2clex::lex_functor<IteratorT, PositionT>::lex_functor(const IteratorT &, const IteratorT &, const PositionT &, boost::wave::language_support) [with IteratorT=char *, PositionT=boost::wave::util::file_position_type]" at line 402
instantiation of "boost::wave::cpplexer::lex_input_interface *boost::wave::cpplexer::new_lexer_gen<IteratorT, PositionT>::new_lexer(const IteratorT &, const IteratorT &, const PositionT &, boost::wave::language_support) [with IteratorT=char *, PositionT=boost::wave::util::file_position_type]" at line 52 of "libs/wave/src/instantiate_re2c_lexer.cpp"

Environment :

Boost libraries version 1.40.0 for linux*
Intel C++ Compiler for linux, version 11.1.046

Root Cause :
Need initializer for const variable cache defined in file cpp_re2c_lexer.hpp, line 107. Refer this article http://software.intel.com/en-us/articles/cdiag409 for details.

Resolution :
This error no longer occurs with the Intel® C++ Compiler 11.1.059 for Linux*. As a workaround as well, you can add an initializer for the const variable cache in file boost/wave/cpplexer/re2clex/cpp_re2c_lexer.hpp. For example:

template <typename IteratorT, typename PositionT>
inline
lexer<IteratorT, PositionT>::lexer(IteratorT const &first, 
IteratorT const &last, PositionT const &pos, 
boost::wave::language_support language_) 
: filename(pos.get_file()), at_eof(false), language(language_),cache(token_cache< typename lexer < IteratorT, PositionT >::string_type >())
{
using namespace std; // some systems have memset in std
memset(&scanner, '\0', sizeof(Scanner));

Intel® Media Software Development Kit (Intel® Media SDK)

Tue, 17 Nov 2009 10:43:59 -0800

Q1: What did Intel announce?
A1: At the Intel Developers Forum, Intel announced the availability of the Intel® Media Software Development Kit (SDK), a tool specifically designed for software developers of media applications for video playback and encoding. Intel Media SDK enables developers to advantage of hardware acceleration in Intel platforms and future-proofs the software by allowing developers to program once and enjoy performance gains on future Intel processors and graphics chipsets.

Q2: What are the benefits to using Intel Media SDK?
A2: Developers using Intel Media SDK no longer have to write separate code paths to tap into platform specific hardware acceleration to improve video performance. The Intel Media SDK features a single API that streamlines workflow and exploits hardware acceleration capabilities within Intel hardware. Additionally, applications integrating Intel Media SDK today will take advantage of hardware acceleration capabilities of future graphics processing solutions without rewriting the program code.

Q3: Is the Intel Media SDK setting the stage for future multi-core products?
A3: Intel Media SDK helps developers produce future-proofed code by using a single API that supports today's hardware as well as well as hardware that will be available in the future. This API is available for developers to evaluate now through membership in Intel's Visual Adrenaline developer program at www.intel.com/software/media.

Q4: Are there developers currently using Intel Media SDK to optimize their media applications?
A4: Yes, Intel has worked with a number of media application developers in the Alpha and Beta phases leading to this announcement. Developers including Corel*, CyberLink*, and Sonic* are just a few of the companies working with Intel to develop and refine this tool. These same developers have made public their intentions to use the Intel Media SDK in future products.

Q5: What platforms does Intel Media SDK support?
A5: Intel Media SDK supports a broad selection of hardware platforms including Intel Integrated Graphics chipsets (starting with Intel® G45/GM45 Express Chipsets), Intel® Architecture Processors (for software-based encode and decode) and third-party graphics platforms (through DLL extensions). Intel® Media SDK supports the Windows* Vista operating system (32-bit and 64-bit) with Windows* 7 support planned for a future release.

Q6: Does the Intel Media SDK tool work with non-Intel graphics?
A6: The API within the Intel Media SDK is extensible, allowing development teams to create dynamic link libraries (DLL) that support platform-specific implementations, including hardware from third party vendors.

Q7: What is the pricing for the Intel Media SDK?
A7: The Intel Media SDK is a free download to members of the Visual Adrenaline Developer program. The Visual Adrenaline Developer program is a no-cost, individual membership offering visual computing developers insight on Intel's software tools, community interaction and developer support. For more information on the Visual Adrenaline developer program visit: http://intel.com/software/graphics/. For information on downloading the Intel Media SDK, visit http://www.intel.com/software/media/.

Q8: What video codecs does Intel Media SDK support?
A8: Intel Media SDK supports encode of AVC/H.264/MPEG-4 part 10 (an international standard for compressing/decompressing video) and MPEG-2 video and decode support for AVC/H.264, MPEG-2 video, and VC-1.

Q9: Does Intel Media SDK support any video pre-processing features?
A9: Yes, Intel Media SDK supports pre-processing functions, including: Inverse Telecine, Scene Detection, Deinterlacing, Denoising, Resizing and Color conversion.

Q10: How does Intel Media SDK work when no hardware acceleration is available?
A10: When hardware is not present for acceleration of decode or encode, Intel Media SDK will fall back to using software. This software will function on legacy and non-Intel CPUs. It is designed to not degrade performance on those non-Intel CPUs, but is not optimized for performance. Performance optimization is included for Intel processors and is fully threaded and utilizes a heritage of software encoders and decoders within the Intel® Integrated Performance Primitives (Intel® IPP) product.

Q11: Does Intel Media SDK software fall back on use of Intel® Streaming SIMD Extensions (Intel® SSE)?
A11: All instruction level optimizations for software fallback originate from Intel® Integrated Performance Primitives (Intel® IPP). Intel guarantees functionality on competitive processors; however performance optimizations are designed for Intel processors. Intel Media SDK 1.0 supports instructions up to Intel® Streaming SIMD Extensions 4.1 (Intel® SSE 4.1).

Q12: Is H.264 optimized for transmission latency?
A12: Intel Media SDK is not optimized for offline video editing, transcoding or video playback usages for streaming or video conferencing usage models where latency would be a focus.

Q13: Why limit support to the Microsoft Windows* operating environments?
A13: Intel is first supporting the Microsoft Windows Vista operating system (32-bit and 64-bit) with Microsoft Windows* 7 support planned for a future release. Intel continues to monitor customer feedback and will factor customer needs into future product plans.

Q14: Does the Intel Media SDK support Apple Mac OS and Apple platforms based on Intel hardware?
A14: For Intel's initial version of Intel Media SDK we chose to support Windows Vista and in the future will support Microsoft Windows 7 in order to support a broad customer base with the first release. Intel continues to monitor customer feedback and will factor customer needs into future product plans.

Q15: How can I use my own SW library for encoding or decoding instead of using the Intel supplied library?
A15: Replace libmfxsw32.dll or libmfxsw64.dll with your own SW library DLL. Use the same naming, and place into your unique install directory.