On 08/04/2015 01:03 AM, "岩倉 澪" wrote:
Hi all, I'm a bit confused today (as usual, haha).
I have a pointer to a struct (let's call it Foo) allocated via a C library.
I need to do some expensive computation with the Foo* to create a Bar[],
but I would like to do that computation in the background, because the
Bar[] is not needed right away.
I definitely do not want there to be a copy of all elements of the Bar[]
between threads, because it is very large.
I tried to implement it like this:
void fooPtrToBarArr(in shared Foo* f, out shared Bar[] b){ /*do
work*/ }
__gshared Foo* foo;
foo = allocateFoo();
__gshared Bar[] bar;
spawn(foo, bar);
To my dismay, it results in a cryptic compiler error:
template std.concurrency.spawn cannot deduce function from argument types
!()(void function(shared(const(Foo*)) f, out shared(Bar[]) b), Foo*,
Bar[]), candidates are:
/usr/include/dlang/dmd/std/concurrency.d(466):
std.concurrency.spawn(F, T...)(F fn, T args) if (isSpawnable!(F, T))
Any help would be greatly appreciated :)
__gshared behaves like C globals and need not be passed to spawned
functions. (Although, if needed, they must be passed as shared and
casted back to non-shared in the thread function.)
The following seems to achieve what you describe:
import std.stdio;
import std.concurrency;
import core.thread;
struct Foo
{}
struct Bar
{
int i;
}
void fooPtrToBarArr()
{
bar ~= Bar(42);
}
__gshared Foo* foo;
__gshared Bar[] bar;
void main()
{
spawn(&fooPtrToBarArr);
thread_joinAll();
writeln(bar);
}
Ali
