[ RMAN @ 05.02.2011. 17:35 ] @
Npr imam string od 1000 karaktera a treba mi substring npr od 350 karaktera do 700-og karaktera.

Da li ce se brse izvrsiti substring(350,700-350); ili npr for petlja koja ide od 350 do 700 i ide karakter po karakter i lepi na string?

Pretpostavljam da ce se pre izvrsiti substring ali ne znam kako izgleda ta funkcija.
[ Shadowed @ 05.02.2011. 19:50 ] @
Brze je Substring ali ne shvatam sta mislis pod tim da ne razumes kako izgleda.
[ RMAN @ 05.02.2011. 21:21 ] @
Pa, kako da objasnim, ne znam kako izgleda sam kod funkcije substring.

Vise me zanima low level, da se tako izrazim(kako se radi sa memorijom dok se radi sa stringovima.)

Nadam se da me razumes. Da li mozda ima neki pdf o ovome? Alociranje memorije dok se radi sa stringovima i slicno?

Pisem neki program gde mi je brzina jako bitna, pa bih da napravim sto brze algoritme (svaka linija koda mi je bitna).
[ Igor Gajic @ 05.02.2011. 22:40 ] @
Ubedljivo najbrze ti je da ides preko substring.

for petlja koja ide od 350 do 700 i ide karakter po karakter i lepi na string?

Ovo ce instancirati 350 stringova, znaci celih klasa i samim tim ovo je 100 puta sporije nego pozivanje f-je substring.

Moguce je odraditi preko unsafe + pointeri ali i to ce biti jedno 3-4 puta sporije



Ako ti je bas toliko stalo do brzine onda pravis posebnu C++ ili MASM biblioteku u koju ces stavljati najkriticnije f-je i po potrebi ih napisati u visoko optimizovanom asembleru.
[ Shadowed @ 06.02.2011. 00:21 ] @
Citat:
Igor Gajic: Moguce je odraditi preko unsafe + pointeri ali i to ce biti jedno 3-4 puta sporije

Substring radi tako pa pretpostavljam da bi bilo priblizno isto :)
[ Dusan Kondic @ 06.02.2011. 06:54 ] @
Ako ti je brzina jako bitna, kod možeš da proveriš tako što ćeš da ga provrtiš kroz neku petlju.
Pre i posle petlje zabeležiš vreme, i na kraju vidiš koliko je to izvršavanje trajalo.
Code:

DateTime d1 = DateTime.Now;
for(int i = 0; i < 1000; i++)
{
//Kod koji proveravamo
}
DateTime d2 = DateTime.Now;
MessageBox.Show("d2 - d1 u nekom odgovarajućem obliku npr. TimeStamp.Seconds");
[ mmix @ 06.02.2011. 10:02 ] @
Zanmimljivo kako radi frameork substring operaciju ;)

Code (csharp):


private unsafe string InternalSubString(int startIndex, int length, bool fAlwaysCopy)
{
    if (((startIndex == 0) && (length == this.Length)) && !fAlwaysCopy)
    {
        return this;
    }
    string str = FastAllocateString(length);
    fixed (char* chRef = &str.m_firstChar)
    {
        fixed (char* chRef2 = &this.m_firstChar)
        {
            wstrcpy(chRef, chRef2 + startIndex, length);
        }
    }
    return str;
}

private static unsafe void wstrcpy(char* dmem, char* smem, int charCount)
{
    if (charCount > 0)
    {
        if ((((int) dmem) & 2) != 0)
        {
            dmem[0] = smem[0];
            dmem++;
            smem++;
            charCount--;
        }
        while (charCount >= 8)
        {
            *((int*) dmem) = *((uint*) smem);
            *((int*) (dmem + 2)) = *((uint*) (smem + 2));
            *((int*) (dmem + 4)) = *((uint*) (smem + 4));
            *((int*) (dmem + 6)) = *((uint*) (smem + 6));
            dmem += 8;
            smem += 8;
            charCount -= 8;
        }
        if ((charCount & 4) != 0)
        {
            *((int*) dmem) = *((uint*) smem);
            *((int*) (dmem + 2)) = *((uint*) (smem + 2));
            dmem += 4;
            smem += 4;
        }
        if ((charCount & 2) != 0)
        {
            *((int*) dmem) = *((uint*) smem);
            dmem += 2;
            smem += 2;
        }
        if ((charCount & 1) != 0)
        {
            dmem[0] = smem[0];
        }
    }
}

 


Izgleda rogobatno ali JIT odlicno optimizuje ove operacije u 64bit/32bit/16bit move i jednu 8 bt operaiju po potrebi. Mada mi nije bas najjasnije zasto jednostavno nisu iskoristi platform dependant internal memcpy implementaciju?

[ RMAN @ 06.02.2011. 10:35 ] @
Hvala na odgovorima, dosta ste mi pomogli
[ Boris B. @ 06.02.2011. 12:32 ] @
@mmix Mozda interni memcpy ne radi tako. Secam se pre mnogo godina kad sam radio igru u C++ da memcpy za kopiranje bitmapa nije bio dovoljno brz i onda sam napisao u ASM nesto veoma slicno tome sto si postovao, (samo bez 64bit MOV naravno) i igra je radila skoro 2x brze. Ako se dobro secam problem je bio da memcpy nije smeo da pretpostavlja da je tvoja memorija aligned na 4 bajta, zato je kopirao bajt po bajt.
[ mmix @ 06.02.2011. 12:57 ] @
Slazem se, zato su pretpostavljam to i uradili. Problem je (po meni bar) sto je memcpy stvar koju treba da implementira runtime (kroz internalcall) i da se koristi sirom frameworka a ne da implementira sam IL na n mesta (identican memcpy kod postoji i u BlockMove i crypto kodu i ko zna gde jos) jer ovakav alignment nije univerzalno pravilo vec nesto sto je prisutno na intel platformi i cak prisutno potpuno drugacije na drugim platformama. Doduse posto se radi u System.* tipu iz mscore pretpostavljam da i wstrcpy za druge platforme izgleda potpuno drugacije. Ne kudim algoritam, cisto kritikujem lezeran odnos prema nacinu implementacije