Re: power line (AS/400) article in computerworld

Hi, Steve:

But how often would you ever really need to save such user spaces, then delete them, and then restore them on the same system, or restore them onto another system (or LPAR)?

Many years ago, I wrote a "persistent heap" that used *USRSPC objects. Pointers in one *USRSPC pointed directly to locations within other *USRSPC objects, etc., to create arbitrarily large and complex data structures. And I never had to worry about it, so long as these *USRSPC objects remained on the same system, even across IPLs, etc. -- this is only a problem when saving and restoring multiple *USRSPC objects that contain embedded MI pointers.

In my reply on 2/28/08: ( http://archive.midrange.com/midrange-l/200802/msg01151.html ), I explained in some detail how you could implement this, if you needed to be able to save and restore multiple *USRSPC objects containing such embedded pointers.

Regards,

Mark S. Waterbury

> Steve Richter wrote:

On Fri, Apr 11, 2008 at 11:56 AM, David Gibbs <david@xxxxxxxxxxxx> wrote:

Steve Richter wrote:

the inablility of pointers to stay valid between IPLs.

Huh? What are you talking about?

No system that I'm aware of can actually guarantee that a memory pointer
will remain valid between restarts.

Actually, when it comes down to it, the System i *CAN* guarantee that a
memory pointer will remain valid between restarts ... it's called a user
space. The memory pointer may change (I don't know for sure), but you
can get a pointer to a user space and it will always contain the correct
data.

correction. my bad. Pointers stored in a user space are invalidated
when the user space is restored on the system. As I understand and
guess, when system objects are restored onto the system, there is a
lot of code that has to run which will reset the pointers stored in
the restored spaces.

any user application that uses pointers in a user space has to include
logic that will revalidate those pointers when the object is restored.
this limitation and others actually matter more than you would think.
A running program often would like to serialize its data structures (
linked lists, arrays ) to permanent storage ( a user space ). Then,
the next time the program runs it could recall the stored data in the
same format and structure as is used in the program. SLS is unique in
having the ability to do this sort of thing. What prevents it are the
problems I am describing with the 16meg limit and invalidation of
pointers when an object is restored.

-Steve