www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - question about keeeping reference to toStringz()

reply Dr.No <jckj33 gmail.com> writes:
The documentation says:

Important Note: When passing a char* to a C function, and the C 
function keeps it around for any reason, make sure that you keep 
a reference to it in your D code. Otherwise, it may become 
invalid during a garbage collection cycle and cause a nasty bug 
when the C code tries to use it.

(from https://dlang.org/library/std/string/to_stringz.html)

consider a C function with this prototype:
void foo(const char *baa);
Does it means I should do:
 string s = ...;
 auto cstring = s.toStringz;
 foo(cstring);
rather just:
 foo(s.toStringz);
?
May 30 2018
parent reply =?UTF-8?Q?Ali_=c3=87ehreli?= <acehreli yahoo.com> writes:
On 05/30/2018 01:09 PM, Dr.No wrote:

 consider a C function with this prototype:
 void foo(const char *baa);
Does it means I should do:
 string s = ...;
 auto cstring = s.toStringz;
 foo(cstring);
rather just:
 foo(s.toStringz);
?
It depends. cstring method above is not sufficient if cstring's life is shorter than the C library's use: void bar() { string s = ...; auto cstring = s.toStringz; foo(cstring); } // <- cstring is gone What if the library saved that pointer while performing foo()? If cstring is in module-scope or in a container (e.g. an array) that's in module-scope then it's fine. But then, you would have to remove it from that container when the C library does not need that pointer anymore. Ali
May 30 2018
parent reply Dr.No <jckj33 gmail.com> writes:
On Wednesday, 30 May 2018 at 20:43:48 UTC, Ali Çehreli wrote:
 On 05/30/2018 01:09 PM, Dr.No wrote:

 consider a C function with this prototype:
 void foo(const char *baa);
Does it means I should do:
 string s = ...;
 auto cstring = s.toStringz;
 foo(cstring);
rather just:
 foo(s.toStringz);
?
It depends. cstring method above is not sufficient if cstring's life is shorter than the C library's use: void bar() { string s = ...; auto cstring = s.toStringz; foo(cstring); } // <- cstring is gone What if the library saved that pointer while performing foo()? If cstring is in module-scope or in a container (e.g. an array) that's in module-scope then it's fine. But then, you would have to remove it from that container when the C library does not need that pointer anymore. Ali
is foo() is being called from a thread, how I am supposed to keep cstring "alive"?
May 30 2018
next sibling parent Jonathan M Davis <newsgroup.d jmdavisprog.com> writes:
On Thursday, May 31, 2018 01:12:34 Dr.No via Digitalmars-d-learn wrote:
 On Wednesday, 30 May 2018 at 20:43:48 UTC, Ali «ehreli wrote:
 On 05/30/2018 01:09 PM, Dr.No wrote:
 consider a C function with this prototype:
 void foo(const char *baa);
Does it means I should do:
 string s = ...;
 auto cstring = s.toStringz;
 foo(cstring);
rather just:
 foo(s.toStringz);
?
It depends. cstring method above is not sufficient if cstring's life is shorter than the C library's use: void bar() { string s = ...; auto cstring = s.toStringz; foo(cstring); } // <- cstring is gone What if the library saved that pointer while performing foo()? If cstring is in module-scope or in a container (e.g. an array) that's in module-scope then it's fine. But then, you would have to remove it from that container when the C library does not need that pointer anymore. Ali
is foo() is being called from a thread, how I am supposed to keep cstring "alive"?
If it's being passed to foo, then it should be on the stack until foo returns, in which case, the GC should see it when it scans. It's when foo could keep a reference to the pointer that you have a problem, since then as soon as foo returns, the pointer you passed to foo won't be on the stack anymore. So, in that case, you'd have to store the pointer somewhere in D code so that the GC will see it when scanning. Or are you concerned about something like spinning up a thread, calling foo, and then exiting the thread while foo stores the pointer somewhere? If that's the case, then you'll need to store the pointer in a shared or __gshared variable in D code so that you can still refer to it after the thread terminates. - Jonathan M Davis
May 30 2018
prev sibling parent reply Mike Parker <aldacron gmail.com> writes:
On Thursday, 31 May 2018 at 01:12:34 UTC, Dr.No wrote:

 is foo() is being called from a thread, how I am supposed to 
 keep cstring "alive"?
As Jonathan explained, you don't have to worry about it if foo() itself doesn't assign the pointer to anything internally. That will be the case for most C functions. Well-behaved functions that need to keep the string around will copy it. That said, you need to be sure you understand fully what any C function you call is doing with the strings, or pointers to any memory allocated by the GC, that you pass to them. In the rare cases where the C function does keep the pointer and you do need to keep a reference (if you don't have one already), the simplest approach is this one: import core.memory; GC.addRoot(cstring); Then, when you no longer need it: GC.removeRoot(cstring); https://dlang.org/phobos/core_memory.html#.GC.addRoot
May 30 2018
parent bauss <jj_1337 live.dk> writes:
On Thursday, 31 May 2018 at 02:10:53 UTC, Mike Parker wrote:
 On Thursday, 31 May 2018 at 01:12:34 UTC, Dr.No wrote:

 is foo() is being called from a thread, how I am supposed to 
 keep cstring "alive"?
As Jonathan explained, you don't have to worry about it if foo() itself doesn't assign the pointer to anything internally. That will be the case for most C functions. Well-behaved functions that need to keep the string around will copy it. That said, you need to be sure you understand fully what any C function you call is doing with the strings, or pointers to any memory allocated by the GC, that you pass to them. In the rare cases where the C function does keep the pointer and you do need to keep a reference (if you don't have one already), the simplest approach is this one: import core.memory; GC.addRoot(cstring); Then, when you no longer need it: GC.removeRoot(cstring); https://dlang.org/phobos/core_memory.html#.GC.addRoot
Actually thank you for this. I had no idea you could do that with the GC.
May 31 2018