----boundary-LibPST-iamunique-261856647_-_-
Content-type: text/plain
Hello, Virgilio!
GRV> Many thanks for your message. After your response I am wandering
GRV> if it would be possible to, let's say, write some code in C/C++
GRV> to parallelize the work and call my previous BlackBox routines
GRV> from the new C/C++ code. :D
Always a pleasure to be helpful. : )
But it turns out that I spoke too soon: it IS possible to create
threads in BlackBox. In fact if you look at the source of module
Kernel (as I did just now), you'll see that it uses
KERNEL32.CreateThread (which maps to the WinAPI CreateThread, of
course) to create a keyboard watcher thread. That is how BlackBox
knows if you press Ctrl+Break. The code function for the thread is
located there too, called KeyboardWatcher.
All this means that you CAN use threads in BlackBox as long as you
know the appropriate API functions.
There are also some bad news again. As far as I know the memory
management is NOT thread-safe in BlackBox. All that pretty stuff
with dynamic memory allocation and garbage collection should be
avoided within all threads except the main one.
I found no more references in BlackBox sources to the CreateThread
function except when it is used to setup KeyboardWatcher. If you
look at the Kernel.KeyboardWatcher procedure, you'll see that it
does not create any objects or arrays, it only uses local
stack-based variables. And when watcher thread needs to communicate
to the main thread (to set break flag) it suspends the latter!
As to calling BlackBox code from C/C++ code - there is no
straightforward way to do this. I mean you cannot import a module
with a header file and then use calls like
BlackboxModule.ExecuteFunction(params);
It won't work. You'll need to develop some communication interface
(windows messages, memory mapped files, files, pipes, TCP/IP,
mailslots, OLE automation or whatever you can think of) and then use
that interface to pass parameters to your code in BlackBox and get
outcome it will produce.
If your Component Pascal code uses dynamic memory allocation
(arrays, strings, objects) you'll have to run separate BlackBox
instances for every line of parallel work. If your functions use
only local variables and neither of them is an array, then you can
use them in threads. You'll meet some troubles transferring outcome
of execution into the main thread, but that's solvable.
Another way is to redesign your code to make it capable of executing
its work in small chunks one-by-one - and then you could use
Services.Action as described in help files.
Resume:
1. You may write thread code entirely in C/C++, put it in a DLL and
then use the DLL in BlackBox. The DLL cannot call any of the
BlackBox's procedures.
2. You may write thread code in BlackBox keeping in mind one general
limitation: thread must manage its own memory (i.e. not to use NEW).
All other issues of concurrent multitasking also must be considered.
3. You may use cooperative multitasking as supported in module
Services.
4. You may redesign BlackBox memory management to make it
thread-safe. Hmm... that sounds like an interesting task.
PS: if you want to pass blocks of memory to or from thread, you
should use windows' GlobalAlloc/GlobalFree functions to allocate and
release memory. But that memory, of course, falls outside the
garbage collector's scope and you'll have to manage it yourself.
... which brings us back to good old pre-Oberon days : )
("... which brings us, once again, to the ugrent realization of just
how much there is still left to own" (c) Mony Python's the Meaning
of Life)
---===---
Alexander
--- BlackBox
--- send subject HELP or UNSUBSCRIBE to blackbox{([at]})nowhere.xy
----boundary-LibPST-iamunique-261856647_-_-
Content-type: application/rtf
Content-transfer-encoding: base64
Content-Disposition: attachment; filename="rtf-body.rtf"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----boundary-LibPST-iamunique-261856647_-_---
Received on Tue Mar 28 2006 - 20:36:03 UTC