Come and join many Intel parallelization experts at the Intel Developer Forum (IDF) September 22-24, 2009 in San Francisco, including folks from the RapidMind and Ct technology team. Hear more about our plans to work with Ct technology and RapidMind. There will be a class by Intel’s Anwar Ghuloum and Amanda Sharp at IDF on Ct, which will soon to be available in beta for you to try out yourself. Ct folks, including me, will also be at Supercomputing 2009, where we will be hosting a Ct related BoF. If you’d like to be involved, please contact me here. Hopefully we’ll see you at these exciting events – your thoughts and feedback on our technology is always welcome!

Watch a special edition of Teach Parallel on Intel Software Network TV -- LIVE TUESDAY 7/21 at 11AM Pacific/2PM Eastern for interviews with Randy Asher, Principal of Brooklyn Technical High School, and Jeffrey M. Birnbaum, Managing Director, Global Head of Platform Solutions at Bank of America, live via webcam from New York.

http://intel.com/software/tv

As James Reinders posted last week, Parallel Programming is fundamental, so  High School, here we come!

For more, read the full story, "Are High School Whiz Kids Ready to 'Think Parallel?'"

• Release two versions of the package
• Extend the library with new features and algorithms including optimized functionality
• Extend a set of the library documentation with the Application Notes
• Extend number of examples that demonstrate the usage of the library
• Complete series of blogs that describe functionality and performance of the library

 We design the library keeping in mind three simple ideas:

• Information volumes substantially raises and will keep raising in all or almost all segments of human activity
• Necessity to quickly process information and make well found data based decisions is an integral part of business
• Up-to-date hardware and parallel algorithms can connect those two aspects and simplify our life

I believe that value of any product, directions for its development strongly depend on its usability in applications and its opportunity to address various problems.

I think we have reached the point where we need to look around and understand how well Intel® Summary Statistics Library implements those ideas.

To help us to understand how the library meets your expectations and requirements, to help us to align the tool with your needs I encourage answering 12 short questions available at
http://intelsoftwareproductsurvey.com/survey/149719/266d/.
The feedback would take a couple of minutes; on the other hand, your response is critical to the success of our product and will help to drive the future direction of the Intel® Math Kernel Library.

Hi,

Last year SunGard, Microsoft, DataSynapse and Intel collaborated on a 512 core test at Intel’s world class CRT Lab in DuPont, WA. SunGard’s industry leading Asset and Liability Management solution, Ambit BancWare ALM, demonstrated the ability to complete a 20,000 path simulation in less than 5 hours. That’s "game-changing" and highlights the world-class performance of Intel® Xeon® hardware platforms. For more information please refer to the following Microsoft case study: http://www.microsoft.com/casestudies/casestudy.aspx?casestudyid=4000003628

Thanks,

George

The need to write scalable applications has been important for programmers in the HPC community for years. Now, with the proliferation of multi/many-core processors and the availability of graphics adapters or data parallel accelerators with many ALU’s, scalability is a top priority for many programmers. But, as Andrew S. Tanenbaum stated at the USENIX ’08 conference, “Sequential programming is really hard” … the difficulty is “parallel programming is a step beyond that.”

So parallel programming is hard. Why would you want to do it more than once? That is where the idea of Intel’s Scaling Performance Forward idea comes from.

What is Scaling Performance Forward From Intel?

* It is using standards based tools to create applications that scale on both multi and many core architectures. This approach can provide a level of future proofing your software code.

* It is about writing software within a single software development environment and one source implementation, and in some cases, one binary, that, with the power of Intel software development tools, will scale-forward performance to future Intel platforms.

* It’s about using tools from Intel that can help you scale-forward performance to future platforms without requiring a massive rebuild – just drop-in a new runtime that is optimized for the new platform to experience the improvement (akin to the printer/display driver model, buy a new printer/display, install the respective driver, and your system enjoys improved benefits).

* It is about enabling an application to run on the appropriate or available architecture that is capable of delivering results in less total time than before.

Caveat Emptor
Intel’s platform roadmap supports scaling performance forward, but wildly different architectures with ALU’s may cause scaling forward to break-down.

I happen to agree with Andrew Tanenbaum – parallel programming is step beyond sequential programming. Understanding where, when and how to introduce parallelism into your software is always complicated and there are many ways to accomplish this. At Intel, we provide you with a complete set of integrated software tools that help you:
•Gain insight to where your best opportunities to introduce parallelism are
•Offer you proven methods to introduce parallelism and
•Increase your confidence with respect to eliminating race conditions and other circumstances that can inhibit your success in developing parallel software.

Finally we also have tools that can quickly and efficiently help you optimize your application performance after you have introduced parallelism. Are these tools easy to use? I am biased, but writing parallel software is hard to do, so making the tools easy to use is paramount.

Start work now to scaling your performance forward. We are there for you with tools that let you scale forward today. And we are leading the charge at the cutting edge of parallel computing research to produce even better technologies for the future.

To learn more about these software development tools and join the largest communities of parallel software developers go to http://intel.com/software/products.

One more comment and the subject of the next blog --- remember it is really not about kernel performance it is about total application performance.

When looking to parallelize your software make sure the return on your time spent parallelizing will influence the total application performance.

The theory and properties of this algorithm are described in [1]. In a nutshell, this method allows getting eps-approximate quantile (that is, the element in the dataset whose rank is within [r-eps*n, r+esp*n] interval for user-provided error eps, size of dataset n and any rank r=1,…,n) for price of one pass over the dataset. Another important aspect of the algorithm is in general case absence of the requirement to know the total size of the dataset in advance. 

To understand how the algorithm works, I developed a simple application. As usual, it passes through four basic important stages: creation of the task, edition of necessary task parameters, getting stat estimates, and de-allocation of the resources. I already described this model here and now demonstrate usage of the editor and computation of the estimate. 

For goals of my experiment I set dimension of the task p to 1 and chose total number of observations n=10,000,000. The dataset “arrives” in blocks of 10,000 elements each. My nearest task is to compute deciles with pre-defined error eps = 0.00001 (that is, I expect to get elements as decile estimates whose rank deviate from the “accurate” one by no more than 100 positions). 

The library contains special editor for this algorithm: 

status =  vsldSSEditStreamQuantiles ( task, &quant_order_n, quant_order, quantiles, &params_n, &params );

Array quant_order is initialized with order of quantiles: 0.1, 0.2, …, 0.9; total number of quantiles I would like to compute is quant_order_n=9. Results of the computations will be placed into array quantiles. Finally, the algorithm for computation of streaming quantiles accepts array of parameters. It contains one element, user-defined error eps which is 0.00001 in my case. To initialize size of array which contains parameters of the algorithm I use the macro defined in the library: params_n = VSL_SS_STREAM_QUANTILES_ZW_PARAMS_N.

The loop for computation of the deciles is as follows:

for ( block_index = 0; block_index < max_block_num; block_index++ )

{

// Get the next data block of size block_n

…

status = vsldSSCompute( task, VSL_SS_STREAM_QUANTILES,  VSL_SS_STREAM_QUANTILES_ZW_METHOD );

// Process computation results

…

}

Immediately after the processing of the next block I get intermediate estimates of deciles. In my case (my dataset contains Gaussian numbers with mean equal to 0 and variance 1) I have the sequence of the estimates:

Block   Streaming deciles:

index          D₁           D₂           D₃           D₄           D₅          D₆          D₇           D₈          D₉

1         -1.267162 -0.844286 -0.525791 -0.266775 -0.011528 0.252491 0.539124 0.849691 1.269578

2         -1.288032 -0.847845 -0.537461 -0.276688 -0.019232 0.240052 0.513117 0.832769 1.269036

3         -1.284862 -0.838628 -0.526169 -0.265614 -0.011068 0.242837 0.516336 0.836675 1.270469

…

…

998     -1.281560 -0.841417 -0.524175 -0.253100  0.000917 0.253695 0.524858 0.841297 1.281417

999     -1.281570 -0.841419 -0.524176 -0.253106  0.000914 0.253691 0.524859 0.841312 1.281418

1000   -1.281543 -0.841419 -0.524180 -0.253124  0.000888 0.253677 0.524839 0.841297 1.281397

Well, what if I do not need to know intermediate estimate of quantiles, and my goal - the estimate for the whole dataset? In this case the library gives me opportunity to use so called “Fast Mode” which allows me just to update the library internal data structures without actual computation of the intermediate estimates.  

for ( block_index = 0; block_index < max_block_num; block_index++ )

{

// Get the next data block of size block_n

…

status = vsldSSCompute( task, VSL_SS_STREAM_QUANTILES_FMODE,  VSL_SS_STREAM_QUANTILES_ZW_METHOD );       

} 

As soon as this loop completes I set block_n variable to zero (please, make sure that this variable was registered in the library during creation of the task or by means of the suitable editor) and call Compute procedure to get the estimates: 

block_n = 0;

status = vsldSSCompute( task, VSL_SS_STREAM_QUANTILES, VSL_SS_STREAM_QUANTILES_ZW_METHOD ); 

The result of this experiment is identical to the last line of the previous table: 

Streaming deciles:

        D₁            D₂           D₃           D₄           D₅          D₆          D₇          D₈          D₉     

-1.281543 -0.841419 -0.524180 -0.253124 0.000888 0.253677 0.524839 0.841297 1.281397

 Finally, I should check the accuracy of the estimates. For this reason I compute “accurate” deciles for the same dataset using the algorithm in the library intended for processing of in-memory datasets. The algorithm can return order statistics as well. Its output turned out to be as follows: 

“Accurate” deciles:

        D₁            D₂           D₃           D₄           D₅          D₆          D₇          D₈          D₉

 -1.281545 -0.841421 -0.524179 -0.253124 0.000889 0.253675 0.524842 0.841302 1.281399  

This is not enough, now I should compute maximal difference between ranks of “in-memory” and “out-of-memory” deciles. As you remember it should not be bigger than 100: 

Rank difference     

    D₁            D₂           D₃           D₄           D₅          D₆          D₇          D₈           D₉  

    4              5              3             1             3             7            8             7             4

 So, I’m absolutely satisfied with these estimates.  

References

[1]  Q. Zhang and W. Wang. A Fast Algorithm for Approximate Quantiles in High Speed Data Streams. SSDBM, p.29, 19th International Conference on Scientific and Statistical Database Management (SSDBM 2007), 2007.

The method for accurate processing of the datasets with missing points is based on the approach in [1]. Expectation-Maximization (EM) and Data Augmentation (DA) algorithms are integral components of this solution (let me call it EMDA solution). Output of the algorithm is m sets of simulated missing points which can be imputed into dataset, thus, producing m complete data copies. For each dataset one can compute a stat estimate of his interest; the final estimate is a combination of these m estimates.

The usage model for EMDA method is similar to that for other algorithms of the library and described here: creation of the task, editing its parameters, computing, and de-allocation of the resources. I show how to pass parameters of the EMDA method into the library and to call the Compute routine.  

EM algorithm does em_iter_num iterations to compute an initial estimate for mean and covariance which are then used to start DA algorithm. EM algorithm can terminate earlier if given accuracy em_accuracy is achieved. In its turn DA algorithm iterates da_iter_num times. It also uses Gaussian random numbers undeneath. For this reason Intel® Summary Statistics Library uses Vector Statistical Library (VSL) component of Intel® Math Kernel Library. BRNG, SEED, and METHOD are the parameters used to initialize VSL generators. Values of the parameters should follow VSL requirements. The EMDA algorithm also requires number of missing values missing_value_num. To compute it I pre-process the dataset and also mark missing values using macro defined in the library VSL_SS_DNAN (if I work in single precision floating point arithmetic I use VSL_SS_SNAN macro). Parameters of the algorithm are passed into the library as the array: 

    em_iter_num       = 10;

    da_iter_num        = 5;

    em_accuracy       = 0.001;

    copy_num           = m;

    miss_value_num   = miss_num;

    brng                     = BRNG;

    seed                     = SEED;

    method                = METHOD;

 

    mi_method_params[0] = em_iter_num;

    mi_method_params[1] = da_iter_num;        

    mi_method_params[2] = em_accuracy;       

    mi_method_params[3] = copy_num;          

    mi_method_params[4] = missing_value_num;

    mi_method_params[5] = brng;

    mi_method_params[6] = seed;             

    mi_method_params[7] = method; 

Editor for EMDA algorithm accepts set of parameters:

errcode=vsldSSEditMissingValues(task, &mi_method_params_n, mi_method_params, &initial_estimates_n, initial_estimates, &prior_n, prior, &simulated_missing_values_n, simulated_missing_values, &estimates_n, estimates);

Array mi_method_params is described above. Array of initial estimates initial_estimates is used to start EM algorithm; its first p positions are occupied with vector of mean and the rest p*(p+1)/2 entries hold upper-triangular part of variance-covariance matrix (p is dimension of the task). Array prior is intended to hold prior parameters for EMDA algorithm; current version of the library does not support user-defined priors, and default values are used. Sets of simulated missing points will be returned in array simulated_missing_values, in total m x missing_value_num values. Missing values are packed one by one, first all missing points for 1^st variable of random vector, then missing values for 2^nd variable, and so forth. To estimate convergence of DA algorithm one passes array estimates which will hold mean/covariance for all iterations and all sets of simulated missing points, in total m x da_iter_num x ( p + 0.5 x (p² + p) ). Each set of estimates is packed as above: first p positions are intended for mean, and the rest 0.5 x (p² + p) entries hold upper-triangular part of the covariance matrix.

Finally, EMDA algorithm is run using Compute routine of the library:

errcode=vsldSSCompute(task,VSL_SS_MISSING_VALUES,SL_SS_MULTIPLE_IMPUTATION);

To have an idea how this solution works I created the task with dimension p = 10 and number of observations n = 10,000. The dataset is generated from multivariate Gaussian distribution with zero mean and covariance matrix which holds 1 on the main diagonal and 0.05 in the rest entries of the matrix. Ratio of missing values in my dataset is 10%; each observation may have one lost point in any position. I’m going to generate m=100 sets of simulated lost points. Start “point” for EM algorithm is vector of zero means and identity covariance matrix; pointer to array prior is set to 0 (size of this array prior_n is also 0).

First, I did trial run of the algorithm with da_iter_num = 10 and analyzed estimates in array estimates. It turned out that number of iterations for DA algorithm can be decreased to 5. I then simulated 100 sets of lost values, imputed simulated values in the dataset and formed 100 complete arrays. For each complete dataset I computed means and variance using the algorithms of Intel® Summary Statistics Library, in total 100 sets of estimates for mean and covariance: 

Set:           Mean:                                

    1         0.013687  0.005529  0.004011 ...  0.008066

    2         0.012054  0.003741  0.006907 ...  0.003721

    3         0.013236  0.008314  0.008033 ...  0.011987

  ...                                                                                              

   99        0.013350  0.012816  0.012942 ...  0.004076

  100       0.014677  0.011909  0.005399 ...  0.006457

___________________________________________________                                                  

Average  0.012353  0.005676  0.007586 ...  0.006004 

Set:        Variance:                            

    1        0.989609  0.993073  1.007031 ... 1.000655   

    2        0.994033  0.986132  0.997705 ... 1.003134   

    3        1.003835  0.991947  0.997933 ... 0.997069   

   ...                                                                                               

    99      0.991922  0.988661  1.012045 ... 1.005406   

   100     0.987327  0.989517  1.009951 ... 0.998941   

________________________________________________                                                     

Average  0.99241   0.992136  1.007225 ... 1.000804

Between-imputation variance:

0.000007 0.000008 0.000008 ... 0.000007

Within-imputation variance:

0.000099 0.000099 0.000101 ... 0.000100   

Total variance:

0.000106 0.000107 0.000108 ... 0.000108   

 I also computed 95% confidence intervals for vector of means:

95% confidence interval:                          

Right boundary of interval: +0.032939 +0.026372 +0.028406 ... +0.026744

Left boundary of interval:   -0.008234   -0.015020 -0.013233 ...  -0.014736

I was curious to know how well the EMDA algorithm performs and repeated the same experiment 20 times. All 20 95% confidence intervals contained true value of mean. Sounds good, is not it?  

References

1. J.L. Schafer. Analysis of Incomplete Multivariate Data, Chapman & Hall/CRC, 1997.

Robust methods in Intel® Summary Statistics Library form solution which is presented with two algorithms, Maronna, [1] and TBS, [2]. First algorithm is used to compute start “point” (covariance and mean) for the second one. TBS algorithm allows iterating until necessary accuracy is achieved or maximal number of iterations is completed. In addition to these parameters one can specify and pass maximal breakdown point (number of outliers the algorithm can hold) and asymptotic rejection probability (ARP), [2] in the library. To avoid iterations of TBS algorithm and compute robust estimate of mean and covariance using just Maronna algorithm it is enough to set number of iterations to zero.

As usual, to use Intel® Summary Statistics Library we pass through 4 stages: creation of the task, edition of task parameters, computation of stat estimates, and de-allocation of the resources. As all these steps are described here I only show how to use the editor for robust methods and Compute routine. Parameters of the algorithms, breakdown point, ARP, accuracy and maximal number of TBS iterations are passed as an array:  

breakdown_point = 0.2;

arp                      = 0.001;

method_accuracy = 0.001;

iter_num              = 5;

 

robust_method_params[0] = breakdown_point;

robust_method_params[1] = arp;

robust_method_params[2] = method_accuracy;

robust_method_params[3] = iter_num;

We also need memory t_est and cov_est where the robust estimates will be stored. In the example below covariance matrix is stored in full format specified in variable robust_cov_storage.

errcode =  vsldSSEditRobustCovariance( task, &robust_cov_storage, &robust_params_n, robust_method_params, t_est, cov_est );

Computation of the estimates is done by means of Compute routine:

 errcode=vsldSSCompute(task, VSL_SS_ROBUST_COVARIANCE, VSL_SS_ROBUST_TBS_METHOD ); 

To have an idea how Intel® Summary Statistics Library manages with outliers I create the task with dimension p = 10 and number of observations n = 10,000. The dataset is generated from multivariate Gaussian distribution with zero mean and covariance matrix which holds 1 on the main diagonal and 0.05 in the rest entries of the matrix. I then contaminate the dataset with shift outliers that have multivariate Gaussian distribution with the same covariance matrix and vector of means all equal to 5.

Use of non-robust algorithm for covariance and mean estimation for this dataset results in biased estimates. There is no surprise to get zero p-values for these estimates.  

Means:

0.2566,0.2583,0.2576,0.2633,0.2439,0.2556,0.2530,0.2716,0.2535,0.2519

Covariance:

2.2540

1.2715 2.1819

1.2852 1.2462 2.2046

1.2885 1.2684 1.2553 2.2310

1.2850 1.2581 1.2571 1.2526 2.2112

1.2650 1.2284 1.2419 1.2820 1.2430 2.1929

1.2789 1.2435 1.2550 1.2555 1.2574 1.2478 2.2113

1.2773 1.2692 1.2676 1.2751 1.2725 1.2733 1.2739 2.2448

1.2813 1.2579 1.2688 1.2723 1.2670 1.2713 1.2839 1.3061 2.2246

1.2696 1.2631 1.2515 1.2701 1.2597 1.2686 1.2554 1.2638 1.2780 2.1893

Use of Maronna algorithm (that is iter_num=0) results in the following estimates:

Means:

-0.0022,0.0081,-0.0075,0.0049,-0.0054,0.0012,-0.0087,0.0194,-0.0073,0.0022

p-values for means:

0.1792 0.6077 0.5640 0.3869 0.4281 0.1014 0.6375 0.9570 0.5602 0.1846  

Covariance:

0.9164

0.0605 0.8945

0.0617 0.0374 0.9269

0.0602 0.0570 0.0472 0.9294

0.0584 0.0469 0.0599 0.0443 0.9183

0.0552 0.0394 0.0395 0.0655 0.0484 0.9049

0.0487 0.0449 0.0471 0.0451 0.0564 0.0461 0.9186

0.0293 0.0555 0.0539 0.0456 0.0450 0.0574 0.0501 0.9149

0.0507 0.0339 0.0433 0.0504 0.0429 0.0603 0.0597 0.0696 0.8962

0.0375 0.0573 0.0470 0.0472 0.0502 0.0607 0.0420 0.0381 0.0484 0.8848 

p-values for covariance:

0.0000

0.2989 0.0000

0.2966 0.5842 0.0000

0.3471 0.4395 0.9592 0.0000

0.3994 0.9148 0.3590 0.8993 0.0000

0.5128 0.7023 0.6708 0.1869 0.8510 0.0000

0.8508 0.9752 0.9515 0.9411 0.4812 0.9714 0.0000

0.2669 0.4841 0.6001 0.9729 0.9530 0.4207 0.7751 0.0000

0.7151 0.4529 0.8765 0.7468 0.8689 0.2968 0.3317 0.0984 0.0000

0.6082 0.3734 0.9088 0.8997 0.7250 0.2720 0.8321 0.6358 0.7895 0.0000 

These estimates are much better; however the main diagonal of the matrix results in the zero p-value. To improve the estimate I do 5 iterations of TBS algorithm (my quick experiments show that it does not make sense to iterate longer as the estimates do not significantly change):

Means:

-0.0018,0.0034,0.0026,0.0067,-0.0108,0.0012,-0.0024,0.0122,-0.0057,-0.0044 

p-values for means:

0.1412 0.2612 0.2025 0.4860 0.7098 0.0943 0.1882 0.7693 0.4263 0.3381 

Covariance:

1.0524

0.0583 1.0172

0.0757 0.0426 1.0403

0.0653 0.0630 0.0490 1.0538

0.0672 0.0604 0.0559 0.0462 1.0367

0.0493 0.0295 0.0434 0.0784 0.0442 1.0261

0.0620 0.0429 0.0509 0.0453 0.0491 0.0488 1.0397

0.0410 0.0503 0.0476 0.0507 0.0497 0.0514 0.0497 1.0367

0.0450 0.0370 0.0486 0.0464 0.0430 0.0526 0.0622 0.0719 1.0179

0.0477 0.0587 0.0461 0.0562 0.0514 0.0645 0.0443 0.0346 0.0485 1.0070

p-values for covariance:

0.0002

0.6951 0.2249

0.1676 0.5972 0.0044

0.4613 0.5057 0.8450 0.0001

0.3761 0.5862 0.8152 0.7231 0.0095

0.8726 0.1942 0.6233 0.1170 0.6604 0.0646

0.5690 0.6118 0.9464 0.6795 0.8671 0.8653 0.0050

0.5092 0.9507 0.7992 0.9266 0.9002 0.9932 0.8944 0.0094

0.6867 0.4013 0.8656 0.7504 0.6147 0.9305 0.5185 0.2177 0.2065

0.8205 0.6243 0.7594 0.7800 0.9869 0.4071 0.6776 0.3207 0.8961 0.6185 

References

1. R.A. Maronna and R.H. Zamar, Robust Multivariate Estimates for High-Dimensional Datasets. Technometrics, 44, 307–317, 2002.

2. David M. Rocke. Robustness properties of S-estimators of multivariate location and shape in high dimension. The Annals of Statistics, 24(3), 1327-1345, 1996.

Dr. Michael Wrinn and I talked functional languages with Don Stewart, Haskell guru and co-author of the O’reilly publication  “Real World Haskell”.

But first the news:

A new version of the Intel® Software Development Emulator (1.61) has been released on http://whatif.intel.com. This version of includes support for SSE4, AES and PCLMULQDQ and the Intel® AVX instruction and includes a new 3-operand FMA instructions, removed VPERMIL2{PS,PD}, new footprint feature, rearranged mix output, added function summaries and miscellaneous bug fixes.

The Smoke Technology Demo continues to be very popular. This showcases (that includes source code) is a framework to support n-way threading of game technologies. By properly threading a game it can have more accurate physics, smarter AI, more particles, and/or a faster frame-rate. You can listen to a replay of the January 6^th Parallel Programming Talk to learn more about Smoke.

Now on with the show:

On the show today Michael Wrinn and I talked with Don Stewart, Haskell Guru and recent author of the O’reilly publication  “Real World Haskell”

Don reviewed his professional background and how he got started in computer science and what led to his interest in Haskell. We discussed how Haskell compare to other language including imperative (procedural) languages like C and related functional languages such as Erlang. 

The conversation covered a few highlights of what people are doing with the Haskell and how the financial services industry is adopting the language for fast high performance modeling. The talk then went to how the performance of Haskell compares to imperative languages.

If you are interested in checking out Haskell you read the book on line, buy a copy or visit the Haskell community web site.  We encourage to listen to the whole show and share your thoughts on functional languages and any question you might have.

For our next Parallel Programming Talk show on January 20^th at 8:00AM PST (1600 GMT) Clay and Aaron will be talking with Tim Mattson about OpenCL. The Open Computing Language is a framework for writing programs that execute across heterogeneous platforms consisting of CPUs, GPUs, and other processors. OpenCL includes a language (based on C99) for writing kernels (functions that execute on OpenCL devices), plus APIs that are used to define and then control the heterogeneous platform.

If dimension of the task p is equal to 1,000 and number of observations is 100,000 then the whole procedure takes less then one minute on Intel® Core™ i7 CPU based machine and a little bit longer – on Intel® Xeon® E5440.

In other words, Intel® Core™ i7 CPU is up 2x times faster than Intel® Xeon® E5440 in this specific application. The graph below that compares two platforms cleans out the CPU speed. As Intel® Core™ i7 CPU has higher frequency then speed-up of the algorithm for detection of outliers on this platform is even higher.

Jugoslav has been a contributor to Intel Software Network for over 8 years (wow!) and has actively supported our communities by participating in the discussion forums, providing product feedback and more. Your contributions are greatly appreciated and valued! Congratulations to Jugoslav :-).

We’ll be back with more Black Belt announcements soon…watch this space!