Forum: D Programlama Dili RSS
malloc ile struct dan hızlı bir yapı yapılabilirmi ?
kaaninel #1
Üye Ock 2013 tarihinden beri · 22 mesaj
Grup üyelikleri: Üyeler
Profili göster · Bu konuya bağlantı
Konu adı: malloc ile struct dan hızlı bir yapı yapılabilirmi ?
Kodda gördüğünüz gibi opst diye bir struct ım var ve VM.run a bakarsanız sUP labelinin altında bu struct la ilgili 2 satır var ama bu 2 satır kodun kendisinden daha yavaş sanırım :) arraylar zaten (disasm sine bakarak konuşuyorum) çok fazla kod kaplıyor ve her seferinde struct larla uğraşmak çok saçma geliyor.

aklıma opst* ı oluşturup bunu ++ ile arttırırsam dizinin işini görür diye bi fikir geldi ama hata verdi tabiki . struct ın boyutu 20 o yüzden 20 şer arttırmayı deniyorum fakat bu seferde gelen struct yanlış oluyor içinde saçma veriler vb.  ve kodu hızlandırmak için önerilerinize açığım :)

 
struct opst
{
    void* op;
    int p1;
    int p2;
    int* a1;
    int* a2;
 
}
 
 
class VM
{
 
    int run(opst[] opca,bool fr = false)
    {
        int ca;
        opst top;
    sUP:
        top = opca[ca];
        void* jmpaddr = top.op;
        asm{ jmp jmpaddr[EBP]; 
}
}
 
opst[][string] pOPs;
void addOP(VM vm,string page,opcs op,int p1 = 0,int p2 = 0,int* a1 = cast(int*)0,int* a2 = cast(int*)0)
{
    pOPs[page] ~= opst(vm.opcL[op],p1,p2,a1,a2);
}
 
int main(string[] argv)
{
    VM vm = new VM();
    addOP(vm,"test",opcs.mov2re,2,0,&vm.a0);
    addOP(vm,"test",opcs.mov2re,5,0,&vm.a1);
    addOP(vm,"test",opcs.loop,1000000);
    addOP(vm,"test",opcs.add,0,0,&vm.a0,&vm.a1);
    addOP(vm,"test",opcs.loopend);
    addOP(vm,"test",opcs.hlt);
    auto currentTime1 = Clock.currTime();
    vm.run(pOPs["test"]);
    auto currentTime2 = Clock.currTime();
    writeln(currentTime2-currentTime1);
    writeln(vm.a0);
    while(1){}
  return 0;
}

Kaan
acehreli (Moderatör) #2
Kullanıcı başlığı: Ali Çehreli
Üye Haz 2009 tarihinden beri · 4527 mesaj
Grup üyelikleri: Genel Moderatörler, Üyeler
Profili göster · Bu konuya bağlantı
Öncelikle, başlıktaki sorunun genel yanıtı şu: Hayır, elle struct'tan daha hızlı kod üretemezsin.

struct'lar zaten olabilecek en hızlı biçimde işlerler. struct'ların yararı, kurma ve sonlandırma işlemlerinin külfetini ortadan kaldırmalarıdır. Durum C'de de aynıdır. C++'ta da öyledir.

Ama burada şunun altını çizmek gerek: Böyle karşılaştırmalar yaparken elle yazdığımız kodun işlevselliğinin de struct ile aynı olmasına dikkat etmek gerekir. Örneğin, daha yeteneksiz kod yazarak struct'tan hızlı olmayı başarabiliriz ama bu doğru bir karşılaştırma olmaz.

Daha kodu incelemedim ama D'nin dizileri indeks değerlerini denetledikleri için de zaman harcarlar. O denetimi kapatmak (ve başka eniyileştirmeler) için -O seçeneği kullanılabilir.

Buna rağmen, gdc ve ldc dmd'den çok daha hızlı kod üretiyorlar. Hızın önemli olduğu durumlarda o derleyicileri kullanmanızı öneririm.

Bir tane daha: struct'lar değer türleri olduklarından işlev parametresi olduklarında da kopyalanırlar. Eğer kopyalamak daha yavaş kalıyorsa parametre 'ref' olarak işaretlenebilir.

kaaninel:
bu 2 satır kodun kendisinden daha yavaş sanırım

"Kodun kendisi" ile ne kasdettiğini anlayamadım. :(

arraylar zaten (disasm sine bakarak konuşuyorum) çok fazla kod kaplıyor

Yapısal olarak tam gerektiği kadardırlar: İlk elemana gösterge ve eleman adedi. Diziler C'nin dizgilerinde olduğu gibi daha küçük olarak da gerçekleştirilebilirler: İlk elemanı gösteren tek gösterge olur ve son elemandan sonraya C dizgilerindeki '\0' karakteri gibi özel bir değer (sentinel) yerleştirilir. İstersen malloc ile yer ayırıp öyle de yapabilirsin.

Ama öyle yaptığın zaman D dilimlerini de geride bırakmak zorunda kalıyorsun.

her seferinde struct larla uğraşmak çok saçma geliyor.

Onu da anlamadım. :) Aslında struct'lar külfeti azaltmıyorlar mı? Bir örnek verir misin.

aklıma opst* ı oluşturup bunu ++ ile arttırırsam dizinin işini görür diye bi fikir geldi ama hata verdi tabiki

Söylediğin kadarında hatalı bir şey yok. Ne hatası verdi? Bunu gösteren küçük bir program gösterir misin.

struct ın boyutu 20 o yüzden 20 şer arttırmayı deniyorum

O yanlış olur. Eğer göstergenin türü zaten 'opst*' ise, ++opst bir sonraki elemana geçer. Yani otomatik olarak 20 bayt artar. Tabii 20 değerini opst.sizeof ile öğrendin, değil mi? Doldurma baytları da olabileceği için 4*5 hesabına güvenmek yanlış olur.

fakat bu seferde gelen struct yanlış oluyor içinde saçma veriler vb.  ve kodu hızlandırmak için önerilerinize açığım :)

Kodun tamamını vermemişsin sanırım. Ben derleyemedim.

Ali
kaaninel #3
Üye Ock 2013 tarihinden beri · 22 mesaj
Grup üyelikleri: Üyeler
Profili göster · Bu konuya bağlantı
module main;
 
import std.stdio;
import std.path;
import core.memory;
import std.datetime;
 
struct opst
{
    void* op;
    int p1;
    int p2;
    int* a1;
    int* a2;
 
}
 
enum opcs : int
{
    mov = 0,mov2re,mov2ra,
    push,pop,
    loop,loopend,
    add,sub,mul,div,
    nop,hlt
}
 
 
 
class VM
{
    int* smem;
    int* smemc;
 
    int a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,b0,b1,b2,b3,b4,b5 = 0;
 
    void*[opcs] opcL;
 
    this(int memsize = 4096)
    {
        smem = cast(int*)GC.malloc(memsize);
        smemc = smem;
        opst[] frst = new opst[1];
        run(frst,true);
    }
 
    int run(opst[] opca,bool fr = false)
    {
        void* pc;
 
        if(fr)
        {
            asm{ call l_mov        ;};opcL[opcs.mov    ] = pc + 0x1;
            asm{ call l_mov2re  ;};opcL[opcs.mov2re    ] = pc + 0x1;
            asm{ call l_mov2ra  ;};opcL[opcs.mov2ra    ] = pc + 0x1;
            asm{ call l_push    ;};opcL[opcs.push    ] = pc + 0x1;
            asm{ call l_pop        ;};opcL[opcs.pop    ] = pc + 0x1;
            asm{ call l_loop    ;};opcL[opcs.loop    ] = pc + 0x1;
            asm{ call l_loopend ;};opcL[opcs.loopend] = pc + 0x1;
            asm{ call l_add        ;};opcL[opcs.add    ] = pc + 0x1;
            asm{ call l_sub        ;};opcL[opcs.sub    ] = pc + 0x1;
            asm{ call l_mul        ;};opcL[opcs.mul    ] = pc + 0x1;
            asm{ call l_div        ;};opcL[opcs.div    ] = pc + 0x1;
            asm{ call l_nop        ;};opcL[opcs.nop    ] = pc + 0x1;
            asm{ call l_hlt        ;};opcL[opcs.hlt    ] = pc + 0x1;
            return 0;
        }
        int ca;
        opst top;
    sUP:
        top = opca[ca];
        void* jmpaddr = top.op;
        asm{ jmp jmpaddr[EBP]; }
    l_mov:
                asm{ call taddr; ret;}
                *(top.a1) = *(top.a2);
                ca++;
                goto sUP;
    l_mov2re:
                asm{ call taddr; ret;}
                *(top.a1) = top.p1;
                ca++;
                goto sUP;
    l_mov2ra:
                asm{ call taddr; ret;}
                *smemc = top.p1;
                smemc++;
                ca++;
                goto sUP;
    l_push:
                asm{ call taddr; ret;}
                *smemc = *(top.a1);
                smemc++;
                ca++;
                goto sUP;
    l_pop:
                asm{ call taddr; ret;}
                smemc--;
                *(top.a1) = *smemc ;
                ca++;
                goto sUP;
    l_loop:
                asm{ call taddr; ret;}
                b5 = top.p1;
                b4 = ca;
                ca++;
                goto sUP;
    l_loopend:
                asm{ call taddr; ret;}
                if(b3<b5)
                {
                    ca = b4;
                    b3++;
                }
                ca++;
                goto sUP;
    l_add:
                asm{ call taddr; ret;}
                *(top.a1) += *(top.a2);
                ca++;
                goto sUP;
    l_sub:
                asm{ call taddr; ret;}
                *(top.a1) -= *(top.a2);
                ca++;
                goto sUP;
    l_mul:
                asm{ call taddr; ret;}
                *(top.a1) *= *(top.a2);
                ca++;
                goto sUP;
    l_div:
                asm{ call taddr; ret;}
                *(top.a1) /= *(top.a2);
                ca++;
                goto sUP;
    l_nop:
                asm{ call taddr; ret;}
                ca++;
                goto sUP;
    l_hlt:
                asm{ call taddr; ret;}
                goto sDown;
        ca++;
        goto sUP;
    sDown:
        return 0;
    taddr:
        asm
        {
            pop EBX;
            mov pc[EBP],EBX;
            ret;
        }
    }
}
 
opst[][string] pOPs;
void addOP(VM vm,string page,opcs op,int p1 = 0,int p2 = 0,int* a1 = cast(int*)0,int* a2 = cast(int*)0)
{
    pOPs[page] ~= opst(vm.opcL[op],p1,p2,a1,a2);
}
 
int main(string[] argv)
{
    VM vm = new VM();
    addOP(vm,"test",opcs.mov2re,2,0,&vm.a0);
    addOP(vm,"test",opcs.mov2re,5,0,&vm.a1);
    addOP(vm,"test",opcs.loop,1000000);
    addOP(vm,"test",opcs.add,0,0,&vm.a0,&vm.a1);
    addOP(vm,"test",opcs.loopend);
    addOP(vm,"test",opcs.hlt);
    auto currentTime1 = Clock.currTime();
    vm.run(pOPs["test"]);
    auto currentTime2 = Clock.currTime();
    writeln(currentTime2-currentTime1);
    writeln(vm.a0);
    while(1){}
  return 0;
}

Kodun tamamı bu çalışan hali .

ben bu yazıyı yazarken baya saçmalamışım aklıma bişeyi takınca genelde böyle oluyor :)

 
00402463  mov         esi,dword ptr [ca]  
00402466  cmp         esi,dword ptr [opca]  
00402469  jb          main@VM@run+41Dh (0402475h)  
0040246B  mov         eax,46h  
00402470  call        main@__array (040A950h)  
00402475  mov         edx,dword ptr [ca]  
00402478  lea         esi,[edx+edx*4]  
0040247B  lea         esi,[esi*4]  
00402482  mov         edx,dword ptr [ebp+10h]  
00402485  mov         eax,dword ptr [opca]  
00402488  add         esi,edx  
0040248A  lea         edi,[top]  
0040248D  movs        dword ptr es:[edi],dword ptr [esi]  
0040248E  movs        dword ptr es:[edi],dword ptr [esi]  
0040248F  movs        dword ptr es:[edi],dword ptr [esi]  
00402490  movs        dword ptr es:[edi],dword ptr [esi]  
00402491  movs        dword ptr es:[edi],dword ptr [esi]
bu sadece
 
        top = opca[ca];
kodunun disasm hali eğer kodun tamamını incelerseniz asıl işlevler(benim çalıştırmak istediğim l_add gibi) bu kadar kod gerektirmiyor. şu anda pOPs["test"] in içini 1_000_000 tane nop(l_nop) op u doldurursak hiç bir işlem yapmamasına rağmen diziden eleman okumak ve ca değişkenini arttırmak 10 ms sürüyor. değişkeni arttırmak zaten çok zaman harcamadığından geriye diziden eleman okumak kalıyor. açıkcası bana array kadar karışık bi sistem gerekmiyor. sadece malloc ile yer açıp burdan struct ımı okusam yeterli. ++ ile denediğimde ise "not a scaler, opst" tarzı bir hata alıyorum(hata tamamen bu değil ama önemli kısımları bunlardı sanırım). c# dan d ye geçince herşey birbirine girdi bazen 1 saat boyunca hatanın nerde olduğunu arayıpta cast yazmadığımı gördüğümde kafayı yiyorum :)
 
c# = (int*)asd;
d = cast(int*)asd;
bu yüzden hatalarda uyarırsanızda sevinirim :D
kaaninel #4
Üye Ock 2013 tarihinden beri · 22 mesaj
Grup üyelikleri: Üyeler
Profili göster · Bu konuya bağlantı
bir arkadaşımın önerisi üzerine şöyle bir kod denedim :
module main;
 
import std.stdio;
import std.path;
import core.memory;
import std.datetime;
 
struct opst
{
    void* op;
    int p1;
    int p2;
    int* a1;
    int* a2;
    opst* n;
}
 
enum opcs : int
{
    mov = 0,mov2re,mov2ra,
    push,pop,
    loop,loopend,
    add,sub,mul,div,
    rsr,nop,hlt
}
 
class VM
{
    int* smem;
    int* smemc;
 
    int a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,b0,b1,b2,b3,b4,b5 = 0;
 
    void*[opcs] opcL;
 
    this(int memsize = 4096)
    {
        smem = cast(int*)GC.malloc(memsize);
        smemc = smem;
        opst* frst = cast(opst*)0;
        run(frst,true);
    }
    int run(opst* top,bool fr = false)
    {
        void* pc;
        if(fr)
        {
            asm{ call l_mov        ;};opcL[opcs.mov    ] = pc + 0x1;
            asm{ call l_mov2re  ;};opcL[opcs.mov2re    ] = pc + 0x1;
            asm{ call l_mov2ra  ;};opcL[opcs.mov2ra    ] = pc + 0x1;
            asm{ call l_push    ;};opcL[opcs.push    ] = pc + 0x1;
            asm{ call l_pop        ;};opcL[opcs.pop    ] = pc + 0x1;
            asm{ call l_loop    ;};opcL[opcs.loop    ] = pc + 0x1;
            asm{ call l_loopend ;};opcL[opcs.loopend] = pc + 0x1;
            asm{ call l_add        ;};opcL[opcs.add    ] = pc + 0x1;
            asm{ call l_sub        ;};opcL[opcs.sub    ] = pc + 0x1;
            asm{ call l_mul        ;};opcL[opcs.mul    ] = pc + 0x1;
            asm{ call l_div        ;};opcL[opcs.div    ] = pc + 0x1;
            asm{ call l_nop        ;};opcL[opcs.nop    ] = pc + 0x1;
            asm{ call l_hlt        ;};opcL[opcs.hlt    ] = pc + 0x1;
            asm{ call l_rsr        ;};opcL[opcs.rsr    ] = pc + 0x1;
            return 0;
        }
    sUP:
        void* jmpaddr = top.op;
        asm{ jmp jmpaddr[EBP]; }
    l_mov:
        asm{ call taddr; ret;}
        *(top.a1) = *(top.a2);
        top = top.n;
        goto sUP;
    l_mov2re:
        asm{ call taddr; ret;}
        *(top.a1) = top.p1;
        top = top.n;
        goto sUP;
    l_mov2ra:
        asm{ call taddr; ret;}
        *smemc = top.p1;
        smemc++;
        top = top.n;
        goto sUP;
    l_push:
        asm{ call taddr; ret;}
        *smemc = *(top.a1);
        smemc++;
        top = top.n;
        goto sUP;
    l_pop:
        asm{ call taddr; ret;}
        smemc--;
        *(top.a1) = *smemc ;
        top = top.n;
        goto sUP;
    l_loop:
        asm{ call taddr; ret;}
        b5 = top.p1;
        top = top.n;
        b4 = cast(int)top;
        goto sUP;
    l_loopend:
        asm{ call taddr; ret;}
        if(b3<b5)
        {
            top = cast(opst*)b4;
            b3++;
        }
        else
            top = top.n;
        goto sUP;
    l_add:
        asm{ call taddr; ret;}
        *(top.a1) += *(top.a2);
        top = top.n;
        goto sUP;
    l_sub:
        asm{ call taddr; ret;}
        *(top.a1) -= *(top.a2);
        top = top.n;
        goto sUP;
    l_mul:
        asm{ call taddr; ret;}
        *(top.a1) *= *(top.a2);
        top = top.n;
        goto sUP;
    l_div:
        asm{ call taddr; ret;}
        *(top.a1) /= *(top.a2);
        top = top.n;
        goto sUP;
    l_nop:
        asm{ call taddr; ret;}
        top = top.n;
        goto sUP;
    l_rsr:
        asm{ call taddr; ret;}
        a0 = a1 = a2 =a3 = a4 = a5 = a6 = a7 = a8 = a9 = b0 = b1 = b2 = b3 = b4 = b5 = 0;
        top = top.n;
        goto sUP;
    l_hlt:
        asm{ call taddr; ret;}
        goto sDown;
    sDown:
        return 0;
    taddr:
        asm
        {
            pop EBX;
            mov pc[EBP],EBX;
            ret;
        }
    }
}
 
int[string] locc;
int[string] cmax;
opst[string] pOPcs;
 
opst* current;
 
void addOP(VM vm,string page,opcs op,int p1 = 0,int p2 = 0,int* a1 = cast(int*)0,int* a2 = cast(int*)0)
{    
    if(page !in pOPcs)
    {
        pOPcs[page] = opst(vm.opcL[op],p1,p2,a1,a2);
        current = &pOPcs[page];
    }
    else
    {
        opst* p = cast(opst*)GC.malloc(opst.sizeof);
        (*p) = opst(vm.opcL[op],p1,p2,a1,a2);
        current.n = p;
        current = (*current).n;
    }
 
}
 
int main(string[] argv)
{
    VM vm = new VM();
    addOP(vm,"test",opcs.mov2re,2,0,&vm.a0);
    addOP(vm,"test",opcs.mov2re,3,0,&vm.a1);
    addOP(vm,"test",opcs.loop,1000000);
    addOP(vm,"test",opcs.add,0,0,&vm.a0,&vm.a1);
    addOP(vm,"test",opcs.loopend);
    addOP(vm,"test",opcs.hlt);
    auto currentTime1 = Clock.currTime();
    vm.run(&pOPcs["test"]);
    auto currentTime2 = Clock.currTime();
    writeln(currentTime2-currentTime1);
    writeln(vm.a0);
    while(1){}
  return 0;
}

ama buda çok kararsız arraydan hızlı olmasına rağmen bazen arrayla aynı hızda çıkabiliyor.
(benim bilgisayar için
array = 18-20 ms
bu kod = 10-20 ms
) çok yüksek bir değişme aralığı var ve istediğim performansı vermiyor.

Bundan önce ise

module main;
 
import std.stdio;
import std.path;
import core.memory;
import std.datetime;
 
struct opst
{
    void* op;
    int p1;
    int p2;
    int* a1;
    int* a2;
}
 
enum opcs : int
{
    mov = 0,mov2re,mov2ra,
    push,pop,
    loop,loopend,
    add,sub,mul,div,
    rsr,nop,hlt
}
 
class VM
{
    int* smem;
    int* smemc;
 
    int a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,b0,b1,b2,b3,b4,b5 = 0;
 
    void*[opcs] opcL;
 
    this(int memsize = 4096)
    {
        smem = cast(int*)GC.malloc(memsize);
        smemc = smem;
        opst* frst = cast(opst*)0;
        run(frst,true);
    }
 
    int run(opst* top,bool fr = false)
    {
        void* pc;
        if(fr)
        {
            asm{ call l_mov        ;};opcL[opcs.mov    ] = pc + 0x1;
            asm{ call l_mov2re  ;};opcL[opcs.mov2re    ] = pc + 0x1;
            asm{ call l_mov2ra  ;};opcL[opcs.mov2ra    ] = pc + 0x1;
            asm{ call l_push    ;};opcL[opcs.push    ] = pc + 0x1;
            asm{ call l_pop        ;};opcL[opcs.pop    ] = pc + 0x1;
            asm{ call l_loop    ;};opcL[opcs.loop    ] = pc + 0x1;
            asm{ call l_loopend ;};opcL[opcs.loopend] = pc + 0x1;
            asm{ call l_add        ;};opcL[opcs.add    ] = pc + 0x1;
            asm{ call l_sub        ;};opcL[opcs.sub    ] = pc + 0x1;
            asm{ call l_mul        ;};opcL[opcs.mul    ] = pc + 0x1;
            asm{ call l_div        ;};opcL[opcs.div    ] = pc + 0x1;
            asm{ call l_nop        ;};opcL[opcs.nop    ] = pc + 0x1;
            asm{ call l_hlt        ;};opcL[opcs.hlt    ] = pc + 0x1;
            asm{ call l_rsr        ;};opcL[opcs.rsr    ] = pc + 0x1;
            return 0;
        }
    sUP:
        void* jmpaddr = top.op;
        asm{ jmp jmpaddr[EBP]; }
    l_mov:
        asm{ call taddr; ret;}
        *(top.a1) = *(top.a2);
        top++;
        goto sUP;
    l_mov2re:
        asm{ call taddr; ret;}
        *(top.a1) = top.p1;
        top++;
        goto sUP;
    l_mov2ra:
        asm{ call taddr; ret;}
        *smemc = top.p1;
        smemc++;
        top++;
        goto sUP;
    l_push:
        asm{ call taddr; ret;}
        *smemc = *(top.a1);
        smemc++;
        top++;
        goto sUP;
    l_pop:
        asm{ call taddr; ret;}
        smemc--;
        *(top.a1) = *smemc ;
        top++;
        goto sUP;
    l_loop:
        asm{ call taddr; ret;}
        b5 = top.p1;
        top++;
        b4 = cast(int)top;
        goto sUP;
    l_loopend:
        asm{ call taddr; ret;}
        if(b3<b5)
        {
            top = cast(opst*)b4;
            b3++;
        }
        else
            top++;
        goto sUP;
    l_add:
        asm{ call taddr; ret;}
        *(top.a1) += *(top.a2);
        top++;
        goto sUP;
    l_sub:
        asm{ call taddr; ret;}
        *(top.a1) -= *(top.a2);
        top++;
        goto sUP;
    l_mul:
        asm{ call taddr; ret;}
        *(top.a1) *= *(top.a2);
        top++;
        goto sUP;
    l_div:
        asm{ call taddr; ret;}
        *(top.a1) /= *(top.a2);
        top++;
        goto sUP;
    l_nop:
        asm{ call taddr; ret;}
        top++;
        goto sUP;
    l_rsr:
        asm{ call taddr; ret;}
        a0 = a1 = a2 =a3 = a4 = a5 = a6 = a7 = a8 = a9 = b0 = b1 = b2 = b3 = b4 = b5 = 0;
        top++;
        goto sUP;
    l_hlt:
        asm{ call taddr; ret;}
        goto sDown;
    sDown:
        return 0;
    taddr:
        asm
        {
            pop EBX;
            mov pc[EBP],EBX;
            ret;
        }
    }
}
 
int[string] locc;
int[string] cmax;
opst*[string] pOPcs;
 
void addOP(VM vm,string page,opcs op,int p1 = 0,int p2 = 0,int* a1 = cast(int*)0,int* a2 = cast(int*)0)
{
    if(page !in pOPcs)
    {
        cmax[page] = 10;
        locc[page] = 0;
        pOPcs[page] = cast(opst*)GC.malloc(cmax[page]*opst.sizeof);
    }
    else
    {
        if(!(locc[page]<cmax[page]))
        {
            cmax[page] += 10;
            pOPcs[page] = cast(opst*)GC.realloc(pOPcs[page], cmax[page] * opst.sizeof);
        }
    }
    *(cast(opst*)((cast(int)pOPcs[page]) + (locc[page] * opst.sizeof))) = opst(vm.opcL[op],p1,p2,a1,a2);
    locc[page]++;
}
 
int main(string[] argv)
{
    VM vm = new VM();
    addOP(vm,"test",opcs.mov2re,2,0,&vm.a0);
    addOP(vm,"test",opcs.mov2re,5,0,&vm.a1);
    addOP(vm,"test",opcs.loop,1000000);
    addOP(vm,"test",opcs.add,0,0,&vm.a0,&vm.a1);
    addOP(vm,"test",opcs.loopend);
    addOP(vm,"test",opcs.hlt);
    auto currentTime1 = Clock.currTime();
    vm.run(pOPcs["test"]);
    auto currentTime2 = Clock.currTime();
    writeln(currentTime2-currentTime1);
    writeln(vm.a0);
    while(1){}
  return 0;
}

bu şekilde bir kod yazdım ve 5-8 ms aralığında zaman alıyor. Ulaşmak istediğim performans bu fakat bu koddada addOP fonksiyonundaki realloc da sorun var sanırım. ilk 10 tane op için sorun çıkarmasada(bunları malloc ile açtığımdan) sonrasında realloc u kullanamadığım için daha fazla struct ekleyemiyorum bu sorunu aşabilirsem performans açısından (benim için en azından) çok iyi olacak.
kaaninel #5
Üye Ock 2013 tarihinden beri · 22 mesaj
Grup üyelikleri: Üyeler
Profili göster · Bu konuya bağlantı
Konuyu kapatabiliriz sorunu hallettim.
Doğrulama Kodu: VeriCode Lütfen resimde gördüğünüz doğrulama kodunu girin:
İfadeler: :-) ;-) :-D :-p :blush: :cool: :rolleyes: :huh: :-/ <_< :-( :'( :#: :scared: 8-( :nuts: :-O
Özel Karakterler:
Bağlı değilsiniz. · Şifremi unuttum · ÜYELİK
This board is powered by the Unclassified NewsBoard software, 20100516-dev, © 2003-10 by Yves Goergen
Şu an: 2017-11-18, 00:34:12 (UTC -08:00)