Intel Threading for Multi-Core Community

Intel® Threading Challenge 2009 - First 4 Winners

Thu, 02 Jul 2009 12:10:28 -0700

Problem #4 - String Matching - Winner Announced:

Congratulations to "BradleyKuszmaul" who is our 4th problem winner.

Problem #3 - Searching - Winner Announced:

Congratulations to "denghui0815" who is our 3rd problem winner.

Problem #2 - 3SAT - Winner Announced:

Congratulations to "haojn" who is our 2nd problem winner.

Problem #1 - Radix Sort - Winner Announced:

Congratulations to "denghui0815" who is our 1st problem winner.

Joe Duffy architect of Parallel Extensions to .NET & author of "Concurrent Programming on Windows" on Parallel Programming Talk

Thu, 02 Jul 2009 12:06:39 -0700

Aaron & Clay talked with Joe Duffy of Microsoft on the 37th episode of Parallel Programming Talk of Parallel Programming Talk. Joe Duffy is the lead developer and architect for Parallel Extensions to .NET. He is the author of two books: Concurrent Programming on Windows and Professional .NET Framework 2.0.

Major Software Tools Update to Intel Compilers and Libraries

Thu, 02 Jul 2009 12:05:13 -0700

On June 23 Intel Software Product Division released updates for our C++ and Fortran compilers, Intel Math Kernel (MKL) and Intel Integrated Performance Primitives (IPP) libraries and Cluster toolkits. Noteworthy additions include outstanding performance enhancements, support of Intel® Advanced Vector Extensions (AVX) and inclusion of some elements that debuted in Intel® Parallel Studio last month.

Features to note including our AVX and AES support in the tools, our adaptation of some of new features from Parallel Studio to Linux and Mac OS X, and really great tuning of our performance leading MPI library.

The specific new product versions are:

Intel® Professional Edition Compilers 11.1 (Fortran & C/C++, for Windows, Linux, Mac OS X)
Intel® Integrated Performance Primitives (IPP) 6.1 (for Windows, Linux, Mac OS X)
Intel® Math Kernel Library (MKL) 10.2 (for Windows, Linux, Mac OS X)
Intel® Cluster Toolkit, Compiler Edition 3.2.1 (for Windows, Linux)
Intel® MPI Library 3.2.1 (for Windows, Linux)

Q&A from Webinar: Find Errors in Windows* C++ Parallel Applications

Tue, 30 Jun 2009 16:56:46 -0700

Q1. Can you disable a single specific parallel region?

A: The "Serialize Parallel Region" option of the Intel(R) Parallel Debugger extensions temporarily sets the OpenMP* omp_set_num_threads() environment variable to 1, thus forcing single threaded execution even on a multi-core system. This temporary change applies to the next parallel block or parallel region in your code relative to the current EIP or program counter location.

Thus, yes - the "Serialize Parallel Region" option can be applied to a specific parallal region of your choice. You can do so by setting a breakpoint just before you enter the parallel region you would like to have executed as a single serial thread and then selecting the serialization option from the Intel(R) Parallel Debugger Extension menu inside Microsoft* Visual Studio.

Q2. Do the Parallel Debugger Extensions only support OpenMP* or also native Windows* threads or Threading Building Blocks?

A: Most of the Parallel Debugger Extension features like Thread Data Sharing Event Detection, Function Reentrancy Detection amd Serialize Parallel Region, rely on instrumentation of debug information and on the OpenMP* library. As such these features are currently only available for OpenMP* based threading. The one feature that is independent of the threading model used are the enhanced and highly configurable SSE register windows.

Q3. Do the Intel(R) Parallel Debugger Extensions use similar instrumentations as the Intel(R) Parallel Inspector?

A: The debug symbol information instrumentation done by the Intel(R) C++ Compiler when the /debug:parallel option is set along with /Zi is different from the code instrumentations used by the Intel(R) Parallel Inspector for it's instrumentation assisted operating mode.
The Intel(R) Parallel Debugger Extensions do not rely on executable code instrumentation, but rather on instrumentation of the symbol information used for debugging. As such the Parallel Debugger Extensions cannot statically anaylze the execution flow, but rely on a detectable event that may be of interest happening at real time during a debug session. At the same time, because only the debug information is instrumented there should only be very minimal performance impact on the execuatble if run outside the Microsoft* Visual Studio Debugger.

Q4. Is the compiler option /Qpenmp required for use of the Intel(R) Parallel Debugger Extension?

A: Yes, all enhanced parallelism features of the Intel(R) Parallel Debugger Extensions rely on OpenMP* based threading, except for the SSE register windows.

Q5. Do the Intel(R) Parallel Debugger Extensions require the use of the Intel(R) Compiler?

A: Yes, the Parallel Debugger Extensions rely on debug info instrumentation added with the Intel(R) Compiler option /debug:parallel in conjunction with /Qopenmp. Therefore the full capabilities of the Intel(R) Parallel Debugger Extensions are only available when used with the Intel(R) Compiler.

Q6. Can I use the Intel(R) Parallel Debugger Extensions to debug parallelism in the Intel(R) Integrated Performance Primitives and to serialize execution in them?

A: In principle yes, BUT this would require rebuilding and relinking the Intel(R) IPP with symbol information and /debug:parallel. Since you are most likely taking the primitives from prebuilt libraries that you link into your project, this not really a supported usage model, although it may work in some cases depending on how the call to the Intel(R) IPP function of your choice is embedded in the rest of your application.
The short answer thus is really no, with some exceptions.

Q7. Does the OpenMP* library have to be linked in statically? Can 3rd party OpenMP* libraries be used?

A: The OpenMP* library can be linked in statically or dynamically into your application build for the use of the Intel(R) Parallel Debugger Extension. The OpenMP* library used by the Intel(R) C++ Compiler is really a standard OpenMP* library. However, there is the dependency on the debug information instrumentation using /debug:parallel. This instrumentation has only been tested and is only expected to work with the OpenMP* libraries provided with the Intel(R) Compiler.

Q8. What is the main benefit of the SSE Register Window? Does it depend on OpenMP*?

A: The SSE Register Window allows you to group the display of the register contents and display said contents in the exact way that you are using it in your parallelized loops, your structured arrays or other parallel structures. By doing this the highly configurable SSE Register Window provides you with the link between your data as it is used in your application and the way this very same data is actually stored and processed in the SSE registers.

This can be quite valuable for understanding more complex heavily parallel multimedia or graphics code for instants.

This feature does not rely on any instrumentation or any specific threading implementation. It is independent of OpenMP*.

For additional questions please also refer to the Intel(R) Parallel Debugger Extension article and whitepaper at http://software.intel.com/en-us/articles/parallel-debugger-extension/

Intel and IBM Collaborate to Boost Performance Lower Power Consumption

Thu, 25 Jun 2009 12:55:12 -0700

Abstract

Timely, trusted information is the currency of success at all levels of business. But increasing data volumes are making it more difficult to deliver that information. And as data volumes go up, so do the costs of data management. For more than a decade, IBM and Intel have collaborated to optimize enterprise solutions: Complete, cost-effective, performance-optimized stacks of IBM® Information Management software running on servers powered by Intel® processors. Our relentless pursuit of performance has led to some impressive results. Compared to what customers could purchase just over a decade ago, they can now benefit from over 600 times the transaction performance from IBM DB2® on Intel-based servers at nearly 99 percent less cost per transaction.

Download Full PDF

Intel and IBM collaborate to boost performance lower power consumption [PDF 256kb]

Customer Testimonials

"Wherescape was founded about 11 years ago in 1998 entirely for the purpose of helping customers expedite the process of creating, building, and managing their data warehouses."
Video Script
Mark Budzinski
VP & GM
WhereScape USA, Inc.

Data Warehousing

"We had a customer last year who purchased a bigger server for their data warehouse because they needed more bandwidth for daily processing and couldn’t put it into their datacenter because it wouldn’t physically fit into the room."
Jason Laws
Chief Architect
WhereScape Inc.

"They say the most expensive server you’re gonna purchase is the one that causes you to build your next datacenter. A lot of people are looking to take their existing datacenter foot print, try and cost reduce it as much as possible."
Shannon Poulin
Director, Xeon Platform Marketing
Intel Corp.

Intel® Xeon® Processor 5500 Series

The way that you do that is you put in these new Xeon 5500 series servers that consume lower energy.

Energy Savings

or the same energy as the ones they were replacing but deliver more performance.

Intelligent Performance

"The intelligent performance of the chips saves energy by turning off processors when they’re not being used. Power isn’t being used unnecessarily to run processors that are doing nothing."
Jason Laws

Intel-IBM Relationship

"We have a long history of working together of creating unique innovation where we can get the best of DB2 working together with the best of Intel. We have delivered a whole new level of innovation with DB2 9.7 on the Intel Xeon Processor 5500 Series."
Berni Schiefer
Distinguished Engineer
IBM, Inc.

"The Xeon 5500 series, that provides almost 80% better performance over the previous generation of processors –producing outstanding results, lowering the cost of operation for our clients."
Sal Vella
VP Development DB2
IBM, Inc.

"And we’ve been able to do that at nearly a 50% improvement in performance per watt."
Shannon Poulin

"We’ve shown not only that you can achieve superb performance results by combining the DB2 product with the Intel processor but we were able to do that with an absolute minimum amount of tuning."
Berni Schiefer

"We have a self-tuning memory manager that looks at the system memory and says, where should I allocate it for best performance depending on the kind of workload? So terrific technology automating things that normally the database administrator would have to do themselves."
Sal Vella

Solution Migration

"This migration is actually pretty easy. We have a partner in China called NewSoft. The sizing to build the solution was 25-person years which is pretty significant. We did it over a weekend with one guy. That is how easy it is to get to DB2 9.7."
Boris Bialek
Program Director, Data Management Solutions
IBM, Inc.

Compression Technologies

"We are industry leading in terms of our compression technologies and capabilities. In DB2 9.7 we’ve really extended that to a whole new level. The rule of thumb for a data warehouse is that a third of the size of the database is in your data tables; another third is in your indexes; another third is in temp space. So in 9.7 we’ve addressed the other two-thirds, really, of that triangle. We’ve introduced compression for indexes and compression for temporary tables and have gotten fantastic results."
Richard Hedges
Dir. of New Development – DB2
IBM, Inc.

"And when we did some tests with compression we found the new DB2 9.7 and the new Xeon 5500 series processors were a lot faster during compression on large tables."
Jason Laws

Increased Performance

Every test we did was faster. In fact some of the tests they ran twice as fast.

"It’s a huge cost savings for our clients, in many cases resulting in millions of dollars of savings."
Sal Vella

Intel® Xeon® Processor 5500 Series
IBM DB2® 9.7
Energy Savings
Intelligent Performance
Compression Technologies
Ease of Use

"And when you really consider what’s going on now with Intel’s intelligent performance, you consider that with what IBM is up to with 9.7 DB2, goodness, this is not business as usual. This is really game changing technology. That when appropriately applied you can get the performance gains that are truly remarkable but do it in such a way that you are managing your power requirements and your other costs as well. "
Mark Budzinski

June 30th Parallel Programming Talk - MS Parallel Extensions to .NET and MS Task Parallel Library

Fri, 19 Jun 2009 11:30:44 -0700

On the June 30th Parallel Programming Talk Joe Duffy from Microsoft will discuss the MS Parallel Extensions to .NET and MS Task Parallel Library. Joe is a rock star among .Net C# developers. He is the lead developer and architect for Parallel Extensions to .NET. He is the author of two books: Concurrent Programming on Windows and Professional .NET Framework 2.0 We’ll be talking to Joe about his thoughts and experiences with threading applications for the Windows environment, especially with regards to the .NET Framework.

Tune is LIVE on June 30th at 8:00AM PST

Research@Intel Day Showcases Parallel Programming

Fri, 19 Jun 2009 11:22:45 -0700

June 18, 2009 was Research@Intel day. Many great hardware and software ideas were demoed at the event. I think that you'll be most interested in the Immersive Connected Experience Zone where out software teams were presenting two key demos of two experimental Parallel Programming Tools, both were applied to optimize computer vision. The first was Concurrent Collections for C++ which is a new language to describe parallel computations. The second is Ct Technology that extends C/C++ to simplify data parallel programs. Read my blog post to learn more.

High Performance XML Processing and Bulk Loading to Oracle System with Microsoft Integration Services

Wed, 17 Jun 2009 13:48:42 -0700

A common pattern when processing data electronically is parsing the data, applying certain rules, and then loading to destination systems. Hand coding a data processing solution in 3GL (C#, C++, VB, Java**and so forth) requires substantial coding effort to develop and maintain the system. In addition, handling large input files (XML or any other format) require careful considerations on efficiently processing the data.

Microsoft* Integration Services addresses this problem by providing a powerful environment for visually building the solution with minimal coding effort.

Another key factor that impacts scalability is the number of round trips to the database. One round trip per row to the database seriously limits the throughput of an application. Processing data in batches by sending several rows worth of data in a single database round trip allows an application to scale efficiently. However, bulk loading to Oracle* from Integration services framework today requires the use of third party components. In this white paper, we are going to look at a solution option for building high throughput application to parse large XML files and perform bulk load to Oracle database.

XML Processing

Typical 3GL approach to XML processing would involve understanding the schema and parsing the elements of interest from the XML instance. While small-medium documents can be loaded as in-memory trees, large documents would require streaming or chunking to efficiently process the input. Writing the code in 3GL would require understanding these important details and hand coding an appropriate solution.

Integration services software on the other hand, hides the complexity involved in parsing an XML and exposes XML as in-memory relational table. Large XMLs are mapped to in-memory table by transparently allocating memory for the rows in use and freeing up the memory once the batch of rows is consumed.

Oracle* Bulk Loading

When an application needs to insert (and update) several rows of data, it is optimal to process several rows of data in one round trip. This bulk processing or fast load capability allows an application to scale efficiently.

Performing bulk operation, also known as Array Binding, is relatively straight forward with ODP.NET drivers as described in this How to: Bind an Array to an ODP.NET Database Command article.

Performing bulk operations in Oracle from Integration Services requires few additional steps and coding. The rest of this paper discusses throughput numbers and a code sample on how to perform bulk operation through integration services.

Unit and Bulk Performance Characterization

The "Customers" table available Oracle SH schema was used as a test bed for validating bulk insert using Integration Services. This table has 24 columns of mixed numeric and varchar data types.

Input XML File

The data to be loaded to Customers table was in XML format with each XML file having several rows of data.

Performance

The table and chart summarizes the performance difference between row-by-row processing and bulk load processing in integration services with Customers Data set.

Please note that several factors influence the overall performance and depending on the number of columns and column length, appropriate batch size needs to be selected.

Rows/File	File Size (MB)	Row-By-Row Insert (Seconds)	Row-By-Row Throughput (Rows/Second)	Bulk Insert Time (Seconds)	Bulk Load Throughput (Rows/Second)
500	0.52	2.6	192.31	1.8	277.78
1,000	1.03	4.1	243.90	1.8	555.56
2,000	2.07	7.2	277.78	2.3	869.57
5,000	5.17	14.8	337.84	3.3	1,515.15
10,000	10.33	28.0	357.14	4.8	2,083.33

Code Approach

A custom destination Script Component available under Data Flow Transformations was used for implementing the bulk insert logic.

The destination script component, by default, provides three methods:

public override void PreExecute()
public override void PostExecute()
public override void Input0_ProcessInputRow(Input0Buffer Row)

All these methods are automatically invoked by the integration services data flow pipeline during appropriate events:

PreExecute - Preparing the custom destination component to consume data

Input0_ProcessInputRow - Invoked for every row that arrives in the pipeline

PostExecute - After all rows are processed, this method is invoked to perform cleanup.

At this point, all that needs to be done is allocate buffers within this script component class and populate the buffers whenever a new row arrives. Once, the number of rows reaches the defined batch size, stored procedure is invoked to pass the buffered data using array binding technique available in ODP.NET.

[Microsoft.SqlServer.Dts.Pipeline.SSISScriptComponentEntryPointAttribute]
public class ScriptMain : UserComponent
{
  
    private OracleConnection _conn;
    private OracleTransaction _tx;
    private int _rowCount;
    private int _rowsPerRoundTrip;
    private int _iterations;

    // Define buffers for all the columns
    private int[] countryId;
    private string[] custCity;  
    private int[] custCityId;
    ….
    public override void PreExecute()
    {
        base.PreExecute();
        _rowCount = 0;
        _rowsPerRoundTrip = <read from configuration variable>;
        _iterations = 0;

        string connectionString = <read from configuration variable>;
        _conn = new OracleConnection (connectionString);
        _conn.Open();

	  // Allocate space
        countryId = new int[_rowsPerRoundTrip];
        custCity = new string[_rowsPerRoundTrip];
        custCityId = new int[_rowsPerRoundTrip];
   …..
    }
// Make sure that the last batch of rows are processed and loaded to database
    public override void PostExecute()
    {
        base.PostExecute();
        if (_rowCount > 0)
        {
            LoadData();
        }

        _conn.Close();
    }

// Process the incoming rows and copy to buffer
public override void Input0_ProcessInputRow(Input0Buffer Row)
    {
        countryId[_rowCount] = Row.COUNTRYID;
        custCity[_rowCount] = Row.CUSTCITY;
        custCityId[_rowCount] = Row.CUSTCITYID;
        …..
  _rowCount++;

        if (_rowCount > _rowsPerRoundTrip - 1)
        {
            LoadData();
        }        
    }
// Function to invoke database stored procedure
private void LoadData()
    {
        _tx = _conn.BeginTransaction();

        OracleCommand cmd = new OracleCommand("Stored Proc Name", _conn);
        cmd.CommandType = CommandType.StoredProcedure;
        cmd.ArrayBindCount = _rowCount;

        OracleParameter pcountryId = new OracleParameter("pi_country_id", OracleDbType.Int32);
        pcountryId.Direction = ParameterDirection.Input;
        pcountryId.Value = countryId;
        cmd.Parameters.Add(pcountryId);
   ….
  cmd.ExecuteNonQuery();
        cmd.Dispose();

        _rowCount = 0;

  _tx.Commit();
}
// Oracle Stored Procedure definition
CREATE OR REPLACE PROCEDURE proc_insert_customer
       (pi_country_id           IN number,
        pi_cust_city           IN VARCHAR2,
        ...
        ) IS
BEGIN

insert into customers(cust_id, cust_first_name, cust_last_name,....)
   values (pi_cust_id,pi_cust_fname,pi_cust_lname,...);

END;

Conclusion

In this paper, we saw how custom Oracle Bulk Processing capability can be incorporated in to Integration Services while leveraging integration services for parsing XML data and preparing the data for backend systems.

This mix provides an efficient mechanism to build scalable applications on Intel® Platforms while reducing the time-to-market.

About the Author

ChandraMohan Lingam (Chandra) is an Architect at Intel where he works for the Technology Development Group developing solutions to address Intel's manufacturing needs. Chandra has a MS degree from Arizona State University, Tempe and a Bachelors Degree in Engineering from Thiagarajar College of Engineering, Madurai, India.

Download article as a PDF file (130 KB).

*Other names and brands may be claimed as the property of others.

Taming a Terabyte of XML Data

Fri, 12 Jun 2009 12:50:54 -0700

Enterprises today are struggling to manage the increasing volume of XML data they generate or consume. Intel and IBM have executed the industry's first terabyte XML database benchmark, based on a financial application scenario, which shows the feasibility of managing high volumes of XML data on cost-effective hardware.

By:

Matthias Nicola (mnicola@us.ibm.com), Senior Software Engineer, IBM Silicon Valley Lab

Agustin Gonzalez (agustin.gonzalez@intel.com), Senior Staff Software Engineer , Intel Corporation

Developer Training

Wed, 10 Jun 2009 14:02:22 -0700

Training on Parallel Programming for the Multi-Core World

Release the power of Multi-Core processors through our Multi-Core training series. Understand how to architect, design, develop and debug software for Multi-Core processors.

Online Training

Take our popular Moving to Multi-Core online course for free and be able to:
- Develop and maintain threaded applications more efficiently
- Thread applications for good performance on systems with and without Hyper-Threading
- Use threading tools to debug and optimize threaded applications

View our new series of parallel programming training videos and downloadable courseware: Three Things you must teach about Parallelism
These modules, developed by Intel Software College Architect Clay Breshears, cover basic content that any professor should teach when introducing parallel programming. While not designed specifically for engineers, this content should be of use for anyone seeking to understand the basicis of parallel programming on multi-core machines.

Recognizing Parallelism
Shared Memory and Threads
Programming with OpenMP

A visual guide to key concepts in threaded programming – Common problems and how to solve them Dr. Clay Breshears, senior parallel architect, Intel Software College, takes us through common threading problems and suggests how to plan for and solve them. Dr. Breshears also discusses a number of useful design patterns, illustrates how they work and suggest when they are most applicable to your applications.

A Gentle Introduction to Parallel Software or Enough with the Theory, Let's See Some Parallel Code Tim Mattson, Principal Engineer, Intel Corporation, introduces some of the best APIs and interfaces to allow you to build parallelism into serial code.

Take our three-part online Moving to Multicore series of courses

Take our Multithreading Quickstart: Application Threading for Java* and .NET* Programmers

Online parallelism and multi-core resources - Aaron Tersteeg, our Parallelism Community Manager chooses his favorite geting started content

Multi-threading for Game Developers - An Overview -- Two Intel senior engineers discuss how to conceptualize parrallelism within a complex computer Game

Learn More about Intel Parallel Tools

If you are a Faculty member looking for Academic Course content, please visit our Academic Community content site.

Other Resources

Articles:

Case Studies:

Participate in online discussions on developer topics on ISN TV

Live and archived events

If you have ideas for a webinar, or if you would like to suggest a colleague or yourself as a guest host, please let us know through a comment below or email me directly.