Bu aralar derleme zamanı olanaklarına kafayı takmış gibi gözüksem de gerçekten ihtiyaç var :)

module main;

import std.stdio;
import core.memory;


int allocate_size = 16;

auto sizeOf(T)() @property{
	static if(T.sizeof < 16) return 16;
	else{
		auto x = T.sizeof;
		x--;
		x |= x >> 1;  // handle  2 bit numbers
		x |= x >> 2;  // handle  4 bit numbers
		x |= x >> 4;  // handle  8 bit numbers
		x |= x >> 8;  // handle 16 bit numbers
		x |= x >> 16; // handle 32 bit numbers
		x++;
		if(x>allocate_size)
			allocate_size = x;
		return x;
	}
}

struct str{
	enum size = sizeOf!(typeof(this));
	int y;
	int z;
	final destroy(){
		GC.free(&this);
	}
}

struct str2{
	enum size = sizeOf!(typeof(this));
	string z, a,b,c,d,w,e,r,t,y,o,k,l,m;
	final destroy(){
		GC.free(&this);
	}
}

T* smalloc(T, D...)(D datas){
	auto v = cast(T*) GC.malloc(str.sizeof);
	*v = T(datas);
	return v;
}

import std.datetime;

int main(string[] argv){

	//GC.disable();

	auto p1 = Clock.currTime();
//	for (int i; i < 1_000_000; i++){
	auto obj = smalloc!str;
	auto obj2 = smalloc!str2;
	writeln("val: ", GC.sizeOf(obj), "-", obj.size);
	obj.destroy();
//	}

	while(1){}
	//writeln(*cast(str*)a);
	return 0;
}

Kodlar karışık durabilir ama burada olay şu smalloc! ile uluşturulan structların en büyük boyutu en büyük olanın boyutu bir değişken içerisinde tutulmak isteniyor :)

Zekeriya

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

Önceden de farkettiğim bir şeyi sorayım: @property'nin normal bir işleve etkisi var mı? Neden yazdığını merak ediyorum.

sizeOf sizeof'a fazla benzeyen bir isim olmuş. Okurken yanıldığım oldu.

Konuyla ilgisiz olsa da hıza önem verdiğin için belirtmek istiyorum: malloc ve free gibi bellek işlemleri yavaş olarak bilinirler. Her nesne için malloc+free masraflı olacaktır.

destroy() diye bir işlev zaten var. Senin aynı isimdeki üye işlevler karışıklığa neden olabilir.

Herhalde 32-bit ortamda derlediğin için farketmiyorsun ama allocate_size'ın türü int olduğu için şu satır derlenemiyor:

           allocate_size = x;

(x'in türü size_t'dir.)

allocate_size'ı derleme zamanında hesaplayabilmek için ilgili bütün türleri derleme zamanında bilmen gerekir ama bu her zaman için mümkün değildir. Şöyle düşün: allocate_size'ın kendi türlerin için derleme zamanında hesaplanabildiğini varsayalım. Diyelim 32 diye hesapladın... sizeOf çalışma zamanında da çağrılabileceği için, derleme zamanında hesaplanan o değer çalışma zamanında 64 yapılamaz.

O yüzden, allocate_size için gereken bütün türleri derleme zamanında biliyor olman gerekir. Bir çözüm:

import std.algorithm;
import std.stdio;

struct A
{
   int[10] a;
}

size_t enBüyükUzunluk(T...)()
{
   static if (T.length == 1) {
       return T[0].sizeof;

   } else {
       return max(T[0].sizeof, enBüyükUzunluk!(T[1..$]));
   }
}

void main()
{
   enum sonuç = enBüyükUzunluk!(int, double, A, string);
   writeln(sonuç);
}

Ali

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

Alıntı:

Evet bu yüzden sistemin başında 1 kere malloc yapıp o açılan alan üzerinde nesneleri kurdurmayı planlıyorum ama hala tam olarak beceremedim :)

Zekeriya

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