• <ins id="pjuwb"></ins>
    <blockquote id="pjuwb"><pre id="pjuwb"></pre></blockquote>
    <noscript id="pjuwb"></noscript>
          <sup id="pjuwb"><pre id="pjuwb"></pre></sup>
            <dd id="pjuwb"></dd>
            <abbr id="pjuwb"></abbr>

            C++ Programmer's Cookbook

            {C++ 基礎(chǔ)} {C++ 高級(jí)} {C#界面,C++核心算法} {設(shè)計(jì)模式} {C#基礎(chǔ)}

            Performance of Iteration Methods (very good)

            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.

            Download source - 6 Kb

            Method #1: Enumeration

            Data implements IEnumerable. It contains GetEnumerator which returns its own DataEnumerator, an inner class.
            public IEnumerator GetEnumerator()
            ????{
            ???? returnnew DataEnumerator(this);
            ????}
            ????
            ????internalclass DataEnumerator : IEnumerator
            ????{
            ???? private Data internal_=null;
            ???? privateintindex=-1;

            ???? public DataEnumerator( Data data)
            ???? {
            ????????internal_=data;
            ???? }

            ???? publicobject Current
            ???? {
            ????????get
            ????????{
            ???????? returninternal_.Array[index];
            ????????}
            ???? }

            ???? publicbool MoveNext()
            ???? {
            ????????index++;
            ????????if(index >=internal_.Array.Length )
            ????????{
            ???????? returnfalse;
            ????????}
            ????????returntrue;
            ???? }

            ???? publicvoid Reset()
            ???? {
            ????????index=-1;
            ???? }
            ????}

            Method #2: Indexing

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

            ????publicdoublethis[intposition]
            ????{
            ???? get
            ???? {
            ????????returnarray_[position];
            ???? }
            ????}

            Method #3: Indirect Array

            I created a property to access the array.

            ????publicdouble[] Array
            ????{
            ???? get
            ???? {
            ????????returnarray_;
            ???? }
            ????}
            When iterating, I called the Array property and then its index operator.
            d = data.Array[j];

            Method #3: Direct Array

            I created a reference to the array.

            double[] array = data.Array;
            Then, I iterate through that reference.
            d = array[j];

            Method #4: Pointer Math

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

            ????????staticvoiditerate( 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. Each access performs a cast. 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++.

            超級(jí)collection類(lèi):

            using?System;
            using?System.Collections;

            namespace?Iterations
            {
            ??
            public?class?Data?:?IEnumerable
            ??
            {
            ????
            private?double[]?array_;

            ????
            public?Data(int?size)?
            ????
            {
            ??????array_?
            =?new?double[size];
            ??????Random?random?
            =?new?Random();
            ??????
            for?(?int?i?=?0;?i?<?size;?i++?)
            ??????
            {
            ????????array_[i]?
            =?random.Next();
            ??????}

            ????}


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

            ????}


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

            ????}


            ????
            public?IEnumerator?GetEnumerator()?
            ????
            {
            ??????
            return?new?DataEnumerator(?this?);
            ????}

            ????
            ????
            internal?class?DataEnumerator?:?IEnumerator
            ????
            {
            ??????
            private?Data?internal_?=?null;
            ??????
            private?int?index?=?-1;

            ??????
            public?DataEnumerator(?Data?data?)?
            ??????
            {
            ????????internal_?
            =?data;
            ??????}


            ??????
            public?object?Current
            ??????
            {
            ????????
            get
            ????????
            {
            ??????????
            return?internal_.Array[index];
            ????????}

            ??????}


            ??????
            public?bool?MoveNext()
            ??????
            {
            ????????index
            ++;
            ????????
            if?(?index?>=?internal_.Array.Length?)?
            ????????
            {
            ??????????
            return?false;
            ????????}

            ????????
            return?true;
            ??????}


            ??????
            public?void?Reset()
            ??????
            {
            ????????index?
            =?-1;
            ??????}

            ????}

            ??}

            }
            test code:
            using?System;
            using?System.Collections;

            using?Iterations;

            namespace?Test
            {
            ??
            class?Test
            ??
            {
            ????
            private?double?d;
            ????
            private?int?reps;
            ????
            private?int?size;
            ????
            private?double?seconds;
            ????
            private?Data?data?=?null;
            ????
            private?DateTime?before;
            ????
            private?TimeSpan?total;

            ????[STAThread]
            ????
            static?void?Main(string[]?args)
            ????
            {
            ??????Test?test;
            ??????
            if?(?args.Length?>?1?)?
            ??????
            {
            ????????test?
            =?new?Test(?int.Parse(?args[0]?),?int.Parse(?args[1]?));
            ??????}
            ?
            ??????
            else?
            ??????
            {
            ????????test?
            =?new?Test();
            ??????}

            ??????test.TestAll();
            ????}


            ????
            public?Test()?:?this(?1000,?1000000?)
            ????
            {
            ????}


            ????
            public?Test(?int?reps,?int?size?)
            ????
            {
            ??????
            this.reps?=?reps;
            ??????
            this.size?=?size;
            ??????data?
            =?new?Data(?size?);
            ????}


            ????
            private?void?TestAll()
            ????
            {
            ??????System.Console.WriteLine();
            ??????System.Console.WriteLine(?
            "repetitions:?"?+?reps?);
            ??????System.Console.WriteLine(?
            "iterations:?"?+?size.ToString(?"e"?));
            ??????System.Console.WriteLine();
            ??????TestEnumeration();
            ??????TestIndexing();
            ??????TestIndirectArrays();
            ??????TestDirectArrays();
            ??????TestPointerMath();
            ??????System.Console.WriteLine();
            ????}


            ????
            private?void?TestEnumeration()?
            ????
            {
            ??????total?
            =?new?TimeSpan(?0?);
            ??????
            for?(?int?i?=?0;?i?<?reps;?i++?)?
            ??????
            {
            ????????before?
            =?DateTime.Now;
            ????????IEnumerator?enumerator?
            =?data.GetEnumerator();
            ????????
            while?(?enumerator.MoveNext()?)?
            ????????
            {
            ??????????d?
            =?(double)?enumerator.Current;
            ????????}

            ????????total?
            +=?DateTime.Now?-?before;
            ??????}

            ??????seconds?
            =?total.Seconds?+?(?total.Milliseconds?/?1000.0?);
            ??????System.Console.WriteLine(?
            "Enumeration:?\t\t"?+?seconds?+?"?seconds"?);
            ????}


            ????
            private?void?TestIndexing()
            ????
            {
            ??????total?
            =?new?TimeSpan(?0?);
            ??????
            for?(?int?i?=?0;?i?<?reps;?i++?)?
            ??????
            {
            ????????before?
            =?DateTime.Now;
            ????????
            for?(?int?j?=?0;?j?<?size;?j++?)
            ????????
            {
            ??????????d?
            =?data[j];
            ????????}

            ????????total?
            +=?DateTime.Now?-?before;
            ??????}

            ??????seconds?
            =?total.Seconds?+?(?total.Milliseconds?/?1000.0?);
            ??????System.Console.WriteLine(?
            "Indexing:?\t\t"?+?seconds?+?"?seconds"?);??????
            ????}


            ????
            private?void?TestIndirectArrays()
            ????
            {
            ??????total?
            =?new?TimeSpan(?0?);
            ??????
            for?(?int?i?=?0;?i?<?reps;?i++?)?
            ??????
            {
            ????????before?
            =?DateTime.Now;
            ????????
            for?(?int?j?=?0;?j?<?size;?j++?)
            ????????
            {
            ??????????d?
            =?data.Array[j];
            ????????}

            ????????total?
            +=?DateTime.Now?-?before;
            ??????}

            ??????seconds?
            =?total.Seconds?+?(?total.Milliseconds?/?1000.0?);
            ??????System.Console.WriteLine(?
            "Indirect?Arrays:?\t"?+?seconds?+?"?seconds"?);?
            ????}


            ????
            private?void?TestDirectArrays()
            ????
            {
            ??????total?
            =?new?TimeSpan(?0?);
            ??????
            for?(?int?i?=?0;?i?<?reps;?i++?)?
            ??????
            {
            ????????before?
            =?DateTime.Now;
            ????????
            double[]?array?=?data.Array;
            ????????
            for?(?int?j?=?0;?j?<?size;?j++?)
            ????????
            {
            ??????????d?
            =?array[j];
            ????????}

            ????????total?
            +=?DateTime.Now?-?before;
            ??????}

            ??????seconds?
            =?total.Seconds?+?(?total.Milliseconds?/?1000.0?);
            ??????System.Console.WriteLine(?
            "Direct?Arrays:?\t\t"?+?seconds?+?"?seconds"?);
            ????}


            ????
            private?void?TestPointerMath()
            ????
            {
            ??????total?
            =?new?TimeSpan(?0?);
            ??????
            for?(?int?i?=?0;?i?<?reps;?i++?)?
            ??????
            {
            ????????before?
            =?DateTime.Now;
            ????????Pointer.iterate(?data?);
            ????????total?
            +=?DateTime.Now?-?before;
            ??????}

            ??????seconds?
            =?total.Seconds?+?(?total.Milliseconds?/?1000.0?);
            ??????System.Console.WriteLine(?
            "Pointer?Math:?\t\t"?+?seconds?+?"?seconds"?);
            ????}

            ????}

            }

            posted on 2006-04-14 12:50 夢(mèng)在天涯 閱讀(355) 評(píng)論(0)  編輯 收藏 引用 所屬分類(lèi): C#/.NET

            公告

            EMail:itech001#126.com

            導(dǎo)航

            統(tǒng)計(jì)

            • 隨筆 - 461
            • 文章 - 4
            • 評(píng)論 - 746
            • 引用 - 0

            常用鏈接

            隨筆分類(lèi)

            隨筆檔案

            收藏夾

            Blogs

            c#(csharp)

            C++(cpp)

            Enlish

            Forums(bbs)

            My self

            Often go

            Useful Webs

            Xml/Uml/html

            搜索

            •  

            積分與排名

            • 積分 - 1808116
            • 排名 - 5

            最新評(píng)論

            閱讀排行榜

            久久亚洲2019中文字幕| 日韩欧美亚洲综合久久影院Ds | 人妻精品久久久久中文字幕69| 狠狠色丁香久久婷婷综合蜜芽五月| 国内精品伊人久久久久妇| 蜜臀av性久久久久蜜臀aⅴ| 热re99久久精品国产99热| 日韩精品无码久久一区二区三| 日韩AV无码久久一区二区| 精品99久久aaa一级毛片| 色8激情欧美成人久久综合电| 无码超乳爆乳中文字幕久久| 香蕉久久夜色精品国产小说| 精品久久久久久久国产潘金莲| 青青草原综合久久大伊人精品| 少妇熟女久久综合网色欲| 香蕉久久一区二区不卡无毒影院| 久久精品亚洲AV久久久无码| 久久久久国产亚洲AV麻豆| 久久精品国产亚洲沈樵| 天堂久久天堂AV色综合| 国产精品久久久久久搜索| 久久久久亚洲AV成人网人人软件| 久久本道综合久久伊人| 欧美精品久久久久久久自慰| 久久久中文字幕日本| 精品一区二区久久| 国产亚洲综合久久系列| 无码国产69精品久久久久网站| 狠狠色丁香久久婷婷综合图片| 久久精品国产亚洲7777| 久久精品亚洲欧美日韩久久| 一本色道久久88加勒比—综合| 1000部精品久久久久久久久| 久久亚洲私人国产精品| 精品综合久久久久久97| 久久久久久久女国产乱让韩| 精品多毛少妇人妻AV免费久久| 2021国内久久精品| 青草国产精品久久久久久| 亚洲AV乱码久久精品蜜桃|