----boundary-LibPST-iamunique-1265491377_-_-
Content-type: text/plain
Hello, Treutwein!
>> In my previous letter I was wrong about one thing. You actually can
>> link BlackBox into a DLL and then use it from C/C++ code (see
>> DevLinker documentation).
TB> hmm, just some thought: There is the option to create a
TB> "dynamic loading" DLL, which is labelled by OMiSys as
TB> "rarely used, present for completeness" which might be
TB> the right thing to use in this case.
>> My guess is that you could call simple functions
>> from C/C++ threads, but anything involving dynamic
>> memory allocation and garbage collection still
>> must be done in only one of those threads.
TB> this is exactly what you would gain from a dynamic
TB> DLL, i.e. one that includes a BlackBox loader:
TB> it would have a separate GC instance for each thread.
I'm afraid that's not exactly what is said in DevLinker
documentation. A "dynamic module loader" mentioned there is not
something that would create a separate instance of GC for every
thread it loaded into. It's just a module which, when called from
the main module initialization section, loads other modules
dynamically. So, this module is just a part of runtime system like
any other. It can decide which modules to load or even where to load
from. This is opposed to "static" aka "unextensible" module set. The
latter set consists of modules which are all known and enumerated at
link time. So, linker can create a sequence of commands to load and
initialize those modules.
I think you've mixed concepts of a dynamic-link library (DLL, windows
term) and dynamic module loader (BlackBox term). When you link
BlackBox into a DLL (or EXE) you may or may not use dynamic module
loader. It doesn't mean you can create two different types of DLLs.
TB> I have no idea, if BlackBox code will be put in
TB> a (shared) code segment or in a thread local
TB> data segment. I know only for sure that "global"
TB> data of a DLL-linked BlackBox module is not global
TB> at all, but thread local. Each thread that attaches
TB> to the DLL gets its own copy of the "global" data.
Let me reply this way.
The dynamic memory allocation (procedure NEW and Garbage Collector)
is performed by module Kernel (source code available at BlackBox\
System\ Mod\ Kernel.odc).
When Kernel module is linked into DLL it uses the heap object of a
parent process to dynamically allocate memory. This heap object is
obtained from GetProcessHeap() function. The functions used to
allocate and release memory are HeapAlloc() and HeapFree().
Here is a recite from Win32 developer's reference (topic on
"HeapCreate" function):
-- begin recite --
The memory of a private heap object is accessible only to the process
that created it. If a dynamic-link library (DLL) creates a private
heap, the heap is created in the address space of the process that
called the DLL, and it is accessible only to that process.
The system uses memory from the private heap to store heap support
structures, so not all of the specified heap size is available to the
process. For example, if the HeapAlloc function requests 64 kilobytes
(K) from a heap with a maximum size of 64K, the request may fail
because of system overhead.
If the HEAP_NO_SERIALIZE flag is not specified (the simple default),
the heap will serialize access within the calling process.
Serialization ensures mutual exclusion when two or more threads
attempt to simultaneously allocate or free blocks from the same heap.
There is a small performance cost to serialization, but it must be
used whenever multiple threads allocate and free memory from the same
heap.
-- end recite --
The HEAP_NO_SERIALIZE flag is never specified by the Kernel module
(and it must never be specified for a heap object obtained from
GetProcessHeap), so heap memory allocation is thread-safe. What does
it mean? It means that simultaneous heap allocation and
deallocation performed by any number of threads will not corrupt
internal WINDOWS heap-related structures (aka "system overhead" in
recited text). BUT there is absolutely no guarantee that it will not
corrupt internal structures of Kernel module itself! (I.e. the chain
of Cluster objects.)
Maybe you've mixed concepts of thread and process in your preceding
text.
My resume: BlackBoxes may live in peace while they are in different
PROCESSES. However there may be several BlackBoxes in one process
(look here, Gomez Rubio!) if:
1) each BlackBox is in separate DLL (to make sure that each has its
own set of global variables, like "root");
2) every BlackBox/DLL must be accessed by only a single thread at a
time.
AFAIK there is no such thing as "thread-local variable" in Windows
like there are thread-local variables in Delphi (declared with
"threadvar" keyword). Global variables declared in a DLL are mapped
to the address space of a parent PROCESS, so they are
"process-local". This applies to the "root" global variable in
module Kernel, which is the first in chain of memory clusters.
Gomez Rubio, maybe this is what you are looking for? Link modules
into different DLLs and use those DLLs in parallel threads - one
thread per DLL?
---===---
Alexander
--- BlackBox
--- send subject HELP or UNSUBSCRIBE to blackbox{([at]})nowhere.xy
----boundary-LibPST-iamunique-1265491377_-_-
Content-type: application/rtf
Content-transfer-encoding: base64
Content-Disposition: attachment; filename="rtf-body.rtf"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----boundary-LibPST-iamunique-1265491377_-_---
Received on Fri Apr 07 2006 - 21:12:33 UTC