Re: Teaching new tricks to an old dog (C++ -->Ada)

[CTips <ctips@bestweb.net>]

Jim Rogers wrote:

> CTips <ctips@bestweb.net> wrote in
> news:112sonip5v4dca6@corp.supernews.com: 
> 
> 
>>Martin Dowie wrote:
>>
>>>CTips wrote:
>>>
>>>
>>>>Will that generate:
>>>>  L0:
>>>>      lwlock temp,&Value
>>>>      add    temp,temp,1
>>>>      stwcond temp,&Value
>>>>      if( failed ) goto L0;
>>>>or will it generate something much more heavy-weight.
>>>
>>>
>>>If you need that particular assembler then you'd best write it
>>>yourself. I don't know of any language that could guarentee what
>>>assembler is produced following a compilation.
>>>
>>>Cheers
>>>
>>>-- Martin
>>
>>But isn't it interesting that Ada can't express this?
>>
>>Roughly speaking, Ada provides synchronous message passing and 
>>(non-nested?) monitors as first class constructs. This means that
>>  - it doesn't support asynchronous communication
>>  - it doesn't support any number of lock-free algorithms
>>Also, Ada's only scheduling/queing discipline is FIFO with priorities 
>>(and priorities are only available if the RT annex is actually 
>>implemented). If I want to do earliest-deadline first, well, how do I
>>go about doing it?
> 
> 
> I think you are missing some Ada capabilities.
> While Ada does provide synchronous message passing and monitors,
> it also provides the ability to declare objects as atomic and
> volatile.
> 
> Atomic objects can be used instead of monitors (what Ada calls
> protected objects) for inter-task communication. You can then
> define your own schemes including lock-free algorithms or 
> dcl.

No you can't. How do you think atomicity is guaranteed (in general)? By 
providing a lock for the atomic object! Try and write code in Ada on a 
machine that supports either CAS or lwlock/stwcond to do an atomic 
increment that can generate the optimal code.

> If you want different scheduling policies you write them, just as 
> in C or C++.

Right - and then what's the advantage of the built-in features of Ada 
over and

> How, using C or C++, would you create a threaded program and
> ensure that signals are handled by a specified thread, and not
> simply by the thread that is currently running when the signal
> is received? 

What do you mean "handled by a thread"? How can you distinguish which 
thread is actually interrupted? More importantly, why do you care?

[If you're using pthreads, the answer is that about the only way you can 
make out that there is a difference is by looking at thread private 
data, and you want to use pthread_kill() to deliver a signal to a 
specific thread, or see below]

> How will you handle general OS signals in this
> manner and not only the specialized signals provided by
> pThreads?

Again you're assuming that C thread library == pthreads. And OS == 
POSIX-compliant. There are alternate OSes and mechanisms. Also POSIX 
signals are process oriented, not thread oriented, so they, in my 
opinoin, are kind of broken.

  However, in POSIX, you can do it by using pthread_sigmask() to disable 
delivery of the signal to all threads other than the handling one.

> You seem to assume that Ada only allows you to use features
> provided by the language while preventing you from creating
> your own features. That idea just doesn't make any sense.

Nope, I didn't say that - what I said was that Ada (particularily the 
concurrent part of Ada) is fairly retarted, particularily if you want to 
get performance. In fact, to get the performance similar to that which 
can be obtained in C, one would pretty much have to write in the C 
subset of Ada [i.e. turn off most of the checking, use libraries written 
in C + asm]. And even there I'd have my doubts - given the additional 
features that Ada compilers have to deal with, I doubt that they would 
have focused as much on the optimizations.

Actually, I can verify that: if I look at the computer shootout 
http://shootout.alioth.debian.org/great/, I find that gcc C beats gnat 
Ada pretty much across the board; actually, Ada's performance sucks 
pretty much across the board. One of gcc C or Intel C is generally among 
the top few programs, while with a couple of exceptions, Gnat Ada is 
around the middle. In matrix multiply it gets beaten by LISP, Java, and 
Python!!! (How can you get beaten by Python? The mind boggles!)

> Linked lists are not implemented as native syntax in either
> Ada or C, yet they are used frequently in both languages.
> How can that be?

And their C implemenations are faster.
> Jim Rogers
>