RE: Multithreading

From: [at]} <support{>
Date: Fri, 21 Feb 2003 09:21:18 +0100

----boundary-LibPST-iamunique-1608937079_-_-
Content-type: text/plain

Wojtek,

Concerning your general question whether multithreading is a good concept or
not our opinion is:

On the one hand multithreading can be very convenient. The main focus of
multithreading is the better distribution of performance as observed by
clients issuing concurrent requests.

However, the resulting increase in complexity over sequential programming is
substantial. In particular, conflicts from concurrent writes (or reads and
writes) to variables accessed by multiple threads need to be avoided.
Synchronization of threads using some form of locking solves this problem
but introduces a new one. Locking too conservatively or in the wrong order
can result in starvation and deadlocks. Synchronization between concurrently
executing threads, even where deadlocks are avoided, can lead to substantial
degradation of performance.

Besides the problem of increased memory consumption (each thread has its own
stack), frequent scheduling and context switching can have negative
performance impacts as well. Also, garbage collection and propagation of
exceptions (traps) across thread boundaries lead to difficult problems.
Finally, due to non-deterministic effects, it is exceptionally difficult to
test and debug code that uses multiple threads and complex interlocking
patterns.

Another issue is that most libraries including the Windows API and BlackBox
are not or only in part thread safe and that it is fairly hard to keep
threaded code portable.

Given all the above listed problems, BlackBox is therefore designed as a
purely sequential programming system, sticking to the Oberon tradition of
using complicated techniques only when absolutely needed.

Obviously, none of these problems can be avoided where true concurrency
needs to be dealt with. Your case of a blocking call to a third party
component is such an example. Another case would be if component instances
execute on separate processors, then concurrent requests need to be handled
(e.g. by a WEB server). Complete locking of a component instance while one
request is handled is possible, but may lead to deadlocks or poor response
time.

In such cases there are three possible solutions we can recommend.

First reconsider your design. Often a problem seems to warrant true
concurrency but in fact it can be solved with sequential solutions. We at
Oberon microsystems are just ready to release a MMI-Application for complex
power plant monitoring systems that is completely Services.Action based.
Modifying your device's firmware seems to be in this respect a somewhat
extreme case, but maybe contributing significantly to the overall system
reliability.

Then, it may be possible to distribute the task on several operating system
processes and let those processes (BlackBox instances) communicate via
TCP/IP (CommStreams) or even shared files. Werner Braun's
Web-Application-Server is an excellent example for this. Werner, thanks a
lot for sketching your solution.

If you absolutely need finer grained integration (i.e. shared memory) then
it could make sense to isolate the threaded code as much as possible and use
the Windows threads library (WinApi.CreateThread etc.). In this scenario,
you must be careful not use any heap allocated data structures in order to
prevent interferences with the garbage collector.

We hope these points help to structure the solution space for your problems
involving concurrent processes.

Best regards,
Marc
Oberon microsystems, Inc.


> -----Original Message-----
> From: Wojtek Skulski [mailto:skulski{([at]})nowhere.xy
> Sent: Sonntag, 16. Februar 2003 03:27
> To: support{([at]})nowhere.xy
> Cc: Wojtek Skulski; BlackBox
> Subject: Multithreading
>
>
> Hello:
>
> I would appreciate hearing from an expert whether
> multithreading in BlackBox 1.5 is planned, and whether
> it is a good concept. I have recently seen a situation
> it perhaps would be beneficial. I am acquiring data
> from a USB device using the standard Windows call
> WinApi.DeviceIoControl. This call appears to be blocking,
> i.e., it does not return unless the device sends the
> requested data. In case the device does not have data,
> the call stalls, and as a consequence BlackBox becomes
> unresponsive (an hour glass appears on screen).

> It would be possible to force the pending data transfer
> by sending another request to the device over a separate
> USB endpoint, but since BlackBox is single-threaded,
> this cannot be done from within the environment.
>
> I solved the problem by pinging the USB device with
> the request "do you have data", which is always answered
> yes/no without any waiting. I am only performing
> the data transfer when the precondition has been
> established that there indeed is data. The hourglass
> no longer is a problem. However, this was possible only
> because I have full control over the USB firmware,
> such that I could modify the firmware to implement
> the ping.
>
> I therefore hesitate to say this is a decisive example
> that multithreading is necessary. However, I hear
> about multithreading so often, that I would like to ask.
> Is it necessary? Is it beneficial? Is the extra complexity
> due to multithreading warranted? Can one always substitute
> a single-threaded solution where the apparent need for
> multithreading seems to exist?
>
> Please e-mail the answer to me directly because I am only
> reading the mailing list once a week.
>
> Thank you,
>
> Wojtek Skulski skulski{([at]})nowhere.xy
>
> --------------------------------------------
>
> To unsubscribe from this mailing list, send a message containing
> the word "unsubscribe" to:
> blackbox-request{([at]})nowhere.xy
>
> To get a list of valid e-mail commands and instructions on their
> usage, send a message containing the word "help" to the above address.
>
> Send any problem reports or questions related to this email list
> to the list owner at
> owner-blackbox{([at]})nowhere.xy
>
> Current posting policy:
>
> a) To post you should use the same address by which you are
> subscribed to the mailing list. That way, the list server will
> recognize you as subscriber and forward your posting immediately,
> without creating any overhead.
>
> b) If, for some reason, you cannot post from the address, by
> which you are subscribed, your message will be moderated to avoid
> spam. Please understand that moderation will often cause some
> delay, in particular over weekends or holydays.

--------------------------------------------

To unsubscribe from this mailing list, send a message containing the word "unsubscribe" to:
   blackbox-request{([at]})nowhere.xy

To get a list of valid e-mail commands and instructions on their usage, send a message containing the word "help" to the above address.

Send any problem reports or questions related to this email list to the list owner at
   owner-blackbox{([at]})nowhere.xy

Current posting policy:

a) To post you should use the same address by which you are subscribed to the mailing list. That way, the list server will recognize you as subscriber and forward your posting immediately, without creating any overhead.

b) If, for some reason, you cannot post from the address, by which you are subscribed, your message will be moderated to avoid spam. Please understand that moderation will often cause some delay, in particular over weekends or holydays.


----boundary-LibPST-iamunique-1608937079_-_-
Content-type: application/rtf
Content-transfer-encoding: base64
Content-Disposition: attachment; filename="rtf-body.rtf"
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==


----boundary-LibPST-iamunique-1608937079_-_---
Received on Fri Feb 21 2003 - 09:21:18 UTC

This archive was generated by hypermail 2.3.0 : Thu Sep 26 2013 - 06:29:26 UTC