Re: Have the Itanium critics all been proven wrong?

[Michael S <already5chosen@yahoo.com>]

On Aug 22, 3:39 pm, Brian Drummond <br...@shapes.demon.co.uk> wrote:
> On Wed, 22 Aug 2012 03:32:00 -0700, Michael S wrote:
> > On Aug 22, 12:09 am, Brian Drummond <br...@shapes.demon.co.uk> wrote:
>
> >> Heh, the book I learned C++ from didn't even mention STL, (or
> >> namespaces for that matter) and regarded templates as a bit unstable.
> >> When did STL appear? (And yes, I have newer books now...)
>
> > Interview with Alex Stepanov.
> >http://www.sgi.com/tech/stl/drdobbs-interview.html
>
> So, not long after Ada-95.
> Interesting article - he even speculates that STL could be implemented in
> Ada. I suppose Ada.Containers goes some way towards that.
>
> >> > Obsession with separate compilation does not help either.
>
> >> Does not help what? I'm unclear what point you have in mind?
> > Ada has his own library/link system. They can store as little or as much
> > info as they like in the intermediate files and do as much processing as
> > needed in the link phase.
> > Times change, noways C and in particular C++ developers very rarely rely
> > on language-agnostic linkers, but language features that would make that
> > type of analysis possible still absent.
>
> Indeed - in gcc, Ada and C use the same linker! though Ada passes through
> a binding stage handling additional inter-module information. C and C++,
> as far as I can see, still rely on external tools to (mis?)manage the
> dependencies.

Well, we are not at managing dependencies now, don't we?
We are at error/warning detection and reporting during link phase.
Gnu ld of today is very far of language agnostic. In Microsoft world
people routinely use link-time  code generation. So, original
technical reasons for not doing that sort of checks do not exist any
more. But the checks are still not provided due to deficiencies of the
language itself.

>
> > BTW, how Ada deals with that? That it how pointer (access) to auto
> > object distinguished from pointers to  dynamic or static objects when
> > they (pointers) are passed to the different module?
>
> Now you have caught me; it's a good question but I can't answer it
> accurately. So I have added c.l.a to the newsgroups in the hope that
> others will keep me straight.
>
> I believe pointers to "auto" (C-speak for stack-allocated?) objects can
> only be passed down the call stack; accessibility checks would otherwise
> fail (unless defeated by unchecked_access).
>
> Given modules A and B, it's not normal to actually access B's pointers
> from module A. More commonly A would only see a "private type" exported
> from B, and not even know it was a pointer. A can hold such types, but
> can only use them by invoking methods from B (such as accessors) on them.
> This puts B in charge of the object lifetimes; if A wants to access a
> stale object, expect an exception.

Exception, if I am lucky.
If I am less lucky, the physical place of old auto object is now
occupied by new auto object of the same or compatible type and the
call to accessor caused silent corruption.

>
> >> Ada ... doesn't by default supply a garbage collector.
> > Automatic garbage collection not aided by compiler is certainly possible
> > and done in practice (Boehm ?). But is not such GC significantly less
> > efficient than GC aided by compiler?
>
> such as Java's GC for example?
>
> I don't know that would generally be the case. If you need GC, you may
> often be able to structure the application to gain some advantage from
> its properties; for example, it may make identical sized garbage objects,
> or it may have natural "down times" when you can harmlessly schedule
> (part of) a GC.

That's not a good argument.
Compiler-supplied GC can also provide hint interface, like
Compact_righ_now, Please_do_not_compact_if_you_dont_have_to.

>
> Without knowing those properties, you can't design a GC to optimally fit.
> So I believe that compiler-supplied GC would often be less efficient. In
> that respect, I agree with the decision shared by Ada and C++, to not
> provide it by default.
>
> - Brian

But when compiler is aware of GC the tracking of liveness of objects
become much easier (for some implementations - trivial). You can
organize your memory database in such way that you will never have to
scan things.