I've been meaning to sit down and try this for a month...and now I have.
One of the things that people seem to be excited about with CALL WORKER is
the ability to run on something other than the main core. I'm not as
excited about this as some, but I'm ready to be convinced. It strikes me as
an excellent feature for a specific subset of problems where the benefits
will really shine...and not worth the effort for most things.
But anyway, that's just my opinion and not the question. Here's the setup
for the question:
* You can run a worker in cooperative (traditional, single-core) mode or
preemptive (multi-core) mode.
* The difference is in how you _start_ the worker.
* Preemptive threads can't access a lot of features because of OS
limitations.
* Therefore, it's illegal to call various commands for execution in a
preemptive thread.
I've got no problem with any of that and, as far as I can tell, 4D have
done a pretty darn good job of giving us access to multi-core programming.
Still getting to the question. Right, so, how do you coordinate UI with a
headless preemptive worker? CALL FORM and CALL WORKER. I guess this is even
the motivation behind these commands in the first place. Now we get to the
question: Pushing illegal code to a preemptive worker.
CALL FORM and CALL WORKER don't send "messages", they send blocks of code
for execution in an existing context. They're remote procedure calls.
There's no broker to intercept or inspect the code that we can see or
influence, 4D gets the call, appends the code to the call chain in the
target context and then runs the code. This isn't exactly how it's
described in the manuals, but that's how it's designed, how it works, and a
different way that it all _could_ be described in the manuals.
Okay, now this gets to the question about illegal code. When you compile,
4D's compiler checks the call chain for a preemptive method and verifies
that there is no chance at all of an illegal call coming through. So, no
open windows, etc. You can't even get the database to compile if there's
_anything_ wrong. I think 4D's done a good job with this and have no
complaints about this approach...but the compiler can only see static code.
So, it can see all of the code at rest, but none of the code at runtime.
What prevents you from pushing over some illegal code with CALL WORKER?
CALL WORKER appends that code to the worker and runs it *in its context.*
In other words:
-- You've got a preemptive thread.
-- It can't run a variety of commands.
-- You push over some illegal code via CALL WORKER.
-- 4D's is meant to EXECUTE the cooperative (illegal) code in the
preemptive (multi-core) context.
What happens? Not what I feared, not what I expected, not what I want, and
not what's documented.
I'm curious what a) people thing should happen, b) what people want to have
happen), and c) what other people see does happen.
**
4D Internet Users Group (4D iNUG)
FAQ: http://lists.4d.com/faqnug.html
Archive: http://lists.4d.com/archives.html
Options: http://lists.4d.com/mailman/options/4d_tech
Unsub: mailto:4d_tech-unsubscr...@lists.4d.com
**
