ASP 101 - Active Server Pages 101 - Web05
The Place ASP Developers Go!

Please visit our partners


Windows Technology Windows Technology
15 Seconds
4GuysFromRolla.com
ASP 101
ASP Wire
VB Forums
VB Wire
WinDrivers.com
internet.commerce internet.commerce
Partners & Affiliates














ASP 101 is an
internet.com site
ASP 101 is an internet.com site
IT
Developer
Internet News
Small Business
Personal Technology

Search internet.com
Advertise
Corporate Info
Newsletters
Tech Jobs
E-mail Offers

ASP 101 News Flash ASP 101 News Flash



 Top ASP 101 Stories Top ASP 101 Stories
What is Adovbs.inc and Why Do I Need It?
An Overview of ASP.NET
Connections, Commands, And Procedures

QUICK TIP:
Send Email from an ASP Page
Show All Tips >>
ASP 101 RSS Feed ASP 101 Updates


Iteration Performance of Numerical Libraries in .NET

by Trevor Misfeldt

Introduction

I've been implementing numerical libraries in .NET and have come to some conclusions about iteration performance. My classes have to hold a large amount of data and be able to iterate through that data as quickly as possible. In order to compare various methods, I created a simple class called Data that encapsulates an array of doubles.

Method #1: Enumeration

Data implements IEnumerable. It contains GetEnumerator which returns its own DataEnumerator, an inner class.

...
    public DataEnumerator GetEnumerator() 
    {
      return new DataEnumerator( this );
    }
    IEnumerator IEnumerable.GetEnumerator()
    {
      return GetEnumerator();
    }
  }
...
  public struct DataEnumerator : IEnumerator
  {
    private Data internal_;
    private int index_;
    public DataEnumerator( Data data ) 
    {
      internal_ = data;
      index_ = 1;
    }
    public double Current
    {
      get
      {
        return internal_.Array[index_];
      }
    }
    object IEnumerator.Current 
    {
      get
      {
        return Current;
      }
    }
    public bool MoveNext()
    {
      index_++;
      if ( index_ >= internal_.Array.Length ) 
      {
        return false;
      }
      return true;
    }
    public void Reset()
    {
      index_ = -1;
    }
  }
}
...

Method #2: Indexing

I implemented an index operator on the class which simply calls the index operator on the array.

    public double this[int position]
    {
      get
      {
        return array_[position];
      }
    }

Method #3: Indirect Array

I created a property to access the array.

    public double[] Array
    {
      get 
      {
        return array_;
      }
    }

When iterating, I called the Array property and then its index operator.

          d = data.Array[j];

Method #4: Direct Array

I created a reference to the array.

        double[] array = data.Array;

Then, I iterate through that reference.

          d = array[j];

Method #5: Pointer Math

Finally, I tried improving performance by iterating through the array in Managed C++ using pointer manipulation.

        static void iterate( Data& data )
        {
          double d;
          double __pin* ptr = &( data.Array[0] );
          for ( int i = 0; i < data.Array.Length; i++ ) 
          {
            d = *ptr;
            ++ptr;
          }
        }

I called it this way:

        Pointer.iterate( data );

Conclusions

To test the different methods, I allocated 1,000,000 doubles into an array and indexed over all of them. I repeated this 1,000 times to minimize randomness. Here are the results...

Results

Enumeration is always slow. That's not surprising as I'm using a general data structure to hold the doubles.

The three operator/property methods differed very slightly. These are probably all optimized similarly.

Using pointer math to traverse over the raw data was significantly faster. This is probably due to the fact that there's no bounds checking.

In summary, if you have large amounts of data and performance is critical, consider using managed C++.

Source Code

You can download a zip file containing the source code referenced in thios article from here: code.zip (6 KB)

Acknowledgements

Thanks to Mark Vulfson of ProWorks for tips on using Flipper Graph Control. Also, to my colleagues Ken Baldwin and Steve Sneller at CenterSpace Software.

About the Author

Trevor Misfeldt is the co-founder and CEO of CenterSpace Software which specializes in .NET numerical method libraries. Trevor has worked as a software engineer for eight years. He has held demanding positions for a variety of firms using C++, Java, .NET, and other technologies, including Rogue Wave Software, CleverSet Inc., and ProWorks. He is coauthor of Elements of Java Style, published by Cambridge University Press, and is currently working on a follow-up book for C++. He has also served on a course advisory board of the University of Washington. His teams have won the JavaWorld "GUI Product of the Year" and XML Magazine "Product of the Year" awards. Trevor holds a BSc in Computer Science from the University of British Columbia and a BA in Economics from the University of Western Ontario.


Home |  News |  Samples |  Articles |  Lessons |  Resources |  Forum |  Links |  Search |  Feedback

Internet.com
The Network for Technology Professionals

Search:

About Internet.com

Legal Notices, Licensing, Permissions, Privacy Policy.
Advertise | Newsletters | E-mail Offers