Administrace komentářů

Potřebuji v D pracovat s jednou knihovnou v C, která má callbacky a jako user_data void*. Potřebuju té fci předat pointer na instanci mé třídy, takže přetypuji na void*:

// C interface

alias extern(C) void function(void*) CallbackFunc;

extern(C) extern void nejaka_c_fce(CallbackFunc func, void* data);

extern(C) extern void cekej_na_callback();

// 

class Bla
{
  uint[] nejakyData;

  this()
  {
    nejakyData = new uint[1024*1024*10]; // 40M
    nejaka_c_fce(&cCallback, cast(void*)this);
  }

  void callback()
  {
    // něco tady
  }

  static extern(C) cCallback(void *data)
  {
    Bla self = cast(Bla)data;
    self.callback();
  }
}

// ...

Bla bla;

void main()
{
  while (true)
  {
    bla = new Bla();

    cekej_na_callback();
    // tahle fce čeká na nějaký data a až dorazí
    // tak zavolá ten callback v tomhle samým vlákně,
    // pak vrátí
  }
}

Něco v tom stylu výše. Referenci na objekt samozřejmě držím stranou, dokud není zavolán callback, takže problém se zrušením objektu by neměl nastat (a ani nenastane, o čemž jsem se přesvědčil přidáním destruktoru).
Problém je, že po 4 iteracích to spadne na alokaci toho pole (po více, když zmenším velikost). Nějaký problém s GC a přetypováním?
Tady je zkompilovatelný kód v D, kde je něco podobného, z nějakého důvodu to padá stejně jako můj kód výše, pokud z kódu odstraním všechny přetypování const(void*)this, tak kód funguje.

import std.stdio;
import core.thread;
//import wayland.callback;

class Callback
{
	void delegate(uint) m_callback;
	Callback m_next;
	uint[] m_lotsOfData;
	
	public this(void delegate(uint) cb)
	{
		writefln("Callback %s create", cast(void*)this);
		m_lotsOfData = new uint[1024*1024*10]; // 40M
		writefln("Callback %s alloc done", cast(void*)this);
		m_callback = cb;
	}
	
	~this()
	{
		writefln("Callback %s destroy", cast(void*)this);
	}
	
	public void call(uint bla)
	{
		m_callback(bla);
	}
}

class Bla
{
	Callback m_callbacks;
	Callback m_last;
	
	public Callback createCallback(void delegate(uint) cb)
	{
		Callback ret = new Callback(cb);
		
		if (m_last is null)
			m_callbacks = ret;
		else
			m_last.m_next = ret;
		
		m_last = ret;
		
		return ret;
	}
	
	public Callback createCallback(void function(uint) cb)
	{
		return createCallback( (uint bla) { cb(bla); } );
	}
	
	public void run()
	{
		while (m_callbacks !is null)
		{
			Callback cb = m_callbacks;
			
			m_callbacks = cb.m_next;
			cb.m_next = null;
			
			if (m_callbacks is null)
				m_last = null;
			
			cb.call(111);
		}
	}
}

Bla bla;

void proc(uint serial)
{
	writeln("call");
	Thread.sleep(dur!("msecs")(10));
	bla.createCallback(&proc);
}

void main()
{
	bla = new Bla();
	bla.createCallback(&proc);
	
	bla.run();
}

/*
Display display;
SyncCallback cb;

void proc(uint serial)
{
	writeln("sync");
	Thread.sleep(dur!("msecs")(10));
	cb = display.sync(&proc);
}

void main()
{
	display = new Display(null);
	
	cb = display.sync(&proc);
	
	while (true)
		display.dispatch();
}
*/