Bitwise shift operators versus alm. Gange & Dividere

Shift i.s.f. gange og divider var noget man gjorde i 16, 20 og 25 MHz
dagene.

Jeg er overbevist om at * er lige så hurtig som << på moderne CPU'er.

>> er muligvis stadig hurtigere end / (ikke så meget på x86 men meget på
forskellige RISC).

Compileren kan principielt godt optimere hvis den kan gennemskue at det
er en konstant.

Og selvom den måske ikke gør det nu, så gør den det måske i næste version.

Medmindre du koder ekstremte tidskritiske applikationer (kryptografisk
analyser eller lignende), så fokuser på at skrive letlæselig kode og
glem alt om den slags optimeringer.

Kode:

using System;

class MainClass
{
    private const int N = 1000000000;
    public static void Main(string[] args)
    {
        int tmp;
        tmp = 0;
        long t1 = DateTime.Now.Ticks;
        for(int i = 0; i < N; i++)
        {
            for(int j = 0; j < 10; j++)
            {
                tmp = tmp << 1;
            }
        }
        long t2 = DateTime.Now.Ticks;
        Console.WriteLine("<<1 : " + (t2 - t1));
        tmp = 0;
        long t3 = DateTime.Now.Ticks;
        for(int i = 0; i < N; i++)
        {
            for(int j = 0; j < 10; j++)
            {
                tmp = tmp * 2;
            }
        }
        long t4 = DateTime.Now.Ticks;
        Console.WriteLine("*2  : " + (t4 - t3));
        tmp = 0;
        long t5 = DateTime.Now.Ticks;
        for(int i = 0; i < N; i++)
        {
            for(int j = 0; j < 10; j++)
            {
                tmp = tmp >> 1;
            }
        }
        long t6 = DateTime.Now.Ticks;
        Console.WriteLine(">>1 : " + (t6 - t5));
        tmp = 0;
        long t7 = DateTime.Now.Ticks;
        for(int i = 0; i < N; i++)
        {
            for(int j = 0; j < 10; j++)
            {
                tmp = tmp / 2;
            }
        }
        long t8 = DateTime.Now.Ticks;
        Console.WriteLine("/2  : " + (t8 - t7));
    }
}

Output:

<<1 : 18281250
*2  : 12031250
>>1 : 12031250
/2  : 208437500

Det kan slet ikke betale sig at << i.s.f. *.

>> er hurtigere end /, men 10 milliarder divsioner på 20 sekunder
er ike et problem for de fleste apps.

jeg takker mange gange for den fine forklaring samt test