Что особенного в цикле foreach, который устраняет проверку границ? - PullRequest
Новая
       14

Что особенного в цикле foreach, который устраняет проверку границ?

5 голосов
/ 10 марта 2009

Каков особый случай с циклом foreach / for, который устраняет проверку границ? Кроме того, какие границы проверки это?

Ответы [ 5 ]

9 голосов
/ 10 марта 2009

Стандарт 

for(int i = 0; i < array.Length; i++) {
    ...
}
Цикл

позволяет JIT безопасно удалять проверки границ массива (находится ли индекс в пределах [0..length-1])

Массивы с циклом foreach эквивалентны стандартным for массивам с циклом.

EDIT: Как указывает Роберт Джеппезен:

Это будет оптимизировано, если массив местный. Если массив доступен из другие места, проверка границ будет все еще будет выполнено. Ссылка: JIT, NGen, and other Managed Code Generation Stuff > Array Bounds Check Elimination in the CLR "> Устранение проверки границ массива в CLR

Спасибо! Я сам этого не знал.

7 голосов
/ 10 марта 2009

SealedSun прав. Не оптимизируйте так, как в C ++. JIT достаточно умен, чтобы делать правильные вещи для вас. Вы всегда можете закодировать цикл разными способами, а затем проверить код IL. 

        static void Main(string[] args)
        {
            int[] array = new int[100];
00000000  push        edi  
00000001  push        esi  
00000002  push        eax  
00000003  xor         eax,eax 
00000005  mov         dword ptr [esp],eax 
00000008  mov         edx,64h 
0000000d  mov         ecx,79174292h 
00000012  call        49E73198 
00000017  mov         esi,eax 
            int sum = 0;
00000019  xor         edx,edx 
0000001b  mov         dword ptr [esp],edx 
            for(int index = 0; index < array.Length; index++)
0000001e  mov         edi,dword ptr [esi+4] 
00000021  test        edi,edi 
00000023  jle         00000033 
            {
                sum += array[index];
00000025  mov         eax,dword ptr [esi+edx*4+8] 
00000029  add         dword ptr [esp],eax 
            for(int index = 0; index < array.Length; index++)
0000002c  add         edx,1 
0000002f  cmp         edi,edx 
00000031  jg          00000025 
            }

            Console.WriteLine(sum.ToString());
00000033  mov         esi,dword ptr [esp] 
00000036  call        493765F8 
0000003b  push        eax  
0000003c  mov         ecx,esi 
0000003e  xor         edx,edx 
00000040  call        49E83A8B 
00000045  mov         edi,eax 
00000047  mov         edx,88h 
0000004c  mov         ecx,1 
00000051  call        49E731B0 
00000056  mov         esi,eax 
00000058  cmp         dword ptr [esi+70h],0 
0000005c  jne         00000068 
0000005e  mov         ecx,1 
00000063  call        4936344C 
00000068  mov         ecx,dword ptr [esi+70h] 
0000006b  mov         edx,edi 
0000006d  mov         eax,dword ptr [ecx] 
0000006f  call        dword ptr [eax+000000D8h] 
00000075  pop         ecx  
        }
00000076  pop         esi  
00000077  pop         edi  
00000078  ret

Теперь, если оптимизировать код так же, как в C ++, вы получите следующее: 

        static void Main(string[] args)
        {
            int[] array = new int[100];
00000000  push        edi  
00000001  push        esi  
00000002  push        ebx  
00000003  push        eax  
00000004  xor         eax,eax 
00000006  mov         dword ptr [esp],eax 
00000009  mov         edx,64h 
0000000e  mov         ecx,79174292h 
00000013  call        49E73198 
00000018  mov         esi,eax 
            int sum = 0;
0000001a  xor         edx,edx 
0000001c  mov         dword ptr [esp],edx 

            int length = array.Length;
0000001f  mov         ebx,dword ptr [esi+4] 
            for (int index = 0; index < length; index++)
00000022  test        ebx,ebx 
00000024  jle         0000003B 
00000026  mov         edi,dword ptr [esi+4] 
            {
                sum += array[index];
00000029  cmp         edx,edi                  <-- HERE
0000002b  jae         00000082                 <-- HERE
0000002d  mov         eax,dword ptr [esi+edx*4+8] 
00000031  add         dword ptr [esp],eax 
            for (int index = 0; index < length; index++)
00000034  add         edx,1 
00000037  cmp         edx,ebx 
00000039  jl          00000029 
            }

            Console.WriteLine(sum.ToString());
0000003b  mov         esi,dword ptr [esp] 
0000003e  call        493765F8 
00000043  push        eax  
00000044  mov         ecx,esi 
00000046  xor         edx,edx 
00000048  call        49E83A8B 
0000004d  mov         edi,eax 
0000004f  mov         edx,88h 
00000054  mov         ecx,1 
00000059  call        49E731B0 
0000005e  mov         esi,eax 
00000060  cmp         dword ptr [esi+70h],0 
00000064  jne         00000070 
00000066  mov         ecx,1 
0000006b  call        4936344C 
00000070  mov         ecx,dword ptr [esi+70h] 
00000073  mov         edx,edi 
00000075  mov         eax,dword ptr [ecx] 
00000077  call        dword ptr [eax+000000D8h] 
0000007d  pop         ecx  
        }
0000007e  pop         ebx  
0000007f  pop         esi  
00000080  pop         edi  
00000081  ret              
00000082  call        4A12746B 
00000087  int         3

Кстати, то же самое с оператором foreach: 

        static void Main(string[] args)
        {
            int[] array = new int[100];
00000000  push        edi  
00000001  push        esi  
00000002  push        eax  
00000003  xor         eax,eax 
00000005  mov         dword ptr [esp],eax 
00000008  mov         edx,64h 
0000000d  mov         ecx,79174292h 
00000012  call        49E73198 
00000017  mov         esi,eax 
            int sum = 0;
00000019  xor         edx,edx 
0000001b  mov         dword ptr [esp],edx 
            for(int index = 0; index < array.Length; index++)
0000001e  mov         edi,dword ptr [esi+4] 
00000021  test        edi,edi 
00000023  jle         00000033 
            {
                sum += array[index];
00000025  mov         eax,dword ptr [esi+edx*4+8] 
00000029  add         dword ptr [esp],eax 
            for(int index = 0; index < array.Length; index++)
0000002c  add         edx,1 
0000002f  cmp         edi,edx 
00000031  jg          00000025 
            }

            Console.WriteLine(sum.ToString());
00000033  mov         esi,dword ptr [esp] 
00000036  call        493765F8 
0000003b  push        eax  
0000003c  mov         ecx,esi 
0000003e  xor         edx,edx 
00000040  call        49E83A8B 
00000045  mov         edi,eax 
00000047  mov         edx,88h 
0000004c  mov         ecx,1 
00000051  call        49E731B0 
00000056  mov         esi,eax 
00000058  cmp         dword ptr [esi+70h],0 
0000005c  jne         00000068 
0000005e  mov         ecx,1 
00000063  call        4936344C 
00000068  mov         ecx,dword ptr [esi+70h] 
0000006b  mov         edx,edi 
0000006d  mov         eax,dword ptr [ecx] 
0000006f  call        dword ptr [eax+000000D8h] 
00000075  pop         ecx  
        }
00000076  pop         esi  
00000077  pop         edi  
00000078  ret

Не пытайтесь оптимизировать свой код без цифр. Как вы можете видеть, JIT многое сделает для вас, если вы не будете на его пути. Используйте профилировщик, прежде чем оптимизировать. ВСЕГДА.

6 голосов
/ 10 марта 2009

См. Это для деталей:

http://codebetter.com/blogs/david.hayden/archive/2005/02/27/56104.aspx

По сути, если у вас есть цикл for и вы явно ссылаетесь на IList.Count или Array.Length, JIT поймает это и пропустит проверку границ. Это делает это быстрее, чем предварительные вычисления длины списка.

foreach для списка или массива будет делать то же самое внутренне, я считаю.

0 голосов
/ 10 марта 2009

Цикл foreach использует перечислитель, который является классом или структурой, которая обрабатывает цикл. Перечислитель имеет свойство Current, которое возвращает текущий элемент из коллекции. Это исключает использование индекса для доступа к элементу в коллекции, поэтому дополнительный шаг для получения элемента, включая проверку границ, не требуется.

0 голосов
/ 10 марта 2009

Что? Я не уверен, возможно ли вообще исключить проверку границ в c #. Если вы хотите неуправляемый код, используйте: 

int[] array;
fixed (int * i = array)
{
 while (i++)
  Console.WriteLine("{0}", *i);
}

например - он не проверяет границы и ужасно умирает. : -)

Добро пожаловать на сайт PullRequest, где вы можете задавать вопросы и получать ответы от других членов сообщества.

Похожие темы

...