Seriously in-depth web delivered content

October 26, 2007

One of my friends was asking me why I have so much hard drive space, and it’s really because the speed at which good resources evaporate, you’d think with all the storage these days there would be no exothermic information transfers et al.

It took me a while to find this site as I’ve not been there before, but this article (14 parts, each part 1-3pages) on CLR framework interaction had the detail I was looking for, too often did I find dead links to (now defunct), or some unfinished business by a more in-experienced writer. Sure the Microsoft blogs and forums helped out (, but they are usually corrupted by knowledge and may lapse in the simple things that otherwise can take hours to find.

This article finally gave me the whole 9 yards on, exactly what CLSID, IID, API superseded what, I do not develop with COM interfaces often and I need that help these days 😉

The reason I had to dig into the framework was that the technique were currently using for binary instrumentation; is one copy. Not just one copy, but, the memory get’s allocated, assigned to (the initial data collection), then transferred into an ObservableCollection<>() in a single copy, all the while being collected in the context of an external process address space. So that’s a fairly appreciatable level of performance.

Previously I was using a horribly inefficient P/Invoke queuing system to marshal into the runtime, now, I’m able to extend VS 2008’s marshal_as library (this actually made it worth the effort to relearn Managed C++, which I previously gave up on).

Too busy these days, trying to run a startup and develop a product, I’m still merging a lot of new design elements, shifting around the layout of the CLR should hopefully be the last time I have to deal with InterOp (which I have now become an expert at every level).


One Response to “Seriously in-depth web delivered content”

  1. I’m sure that was the last time I’m dealing with managed/native InterOp , after testing some of our native engine/CLR message passing command & control architechture. I measured the throughput at over a billion messages per second, that’s a minuscule level of overhead IMHO, considering what it’s accomplishing. Which is, from a remote process (sure we are using shared memory), to the run time (somewhat like another remote process), into a managed object type and stored into a collection. I do have a quad 2.8Ghz Opteron that is my workstation but, even so, I’m really happy with what you can do with C++/CLI these days.

    I’ve even seen in Nish’s book(and thanks for writing the book Nish), how you can actually get intel assembly executed from the runtime directly, with no delegate. COol!

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )


Connecting to %s

%d bloggers like this: