Ada 0Y plans for garbage collection?

Ada 0Y plans for garbage collection?

[Jano]

Hello,

I'm very happy using Ada but when one needs to use heap-allocated 
objects and unchecked deallocation it becomes tiresome rapidly, and that 
leaving aside memory leaks.

After some time using Java/.NET or other managed languages this becomes 
rapidly a great pain if you are in the less real time constrained 
environments. I was wondering if there are plans to add a standard 
garbage collection mechanism to the next revision of Ada. Seeing where 
are going things this seems almost a necessity if Ada has to keep 
current with times.

I've seen past discussions about Ada and GC, but mostly focus on 
technical difficulties or social (fictitious?) "cultural" opposition to 
it being implemented, or lack of demand, or whatever, but nothing about 
definite plans for the next revision.

Can someone comment on this? Are there plans to mandate it in 0Y? As a 
side note, is out there any public implementation of GC for Ada 95?

TIA,

-- 
-------------------------
Jano
402450.at.cepsz.unizar.es
-------------------------

Re: Ada 0Y plans for garbage collection?

[Martin Krischik]

Jano wrote:

> Hello,
> 
> I'm very happy using Ada but when one needs to use heap-allocated
> objects and unchecked deallocation it becomes tiresome rapidly, and that
> leaving aside memory leaks.

I feel the same.
 
> After some time using Java/.NET or other managed languages this becomes
> rapidly a great pain if you are in the less real time constrained
> environments. I was wondering if there are plans to add a standard
> garbage collection mechanism to the next revision of Ada. Seeing where
> are going things this seems almost a necessity if Ada has to keep
> current with times.

Right.

> Can someone comment on this? Are there plans to mandate it in 0Y?

I heard rumors but never found any hard facts.

Also take a look at s-parame.ads file which came with your GNAT:

   ----------------------------------------------
   -- Behavior of Pragma Finalize_Storage_Only --
   ----------------------------------------------

   --  Garbage_Collected is a Boolean constant whose value indicates the
   --  effect of the pragma Finalize_Storage_Entry on a controlled type.

   --    Garbage_Collected = False

   --      The system releases all storage on program termination only,
   --      but not other garbage collection occurs, so finalization calls
   --      are ommitted only for outer level onjects can be omitted if
   --      pragma Finalize_Storage_Only is used.

   --    Garbage_Collected = True

   --      The system provides full garbage collection, so it is never
   --      necessary to release storage for controlled objects for which
   --      a pragma Finalize_Storage_Only is used.

   Garbage_Collected : constant Boolean := False;
   --  The storage mode for this system (release on program exit)

I take it there are plans. Just not finished yet. So don't give up.

> As a
> side note, is out there any public implementation of GC for Ada 95?

Yes there is: http://adacl.sourceforge.net

Also read:

http://adacl.sourceforge.net/gc.html

With Regards

Martin

-- 
mailto://krischik@users.sourceforge.net
http://www.ada.krischik.com

Re: Ada 0Y plans for garbage collection?

[Jeffrey Carter]

Jano wrote:
> 
> I'm very happy using Ada but when one needs to use heap-allocated 
> objects and unchecked deallocation it becomes tiresome rapidly, and that 
> leaving aside memory leaks.
> 
> After some time using Java/.NET or other managed languages this becomes 
> rapidly a great pain if you are in the less real time constrained 
> environments. I was wondering if there are plans to add a standard 
> garbage collection mechanism to the next revision of Ada. Seeing where 
> are going things this seems almost a necessity if Ada has to keep 
> current with times.
> 
> Can someone comment on this? Are there plans to mandate it in 0Y? As a 
> side note, is out there any public implementation of GC for Ada 95?

Ada was designed for mission-critical real-time embedded systems. It is 
the only widely used language designed for real-time embedded systems. 
That's why it has features such as fixed-point types. In other 
languages, such things have to be simulated manually, with the inherent 
increase in errors that entails.

Languages with mandatory GC are generally not used in such systems, and 
are unlikely to be used in such systems in the near future. Therefore, 
the standard will not mandate GC.

The standard could allow GC, so compilers for real-time systems can not 
provide it, but compilers for other systems can. In fact, the standard 
already does allow GC. That you cannot obtain a compiler with GC 
indicates the importance paying customers put on this feature.

For an example of the "Ada way" of addressing memory management, see the 
unbounded, unprotected data-structure components of the PragmAda 
Reusable Components:

http://home.earthlink.net/~jrcarter010/pragmarc.htm

The implementations of these perform manual allocation and deallocation, 
but the client need never concern himself with it. A person, such as 
you, developing systems where memory management is acceptable, can use 
such components and pretend that the language has GC; those developing 
real-time software can avoid such components. If you need to move your 
software to another compiler, you need not limit your compiler selection 
to those that provide GC.

The need for explicit heap allocation is much rarer in Ada than in 
lesser languages. If you are using heap allocation for anything other 
than dynamic data structures, the odds are very good that you can do the 
same thing without heap allocation.

So, if you are a software engineer, memory management is isolated in a 
few well defined places in your software, and the bulk of your 
development effort can ignore memory management issues. If there are 
problems with the memory management, they are easy to find and correct. 
If, on the other hand, you are a coder and sprinkle allocations and 
deallocations throughout your system, then you get what you deserve.

The best thing you could do if you want to demonstrate the importance of 
GC in Ada is to modify GNAT to include GC. If there is really an 
incipient demand for GC, then your version would become widely used, and 
your changes would be incorporated into the mainstream versions of GNAT. 
If not, you would still have a version with GC for your personal efforts.

-- 
Jeff Carter
"Nobody expects the Spanish Inquisition!"
Monty Python's Flying Circus
22

Re: Ada 0Y plans for garbage collection?

[olehjalmar kristensen - Sun Microsystems - Trondheim Norway]

I still think the way it was done in Modula-3 gives you the best of
both worlds. If you want garbage collection, you allocate from a
different pool. If you don't want it you don't use it, and there is no
overhead.

>>>>> "JC" == Jeffrey Carter <spam@spam.com> writes:

<snip>

    JC> http://home.earthlink.net/~jrcarter010/pragmarc.htm

    JC> The   implementations   of  these   perform   manual  allocation   and
    JC> deallocation, but  the client  need never concern  himself with  it. A
    JC> person,  such as you,  developing systems  where memory  management is
    JC> acceptable, can use such components  and pretend that the language has
    JC> GC; those developing real-time  software can avoid such components. If
    JC> you need to move your software to another compiler, you need not limit
    JC> your compiler selection to those that provide GC.


    JC> The need  for explicit heap  allocation is much  rarer in Ada  than in
    JC> lesser languages. If you are  using heap allocation for anything other
    JC> than dynamic data  structures, the odds are very good  that you can do
    JC> the same thing without heap allocation.


    JC> So, if you are a software engineer, memory management is isolated in a
    JC> few  well  defined places  in  your software,  and  the  bulk of  your
    JC> development effort  can ignore memory management issues.  If there are
    JC> problems  with  the memory  management,  they  are  easy to  find  and
    JC> correct.  If,  on  the  other  hand,  you are  a  coder  and  sprinkle
    JC> allocations  and deallocations  throughout your  system, then  you get
    JC> what you deserve.


    JC> The best thing you could do  if you want to demonstrate the importance
    JC> of GC in  Ada is to modify GNAT  to include GC. If there  is really an
    JC> incipient demand for  GC, then your version would  become widely used,
    JC> and your changes would be incorporated into the mainstream versions of
    JC> GNAT. If not, you would still have a version with GC for your personal
    JC> efforts.


    JC> -- 
    JC> Jeff Carter
    JC> "Nobody expects the Spanish Inquisition!"
    JC> Monty Python's Flying Circus
    JC> 22

Re: Ada 0Y plans for garbage collection?

[Martin Krischik]

olehjalmar kristensen - Sun Microsystems - Trondheim Norway wrote:

> I still think the way it was done in Modula-3 gives you the best of
> both worlds. If you want garbage collection, you allocate from a
> different pool. If you don't want it you don't use it, and there is no
> overhead.

Well, you can have this allready at least with GNAT. See
http://www.ada.krischik.com for details.

With Regards

Martin

-- 
mailto://krischik@users.sourceforge.net
http://www.ada.krischik.com

Re: Ada 0Y plans for garbage collection?

[Robert I. Eachus]

Martin Krischik wrote:

>>I still think the way it was done in Modula-3 gives you the best of
>>both worlds. If you want garbage collection, you allocate from a
>>different pool. If you don't want it you don't use it, and there is no
>>overhead.
> 
> Well, you can have this allready at least with GNAT. See
> http://www.ada.krischik.com for details.

Exactly.  And if you read the documentation there, you eventually 
conclude that a garbage collected pool for Ada implementations may seem 
like a good thing, but it creates more issues than it solves.  It can be 
done, and it has been done.  But in practice building reference counts 
into types which need garbage collection gives you much better control 
over finalization.

And yes, I know that there are general graph structures where reference 
counts don't work.  I also know that in practice most such general 
graphs can be constructed with structural pointers and general pointers 
so that the structural pointers define a tree and nodes not in the tree 
should be reclaimed. You could say that doing that is a lot of extra work.

It is a lot of work.  But in the cases where I have run into this issue, 
the graph partitioning was part of a proof of correctness that I really 
needed to be able to do anyway.  (Note that this is a proof of 
correctness of the algorithm to be implemented, before I ever got to 
writing code.)

-- 
                                              Robert I. Eachus

"As far as I'm concerned, war always means failure." -- Jacques Chirac, 
President of France
"As far as France is concerned, you're right." -- Rush Limbaugh

Re: Ada 0Y plans for garbage collection?

[Dmitry A. Kazakov]

On Thu, 11 Sep 2003 21:21:21 GMT, "Robert I. Eachus"
<rieachus@attbi.com> wrote:

>>>I still think the way it was done in Modula-3 gives you the best of
>>>both worlds. If you want garbage collection, you allocate from a
>>>different pool. If you don't want it you don't use it, and there is no
>>>overhead.
>> 
>> Well, you can have this allready at least with GNAT. See
>> http://www.ada.krischik.com for details.
>
>Exactly.  And if you read the documentation there, you eventually 
>conclude that a garbage collected pool for Ada implementations may seem 
>like a good thing, but it creates more issues than it solves.  It can be 
>done, and it has been done.  But in practice building reference counts 
>into types which need garbage collection gives you much better control 
>over finalization.

Absolutely!

(I saw no single real-life example, where automatic GC were a solution
of choice)

>And yes, I know that there are general graph structures where reference 
>counts don't work.  I also know that in practice most such general 
>graphs can be constructed with structural pointers and general pointers 
>so that the structural pointers define a tree and nodes not in the tree 
>should be reclaimed. You could say that doing that is a lot of extra work.

Actually, it is not so much work. I did it many times. 

---------
But reference counting could be made much more easy and attractive if
smart pointers have more light-weighted implementation than controlled
types in generic packages. There are too many problems with that:

1. Controlled types are slow.

2. They have by-reference semantics, which is a source of nasty
pitfalls.

3. They are not transparent as true access types are. So you have to
define a plethora of proxy methods and take a great care to maintain
them when the pointed type gets changed. It is awful and unsafe.

4. Derived types are not supported. That is, there is no way to make a
smart pointer to a derived type class a member of the class of smart
pointers pointing to the base type class. One need to support two
parallel type hierarchies which is absolutely impossible with
generics.

---
Regards,
Dmitry Kazakov
www.dmitry-kazakov.de

Re: Ada 0Y plans for garbage collection?

[Martin Krischik]

Dmitry A. Kazakov wrote:

> On Thu, 11 Sep 2003 21:21:21 GMT, "Robert I. Eachus"
> <rieachus@attbi.com> wrote:
 
> (I saw no single real-life example, where automatic GC were a solution
> of choice)

Java. All of it. I fact all new Languages.

I would like to invite you to read my "containers and garbage collections."
article as well.

With Regards.

-- 
mailto://krischik@users.sourceforge.net
http://www.ada.krischik.com

Re: Ada 0Y plans for garbage collection?

[Martin Krischik]

Dmitry A. Kazakov wrote:


> But reference counting could be made much more easy and attractive if
> smart pointers have more light-weighted implementation than controlled
> types in generic packages. There are too many problems with that:

I agree with you on that one. A reference counting access type would be as
good a real garbage collector.
 
With Regards
-- 
mailto://krischik@users.sourceforge.net
http://www.ada.krischik.com

Re: Ada 0Y plans for garbage collection?

[Robert I. Eachus]

Dmitry A. Kazakov wrote:

> But reference counting could be made much more easy and attractive if
> smart pointers have more light-weighted implementation than controlled
> types in generic packages. There are too many problems with that...

Agreed, which is why you want to use a reference counted storage pool. 
That way the count is stored with the object, and you only incur the 
overhead when you create a new counted access value.

I've done this to create a pool of fixed sized objects.  I keep 
intending to rewrite it to support variable sized objects, but it is 
always easier to create a fixed-sized reference-counted object with an 
access value into the normal heap, and do explicit deallocation of that 
object when the reference count reaches zero.

Anyone want to work with me on a "standard" reference counted storage 
pool for Ada 200Y?  The storage pool will only be a couple of pages of 
code.  The real effort is in documenting it and providing examples of use.

Or did you mean that the fact that the storage pool was a controlled 
type was a problem?  I don't see that.  Typically a program will create 
a storage pool once and then just use it.  The controlled overhead 
really only comes into play if the storage pool is located inside a 
nested procedure.

--
                                         Robert I. Eachus

"As far as I'm concerned, war always means failure." -- Jacques Chirac, 
President of France
"As far as France is concerned, you're right." -- Rush Limbaugh

Re: Ada 0Y plans for garbage collection?

[Martin Krischik]

Robert I. Eachus wrote:

> Dmitry A. Kazakov wrote:
 
>> But reference counting could be made much more easy and attractive if
>> smart pointers have more light-weighted implementation than controlled
>> types in generic packages. There are too many problems with that...
> 
> Agreed, which is why you want to use a reference counted storage pool.
> That way the count is stored with the object, and you only incur the
> overhead when you create a new counted access value.

Yes.
 
> Anyone want to work with me on a "standard" reference counted storage
> pool for Ada 200Y?  The storage pool will only be a couple of pages of
> code.  The real effort is in documenting it and providing examples of use.

But for it to work realy user friendly, would you not need compiler support?
Everytime a new access is created or destroyed the compiler would need to
tell the storrage pool.

Remember: controlled types where considered not user friendly. If I
undersand the OP right he wants:

type Some_Access is access Some_Type;
for Some_Access'Storrage_Pool use Ada.Reference_Counted__Pools.Pool;

the rest need to be done by the compiler.

With regards

Martin

-- 
mailto://krischik@users.sourceforge.net
http://www.ada.krischik.com

Re: Ada 0Y plans for garbage collection?

[Robert I. Eachus]

Martin Krischik wrote:

 > But for it to work realy user friendly, would you not need compiler
 > support? Everytime a new access is created or destroyed the compiler
 > would need to tell the storrage pool.
 >
 > Remember: controlled types where considered not user friendly. If I
 > undersand the OP right he wants:
 >
 > type Some_Access is access Some_Type; for Some_Access'Storrage_Pool
 > use Ada.Reference_Counted__Pools.Pool;
 >
 > the rest need to be done by the compiler.

All that is currently allowed.  Well technically, it should be

My_Storage_Pool: Reference_Counted_Storage_Pool;

type Some_Access is access Some_Type;
for Some_Access'Storage_Pool use My_Storage_Pool;

...but that is a detail.  Should we require such a storage pool type in
Ada 200Y? I think it would be a good idea.  But requiring that there be
an instance of such a pool might not be a good idea.

And I tend to like my current implementation, where I create a pool by 
instantiating a generic package, with the size of each allocated object, 
and the number of objects in the heap.  It has a very low overhead for 
allocate and free.  (And both operations are bounded in time.)

-- 
                                      Robert I. Eachus

"As far as I'm concerned, war always means failure." -- Jacques Chirac,
President of France
"As far as France is concerned, you're right." -- Rush Limbaugh

Re: Ada 0Y plans for garbage collection?

[Matthew Heaney]

Jano <nono@celes.unizar.es> writes:

> I'm very happy using Ada but when one needs to use heap-allocated 
> objects and unchecked deallocation it becomes tiresome rapidly, and that 
> leaving aside memory leaks.

Why don't you simply encapsulate the allocation and deallocation behind
an abstraction?

For example, if I have a container like this:

procedure Op (C : in out CT; E : ET) is
begin
   Insert (C, E);
   ...
   Clear (C);

The memory necessary to store element E in container C is allocated
behind the scenes in the implementation of Insert.  That same memory is
deallocated when the container is cleared.

The container itself is controlled, so that when the scope of the
container ends, all the memory it owns is deallocation automatically.

If you must manipulte pointers --say, you're doing class-wide
programming-- then you can still hide the allocation and deallocation
like this:

package P is
   type T is abstract tagged null record;
   type T_Class_Access is access all T'Class;
   procedure Free (X : in out T_Class_Access);
   ...
end P;

package P.C is
   type NT (<>) is new T with private;
   function New_NT return T_Class_Access;
...
private
   type NT is new NT with null record;
end;


By declaring the partial view of the type as indefinite, then you force
clients to use your contructor function:

declare
  O : T_Class_Access := New_NT;
begin
  ...
  Free (O);
end;


That hides explicit calls, and allows each type in the class to allocate
objects in whatever manner is most appropriate.

If you want to automate calls to Free, you can use something like the
auto_ptr in C++, which transfers ownership of an access object across
assignments.  In the Charles library, there is similar abstraction,
allowing you to do this:

declare
   O, O2 : Pointer_Type;
begin
   Initialize (O, New_NT);  --O owns ptr
   Op (+O);
   Assign (O2, O);  --now O2 owns ptr
   Op (+O2);
end; --no Free: O2 does it automatically

Here, when the Pointer_Type object is finalized, it calls the Free
operation automatically.

See Charles.Access_Control for the full implementation.

<http://home.earthlink.net/~matthewjheaney/charles/index.html>

If you need to have pointer sharing, then you can use reference
counting, something like:

package P is
   type T is abstract tagged null record;
   type T_Class_Access is access all T'Class;

   type Handle_Type is private;  --aka "smart pointer"
...
end P;

package P.C is
   type NT is new T with private;
   function New_NT return Handle_Type;
end;

During assignment, the reference count is bumped:

declare
   O1 : Handle_Type := New_NT;  --cnt is 1
begin
   Op (+O1);

   declare
      O2 : Handle_Type := O1;  --inc cnt
   begin
      Op (+O2);
   end;  --dec cnt
end; --dec cnt; cnt = 0; call Free


The point is that the language already provides many abstraction
mechanims to make manipulation of memory easy and safe, and demonstrated
above.

GNAT also provides a debug storage pool, that can help find errors in
heap memory use.  They'll probably add a garbage-collected pool if
there's interest.

Re: Ada 0Y plans for garbage collection?

[Matthew Heaney]

olehjalmar kristensen - Sun Microsystems - Trondheim Norway <ok145024@sun.com> writes:

> I still think the way it was done in Modula-3 gives you the best of
> both worlds. If you want garbage collection, you allocate from a
> different pool. If you don't want it you don't use it, and there is no
> overhead.

This would be the case in Ada, too, were an Ada vendor to provide such a
pool (which the language was specifically designed to allow).

Something like:

  type T is ...;

  type T_Access is access T;

  for T_Access'Storage_Pool use Garbage_Collected_Pool;

Now when you do this:

  O : T_Access := new T;

then the object is allocated from the garbage collected storage pool.

However, I don't think there are any Ada vendors that provide such a
pool, mostly because there has not been a market for it.

Re: Ada 0Y plans for garbage collection?

[Matthew Heaney]

Martin Krischik <krischik@users.sourceforge.net> writes:

> I agree with you on that one. A reference counting access type would be as
> good a real garbage collector.

If you need a reference-counted pointer, then just build one.  Something
like:

package P is

  type T (<>) is limited private;

  type T_Access is access all T;

  type Handle_Type is private;

  function New_T return Handle_Type;

  function "+" (Handle : Handle_Type) return T_Access;

  procedure Op (O : access T);

...

end P;

Now you can do this:

declare
  O : Handle_Type := New_T;
begin
  Op (+O);
end;  --automatically deallocates object

The only problem with this schema is that it's still possible for a
client to use "+" to get the internal access type, and then hold on to
it. 

I pitched the idea to have an access types with a partial view, like
this:

package P is

  type T (<>) is limited private;

  type T_Access (<>) is limited access all T with private;

Now this limits what you can do with the value returned by "+"; for
example, you wouldn't be able to make a copy of it.

However, there didn't seem to be much enthusiasm for such a language
change.

Actually, if you don't need dispatching, then you could do this already:

package P is

  type T (<>) is limited private;

  type T_Access (<>) is limited private;

  procedure Op (O : T_Access);
...
private

  type T_Access is access all T;

end P;

Re: Ada 0Y plans for garbage collection?

[Berend de Boer]

>>>>> "Martin" == Martin Krischik <krischik@users.sourceforge.net> writes:

    Martin> I agree with you on that one. A reference counting access
    Martin> type would be as good a real garbage collector.

Only it adds a lot of overhead. A real garbage collector might take
lots less cycles than all that reference counting.

-- 
Regards,

Berend. (-:

Re: Ada 0Y plans for garbage collection?

[Ludovic Brenta]

Berend de Boer <berend@xsol.com> writes:

> >>>>> "Martin" == Martin Krischik <krischik@users.sourceforge.net> writes:
> 
>     Martin> I agree with you on that one. A reference counting access
>     Martin> type would be as good a real garbage collector.
> 
> Only it adds a lot of overhead. A real garbage collector might take
> lots less cycles than all that reference counting.

Linus Torvalds differs quite strongly on this:

http://gcc.gnu.org/ml/gcc/2002-08/msg00571.html

-- 
Ludovic Brenta.

Re: Ada 0Y plans for garbage collection?

[Robert I. Eachus]

Ludovic Brenta wrote:

> Linus Torvalds differs quite strongly on this:
> 
> http://gcc.gnu.org/ml/gcc/2002-08/msg00571.html

Couldn't have said it better myself.  On one project I wanted to compare 
using garbage collection to Controlled types and managing the allocation 
and deallocation of objects myself.

First I wrote a version that just did heap allocation, with NO garbage 
collection.  Of course it was possible to run out of storage with this 
version, but I wanted to see how much overhead GC would add.  As long as 
I had a test case that did not result in paging, this was the ultimate 
best case for the GC version.

Then I changed the implementation to use a Controlled type, with 
explicit immediate frees as soon as an object was no longer used.  I 
added less than a page of code to implement all this.  Remember now the 
code is explicitly freeing everything.

The version with the Controlled type was three times as fast as the 
version with no deallocation.  You can imagine how motivated I was to 
find out how much overhead GC would add. ;-)  Worse, I then changed 
things a bit more.  Since all the nodes I was allocating were the same 
size, I grabbed a chunk of memory and used it as a reference counted 
heap where every object was the same size.  (I then twiddled a bit more 
so objects were exactly one cache line long, and my allocater returned 
blocks that were cache line aligned.)  Net result, this version was 
almost ten times as fast as the na�ve version that would quickly start 
paging to virtual memory if I let it.

-- 
                                               Robert I. Eachus

"As far as I'm concerned, war always means failure." -- Jacques Chirac, 
President of France
"As far as France is concerned, you're right." -- Rush Limbaugh

Re: Ada 0Y plans for garbage collection?

[Martin Krischik]

Matthew Heaney wrote:

> olehjalmar kristensen - Sun Microsystems - Trondheim Norway
> <ok145024@sun.com> writes:
> 
>> I still think the way it was done in Modula-3 gives you the best of
>> both worlds. If you want garbage collection, you allocate from a
>> different pool. If you don't want it you don't use it, and there is no
>> overhead.
> 
> This would be the case in Ada, too, were an Ada vendor to provide such a
> pool (which the language was specifically designed to allow).

> However, I don't think there are any Ada vendors that provide such a
> pool, mostly because there has not been a market for it.

GCC 3.3 will provide such a pool for all GCC langunages. An Ada binding
takes less 50 of code (w/o comments, package specs etc. pp.). But then GCC
does not have a "verndor" ;-).

With Regards

Martin

-- 
mailto://krischik@users.sourceforge.net
http://www.ada.krischik.com

Re: Ada 0Y plans for garbage collection?

[Dmitry A. Kazakov]

On Fri, 12 Sep 2003 17:20:27 GMT, "Robert I. Eachus"
<rieachus@attbi.com> wrote:

>Dmitry A. Kazakov wrote:
>
>> But reference counting could be made much more easy and attractive if
>> smart pointers have more light-weighted implementation than controlled
>> types in generic packages. There are too many problems with that...
>
>Agreed, which is why you want to use a reference counted storage pool. 
>That way the count is stored with the object, and you only incur the 
>overhead when you create a new counted access value.

Sounds great, really!

It also solves nasty problems when a GC object is allocated on the
stack, or with [unsupported] MI (:-)), because the reference count is
no more a part of the object.

But I suppose that this would require massive compiler support. If so,
then why not to make access types to counted storage pool more
transparent. At least when:

1. passing to a subprogram expecting the designated object.

2. dispatching. Named access types do not dispatch and define no
primitive operations.

I mean, to finally kick GC off, access types to reference counted
objects should fully mimic the designated types. I.e. ".all" dropped,
"null" is not a valid value etc. AFAIK access types with no "null" are
planned (?), so dropping ".all" would be a logical consequence.
Assignment should then just copy the reference. BUT, what about
cloning [non-limited] objects when they are modified through a counted
access, while the reference count is greater than 1? This is not so
easy.

>I've done this to create a pool of fixed sized objects.  I keep 
>intending to rewrite it to support variable sized objects, but it is 
>always easier to create a fixed-sized reference-counted object with an 
>access value into the normal heap, and do explicit deallocation of that 
>object when the reference count reaches zero.
>
>Anyone want to work with me on a "standard" reference counted storage 
>pool for Ada 200Y?  The storage pool will only be a couple of pages of 
>code.  The real effort is in documenting it and providing examples of use.

If I can help...

>Or did you mean that the fact that the storage pool was a controlled 
>type was a problem?

No. The problem was that the reference type has to be controlled.

> I don't see that.  Typically a program will create 
>a storage pool once and then just use it.  The controlled overhead 
>really only comes into play if the storage pool is located inside a 
>nested procedure.

---
Regards,
Dmitry Kazakov
www.dmitry-kazakov.de

Re: Ada 0Y plans for garbage collection?

[Dmitry A. Kazakov]

On Fri, 12 Sep 2003 17:38:14 +0200, Martin Krischik
<krischik@users.sourceforge.net> wrote:

>Dmitry A. Kazakov wrote:
>
>> On Thu, 11 Sep 2003 21:21:21 GMT, "Robert I. Eachus"
>> <rieachus@attbi.com> wrote:
> 
>> (I saw no single real-life example, where automatic GC were a solution
>> of choice)
>
>Java. All of it. I fact all new Languages.

GC is a big hype now.

>I would like to invite you to read my "containers and garbage collections."
>article as well.

It would be very interesting. Do you have a link?

---
Regards,
Dmitry Kazakov
www.dmitry-kazakov.de

Re: Ada 0Y plans for garbage collection?

[Alexander Kopilovitch]

Dmitry A. Kazakov wrote:

> On Fri, 12 Sep 2003 17:20:27 GMT, "Robert I. Eachus"
> <rieachus@attbi.com> wrote:
>
> ...
>
> >Anyone want to work with me on a "standard" reference counted storage 
> >pool for Ada 200Y?  The storage pool will only be a couple of pages of 
> >code.  The real effort is in documenting it and providing examples of use.
>
>If I can help...

I am second with the same formula. (I'm an expert neither in Ada, nor in GC,
although I certainly know enough of both to see rather clearly a substantial
distance between me and experts in these things -;)



Alexander Kopilovitch                      aek@vib.usr.pu.ru
Saint-Petersburg
Russia

Re: Ada 0Y plans for garbage collection?

[Jon S. Anthony]

"Robert I. Eachus" <rieachus@attbi.com> writes:

> Ludovic Brenta wrote:
> 
> > Linus Torvalds differs quite strongly on this:
> > http://gcc.gnu.org/ml/gcc/2002-08/msg00571.html

Modern GCs do in fact take locality and temporal aspects into account.
So, this may not be particularly relevant in the general case.

> Couldn't have said it better myself.  On one project I wanted to
> compare using garbage collection to Controlled types and managing the
> allocation and deallocation of objects myself.

Having used manual new/free, controlled types style, "smart pointers";
and modern generational GCs with, my experience strongly indicates
that you cannot beat a GC in the general case.  Moreover, in a
"typical" application, you can't beat a GC with any combination of the
former techniques wrt overall throughput.

YMMV, but unless you use true state of the art versions, the sort of
example you give here is pretty irrelevant.

/Jon

Re: Ada 0Y plans for garbage collection?

[Martin Krischik]

Dmitry A. Kazakov wrote:

> On Fri, 12 Sep 2003 17:38:14 +0200, Martin Krischik
> <krischik@users.sourceforge.net> wrote:
 
>>I would like to invite you to read my "containers and garbage
>>collections." article as well.
 
> It would be very interesting. Do you have a link?

I think you found it allready ;-)

Martin

-- 
mailto://krischik@users.sourceforge.net
http://www.ada.krischik.com

Re: Ada 0Y plans for garbage collection?

[Berend de Boer]

>>>>> "Ludovic" == Ludovic Brenta <ludovic.brenta@insalien.org> writes:

    Martin> I agree with you on that one. A reference counting access
    Martin> type would be as good a real garbage collector.
    >>  Only it adds a lot of overhead. A real garbage collector might
    >> take lots less cycles than all that reference counting.

    Ludovic> Linus Torvalds differs quite strongly on this:

But really has no idea what current gc's can do.

He says that compacting gc's solve the spatial locality. Performance
is not a problem he says, so let's dismiss the extra overhead he
mentions here, but had dismissed before.

Temporal locality is solved by generational gc's.

Start reading here:

  http://www.hpl.hp.com/personal/Hans_Boehm/pubs.html

In a hurry? Read just this:

  ftp://ftp.cs.utexas.edu/pub/garbage/gcsurvey.ps


And Linux was talking about a specific case: max speed. Perhaps he was
correct. That doesn't imply gc is bad for every other app for which
speed isn't that all important.

-- 
Regards,

Berend. (-:

Re: Ada 0Y plans for garbage collection?

[Jeffrey Creem]

"Berend de Boer" <berend@xsol.com> wrote in message
news:ur82gs8zd.fsf@xsol.com...
>>
> And Linux was talking about a specific case: max speed. Perhaps he was
> correct. That doesn't imply gc is bad for every other app for which
> speed isn't that all important.
>

You know..some day this might be true. I have been hearing the "computers
are so fast it does not matter anymore" story for at least 10 years now...

But until I can

Boot my OS in less than 3 seconds.
Launch any application at random in the sub 100msec range
Ecode and burn a 2 hour MPEG DVD in 3-4 seconds.
Perform complicated embedded DSP algorithms in 10% of a CPU running on 100
Mwatts

I am not going to believe it.

Everything (and yes I mean everything) still runs slower than I'd like. And
with the next generation of kids
growing up feeling that instant gratitification takes too long, I suspect we
still have a few years before anything other
than a "guess want number" game runs fast enough.

Re: Ada 0Y plans for garbage collection?

[Larry Kilgallen]

In article <dXO9b.481787$uu5.83124@sccrnsc04>, "Jeffrey Creem" <jeff@thecreems.com> writes:
> 
> "Berend de Boer" <berend@xsol.com> wrote in message
> news:ur82gs8zd.fsf@xsol.com...
>>>
>> And Linux was talking about a specific case: max speed. Perhaps he was
>> correct. That doesn't imply gc is bad for every other app for which
>> speed isn't that all important.
>>
> 
> You know..some day this might be true. I have been hearing the "computers
> are so fast it does not matter anymore" story for at least 10 years now...
> 
> But until I can
> 
> Boot my OS in less than 3 seconds.

Ideally, you should never have to "boot" your computer.
Replacement of software and hardware components should be possible while
operations are underway.

Re: Ada 0Y plans for garbage collection?

[Jon S. Anthony]

"Jeffrey Creem" <jeff@thecreems.com> writes:

> "Berend de Boer" <berend@xsol.com> wrote in message
> news:ur82gs8zd.fsf@xsol.com...
> >>
> > And Linux was talking about a specific case: max speed. Perhaps he was
> > correct. That doesn't imply gc is bad for every other app for which
> > speed isn't that all important.
> >
> 
> You know..some day this might be true. I have been hearing the "computers
> are so fast it does not matter anymore" story for at least 10 years now...

Actually, wrt to dynamic languages (aside: Java is still a static
language despite the GC) this _has_ been true for at least 8 years
now.  People still stuck on static languages for the sort of reasons
you mention are the exact current analogue of assembly programmers to
then "hll" advocates.  In general they were wrong and proven to be so.
Similarly, in general dynamic languages can and should be used for
most applications today - for very similar reasons:

1) They are far more expressive and thus far more productive.

2) Because they are more expressive, they can be closer to the domain
   semantics of an application and thus will generally be more
   maintainable.

3) They are as fast and often faster than the static alternatives.


People who talk about how GC "can't" be as fast as programmers hacking
new/free style allocation are just like assembly hackers saying
optimizing compilers will never produce code as fast as hand crafted
assembly.  This is just plain wrong - in both cases.  Sure, there are
examples where both claims hold, but in general the exact opposite is
true - the optimizing compiler will beat the assembly hack and the
modern generational GC will blow away the new/free/controlled_type
hack.

> I am not going to believe it.

Actually you will never believe it, because


> Everything (and yes I mean everything) still runs slower than I'd
> like.

The software that is running slower is doing vastly more than before.
Sometimes it even does something more useful, though it often seems
that it is just more poorly rendered.  And as long as SW
(function/bloat/creeping featurism) holds sway things will continue to
appear "slower than wanted".


/Jon

Re: Ada 0Y plans for garbage collection?

[Gautier Write-only]

Jeffrey Creem:

# But until I can

# Boot my OS in less than 3 seconds.
# Launch any application at random in the sub 100msec range
# Ecode and burn a 2 hour MPEG DVD in 3-4 seconds.
# Perform complicated embedded DSP algorithms in 10% of a CPU running on 100
# Mwatts

# I am not going to believe it.

# Everything (and yes I mean everything) still runs slower
# than I'd like.

It's Parkinson's law applied to computers:
"Work expands so as to fill the time available
for its completion" becomes something like "Software
effort expands so as to fill the CPU cycles available
for its completion, in a given time".
In other words, there is an apparent competition between
progress in hardware and bloat in software resulting to
about the same time for equivalent jobs. Maybe it's just that
slower software helps selling faster hardware...
________________________________________________________
Gautier  --  http://www.mysunrise.ch/users/gdm/gsoft.htm

NB: For a direct answer, e-mail address on the Web site!

Re: Ada 0Y plans for garbage collection?

[Berend de Boer]

>>>>> "Jeffrey" == Jeffrey Creem <jeff@thecreems.com> writes:

    Jeffrey> Boot my OS in less than 3 seconds.

Try BeOS. Or try booting win 3.11 on your current hardware.

-- 
Regards,

Berend. (-:

Re: Ada 0Y plans for garbage collection?

[chris]

Jeffrey Creem wrote:

> But until I can
> 
> Boot my OS in less than 3 seconds.

Intel are taking care of it... and not for the first time ;)

http://www.theregister.co.uk/content/3/32881.html

Re: Ada 0Y plans for garbage collection?

[Robert I. Eachus]

chris wrote:

> Intel are taking care of it... and not for the first time ;)
> 
> http://www.theregister.co.uk/content/3/32881.html

Actually, this is going to happen--as far as the hardware is concerned. 
  There are several types of memory that may replace DRAM in the next 
few years, polymer memory and MRAM seem the leading candidates right now.

But the common property of all these new memory types is that they are 
persistant, just like flash memory.  So assuming that the OS allows it, 
cycling power (or a power failure) won't require a reboot.  The OS will 
already be in memory and initialized.  Of course, the gotcha in that 
phrase is "if the OS allows" and if Windows doesn't and Linux does for 
some period of years, that could be the end of Windows.  (But I don't 
expect that. Windows currently supports sleep states in laptops that 
should be fairly similar in implementation.)

-- 
                                          Robert I. Eachus

Ryan gunned down the last of his third white wine and told himself it 
would all be over in a few minutes.  One thing he'd learned from 
Operation Beatrix: This field work wasn't for him. --from Red Rabbit by 
Tom Clancy.

Re: Ada 0Y plans for garbage collection?

[Warren W. Gay VE3WWG]

Robert I. Eachus wrote:
> chris wrote:
> 
>> Intel are taking care of it... and not for the first time ;)
>> http://www.theregister.co.uk/content/3/32881.html
> 
> Actually, this is going to happen--as far as the hardware is concerned. 
>  There are several types of memory that may replace DRAM in the next few 
> years, polymer memory and MRAM seem the leading candidates right now.
> 
> But the common property of all these new memory types is that they are 
> persistant, just like flash memory.  So assuming that the OS allows it, 
> cycling power (or a power failure) won't require a reboot.  The OS will 
> already be in memory and initialized.  Of course, the gotcha in that 
> phrase is "if the OS allows" and if Windows doesn't and Linux does for 
> some period of years, that could be the end of Windows.  (But I don't 
> expect that. Windows currently supports sleep states in laptops that 
> should be fairly similar in implementation.)

Microsoft will still need to work on eliminating the need to reboot
after every software install, or after most "Windows Updates"
have completed. Not to mention the need to reboot after ref counters
for COM/DCOM objects get messed up due to abnormal process
termination events and such.

-- 
Warren W. Gay VE3WWG
http://home.cogeco.ca/~ve3wwg

Re: Ada 0Y plans for garbage collection?

[chris]

Robert I. Eachus wrote:

> But the common property of all these new memory types is that they are 
> persistant, just like flash memory.  So assuming that the OS allows it, 
> cycling power (or a power failure) won't require a reboot.  The OS will 
> already be in memory and initialized.  Of course, the gotcha in that 
> phrase is "if the OS allows" and if Windows doesn't and Linux does for 
> some period of years, that could be the end of Windows.  (But I don't 
> expect that. Windows currently supports sleep states in laptops that 
> should be fairly similar in implementation.)

Yep, and I'm looking forward to it.  Persistance and Orthogonal 
Persistance are the way things should be and in my experience it's what 
users expect from a pc the first time the use one.  People have to be 
trained to think in terms of saving (usually with painful first lesson).



Chris

Re: Ada 0Y plans for garbage collection?

[Dmitry A. Kazakov]

On Mon, 22 Sep 2003 15:51:37 GMT, "Robert I. Eachus"
<rieachus@attbi.com> wrote:

>Actually, this is going to happen--as far as the hardware is concerned. 
>  There are several types of memory that may replace DRAM in the next 
>few years, polymer memory and MRAM seem the leading candidates right now.
>
>But the common property of all these new memory types is that they are 
>persistant, just like flash memory.  So assuming that the OS allows it, 
>cycling power (or a power failure) won't require a reboot.  The OS will 
>already be in memory and initialized.  Of course, the gotcha in that 
>phrase is "if the OS allows" and if Windows doesn't and Linux does for 
>some period of years, that could be the end of Windows.  (But I don't 
>expect that. Windows currently supports sleep states in laptops that 
>should be fairly similar in implementation.)

Yep. Especially interesting it becomes with plug'n'play devices. You
have, say a USB or PCMCIA device attached, before your Windoze
hibernates. While it peacefully sleeps, you archly eject the hardware
and then wake it up! The effect might be amazing, though predictable
...

Of course in a truly memory-mapped OS, the present concept of hardware
drives is out of place. One more reason for Ada OS?

---
Regards,
Dmitry Kazakov
www.dmitry-kazakov.de

Re: Ada 0Y plans for garbage collection?

[Nick Roberts]

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message
news:2q30nv4fain641rin9dia3onjr7ut01our@4ax.com...

[re booting and sleeping]
> Yep. Especially interesting it becomes with plug'n'play devices. You
> have, say a USB or PCMCIA device attached, before your Windoze
> hibernates. While it peacefully sleeps, you archly eject the hardware
> and then wake it up! The effect might be amazing, though predictable
> ...
> Of course in a truly memory-mapped OS, the present concept of
> hardware drives is out of place. One more reason for Ada OS?

I think the broad scheme I would like to adopt for AdaOS would be as
follows.

Each device driver, having at least once gone through a complete hardware
configuration procedure, would record the hardware configuration upon
shutdown. Upon the next reboot, the device driver would reinstate this
configuration, and would perform a quick check that the configuration still
accords with the detectable hardware (if this check failed, the full
configuration procedure would be activated).

With a bit of care, this technique should make it possible to fully shutdown
and then reboot very rapidly, but it would still be safe in the case of
intervening hardware changes (which would automatically cause
reconfiguration).

I intend to design the user application software for AdaOS so that it
(normally) remembers its important state in between the user logging off and
back on again. This is primarily to encourage users to log off whenever they
leave the workstation, but it also means that a user can log off, shutdown,
reboot, and log on, and all (or most) of their work (open windows) will be
reinstated as it was when the user logged off.

I don't know why operating systems (Windows, SunOS, and Linux in my direct
experience) are so slow at booting up, but I suspect it has a lot to do with
device drivers intialising themselves and their hardware. If this
initialisation can be either avoided (by the above tactics) or deferred (to
be done in the background after the boot procedure has got the system to a
usable stage), the user will perceive a fast boot process.

If the user can shutdown and reboot quickly (within a few seconds, I
suppose), and does not have to go through the rigmarole of closing a lot of
programs (windows) and then restarting them, I suspect the demand for a
'sleep mode' would be largely obviated.

If any OS is to be really secure, it must be basically reliable. I think
Dmitry has neatly illustrated the dangers of such fundamental complications
as sleep modes and other forms of partial shutdown. If a machine supports a
sleep mode, I think that's okay (especially as part of an overall power
management regime), but a full shutdown is better.

However, I'm open to debate!

--
Nick Roberts
Jabber: debater@charente.de [ICQ: 159718630]


[CROSS POSTED!  Please ensure replies go only to alt.os.development -
thanks.]

Re: Ada 0Y plans for garbage collection?

[Maxim S. Shatskih]

> Each device driver, having at least once gone through a complete hardware
> configuration procedure, would record the hardware configuration upon
> shutdown. Upon the next reboot, the device driver would reinstate this
> configuration, and would perform a quick check that the configuration still
> accords with the detectable hardware (if this check failed, the full
> configuration procedure would be activated).

Windows does nearly the same for non-PnP obsolete devices, though without the
last step.
PnP devices do not need this.

> I don't know why operating systems (Windows, SunOS, and Linux in my direct
> experience) are so slow at booting up,

XP is rather fast. The main time spent is to start the service/daemon
executables.

>but I suspect it has a lot to do with
> device drivers intialising themselves and their hardware.

Only a minority need the complex init paths - IDE, for instance, due to
compatibility with some obsolete CD drives.

> If the user can shutdown and reboot quickly (within a few seconds, I
> suppose), and does not have to go through the rigmarole of closing a lot of
> programs (windows) and then restarting them, I suspect the demand for a
> 'sleep mode' would be largely obviated.

This is how hibernate works.

--
Maxim Shatskih, Windows DDK MVP
StorageCraft Corporation
maxim@storagecraft.com
http://www.storagecraft.com

Re: Ada 0Y plans for garbage collection?

[Preben Randhol]

On 2003-09-24, Maxim S. Shatskih <maxim@storagecraft.com> wrote:
> XP is rather fast. The main time spent is to start the service/daemon
> executables.

Well it take ages when you login because then it starts up antivirus,
firewall different applications etc... 

> This is how hibernate works.

If it works.

Preben

Re: Time Taken to Boot

[Nick Roberts]

"Maxim S. Shatskih" <maxim@storagecraft.com> wrote in message
news:bksdr3$2vhi$3@gavrilo.mtu.ru...

> ...
> XP is rather fast. The main time spent is to start the service
> daemon executables.

That's interesting. I have no experience of booting XP, but I have observed
booting NT 4 from a network take more than 100 seconds. I cannot say whether
it was the particular network or configuration that was causing a special
delay (it was a part of the British government's huge 'corporate' intranet).

> Only a minority need the complex init paths - IDE, for instance,
> due to compatibility with some obsolete CD drives.

I know some CD drives can take ages to intialise. I think the clear solution
is to have the CD driver (including its initialisation routine) execute in
parallel with the rest of the boot procedure. Of course, this won't help if
you are booting /from/ a CD!

> > If the user can shutdown and reboot quickly ...

> This is how hibernate works.

Yes, I thought I had read about the scheme I described, somewhere (but I
don't remember where), a long time ago. I guess that's it. It seems fairly
obvious.

--
Nick Roberts
Jabber: debater@charente.de [ICQ: 159718630]

Re: Ada 0Y plans for garbage collection?

[Stephane Richard]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 589 bytes --]

"Preben Randhol" <randhol+abuse@pvv.org> wrote in message
news:slrnbn3fv8.5u0.randhol+abuse@kiuk0152.chembio.ntnu.no...
> On 2003-09-24, Maxim S. Shatskih <maxim@storagecraft.com> wrote:
> > XP is rather fast. The main time spent is to start the service/daemon
> > executables.
>
> Well it take ages when you login because then it starts up antivirus,
> firewall different applications etc...
>
> > This is how hibernate works.
>
> If it works.
>
> Preben


I see we have another victim of "Plug N Pray"  hehehehe
-- 
St�phane Richard
"Ada World" Webmaster
http://www.adaworld.com

Re: Ada 0Y plans for garbage collection?

[chris]

Stephane Richard wrote:
> 
> I see we have another victim of "Plug N Pray"  hehehehe

Why do people dislike Plug'N'Play?  I have never had any bother with it, 
so I'm genuinely interested in other problems.

To me all Desktop OS should support runtime configuration of hw that 
doesn't require rebooting (not necessarily plug'n'play).  Rebootings 
taking the easy way out.

Re: Time Taken to Boot

[Mark A. Biggar]

Nick Roberts wrote:

> "Maxim S. Shatskih" <maxim@storagecraft.com> wrote in message
> news:bksdr3$2vhi$3@gavrilo.mtu.ru...
> 
> 
>>...
>>XP is rather fast. The main time spent is to start the service
>>daemon executables.
> 
> 
> That's interesting. I have no experience of booting XP, but I have observed
> booting NT 4 from a network take more than 100 seconds. I cannot say whether
> it was the particular network or configuration that was causing a special
> delay (it was a part of the British government's huge 'corporate' intranet).
> 
> 
>>Only a minority need the complex init paths - IDE, for instance,
>>due to compatibility with some obsolete CD drives.
> 
> 
> I know some CD drives can take ages to intialise. I think the clear solution
> is to have the CD driver (including its initialisation routine) execute in
> parallel with the rest of the boot procedure. Of course, this won't help if
> you are booting /from/ a CD!
> 
> 
>>>If the user can shutdown and reboot quickly ...
> 
> 
>>This is how hibernate works.
> 
> 
> Yes, I thought I had read about the scheme I described, somewhere (but I
> don't remember where), a long time ago. I guess that's it. It seems fairly
> obvious.

A large percentage of windows boot time is reading and parsing the 
registry.  Which brings up the issue that the windows registry is one
of the biggest problems with security in Windows.  A folder with
separate files for each program/service would not only be faster but
would help with the security problems as well.

-- 
mark@biggar.org
mark.a.biggar@comcast.net

Re: Ada 0Y plans for garbage collection?

[Robert C. Leif]

If this could be done, it would be extremely valuable. A major problem
with PCs is what was an information appliance was transformed into a
computer with a full blown operating system. This is exactly what the
majority of customers do NOT need. They would be much better served by
a device that could be turned on and off by a simple switch.
 
Parenthetically, Nick has one year from the date of publication to
apply for a US Patent. If his technology works and is new, this patent
could be very valuable. He could even license it with a clause that
requires the code to be written in Ada.
Bob Leif
Robert C. Leif, Ph.D.
Email rleif@rleif.com


"Nick Roberts" <nickroberts@blueyonder.co.uk> wrote in message news:<bkqt28$3v03r$1@ID-25716.news.uni-berlin.de>...
> "Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message
> news:2q30nv4fain641rin9dia3onjr7ut01our@4ax.com...
> 
> [re booting and sleeping]
> > Yep. Especially interesting it becomes with plug'n'play devices. You
> > have, say a USB or PCMCIA device attached, before your Windoze
> > hibernates. While it peacefully sleeps, you archly eject the hardware
> > and then wake it up! The effect might be amazing, though predictable
> > ...
> > Of course in a truly memory-mapped OS, the present concept of
> > hardware drives is out of place. One more reason for Ada OS?
> 
> I think the broad scheme I would like to adopt for AdaOS would be as
> follows.
> 
> Each device driver, having at least once gone through a complete hardware
> configuration procedure, would record the hardware configuration upon
> shutdown. Upon the next reboot, the device driver would reinstate this
> configuration, and would perform a quick check that the configuration still
> accords with the detectable hardware (if this check failed, the full
> configuration procedure would be activated).
> 
> With a bit of care, this technique should make it possible to fully shutdown
> and then reboot very rapidly, but it would still be safe in the case of
> intervening hardware changes (which would automatically cause
> reconfiguration).
> 
> I intend to design the user application software for AdaOS so that it
> (normally) remembers its important state in between the user logging off and
> back on again. This is primarily to encourage users to log off whenever they
> leave the workstation, but it also means that a user can log off, shutdown,
> reboot, and log on, and all (or most) of their work (open windows) will be
> reinstated as it was when the user logged off.
> 
> I don't know why operating systems (Windows, SunOS, and Linux in my direct
> experience) are so slow at booting up, but I suspect it has a lot to do with
> device drivers intialising themselves and their hardware. If this
> initialisation can be either avoided (by the above tactics) or deferred (to
> be done in the background after the boot procedure has got the system to a
> usable stage), the user will perceive a fast boot process.
> 
> If the user can shutdown and reboot quickly (within a few seconds, I
> suppose), and does not have to go through the rigmarole of closing a lot of
> programs (windows) and then restarting them, I suspect the demand for a
> 'sleep mode' would be largely obviated.
> 
> If any OS is to be really secure, it must be basically reliable. I think
> Dmitry has neatly illustrated the dangers of such fundamental complications
> as sleep modes and other forms of partial shutdown. If a machine supports a
> sleep mode, I think that's okay (especially as part of an overall power
> management regime), but a full shutdown is better.
> 
> However, I'm open to debate!

Re: Time Taken to Boot

[Maxim S. Shatskih]

> A large percentage of windows boot time is reading and parsing the
> registry.

No. I have listed the causes for slow Windows boot.

>Which brings up the issue that the windows registry is one
> of the biggest problems with security in Windows.

Sorry, how the boot speed is connected with security? Registry keys are
protected by ACLs.
You cannot achieve better protection with files.

>A folder with
> separate files for each program/service would not only be faster but

Will be slower. Each file should be opened. Dirent read+metadata read+data
read. Several seeks.
Registry is read linearly in 64KB chunks on boot. All parsing is done in
memory.

> would help with the security problems as well.

No. For instance, there is FAT filesystem with no ACLs on files. Registry is
still protected.

Not to say that "many files" approach hardens the "backup system state" task a
lot.

--
Maxim Shatskih, Windows DDK MVP
StorageCraft Corporation
maxim@storagecraft.com
http://www.storagecraft.com

Re: Time Taken to Boot

[Warren W. Gay VE3WWG]

Maxim S. Shatskih wrote:

>>A large percentage of windows boot time is reading and parsing the
>>registry.
> 
> No. I have listed the causes for slow Windows boot.
> 
>>Which brings up the issue that the windows registry is one
>>of the biggest problems with security in Windows.
> 
> Sorry, how the boot speed is connected with security? Registry keys are
> protected by ACLs.
> You cannot achieve better protection with files.

The problem as I see it, is nobody makes use of that security!
Almost every week, my spyware software is telling me I have
gator installed. This stupid thing is thanks to the stupid
security around ActiveX and the way registry entries are
permitted to be changed. If you set it to "prompt", then you're
bugged constantly, including for plugins for Adobe (to read
PDF files). If you disable it, then Adobe's plugin doesn't
run (I mean, at least separate plugins you have installed vs
the web download-on-the-fly ActiveX crap).

In XP, I set up my family as unpriviledged users (whatever that
was named), initially. But in the end, I had to give in and make
my wife and kids administrator, because they couldn't do the
things they needed to do. Sigh.

So why bother putting a security layer in place, Microsoft, if
you're not going to plan out a decent design of roles and use
of the system!?!?!?  </rant>

-- 
Warren W. Gay VE3WWG
http://home.cogeco.ca/~ve3wwg

Re: OT Ada 0Y plans for garbage collection?

[Pascal Obry]

Preben Randhol <randhol+abuse@pvv.org> writes:

> Well it take ages when you login because then it starts up antivirus,
> firewall different applications etc... 
> 
> > This is how hibernate works.
> 
> If it works.

I can tell you it works quite on my Laptop with Windows XP. I haven't
rebooted since at least 2 monthes.

Pascal.

-- 

--|------------------------------------------------------
--| Pascal Obry                           Team-Ada Member
--| 45, rue Gabriel Peri - 78114 Magny Les Hameaux FRANCE
--|------------------------------------------------------
--|         http://perso.wanadoo.fr/pascal.obry
--| "The best way to travel is by means of imagination"
--|
--| gpg --keyserver wwwkeys.pgp.net --recv-key C1082595

Re: OT Ada 0Y plans for garbage collection?

[Pascal Obry]

Pascal Obry <p.obry@wanadoo.fr> writes:

> I can tell you it works quite on my Laptop with Windows XP. I haven't
                               ^
                               well
> rebooted since at least 2 monthes.

Pascal.

-- 

--|------------------------------------------------------
--| Pascal Obry                           Team-Ada Member
--| 45, rue Gabriel Peri - 78114 Magny Les Hameaux FRANCE
--|------------------------------------------------------
--|         http://perso.wanadoo.fr/pascal.obry
--| "The best way to travel is by means of imagination"
--|
--| gpg --keyserver wwwkeys.pgp.net --recv-key C1082595

Re: OT Ada 0Y plans for garbage collection?

[tmoran]

> > > This is how hibernate works.
> >
> > If it works.
>
> I can tell you it works quite on my Laptop with Windows XP. I haven't
> rebooted since at least 2 monthes.
  My XP laptop must alternate between Shutdown and Hibernate.  A second
Hibernate in a row hangs so power off is the only option.  It used to work
till one day I ran Windows Update and it stopped working.

Re: OT Ada 0Y plans for garbage collection?

[Pascal Obry]

tmoran@acm.org writes:
>   My XP laptop must alternate between Shutdown and Hibernate.  A second
> Hibernate in a row hangs so power off is the only option.  It used to work
> till one day I ran Windows Update and it stopped working.

Ok. My point was more anyway that I'd like to see less "stupid" Windows
bashing. Most of the critics I see here is as if we were still using Windows
9x. I'm a free software (as in free speech) defender but we must all recognize
how good Windows XP is today, this is what we have to fight against. Windows
XP is a very good operating system, we need to work very hard to do
better. That is my whole point.

BTW, ever tried to hibernate a GNU/Linux box ?

Of course all this is far off topic for comp.lang.ada and I apologise :)

Pascal.

-- 

--|------------------------------------------------------
--| Pascal Obry                           Team-Ada Member
--| 45, rue Gabriel Peri - 78114 Magny Les Hameaux FRANCE
--|------------------------------------------------------
--|         http://perso.wanadoo.fr/pascal.obry
--| "The best way to travel is by means of imagination"
--|
--| gpg --keyserver wwwkeys.pgp.net --recv-key C1082595

Re: OT Ada 0Y plans for garbage collection?

[Stephane Richard]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 2052 bytes --]

You're right of course Pascal :-)

From Windows 95 to Windows XP is like night and day.  They finally got it
right :-).  I have to admit.  Where they''ll go next however may be a
different stury but I dont know yet.  we'll have to follow though on that.

Indeed there's a lot of work ahead of us to attempt to top that.  and Of
course it doesn't mean we shouldn't do it ;-) either.  But like Microsoft we
should be more than one on the project each with expertise in each part of
what's needed to make anything close to Windows XP.  (Networking, Internet,
GUI Design, Artists, System Access, OS development, etc etc..).  and see if
we can make it all fit together.



-- 
St�phane Richard
"Ada World" Webmaster
http://www.adaworld.com


"Pascal Obry" <p.obry@wanadoo.fr> wrote in message
news:ur823idhu.fsf@wanadoo.fr...
>
> tmoran@acm.org writes:
> >   My XP laptop must alternate between Shutdown and Hibernate.  A second
> > Hibernate in a row hangs so power off is the only option.  It used to
work
> > till one day I ran Windows Update and it stopped working.
>
> Ok. My point was more anyway that I'd like to see less "stupid" Windows
> bashing. Most of the critics I see here is as if we were still using
Windows
> 9x. I'm a free software (as in free speech) defender but we must all
recognize
> how good Windows XP is today, this is what we have to fight against.
Windows
> XP is a very good operating system, we need to work very hard to do
> better. That is my whole point.
>
> BTW, ever tried to hibernate a GNU/Linux box ?
>
> Of course all this is far off topic for comp.lang.ada and I apologise :)
>
> Pascal.
>
> -- 
>
> --|------------------------------------------------------
> --| Pascal Obry                           Team-Ada Member
> --| 45, rue Gabriel Peri - 78114 Magny Les Hameaux FRANCE
> --|------------------------------------------------------
> --|         http://perso.wanadoo.fr/pascal.obry
> --| "The best way to travel is by means of imagination"
> --|
> --| gpg --keyserver wwwkeys.pgp.net --recv-key C1082595

Re: OT Ada 0Y plans for garbage collection?

[Preben Randhol]

On 2003-09-27, Stephane Richard <stephane.richard@verizon.net> wrote:
> From Windows 95 to Windows XP is like night and day.

And to Linux is like stepping into a bright warm summerday ;-)

Sorry couldn't resist.

Preben

Re: OT Ada 0Y plans for garbage collection?

[chris]

Stephane Richard wrote:
> You're right of course Pascal :-)
> 
> From Windows 95 to Windows XP is like night and day.  They finally got it
> right :-).  I have to admit.  Where they''ll go next however may be a
> different stury but I dont know yet.  we'll have to follow though on that.

They had it right with 2k, they just didn't release a home version.  XP 
is IMO good iff you take out activation (and turn off the Fisher Price 
GUI), which as time goes on *seems* to becoming more of an issue with 
techies and laymen than before.  Also the policy of not supplying a CD 
via OEM distribution (instead a "recovery partition" distribution is 
causing real problems for some folk.  Still it's better than single user 
land, which is IMO the root of many of M$ current problems.  Things can 
only get better from here.