Re: new_line in a put_line

[Jeffrey Carter <jrcarter@acm.org>]

Stephen Leake wrote:
> 
> Assuming Lock is a controlled type, that releases the lock in
> Finalize, this [using a semaphore] is an excellent design.

I would disagree. Using a high-level feature such as a protected type to 
implement a low-level construct such as a semaphore is abstraction 
inversion. Ada has high-level concurrency features, and it should be 
possible to solve this problem directly in terms of those features. 
Using a semaphore probably indicates a lack of familiarity with those 
features rather than a reasoned decision that a semaphore is the best 
solution.

For a real-time system I designed a debug-output system based on a 
protected bounded queue of bounded strings with a very high ceiling 
priority (any task could make a debug-output call) and a task with a 
very low priority (it only ran when nothing else was running) to 
actually do the output. Some logic deleted the oldest message in the 
queue if new messages were added when the queue was full, though that 
never happened in practice. The idea was that calls to produce output 
never blocked the caller so the system had minimal impact on the timing 
of the system.

Of course, that had more complex requirements than what is being 
discussed here. Apparently the OP doesn't mind if the tasks are blocked 
during output, so simply rendezvousing with a task that does the output 
would solve the problem and be simpler and clearer than the semaphore + 
protected type approach.

-- 
Jeff Carter
"Go and boil your bottoms."
Monty Python & the Holy Grail