Intel Integrated Performance Primitives for Intel Architecture

Transcription

1 Intel Integrated Performance Primitives for Intel Architecture Using Intel Integrated Performance Primitives in Microsoft* C#.NET* String Manipulation Version 2.0 June, 2004

2 Information in this document is provided in connection with Intel products. No license, express or implied, by estoppel or otherwise, to any intellectual property rights is granted by this document. EXCEPT AS PROVIDED IN INTEL'S TERMS AND CONDITIONS OF SALE FOR SUCH PRODUCTS, INTEL ASSUMES NO LIABILITY WHATSOEVER, AND INTEL DISCLAIMS ANY EXPRESS OR IMPLIED WARRANTY, RELATING TO SALE AND/OR USE OF INTEL PRODUCTS INCLUDING LIABILITY OR WARRANTIES RELATING TO FITNESS FOR A PARTICULAR PURPOSE, MERCHANTABILITY, OR INFRINGEMENT OF ANY PATENT, COPYRIGHT OR OTHER INTELLECTUAL PROPERTY RIGHT. Intel products are not intended for use in medical, life saving, or life sustaining applications. This document as well as the software described in it is furnished under license and may only be used or copied in accordance with the terms of the license. The information in this document is furnished for informational use only, is subject to change without notice, and should not be construed as a commitment by Intel Corporation. Intel Corporation assumes no responsibility or liability for any errors or inaccuracies that may appear in this document or any software that may be provided in association with this document. Designers must not rely on the absence or characteristics of any features or instructions marked "reserved" or "undefined." Intel reserves these for future definition and shall have no responsibility whatsoever for conflicts or incompatibilities arising from future changes to them. The software described in this document may contain software defects which may cause the product to deviate from published specifications. Current characterized errata are available on request. Intel SpeedStep, Celeron, Dialogic, i386, i486, icomp, Intel, Intel Centrino, Intel logo, Intel386, Intel486, Intel740, IntelDX2, IntelDX4, IntelSX2, Intel Inside, Intel Inside logo, Intel NetBurst, Intel NetStructure, Intel Xeon, Intel XScale, Itanium, MMX, MMX logo, Pentium, Pentium II Xeon, Pentium III Xeon, and VTune 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. Copyright 2004 Intel Corporation.

3 Using Intel Integrated Performance Primitives in Microsoft C#.NET* - String Manipulation Table of Contents Introduction...4 Intel IPP Interfaces...4 String Class...5 Performance...7 Use of Intel IPP String vs.net String...8 GetHashCode Method...8 Test System Specification...9 References...9 iii

4 Introduction The Intel Integrated Performance Primitives (Intel IPP) provide an interface to develop applications in C language. Due to the use of the calling conventions stdcall for the Microsoft* Windows*, the primitives may be used in applications written in many other languages, for example, Fortran, C#, Java and so on. The Intel IPP sample described in more detail later in this document demonstrates the possibility of using Intel IPP in developing an application in the Microsoft*.NET Framework using the C# language. Specifically this sample shows the use of the Intel IPP string manipulation primitives in developing a class and its methods that is analogous to the class System.String. The sample uses the C# implementation of the class String from the.net Frameworks Class Library (FCL). Intel IPP Interfaces Intel IPP libraries are C style unmanaged code DLLs. To enable using these DLLs in C#, special wrapper classes ipps.cs and ippch.cs are created for signal processing (ipps) and string manipulation (ippch) application domains. These classes are declared as follows: // ipps.cs namespace ipp { public class sp { // ippch.cs namespace ipp { public class ch { Enumerated data types that are used in the Intel IPP libraries must be declared in the wrapper classes with a keyword enum. For example, the enumerator IppRoundMode is declared as follows: public enum IppRoundMode { ipprndzero = 0, ipprndnear = 1, Many Intel IPP functions use structures as parameters. To pass structures from the managed environment to the unmanaged one, the managed class struct must comply with the corresponding library in the unmanaged code. The attribute StructLayout is used with the value LayoutKind.Sequential. The code bellow shows how to use the structure Ipp64fc: [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi)] public struct Ipp64fc { public double re; public double im; public Ipp64fc( double re, double im ) { 4

5 this.re = re; this.im = im; To access the unmanaged DLL functions from the managed code, the function name and the name of the corresponding DLL must be indicated. This information is included in the managed description of the unmanaged functions that are called from the DLL. The attribute DllImport and function specifiers static, extern specify the method that is used by.net to create a function and to marshal data. The attribute MarshalAs is used with the corresponding fields. For example, the function ippchgetlibversion is called as follows: using System.Runtime.InteropServices; namespace ipp { [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi)] unsafe public class IppLibraryVersion { public int major; public int minor; public int majorbuild; public int build; [MarshalAs(UnmanagedType.ByValTStr, SizeConst=4)] public string targetcpu; public sbyte* Name; public sbyte* Version; public sbyte* BuildDate; public class ch { [DllImport( ippch20.dll )] public static extern IppLibraryVersion ippchgetlibversion(); Almost all Intel IPP functions have pointers as parameters. The functions with pointers must be declared in the unsafe context. For example, the function ippscopy_8u is declared as: using System.Runtime.InteropServices; namespace ipp { public enum IppStatus { ippstsnoerr = 0, unsafe public class sp { [DllImport( ipps20.dll )] public static extern IppStatus ippscopy_8u ( byte* psrc, byte* pdst, int len ); This code must be compiled with the /unsafe option. Note that working with pointers in the C# application requires using the operator fixed. The fixed statement sets a pointer to a managed variable and "pins" that variable during the execution of the statement. Without the fixed statement, pointers to managed variables would be of little use since garbage collection could relocate the variables unpredictably. String Class The class IPPSystem.String is created using the Intel IPP functions as follows: 5

6 namespace IPPSystem { [Serializable] public sealed class String: IComparable, ICloneable, IConvertible, IEnumerable, ISerializable { This class contains all the methods of the class System.String with the exception of methods Intern(), IsIntern(). The distinctive feature of the developed class IPPSystem.String is the possibility to use both classes System.String and IPPSystem.String in the application. The IPPSystem.String methods with string parameters are duplicated to be used both as System.String and IPPSystem.String class methods without conversion from one to another: ///<summary> ///Creates a new instance of String with the same value as a specified /// instance of String. ///</summary> public static string Copy(string str) { public static String Copy(String str) { To convert these classes, the following operators are used: public static implicit operator System.String(String value) { public static implicit operator String(System.String value) { When methods are called in the application, the corresponding class must be specified for the compiler. The type string (in lowercase) denotes the System.String class. If you specify the class as String (with uppercase S), this will lead to the compiler error message: 'reference' ('String') is an ambiguous reference'. Therefore, the namespace and class must be either specified explicitly, or the corresponding names of the classes need be defined. The code below shows the possibility of using simultaneously both System.String and IPPSystem.String classes. using stringy = IPPSystem.String; class Example { static void Main( string[] args ) { stringy ippstr = ; // equivalent to IPPSystem.String // ippstr = ; string str = string.copy( ippstr ); //equivalent to System.String // str = System.String.Copy(ippstr); Console.WriteLine( {0 {1, ippstr, str ); One more additional feature of the developed class is the implementation of the methods of the System.String objects. These methods have additional (first) parameter self of string type: ///<summary> ///Copies a specified number of characters from a specified position in // the current String instance to a specified position in a specified // array of Unicode characters. 6

7 ///</summary> public void CopyTo(int sourceindex, char[] destination, int destinationindex, int count); public void CopyTo(string self, int sourceindex, char[] destination, int destinationindex, int count); Performance The Intel IPP code is optimized for the Intel processors and significantly improves the performance of different kinds of applications including the System.String, which is a.net application. To test the developed class IPPSystem.String and its methods and to measure their performance, the special example program named stripps.exe (includes files base.cs, Test.cs, Perf.cs, stripps.cs) was created. It tests the methods IndexOf, LastIndexOf, CompareOrdinal, GetHashCode, Equals, Split, Compare. The performance in CPU cycles was measured for different string lengths on the 2.40 GHz Intel Pentium 4 processorbased system, which is detailed in the Test System Specification section. Before analyzing the results of performance measurements, consider the factors that can slow down the performance of an application. The first of them is a mechanism of the Platform Invocation Service (P/Invoke) described in [4]. The second factor is the use of String class methods that return a new string, since performance of such methods is impossible to improve. To perform a required operation, these methods need to construct a new object. Public constructors of the object System.String, as well as constructors of the symbol arrays in the IPPSystem.String, allocate and initialize memory, and place objects into the table that will be used by garbage collection. These procedures initialize slowly and take a long time to continue, sometimes even longer than an operation itself. As an illustration, Table 1 gives the performance numbers for the method String.Concat(String, String) that returns a new string and copies to it two other 16-element strings. Table 1: Performance in CPU cycles of the method String.Concat Method Performance System.String.Concat 350 IPPSystem.String.Concat 660 However, methods that do not create new strings operate much faster when they use Intel IPP. For example Table 2 gives the performance numbers for the method String.IndexOf(String) that returns the index of the first occurrence of the specified 5-element substring in the 16-element string. Table 2: Performance in CPU cycles of the method String.IndexOf Method Performance System.String.IndexOf 820 IPPSystem.String.IndexOf 170 The Table 3 gives the measured performance numbers for both System.String (denoted as MS) and IPPSystem.String (denoted as IPP) methods. 7

8 Table 3: Performance of Different Methods, CPU cycles String/substring length, elements Method IndexOf(String) IndexOf(Char) Insert(String) 16/5 64/- 8/8 MS IPP Use of Intel IPP String vs.net String If an application uses extensively methods that create a new string (for example, such methods as Copy, Insert, PadLeft, PadRight, Remove, Substring, Concat, Split), the developed class IPPSystem.String operates slower than the corresponding.net class because Intel IPP string has to call the constructor that additionally initializes an array. On the contrary, if an application uses methods that do not create new strings, or the cost of the operation is comparable to the overhead of string construction (for example, such methods as IndexOf, GetHashCode, EndsWith, StartsWith, Equals, IndexOfAny, ToCharArray, Trim), then the use of the class IPPSystem.String based on Intel IPP functions brings significant performance gain. GetHashCode Method The method GetHashCode of the.net class System.String stops execution and returns a hash code if zero is met in the string. The remainder of the string is not processed despite the fact that a string in C# is not zero-ended. Therefore the.net version of the method can produce the same hash code for two different strings. For example: class Example { static void Main( string[] args ) { int hash; string Str1 = "abc"+'\u0000'+"d"; string Str2 = "abc"+'\u0000'+"e"; hash = Str1.GetHashCode(); Console.WriteLine(hash); // hash = Str2.GetHashCode(); Console.WriteLine(hash); // In Intel IPP functions the region of interest (ROI) or length of the data array to be processed is passed as an argument. This excludes the above described situation. Compare with the following code example that uses the GetHashCode method of the IPPSystem.String class: using IPPSystem; class Example { static void Main( string[] args ) { int hash; IPPSystem.String Str1 = "abc"+'\u0000'+"d"; IPPSystem.String Str2 = "abc"+'\u0000'+"e"; hash = Str1.GetHashCode(); Console.WriteLine(hash); //1256 8

9 hash = Str2.GetHashCode(); Console.WriteLine(hash); //1257 Note that Intel IPP has several hushing algorithms. In the above example, the proprietary hashing algorithm implemented in the optimized function ippshash_16u32u is used. To provide compatibility with the Microsoft C#, the function ippshashmscs_16u32u can be used (for compatibility with the Sun* Java use the function ippshashsj2_16u32u). Test System Specification Configuration of the base machines used for testing is given in the table below: Table 4: System Configurations Processor System Processor Stepping GHz Intel Pentium 4 processor Intel MS440GX motherboard Bios Version Award Software International, Inc PG, Secondary Cache Memory Size Hard Disk 512KB 512 MB Seagate Cheetah* ST360021A Video Controller/Bus NVIDIA GeForce4* MX 440 Video Memory Size/Type 64MB SGRAM Video Driver Revision Graphics Operating System Sound Card 1280x1024, 85 Hz, 32bit Color Microsoft Windows* XP Professional - Build 2600 w/service pack 1 Advance AC97 Audio References [1] Intel Integrated Performance Primitives [2].NET Development [3].NET Platform Invoke Services [4] Using Intel Integrated Performance Primitives in Microsoft* C#.NET. Intel Corporation,