Bir veri dizimiz olsun, bu veri dizisi üzerinde ise hiçbir şekilde tür belirtmeden veri saklayabilelim. Ve daha sonra cast işlemleri ile bu veri dizisi üzerinden istediğimiz veriyi alabilelim. Peki bunu nasıl yapabiliriz?

Örneğin:
10000 250 0 1 metin #herhangi bir struct# bu şekilde verilerin depolandığını düşünürsek ve istediğimiz veriye erişebileceğimiz bir yapı yapabilir miyiz?

Not: Hangi verinin hangi offset'den itibaren başladığını biliyoruz.

Zekeriya

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

	union MetinUnion{
		string metin;
		size_t uzunluk;
		void*[2] vals;
	}

Yine çok önceden dizinin ptr sine erişmek istiyordum. Şeklinde parçaladığımda valsin 1.indeksinde ptr adresi yazılıyor. Ve aklıma şu geldi acaba ptr yi iptal edip uzunluk, charlar şeklinde olacak şekilde bir yapı oluşturabilir miyiz?

Zekeriya

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Ben, yukarıdaki yapıyı/birliği hayal ettiğimde şu şekilde olduğunu varsayıyorum:

auto deneme = MetinUnion("metin");
assert(deneme.uzunluk == 109)

Meğer öyle değilmiş çünkü string'i, bir '''immutable'('char'[])'' dizisi gibi düşünmenin yanında onun içinde .length, .dup gibi üye işlevlerin olduğu bir yapı olarak bilmemiz gerekiyormuş. İşte o yüzden Talha kardeşimin, yukarıda kurduğu yapıdaki uzunluk değişkenine, aslında '''size_t' metin.length() '@property''' işlevinden dönen değer eşitleniyormuş...:)

import std.stdio;

struct String {
 size_t len;
 char[] str;

 this(string data) {
   this.len = data.length;
   this.str = data.dup;
 }
}

union MetinUnion {
 String metin;
 size_t uzunluk;
 char[] harfler; /*** test edilemedi ***/
}

void main(){
                /* m    e    t    i    n */
 char[] metin = [ 109, 101, 116, 105, 110 ];
 writefln("%(   %c\t%)", metin);
 /* Çıktısı:
    m       e       t       i       n
 1101101 1100101 1110100 1101001 1101110
 */
 writefln("%(%b\t%)", metin);

 auto Metin = String("metin");
 assert(Metin.str == "metin");
 assert(Metin.len == 5);

 auto test = MetinUnion(Metin);
 assert(test.uzunluk == 5);
 /*
 foreach(i, h; test.harfler) {
   assert(h == metin[i]);
 }//*/
}

Çok hoşmuş...:)

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Kesinlikle çok hoş :) Ve artık bu yapılarla uğraşmaktan rüyamda bile bunları görmeye başladım.

Ama orada .dup işlevi diziyi kopyalıyor. valsin 0.indeksi uzunluk, 1.indeksi ise dizinin ilk elemanının adresini veriyor :) Her ne ise bunlara ihtiyaç kalmadı ama :)

module main;
import std.stdio;
import std.datetime;
enum OP : int{
	HLT, CALL, LOAD, IS_EQUAL, VARIABLE, INC, GOTO, DEFINE, LOADPARAM, TIMES, PLUS, DIVIDE, MINUS, JNE, JE, NEXT,
}
ubyte[] dizi;
struct deneme{
	int b;
}
int main(string[] argv){
	long a1, a2;
   auto f = File("test.txt", "w");
	a1 = Clock.currAppTick().usecs();
	dizi ~= cast(ubyte[]) "metin";
	dizi ~= cast(ubyte) OP.LOAD;
//	dizi ~= cast(ubyte) deneme(2);//bu nasıl olacak?
	f.rawWrite(dizi);
	a2 = Clock.currAppTick().usecs();
	writeln(a2-a1);
	while(1){}
	return 0;
}

Bunu bu şekilde türsüz olarak atıyorum. Daha sonra txt ye yazıyorum ve okuyacağım. Bu sayede RhS kodları derlenebilecek :) Sanırım aynı asm gibi komutları okuyacak :)

Şimdi o veri dizisine int, string, bool atabilirken bir struct atmak istiyorum peki bu nasıl olacak?

Zekeriya

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Alıntı:

>   char[] harfler; /*** test edilemedi ***/
>
> ```


Sebebi çok basit string içerisinde uzunluk ve ilk elemanın adresi saklanıyor. Direk olarak harfler saklanmıyor. Benim de sorunun başında istediğim şey ilk elemanın adresi saklanması yerine direk harfler saklanması idi.

Sanırım o da şu şekilde oluyor.

char[4] e = ['a','b','c','d'];

İlk elemanın adresine ihtiyaç yok çünkü dizi uzunluğu sabit ve dizi hiçbir şekilde uzatılmayacak.

Zekeriya

-- 
[ Bu gönderi, <http://ddili.org/forum>'dan dönüştürülmüştür. ]

module main;
import std.stdio;
import std.datetime;
enum OP : int{
	HLT, CALL, LOAD, IS_EQUAL, VARIABLE, INC, GOTO, DEFINE, LOADPARAM, TIMES, PLUS, DIVIDE, MINUS, JNE, JE, NEXT,
}
enum DT : int {
	STRING, INT, dFunction, BOOL
}
ubyte[] dizi;
struct deneme{
	ubyte[] metin;
}
union veri(T){
	T val;
	ubyte[val.sizeof/4] z;
}
ubyte[] toByte(T)(T z){
	return veri!T(z).z;
}
void RhOp(string veri){
	dizi ~= cast(ubyte) DT.STRING;
	dizi ~= cast(ubyte) veri.length;
	dizi ~= cast(ubyte[]) veri;
}
void RhOp(OP veri){
	dizi ~= cast(ubyte) veri;
}
void RhOp(int veri){
	dizi ~= cast(ubyte) DT.INT;
	dizi ~= cast(ubyte) veri;
}
void RhOpR(ushort veri){
	dizi ~= cast(ubyte) veri;
}
int main(string[] argv){
	long a1, a2;
   auto f = File("test.txt", "w");
	a1 = Clock.currAppTick().usecs();
//	for(int i;i<1_000_000;i++){
//LOAD 2, "talha" => 2 = register, "talha" = register value
		RhOp(OP.LOAD);//1
		RhOpR(2);//1
		RhOp("talha");//7
//	}
	f.rawWrite(dizi);
	a2 = Clock.currAppTick().usecs();
	writeln(a2-a1);
	while(1){}
	return 0;
}

Salih hocam kafamdaki şey bu idi. Hem hafızada daha az yer kaplıyor hem de kodları derlememizi sağlıyor.

Zekeriya

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Ali hocam sabahtan beri kafam davul gibi olmuş hiç birşey anlayamıyorum okuduğumdan bunu yarın inceleyeceğim.

module main;
import std.stdio;
import std.datetime;
enum OP : int{
	HLT, LOAD
}
enum DT : int {
	INT, dFunction, STRING, BOOL
}
ubyte[] veridizisi;

void RhOp(string veri){
	veridizisi ~= cast(ubyte) DT.STRING;
	veridizisi ~= cast(ubyte) veri.length;
	veridizisi ~= cast(ubyte[]) veri;
}
void RhOp(OP veri){
	veridizisi ~= cast(ubyte) veri;
}
void RhOp(int veri){
	veridizisi ~= cast(ubyte) DT.INT;
	veridizisi ~= cast(ubyte) veri;
}
void RhOpR(ushort veri){
	veridizisi ~= cast(ubyte) veri;
}
void*[] opcodes;
string[] opnames;

private enum next = q{cur++; adr = opcodes[*cur]; asm{jmp adr;}};


int main(string[] argv){
	int leng;
	long start, finish;
   auto f = File("test.txt", "w");
	void* adr;

	opcodes = new void*[OP.max+1];
	opnames= new string[OP.max+1];
	with(OP){
		asm{ call op_load;} opcodes[LOAD] = adr; opnames[LOAD] = "LOAD";
		asm{ call op_hlt;} opcodes[HLT] = adr;opnames[HLT] = "HLT";
	}
	for(int i ; i <1_000_000;i++){
		RhOp(OP.LOAD);
		RhOpR(2);
		RhOp("Zekeriya");
	}
	RhOpR(OP.HLT);
	ubyte* cur = &veridizisi[0];
	adr = opcodes[*cur];
	start = Clock.currAppTick().usecs();
	asm{jmp adr;}
end:
	writefln("Program çalışmayı bitirdi.\nGeçen süre: %s",finish - start);

	//	f.rawWrite(veridizisi);
	while(1){}
	return 0;
struct veri{
	int typ;
	int length;
	char[] dizi;
}
union strl{
	string val;
	void*[2] vals;
}
op_load: asm{ call adresal; }
cur++;
	strl b = strl("");
	cur++;
	leng = *(cur++);
	b.vals[0] = cast(void*) leng;
	b.vals[1] = cur;
	cur += leng * 4;
	mixin(next);
op_hlt: asm{ call adresal; }
	finish = Clock.currAppTick().usecs();
	asm{jmp end;}
adresal: asm{
	pop EBX;
	mov adr[EBP],EBX;
	ret;
}
}

Verileri ilk başta belirttiğim şekilde sakladım ve işledim. Geri kalan işlemleri yapmadığım halde oldukça yavaş. Sanırım bu yapıyı daha fazla ilerletmenin bir anlamı yok :(

Zekeriya

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Güzel konular. :) RPC veya serialization gibi konularda da veriler burada dosyaya yazıldığı gibi yazılır.

En baştaki soruya dönersek, herhangi bir yerde yapı veya sınıf kurmak için emplace() işlevi var. O nesneleri sonlandırmak için de destroy(). Aşağıdaki bölümdeki şu başlıklar ilgili:

• Yapı nesnelerini belirli bir yerde kurmak
• Sınıf nesnelerini belirli bir yerde kurmak
• Nesneyi belirli bir zamanda sonlandırmak

http://ddili.org/ders/d/bellek_yonetimi.html

Ali

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Ali hocam dersiniz Hızır gibi yetişti vallahi :)

Burada da yazayım belki benim gibi ihtiyacı olan birileri çıkar :)

Ben bir nevi serialize işlemi yaptığım için bu serialize yaptığım verileri tekrardan okumam gerekiyordu. INT, char gibi bir dizi olmayan verileri çok rahat işleyebilirken dizilerde (uzunluk, ilk veri adresi) şeklinde saklandığı için bunları tekrar eski haline getirme işlemi için union kullanıyordum ve bu da vakit alıyordu.

Ama Ali hocamın da D.ershane de yazdığı gibi işleyince bir ton gereksiz koddan kurtulmuş olup hızlı bir yapı elde ettim :)

Alıntı:

>     elemanların_ilkini_gösteren_gösterge[0 .. eleman_adedi];
> ```

>

Yazdığım koda gelirsek eğer:

module main;
import std.stdio;
import std.datetime;
// Operandlar
enum OP : ushort{
HLT, LOAD
}
// Veri türleri
enum DT : ushort{
INT, dFunction, STRING, BOOL
}
ubyte[] veridizisi;
static class Rh{
static void newOp(in string veri){
veridizisi ~= cast(ubyte) DT.STRING;
veridizisi ~= cast(ubyte) veri.length;
veridizisi ~= cast(ubyte[]) veri;
}
static void newOp(in int veri){
veridizisi ~= cast(ubyte) DT.INT;
veridizisi ~= cast(ubyte) veri;
}
static void newOp(in ushort veri){
veridizisi ~= cast(ubyte) veri;
}

}
void*[] opcodes;
string[] opnames;

private enum next = q{adr = opcodes[*cur]; cur++; asm{jmp adr;}};
enum : ushort {REG0, REG1, REG2, REG3, REG4, REG5, REG6, REG7, REG8, REG9}

int main(string[] argv){
int leng;
long start, finish;
void* adr;

opcodes = new void*[OP.max+1];
opnames= new string[OP.max+1];
with(OP){
	asm{ call op_load;} opcodes[LOAD] = adr; opnames[LOAD] = "LOAD";
	asm{ call op_hlt;} opcodes[HLT] = adr;opnames[HLT] = "HLT";
}

// for(int i ; i <1_000_000;i++){
Rh.newOp(OP.LOAD);
Rh.newOp(REG0);
Rh.newOp("Zekeriya");
// }
Rh.newOp(OP.HLT);
ubyte* cur = veridizisi.ptr;
start = Clock.currAppTick().usecs();
mixin(next);
end:
writefln("Program çalışmayı bitirdi.\nGeçen süre: %s",finish - start);
//f.rawWrite(veridizisi);
// while(1){}
return 0;
op_load: asm{ call adresal; }
cur++;//register: REG0
cur++;//veri türü: 2 (String)

'	writeln(cast(string) (cur+1)[0..*cur]);//Veriyi oku'

cur+=*cur + 1;//verinin uzunluğu(8) + veri uzunluğu için alan (1)
mixin(next);

op_hlt: asm{ call adresal; }
finish = Clock.currAppTick().usecs();
asm{jmp end;}
adresal: asm{
pop EBX;
mov adr[EBP],EBX;
ret;
}
}

Zekeriya

-- 
[ Bu gönderi, <http://ddili.org/forum>'dan dönüştürülmüştür. ]

Anlamadım, olay nedir... :blush:

Serialize olayından hiç çakmam. Mutlaka 3 yaşındaki bir çocuğun anlayacağı bir dilde biri çıkıp anlatsa anlarım herhalde ama şu terimler bana yabancı maalesef...:)

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]