import core.thread;
import std.stdio;

struct Foo
{
    int field;
    void test()
    {
        writeln("field: ", &field);
    }
}

void main()
{
    Foo foo;
    auto thread = new Thread(&foo.test);
    thread.start();
    thread.join();
    foo.test();
}

This prints the same addresses. std.concurrency won't let you do this, while std.parallelism uses some form of "weaker isolation", and it seems core.thread has the same weaker isolation principle.

If "foo" is in TLS, how come a new thread can access its members?

On Tue, 22 Nov 2011 23:00:17 +0100, Andrej Mitrovic <andrej.mitrovich@gmail.com> wrote:

> import core.thread;
> import std.stdio;
>
> struct Foo
> {
>     int field;
>     void test()
>     {
>         writeln("field: ", &field);
>     }
> }
>
> void main()
> {
>     Foo foo;
>     auto thread = new Thread(&foo.test);
>     thread.start();
>     thread.join();
>     foo.test();
> }
>
> This prints the same addresses. std.concurrency won't let you do this,
> while std.parallelism uses some form of "weaker isolation", and it
> seems core.thread has the same weaker isolation principle.
>
> If "foo" is in TLS, how come a new thread can access its members?

You are passing a delegate that contains the pointer to the Foo you
have put on the stack. What would you expect to happen?

foo is not in tls, it is on the stack (which is also thread-local, but
not considered tls). Passing an object on the stack to another thread
is almost never safe, as the stack may unwind before the thread is
done with the object.

If you want to do this with tls, make a static/global variable with a
Foo, and operate on it directly instead of passing the object between
threads:

import core.thread;
import std.stdio;

struct Foo {
    int field;
}

Foo foo;

void test()
{
    writeln("field: ", &foo.field);
}

void main()
{
    auto thread = new Thread(&test);
    thread.start();
    thread.join();
    test();
}

Andrej Mitrovic , dans le message (digitalmars.D.learn:30764), a écrit :
> import core.thread;
> import std.stdio;
> 
> struct Foo
> {
>     int field;
>     void test()
>     {
>         writeln("field: ", &field);
>     }
> }
> 
> void main()
> {
>     Foo foo;
>     auto thread = new Thread(&foo.test);
>     thread.start();
>     thread.join();
>     foo.test();
> }
> 
> This prints the same addresses. std.concurrency won't let you do this, while std.parallelism uses some form of "weaker isolation", and it seems core.thread has the same weaker isolation principle.
> 
> If "foo" is in TLS, how come a new thread can access its members?

It could with a cast to shared, couldn't it ?

A fix would be to make Thread check the shared-ness of context pointer of the delegate (which may have to be fixed at the compiler level).

-- 
Christophe

On Fri, 25 Nov 2011 10:34:12 +0100, Christophe <travert@phare.normalesup.org> wrote:

> Andrej Mitrovic , dans le message (digitalmars.D.learn:30764), a écrit :
>> import core.thread;
>> import std.stdio;
>>
>> struct Foo
>> {
>>     int field;
>>     void test()
>>     {
>>         writeln("field: ", &field);
>>     }
>> }
>>
>> void main()
>> {
>>     Foo foo;
>>     auto thread = new Thread(&foo.test);
>>     thread.start();
>>     thread.join();
>>     foo.test();
>> }
>>
>> This prints the same addresses. std.concurrency won't let you do this,
>> while std.parallelism uses some form of "weaker isolation", and it
>> seems core.thread has the same weaker isolation principle.
>>
>> If "foo" is in TLS, how come a new thread can access its members?
>
> It could with a cast to shared, couldn't it ?
>
> A fix would be to make Thread check the shared-ness of context pointer
> of the delegate (which may have to be fixed at the compiler level).

It would, but core.thread is not supposed to do that. It's the unsafe,
pedal-to-the-metal layer, and shouldn't stop people from doing stupid
things.