Sayfa:  1  2  sonraki 

Mesajlarını aradığınız kullanıcı: kaaninel (22)

konu: Kaynak kod'a dosya gömülebilir mi?  ; forum:: D Programlama Dili
kaaninel #1
Üye Ock 2013 tarihinden beri · 22 mesaj
Grup üyelikleri: Üyeler
Profili göster · Bu konuya bağlantı
Kodu denemedim fakat dosyayı string olarak veya herhangi bir array içinde saklayıp sonradan istediğin türde cast edebilirsin.

string OneClick_Data = "Buraya Gömülecek Dosya Verisi";
byte[] dosyaOneClick = cast(byte[])OneClick_Data;
Bunu otomatik yapması için bir d fonksiyonu geliştirebilirsiniz.
Bu mesaj kaaninel tarafından değiştirildi; zaman: 2013-07-01, 17:39.
konu: linux dinamik kütüphane çağırma  ; forum:: D Programlama Dili
kaaninel #2
Üye Ock 2013 tarihinden beri · 22 mesaj
Grup üyelikleri: Üyeler
Profili göster · Bu konuya bağlantı
Yanıtlanan mesaj ID 9540
Çok teşekkürler kodları buna göre düzenledim. Rhodeus Script i Ubuntu x64 de çalıştırmayı deniyorum ve sadece hata çıkıyor karşıma ama kodları düzenleyip crossplatform desteklemesini sağlayacağım.

Kaan
konu: linux dinamik kütüphane çağırma  ; forum:: D Programlama Dili
kaaninel #3
Üye Ock 2013 tarihinden beri · 22 mesaj
Grup üyelikleri: Üyeler
Profili göster · Bu konuya bağlantı
Yanıtlanan mesaj ID 9532
Aslında tam olarak böyle değil. Bu yazdığınız kodlarda so dosyalarına compile time erişiyor ama bizim ihtiyacımız olan şey bu so dosyalarını runtime olarak erişip içindeki fonksiyonları çağırmak.

Runtime.loadLibrary ile bu dosyalara erişebiliyoruz ama içerisindeki işlevlere windows ortamında farproc ile erişebilirken linuxda bunun karşılığı ne bilmiyorum. Bunun linux için karşılığı var mı?

Kaan
konu: linux dinamik kütüphane çağırma  ; forum:: D Programlama Dili
kaaninel #4
Üye Ock 2013 tarihinden beri · 22 mesaj
Grup üyelikleri: Üyeler
Profili göster · Bu konuya bağlantı
Konu adı: linux dinamik kütüphane çağırma
Windows ortamında rahatlıkla dinamik olarak dll çağırabiliyorum aynı şekilde linuxda da so kütüphanelerini çağrımak istiyorum ama windowsta FARPROC diye bir şey kullanıyoruz ve sanırım linux için bunu nasıl yapabiliriz ?
konu: GDB (ubuntu)  ; forum:: D Programlama Dili
kaaninel #5
Üye Ock 2013 tarihinden beri · 22 mesaj
Grup üyelikleri: Üyeler
Profili göster · Bu konuya bağlantı
Yanıtlanan mesaj ID 9522
sorunu bende tam olarak bilmiyorum http://mono-d.alexanderbothe.com/?p=997 burdaki yorumlarda tartışılmış bu sorun . sadece ubuntu altında windowsta visual studio ile yaptığım gibi d kodunu disasm ile incelemekti. zaten bir süre c++ ile ilgileneceğim sanırım bu yüzden çok büyük sorun değil.
konu: GDB (ubuntu)  ; forum:: D Programlama Dili
kaaninel #6
Üye Ock 2013 tarihinden beri · 22 mesaj
Grup üyelikleri: Üyeler
Profili göster · Bu konuya bağlantı
Yanıtlanan mesaj ID 9517
sorun .net değil . zaten .net yazcak olsam windowstan ayrılamazdım . d için soruyorum bunu
konu: malloc ile struct dan hızlı bir yapı yapılabilirmi ?  ; forum:: D Programlama Dili
kaaninel #7
Üye Ock 2013 tarihinden beri · 22 mesaj
Grup üyelikleri: Üyeler
Profili göster · Bu konuya bağlantı
Yanıtlanan mesaj ID 9509
Konuyu kapatabiliriz sorunu hallettim.
konu: GDB (ubuntu)  ; forum:: D Programlama Dili
kaaninel #8
Üye Ock 2013 tarihinden beri · 22 mesaj
Grup üyelikleri: Üyeler
Profili göster · Bu konuya bağlantı
Konu adı: GDB (ubuntu)
Sonunda mono-develop a güvenerek ubuntuya geçtim fakat gdb sorun çıkartıyor ve debug yapamıyorum. windowstayken 32 bit derliyodum ama şimdi 64 bit derlemeye çalışıyorum fakat pointerlarda sorun var gibi görünüyor gdb çalışmadığı içinde hiç bişey anlayamıyorum. IDE - debugger önerilerinize açığım

Kaan
konu: malloc ile struct dan hızlı bir yapı yapılabilirmi ?  ; forum:: D Programlama Dili
kaaninel #9
Üye Ock 2013 tarihinden beri · 22 mesaj
Grup üyelikleri: Üyeler
Profili göster · Bu konuya bağlantı
Yanıtlanan mesaj ID 9507
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.
konu: Ne tür müzikler dinlersiniz  ; forum:: Tanışma ve Kaynaşma
kaaninel #10
Üye Ock 2013 tarihinden beri · 22 mesaj
Grup üyelikleri: Üyeler
Profili göster · Bu konuya bağlantı
Yanıtlanan mesaj ID 9454
burada Linkin Park'ı rahatlatıcı bulan tek ben miyim :)

Talhaya yanındayken söyleyince dinlemiyor bile beni çok gürültülüymüş o yüzden onu saymıyorum zaten onu 2 senedir çözemedim bu saatten sonrada çözeceğime inanmıyorum :D
konu: malloc ile struct dan hızlı bir yapı yapılabilirmi ?  ; forum:: D Programlama Dili
kaaninel #11
Üye Ock 2013 tarihinden beri · 22 mesaj
Grup üyelikleri: Üyeler
Profili göster · Bu konuya bağlantı
Yanıtlanan mesaj ID 9506
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
konu: malloc ile struct dan hızlı bir yapı yapılabilirmi ?  ; forum:: D Programlama Dili
kaaninel #12
Ü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
konu: Matrix  ; forum:: D Programlama Dili
kaaninel #13
Üye Ock 2013 tarihinden beri · 22 mesaj
Grup üyelikleri: Üyeler
Profili göster · Bu konuya bağlantı
Yanıtlanan mesaj ID 8989
Çok dalgınım bu ara :D
R[int][int][int] Matrix;
şeklindeydi aslında neden silmişim bilmiyorum :D Biraz gereksiz bir başlık oldu :D
konu: Matrix  ; forum:: D Programlama Dili
kaaninel #14
Üye Ock 2013 tarihinden beri · 22 mesaj
Grup üyelikleri: Üyeler
Profili göster · Bu konuya bağlantı
Konu adı: Matrix
Bir matrix oluşturdum ve içine veri atmaya çalışıyorum fakat ram hatası veriyor. Önce kendi yazdığım kodlardan sandım fakat o koda kadar hatta ondan birkaç satır sonrada hiç bir adres işlemi yapmamışım. Debug yaptığımda
call main@__array
Satırına gelince hata verdiğini gördüm.

Hata veren kodlar
struct R
{
    int ID;
    uint Size;
    int* FData;
    int Type;
 
    this(int id,uint size)
    {
        ID = id;
        Size = size;
        FData = cast(int*)GC.malloc(size);
         }
}
 
R[][][] Matrix;
 
Matrix[Variable][type][id] = R(id,Data[0].sizeof);

Not: Variable enum , type ve id ler int, Datada Tuple
Bu mesaj kaaninel tarafından değiştirildi; zaman: 2013-02-28, 08:50.
konu: D'nin arm desteği  ; forum:: Diğer Konular
kaaninel #15
Üye Ock 2013 tarihinden beri · 22 mesaj
Grup üyelikleri: Üyeler
Profili göster · Bu konuya bağlantı
Yanıtlanan mesaj ID 8867
Ben GDC arm destekliyor diye biliyorum ama :D
Özel Karakterler:
Sayfa:  1  2  sonraki 
Özel sorgulamalar

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-20, 01:28:29 (UTC -08:00)