GC and pinned pointers

[_BNC]

Another thread mentioned non-Pinned pointers as a possible reason for an
Interop bug. I'd like to find out more about how this comes about. I
presume that the Garbage Collector makes a sweep, decides to realloc
memory that is not pinned, and that the unmanaged code's pointer becomes
invalid.

How often does the GC run, given a reasonably large app running on
a P4 300ghz with over 1 gig ram? I would have thought that it did not
need to run often at all.

Is there any other possible cause for the unpinned pointer problems?

[Joakim Karlsson]

_BNC wrote:

Another thread mentioned non-Pinned pointers as a possible reason for an
Interop bug. I'd like to find out more about how this comes about. I
presume that the Garbage Collector makes a sweep, decides to realloc
memory that is not pinned, and that the unmanaged code's pointer becomes
invalid.
IIRC unmanaged code can only reference pinned objects, the GC is not
allowed to move pinned objects, so the unmanaged pointer does not become
invalid.

How often does the GC run, given a reasonably large app running on
a P4 300ghz with over 1 gig ram? I would have thought that it did not
need to run often at all.

A GC is performed each time your application wants to allocate an object
and generation 0's threshold is reached (something like 256K i think).
So, how often a GC is performed depends on how your application is behaving.

Regards,
Joakim

[Willy Denoyette [MVP]]

The number of GC run's depend highly on your usage pattern NOT the systems
CPU performance, if you allocate very frequently, the GC will run very
frequently .
If you don't allocate at all, the GC will not run at all(unless the system
runs low on memory).
You should not care about the number of GC runs, you have to pin the
pointers you pass to unmanaged code that's all.

Willy.

"_BNC" <_B**@nospam.co m> wrote in message
news:p4******** *************** *********@4ax.c om...

Another thread mentioned non-Pinned pointers as a possible reason for an
Interop bug. I'd like to find out more about how this comes about. I
presume that the Garbage Collector makes a sweep, decides to realloc
memory that is not pinned, and that the unmanaged code's pointer becomes
invalid.

How often does the GC run, given a reasonably large app running on
a P4 300ghz with over 1 gig ram? I would have thought that it did not
need to run often at all.

Is there any other possible cause for the unpinned pointer problems?

[_BNC]

On Wed, 12 Jan 2005 23:05:39 +0100, "Willy Denoyette [MVP]"
<wi************ *@pandora.be> wrote:

The number of GC run's depend highly on your usage pattern NOT the systems
CPU performance, if you allocate very frequently, the GC will run very
frequently .
If you don't allocate at all, the GC will not run at all(unless the system
runs low on memory).
You should not care about the number of GC runs, you have to pin the
pointers you pass to unmanaged code that's all.

Willy.

Thanks for your reply, Willy. I'm not being stubborn about pinning
pointers...I'm trying to figure out if I missed one somewhere. Or maybe
it's another problem entirely, I don't know. I'm not doing that many
memory allocs. I initially didn't figure that the GC would be the
culprit, but since problems turn up only when the program is stressed, it
would seem a likeley suspect. The smaller test models that I've worked up
run fine, of course.

I'm still trying to get a handle on the subtleties of the
managed-to-unmanaged bridge. Much of this seems counterintuitiv e to me.
For instance, the MSDN code that uses a similar method:

http://msdn.microsoft.com/library/de...nagedtypes.asp

does not __pin the pointer to the unmanaged struct (see constructor:
"city = new CITY;"). I'm trying to figure out why that pointer does not
need to be pinned.

I started my original model from code in a wrox book
"Visual C++.NET: a primer for C++ Developers" (Aravind Corera, etc,
ISBN 1861005962). which outlines the approach of using 'concentric'
classes layered around internal unmanaged code (Center = DLL, then
unmanaged C++ wrapper, then managed C++ wrapper, then C#). They
do not pin the pointer to the unmanaged C++ wrapper either.

I would have gone with PInvoke from the start, but the central DLL is such
a mess, with tons of obscure structs and defined data types, that it
seemed more logical to encapsulate the ugly stuff on the unmanaged side of
the fence.

I'm afraid that by the time I get a good handle on how the interim
layering works, Whidbey will have made it obsolete and my project will be
over. <g> (IOW, the real problem is a stupid typo somewhere)

_B

[Derrick Coetzee [MSFT]]

_BNC wrote:

I'm still trying to get a handle on the subtleties of the
managed-to-unmanaged bridge. Much of this seems counterintuitiv e to me.
For instance, the MSDN code that uses a similar method:

http://msdn.microsoft.com/library/de...nagedtypes.asp

does not __pin the pointer to the unmanaged struct (see constructor:
"city = new CITY;"). I'm trying to figure out why that pointer does not
need to be pinned.

I can try to help explain this part. The garbage collector ignores
unmanaged objects altogether; it will not move them, it will not free
them, and they cannot be pinned. If you define a managed (__gc) C++
class that contains pointers to unmanaged objects, the garbage collector
simply ignores these pointers. It is the job of that class's destructor
to deallocate the objects properly, and GC invokes this destructor at
the appropriate time. More generally, *managed code* is able to deal
with and contain *unmanaged objects* without much of a problem.

It is going in the other direction that pinning comes into play - if you
use *unmanaged code* to deal with pointers to *managed objects*. In this
case, GC does know about the object, and what it doesn't know about are
the unmanaged pointers to it. This prevents it from updating these
pointers after moving the object. Also, if only unmanaged pointers to an
object exist (which it doesn't know about) it will assume the object can
be freed. Pinning prevents this as well. Unfortunately, excessive
pinning also inhibits the efficiency of the collector, because it's
harder to find space to allocate in a highly fragmented memory pool.
--
Derrick Coetzee, Microsoft Speech Server developer
This posting is provided "AS IS" with no warranties, and confers no
rights. Use of included code samples are subject to the terms
specified at http://www.microsoft.com/info/cpyright.htm

[_BNC]

On Thu, 13 Jan 2005 19:11:35 -0500, "Derrick Coetzee [MSFT]"
<dc******@onlin e.microsoft.com > wrote:

_BNC wrote:

I'm still trying to get a handle on the subtleties of the
managed-to-unmanaged bridge. Much of this seems counterintuitiv e to me.
For instance, the MSDN code that uses a similar method:

http://msdn.microsoft.com/library/de...nagedtypes.asp

does not __pin the pointer to the unmanaged struct (see constructor:
"city = new CITY;"). I'm trying to figure out why that pointer does not
need to be pinned.
I can try to help explain this part. The garbage collector ignores
unmanaged objects altogether; it will not move them, it will not free
them, and they cannot be pinned. If you define a managed (__gc) C++
class that contains pointers to unmanaged objects, the garbage collector
simply ignores these pointers. It is the job of that class's destructor
to deallocate the objects properly, and GC invokes this destructor at
the appropriate time. More generally, *managed code* is able to deal
with and contain *unmanaged objects* without much of a problem.

That makes sense. Still, it seems like the example code effectively
allocs the inner unmanaged struct and maintains that pointer to that
struct without having to be pinned. I could swear that I've seen
equivalent pointers pinned in some example code, but I guess this will
make sense after it sinks in.

Now I've got to look for another cause for my problems though, cause I'm
allocing a block of ram in an unmanaged module, and the only thing that
the managed code does is pass the pointer to it to another unmanaged
class. No allocs are done by the managed code, and my understanding
is that the pointer itself is safe, being a low-level item.
It is going in the other direction that pinning comes into play - if you
use *unmanaged code* to deal with pointers to *managed objects*. In this
case, GC does know about the object, and what it doesn't know about are
the unmanaged pointers to it. This prevents it from updating these
pointers after moving the object. Also, if only unmanaged pointers to an
object exist (which it doesn't know about) it will assume the object can
be freed. Pinning prevents this as well.
A lucid explanation, Derrick.
Unfortunately, excessive
pinning also inhibits the efficiency of the collector, because it's
harder to find space to allocate in a highly fragmented memory pool.

I've heard that pinned pointers can effectively slow down the managed
code by a factor of 25 (!) so I've been trying to avoid them.

_B

[Derrick Coetzee [MSFT]]

> Still, it seems like the example code effectively

allocs the inner unmanaged struct and maintains that pointer to that
struct without having to be pinned.
That's true; in fact, there's no point in pinning a pointer to an unmanaged
object, because the GC doesn't know about these objects and won't move them,
and ignores the pointer. Such blocks of memory are outside its control, just
like a block allocated in an unmanaged program. They are, effectively,
already pinned.
I could swear that I've seen equivalent pointers pinned in some example code [ . . . ]

This may have been a pointer to a managed object, or it might have been a
mistake. It might let you create pinned pointers to unmanaged objects,
although this is pointless, since they're already "pinned."
Now I've got to look for another cause for my problems though, cause I'm
allocing a block of ram in an unmanaged module, and the only thing that
the managed code does is pass the pointer to it to another unmanaged
class. No allocs are done by the managed code, and my understanding
is that the pointer itself is safe, being a low-level item.
The Framework shouldn't interfere with unmanaged-to-unmanaged interactions,
as a rule. It sounds like your application has some very subtle problems.
I'm not sure where to tell you to start, but if you can find an alternative
to interfacing managed and unmanaged code using a mixed-code DLL, this might
be the simplest way to go. For example, I once did something similar to this
where in the end I ended up driving the C module through a command-line
interface and input/output files. You may also try using PInvoke to call
directly from the managed to the unmanaged code. In C# this is done with the
DllImport attribute; see an example here:

http://msdn.microsoft.com/library/de...okevisualc.asp
I've heard that pinned pointers can effectively slow down the managed
code by a factor of 25 (!) so I've been trying to avoid them.

The main problem is that it slows down garbage collection cycles and
allocations a great deal if you use many pinned pointers at once, and the
larger the objects you pin the worse the effect. Pinning some small things
here and there is relatively harmless.
--
Derrick Coetzee, Microsoft Speech Server developer
This posting is provided "AS IS" with no warranties, and confers no rights.

[_BNC]

On Fri, 14 Jan 2005 10:59:19 -0800, "Derrick Coetzee [MSFT]"
<dc******@onlin e.microsoft.com > wrote:

... there's no point in pinning a pointer to an unmanaged
object, because the GC doesn't know about these objects and won't move them,
and ignores the pointer. Such blocks of memory are outside its control, just
like a block allocated in an unmanaged program. They are, effectively,
already pinned.
That finally makes sense. I've assumed that if the alloc was done within
managed code, that it would be subject to garbage collection. It's one of
those subtleties that was not clear in the docs that I've read.

Now I've got to look for another cause for my problems though, cause I'm
allocing a block of ram in an unmanaged module, and the only thing that
the managed code does is pass the pointer to it to another unmanaged
class. No allocs are done by the managed code, and my understanding
is that the pointer itself is safe, being a low-level item.

The Framework shouldn't interfere with unmanaged-to-unmanaged interactions,
as a rule. It sounds like your application has some very subtle problems.
I'm not sure where to tell you to start, but if you can find an alternative
to interfacing managed and unmanaged code using a mixed-code DLL, this might
be the simplest way to go.

I've heard of subtle bugs in .NET mixed mode in general. It's frustrating
in that so much work went into the mixed mode bridge, and it's difficult
to trace problems. Smaller, or unstressed models of the code work fine.
I thought maybe it was a task prioritization thing, as the access to the
mixed mode code occurs in a thread. Strangely enough, increasing the
thread priority makes the code *less* reliable. I'm not getting runtime
errors or exceptions--just wrong results. Very counterintuitiv e.
For example, I once did something similar to this
where in the end I ended up driving the C module through a command-line
interface and input/output files. You may also try using PInvoke to call
directly from the managed to the unmanaged code. In C# this is done with the
DllImport attribute; see an example here:

http://msdn.microsoft.com/library/de...okevisualc.asp
Thanks for the link, Derrick. I first considered PInvoke, but thought
that mixed mode would be better for this app (see below). However, if the
..NET mixed-mode DLL has inherent problems, as in:

http://msdn.microsoft.com/library/de...ingProblem.asp

...then I suppose I'll have to give up on it. Unfortunately, the inner C
DLL is very messy, with lots of typedefs and structs that would be tough
to marshal via PInvoke. The fallback plan may be to encapsulate the C DLL
in an unmanaged C++.NET class to simplify the interface, and use PInvoke
to access that.

I've essentially done the encapsulation part already in the course of
writing the mixed-mode DLL, so I suppose I could start from there and
just PInvoke the encapsulating class.

I've also written a completely unmanaged version of the code which works
fine under run-time stress. In other words, I've got lots of clues, all
pointing in different directions. <g>
Derrick Coetzee, Microsoft Speech Server developer

Thanks for your perspective, Derrick. My understanding of the
managed-to-unmanaged transition is improving.

Re MS Speech server: I know you're probably more involved with the
ASP-related side of the MS Speech SDK, but I'm curious about MS's 'local'
speech SDK. I haven't had much luck with the 5.1 SDK under .NET. There
was a v5.2 mentioned somewhere that had more .NET support, but it seems to
have disappeared. Do you happen to know if anything new is imminent?

_B