If you have a Windows test machine with a large number of CPU cores that you wish to use for testing performance and compatibility with a lesser number of CPU cores you may be able to use that one machine to test several multicore scenarios. For example, an 8-core machine can be configured to restrict Windows from using all 8-cores, forcing it to use, for example, only 4, 2, or even one core in the machine. This technique can be used to more evenly compare system performance by varying the number of cores on the machine and to verify proper operation or scalability of your software for a variety of multicore configurations.

Note: You will have to modify your BOOT.INI file or Boot Configuration Data (BCD on Windows Vista) to setup a machine for this purpose.

To restrict the number of CPU cores Windows will use on a multicore machine follow these instructions:

1.) Determine how many logical CPUs are in your system. Do this by opening the following registry key:

HKEY_LOCAL_MACHINE\HARDWARE\DESCRIPTION\System\CentralProcessor

There will be one subkey for each logical CPU. The precise number of logical CPUs depends on the number of cores in your processor(s) and whether or not those cores are using Hyper-Threading technology. For example, a four-core machine with Hyper-Threading technology can appear to have eight logical CPUs (two threads per core * four cores = eight logical CPUs or threads).

2.) On a Windows XP system, edit the BOOT.INI file located in the root directory of your boot drive (usually C:).

Find the line in the [Operating Systems] section that boots the Windows system you are using (on systems with multiple Windows boot partitions you must take care to identify the correct line). This line usually looks something like the following:

multi(0)disk(0)rdisk(0)partition(1)\WINDOWS="Microsoft Windows XP" /fastdetect

3.) Add one (or more) lines with the /NUMPROC parameter to create a second boot option that limits Windows to the desired number of logical cores.

For example assuming an eight logical CPU system (eight possible execution threads), you might want to add the following boot scenarios (new text is marked in bold):

multi(0)disk(0)rdisk(0)partition(1)\WINDOWS="Microsoft Windows XP" /fastdetect
multi(0)disk(0)rdisk(0)partition(1)\WINDOWS="Microsoft Windows XP, 1 core" /fastdetect /NUMPROC=1
multi(0)disk(0)rdisk(0)partition(1)\WINDOWS="Microsoft Windows XP, 2 cores" /fastdetect /NUMPROC=2
multi(0)disk(0)rdisk(0)partition(1)\WINDOWS="Microsoft Windows XP, 4 cores" /fastdetect /NUMPROC=4
multi(0)disk(0)rdisk(0)partition(1)\WINDOWS="Microsoft Windows XP, 6 cores" /fastdetect /NUMPROC=6

This configuration would allow you, at boot time, to choose to boot Windows in 1-threads, 2-threads, 4-threads, 6-threads and "all-threads" modes. Your Windows configuration is identical other than the number of execution threads available.

Note: you should modify each description so you can easily identify the specific boot options at boot time.

For full details of all of the BOOT.INI options see the SysInternals website (now part of Microsoft) at:
http://www.microsoft.com/technet/sysinternals/information/bootini.mspx

To configure your Windows Vista system to include a second boot option you will need a BCD editor. For example, you can use VistaBootPRO (www.pro-networks.org) to create and name additional boot entries in your Vista BCD and then use the Microsoft msconfig tool to configure each of your boot options.

-- Configure the number of threads with msconfig.
-- Use VistaBootPRO to create and name those boot options.

Using msconfig seems to work better than VistaBootPRO to configure boot options. VistaBootPRO is easier to use to create additional BCD boot entries.

By Ying Song, Intel Corporation

The Intel® Integrated Performance Primitives (Intel® IPP) is a cross-architecture software library that provides a broad range of library functions for video codecs (for example, H.264 and MPEG-4), audio, image coding (for example, JPEG, JPEG2000), image processing, signal processing, data compression, speech compression (for example, G.729, G.723, GSM AMR), cryptography, and computer vision, as well as math support routines for such processing capabilities. Intel IPP is optimized for the wide range of Intel microprocessors, including:

• Intel® Pentium® 4 Processor
• Intel® Pentium® 4 Processor with Hyper Threading Technology
• Intel® Pentium® M Processor component of Intel® Centrino® Mobile Technology
• Intel® Xeon® Processor
• Intel® Xeon® Processor with Intel® Extended Memory 64 Technology (Intel® EM64T)
• Intel® Core™ Quad and Intel® Core™ 2 Duo Microarchitectures
• Intel® Core™ i7 processor 
• Intel® Atom™ Processor
• Intel® Itanium® Processor

One of key advantages within Intel IPP is performance. This paper introduces a powerful performance test tool packaged inside the Intel IPP library and demonstrates how you can use this tool to test the performance of each Intel IPP function on various Intel® Pentium,  and Itanium processor systems.

The Intel IPP Performance Test Tool for both Windows* and Linux* based on Intel Pentium Processors and Itanium Processors is a timing system specially designed for accomplishing Intel IPP functions performance tests on the same hardware platforms as the related Intel IPP libraries. It contains command line programs for testing the performance of each IPP function in various ways. 

You can control the course of tests and generate the results in the desirable format by using command line options. The results are saved in the .csv file for further processing with Microsoft Excel*. The course of timing is displayed on the console and can be saved in a .txt file. You can create a list of functions to be tested and set required parameters with which the function should be called during the performance test. The list of functions to be tested and their parameters can either be defined in the .ini file, or entered directly from the console.

Additionally, this performance test tool provides all performance test data in .csv format. It contains data covering all domains and cpu types support on Intel IPP. For more information, read the reference data located in the subdirectory \tools\perfsys\data.

Once you install the Intel IPP package, you can locate the performance test *.exe files in the \tools\perfsys directory.

The following table explains the corresponding .exe file that can be used for each Intel IPP domain. For example, the .exe file name containing “64” is targeted to Intel Itanium Processors and the .exe files name containing “em64t” is targeted to Intel Xeon Processor with Intel® 64, and so on.

Executable Names	Domains
ps_ippac(64/em64t).exe	Audio Coding
ps_ippi(64/em64t).exe	Image Processing
ps_ipps(64/em64t).exe	Signal Processing
ps_ippvc(64/em64t).exe	Video Coding
ps_ippdc(64/em64t).exe	Data Compression
ps_ippch(64/em64t).exe	Strings
ps_ippcp(64/em64t).exe	Cryptography
ps_ippcv(64/em64t).exe	Computer Vision
ps_ippj(64/em64t).exe	JPEG
ps_ippvm(64/em64t).exe	Vector Math
ps_ippm(64/em64t).exe	Small Matrix
ps_ippcc(64/em64t).exe	Color Conversion
ps_ippsc(64/em64t).exe	Speech Coding
ps_ippsr(64/em64t).exe	Speech Recognition
ps_ippr(64/em64t).exe	Realistic Rendering
ps_ippdi(64/em64t).exe	Data Integrity

Command Line Format and Options

As we mentioned above, this performance test tool contains command line programs. Following is the command line format:

<ps_FileName>.exe [switch_1] [switch_2]… [switch_n]

A short reference for the command line options can be displayed on the console. To invoke it, enter -? or -h in command line:
ps_ipps.exe –h

The command line options can be divided by their functionality into 6 groups. You can enter switches in an arbitrary order with at least one space between. Options like –r, -V, -o, -O can be entered several times with different file names.

 

The following examples illustrate how you can use this tool in different ways to generate Intel IPP function performance data on the targeted system.

This is the simplest way to get a full set of performance data on your target system. For example:

ps_ippch.exe –B –v

All IPP string functions are tested by the default timing method on standard data (-B option). The results are generated in the ps_ippch.csv file.

This is common usage to measure IPP functions. You can select only one specific function or several functions from one domain to get performance data. For example:

ps_ipps.exe -fFIRLMS_32f -V firlms.csv

It measures signal processing function FIRLMS_32f (-f option), and generates a .csv file named firlms.csv (-V option). For example:

ps_ippch -B -V string.csv -fFind -fCompare –fRemove

It outputs the data for the functions, find, compare, and remove from the string domain.

Run the following command to find out the functions included in a domain:

ps_ippvc.exe  -e –o vc_list.txt 

The output file vc_list.txt (-o option) will list all IPP video coding functions (-e option). 

ps_ippvc.exe  -e -r H264.csv -f H264

The list of functions with names containing H264 (–f option) that may be tested (-e option) is displayed on the console and stored in the file H264.csv (-v option).

Use the .ini file is to avoid entering all the required parameters while running the console performance tool. You can also customize the required parameters in .ini file to simply the tests. For example:

ps_ipps.exe –B –I

A ps_ipps.ini file ps_ippps.ini is created after the first run (-I option).

ps_ipps.exe –i –v 

Optionally, before running this command, you can modify the ps_ipps.ini file to choose the functions, the array of vectors, the length of vectors, and so on. This will test all or limited functions, reading timing procedure and all or limited function parameters values from the ps_ipps.ini file (-i option). It also generates the ps_ipps.csv (-v option) output file.

While running the performance tool in console command line, you are prompted to enter the parameters for timing methods, options, and other common parameters. Use a set of meaningful parameters to influence the performance of the function.

The following table gives you a detailed description to enable you to choose the appropriate parameters:

 

You can use the last three procedures to check the results yielded by the first method if you have doubt the reliability of the measurement results.

Setting Function Parameters

In the course of the timing procedure the parameters of IPP functions should be specified. Certain parameters like array addresses, array element values, and parameters that have a small influence on the performance of the functions are defined within the test and you cannot change them.

Other parameters including the vector length, image size, scale factor, and function-specific parameters may significantly affect the function performance. The test varies their values to obtain more detailed measurements of the performance. The test specifies the parameters that are variable for a given function.

Most of the tests have several variable parameters. The test measures performance for all possible combinations of parameter values. For example, if the vector length has five possible values and scale factor has three possible values for a certain function the total number of performance measurements is 5*3 = 15. The values of variable parameters are written into the .csv file in the same order as they were prompted to be entered from the console, or placed by the PS in the .ini file.

You can set the values for the specific function parameters either from the console in the .ini file. There are several methods to identify in the course of the time procedure. This paper does not include these details. If you have any questions, refer to the “Reference” section and contact us.

The output data file is in .csv format, which can be viewed with a spreadsheet program such as Microsoft Excel. The output performance data contains both the elapsed execution time in microseconds, as well as in the more commonly used u nits, clocks per element (cpe).  Following is a snap shot of the first few rows from an output .csv file from running the example mentioned above. It also includes test system information such as processor, operating system, the Intel IPP library version and start time:



Click on image to view large size.

When viewing the .csv file, you may notice some columns with the headings nLps, Clocks, and per.

The nLps contains the number of repetitions in the loop, for example 16 iterations were measured. The column with Clocks is associated with the column per, implying clocks per element (cpe). The column Time specifies the time spent for the execution of this function.

The output for function ippsFIRLMS (illustrated above) displays the performance data on the 32f data type; it averages 30 clocks per cpMac (defined below). It also implies that it takes 0.82 usec to run on a loop with 16 iterations.

The following table is gives a detailed description on the units used in column “per” for all IPP domains:

Intel IPP provides a powerful performance test enabling you to simplify the process of the performance benchmark for Intel IPP functions on various Intel based microprocessors. Additionally, it provides a comprehensive data set to help you analyze performance data.

• Download the Intel IPP
• The Intel IPP Knowledge Base (Self help, FAQs, Solutions…)
• Share your experience with other users at the Intel IPP Forum
• Contact us via Intel® Premier Support for any questions related to Intel IPP
• Buy the Intel IPP book

Ying Song is currently a Technical Consulting Engineer for Intel Integrated Performance Primitives at the Intel Software & Service Group.

In some cases, you can also call Intel IPP common function ippCoreGetCpuClocks in your application to measure Intel IPP function performance or any function performance measurement. The ippCoreGetCpuClocks function reads the current state of the time stamp counter (TSC) register and returns its value.  Subtracting two successive polling results before and after the function call gives a very accurate measurement of elapsed time.

Following is a flow chart to illustrate how to use this Intel IPP common function:



Following is an example to show you how to use this ippCoreGetCpuClocks to measure function performance:

// Measure FFT performance //

#include "stdafx.h"
#include <stdio.h>
#include "math.h"
#include "ipp.h"

int main()
{
	//Get the version of IPP on this machine
	
	const IppLibraryVersion* lib;
	lib = ippsGetLibVersion();

    printf("Intel(R) Performance Primitives 
&quo
t;);
    printf("CPU       : %s
",lib->targetCpu);
    printf("Name      : %s
",lib->Name);
    printf("Version   : %s
",lib->Version);
    printf("Build date: %s
",lib->BuildDate);

    //Measure FFT performance
	
    #define Nord	10  
    #define LEN		1024
    #define IPP_PI    ( 3.14159265358979323846 )
	Ipp32f  Signal[LEN],SignalFft[LEN];
	Ipp32f  Amp=1;
	Ipp32f  fsample=51.2e6;
	Ipp32f  fc=3e6;
    
	int NoFFT=100000; 
	int   i;
	IppsFFTSpec_R_32f* FftSpec;
	int FftOrder=Nord;
	int FftFlag=IPP_FFT_DIV_FWD_BY_N;
	//IppHintAlgorithm FftHint;
    IppStatus Status;  

	Ipp64s start,stop;
    
    // Generate sine wave 
	for (i=0;i<LEN;i++)
	{
	 Signal[i]=Amp*cos(2*IPP_PI*i*fc/fsample);
             }

	 ippsFFTInitAlloc_R_32f(&FftSpec,FftOrder,FftFlag,ippAlgHintNone); 
  
     start = ippGetCpuClocks();
     for (i=0;i<NoFFT;i++)
	 {
      		 ippsFFTFwd_RToPack_32f(Signal,SignalFft,FftSpec, NULL);
	 } 
  
     stop = ippGetCpuClocks();

     float ippFFTPerf = (float) (stop-start)/LEN/NoFFT;
     printf ("FFT 32f: ipp=%.1f
", ippFFTPerf);
   
     ippsFFTFree_R_32f(FftSpec); 
	 ippsFree(Signal);
	 ippsFree(SignalFft); 
	 
	 return 0;
}

The following lists processor-specific codes used in Intel IPP:

·         IA-32 Intel® architecture
       o   px - C-optimized for all IA-32 processors

o   a6 - Optimized for Pentium III processors (it is removed in Intel IPP v6.0)

o   w7 - Optimized for Pentium 4 processors

o   t7 - Optimized for Pentium 4 processors with Streaming SIMD Extensions 3 (SSE3)

o   v8 - New Optimizations for 32-bit applications on Intel® Core™2 and Intel® Xeon® 5100 processors

o   p8 - New Optimizations for 32-bit applications on 45nm Intel® Core™2 Duo (Penryn) family processors and Intel® Core™ i7 processors (Nehalem)

o   s8 – Optimized for Intel® Atom™ Processors ( new in Intel IPP v6.0)

·         Intel® 64 (Intel® EM64T) architecture
      o   mx - C-optimized for all Intel® EM64T-based platforms

o   m7 - Optimized for Intel EM64T-based platforms

o   u8 - New Optimizations for 64-bit applications on Intel Core 2 and Intel Xeon 5100 processors

o   y8 - New Optimizations for 64-bit applications on 45nm Intel® Core™2 Duo (Penryn) family processors and Intel® Core™ i7 processors (Nehalem)

o   n8 – Optimized for Intel® Atom™ Processors ( new in Intel IPP v6.0)

·         Intel® Itanium® architecture
       o   i7 – Optimized for Intel® Itanium® processor family

·         Intel® IXP4XX Network processors (it is removed in Intel IPP v6.0, check here for more details)

o    sx - C-optimized for the IXP4XX product line

o   s2 - Optimized for the IXP4XX product line

Contents:

• Where can I download the Intel® IPP JPEG sample package?
• What JPEG samples does Intel IPP JPEG sample package contain?
• What features are supported in the Intel IPP JPEG sample package?
• Where can I find the performance data for Intel IPP JPEG samples?
• Which Intel IPP JPEG encoder/decoder is faster than the IJL?

Where can I download the Intel® IPP JPEG sample package?
You can download the Intel IPP JPEG sample package from the following URL:
http://www.intel.com/cd/software/products/asmo-na/eng/perflib/ipp/219967.htm

What JPEG samples does Intel IPP JPEG sample package contain?
The Intel IPP JPEG sample package contains different samples, depending on the OS. The following samples are available:

What features are supported in the Intel IPP JPEG sample package?
The Intel IPP JPEG samples implement different JPEG features as described below:

• IJG-IPP and IJL-IPP: These samples support all JPEG standard features excluding 12-bit per color component and arithmetic coding.
• JPEG2000: The decoder supports most features including several progression orders, multi-tile image decoding, lossy and lossless coding. The restriction of decoder is of streams with arbitrary-access markers, like SOP, EPH, PPM (and others) and ROI coding. The encoder supports basic options including lossy and lossless coding, 97 and 53 filter banks, quantization and rate-distortion optimization. The encoder is restricted to supporting one layer-resolution level-component-position, one layer compressed data organization and single tile/single precinct (per resolution level).
• JPEGView: This sample supports 444, 422, 244 and 411 sampling factors (multi-threading used only for 444 and 422), image output in YUY2 format (if compressed with 422 sampling) and retrieval of Exif metadata. Lossless mode supports one-channel images only. Baseline JPEG encoding with several scans is not supported.

Where can I find the performance data for Intel IPP JPEG samples?
Performance data is available in the following locations:

• IJG-IPP: Performance data is provided in the ijg_ipp.pdf document located in the JPEG sample package folder \jpeg\IJG\doc.
  IJG-IPP sample code also provides the ijg_timing utility that can measure JPEG coding performance. After building the sample code, you can find the ijg_timing application at folder \JPEG\IJG\bin\xxxx\. Please refer to Readme.htm file in the sample to learn how to run the application.
• IJL-IPP: Performance data is provided in the ijl-ipp.pdf document located in the JPEG sample package folder \jpeg\JPEG_IJL\doc.
• JPEG2000: Performance data is distributed with the Intel IPP binaries package in the \tools\perfsys\data directory; check the files named ps_ippj*.csv.
  JPEG2000 sample code also includes the j2kit application that can measure JPEG200 coding performance. After building the sample code, you can find the j2kit application at folder \JPEG\JPEG2000\ bin\xxxx\ . Please refer to Readme.htm file in the sample to learn how to run the application.
• JPEGView: Performance data is distributed with the Intel IPP binaries package in the \tools\perfsys\data directory; check the files named ps_ippj*.csv.

Which Intel IPP JPEG encoder/decoder is faster than the IJL?
The Intel IPP JPEG codec from the JPEGView sample is implemented for maximum performance and is faster than IJL v1.51 and the IJL-IPP sample.

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

Operating System: