[M3devel] Using REFANYs to store integers?

[Mika Nystrom]

Hi Rodney,

You're reading my mind.  What I am thinking of doing is that I want
to optimize the handling of small integers (only), exactly the way
it's done in Smalltalk, that is, immutable, single-instance objects.
And only the interpreter will ever dereference the objects, so it
would check the LSBs---if they are set to zero, it will assume that
it's a heap object, if anything else, it's a special immutable value
of some sort.

I'm well aware it's a very dirty trick to attempt!  But I was
thinking that by doing this sort of thing I could avoid having to
code my own garbage collector.  I'm not surprised that the current
garbage collector has issues with it but I also cannot think of a
reason why one couldn't make it ignore unaligned "pointers" unless
the trick is already used for some purpose I am not aware of.

    Mika

"Rodney M. Bates" writes:
>I presume "pointers" that are not 0 MOD 4 "refer to" some kinds
>of immutable, single-instance objects and don't actually point
>to heap objects in need of collection, as in Smalltalk?  I would
>think it would be a simple modification of the existing M3 GC to
>just make it ignore words containing misaligned pointers.
>
>Will only interpreted bytecode ever dereference these pointers?
>Or does M3 compiler-generated code also dereference them?  Then
>the compiler would also have to generate checks and do whatever
>with misaligned pointers.
>
>Mika Nystrom wrote:
>> Hello Modula-3ers...
>> 
>> I have a question about garbage collecting, pointers, and dirty
>> tricks that I'm curious if anyone (Tony??) can answer.
>> 
>> Here it is.  I am considering writing a bytecode interpreter that
>> is to run mixed into a Modula-3 environment, that is, it will be
>> able to deal with bytecodes as well as Modula-3 objects.  There is
>> no problem with that of course, as bytecodes are "code" and Modula-3
>> objects are "objects" and can live on separate stacks.  However,
>> as an optimization (not an uncommon one in these types of systems),
>> I'd like a space and time efficient representation for "small
>> integers".  A tried-and-true method (it goes back at least to the
>> Smalltalk-80 runtime) is to realize that pointers (in my case
>> REFANYs) always point to word-aligned addresses.  We can then use
>> integers that are congruent to 1, 2, and 3 (mod 4) to represent
>> other types of data.
>> 
>> What will happen if I LOOPHOLE such integers back and forth to
>> REFANY?  Will the garbage collector just ignore them?  I wrote a
>> test program that does it and it doesn't crash... except when you
>> hit ctrl-C, it often dies with an assertion failure in
>> RTCollector.m3.. (This both with my ancient PM3 on FreeBSD and a
>> relatively recent update of CM3 on PPC_DARWIN.)  If the garbage
>> collector somehow disapproves of these integers, is there any
>> conceivable thing that would be broken by making necessary adjustments
>> to the garbage collector such that it would just ignore them?
>> Or is there a better way of solving my problem?
>> 
>>       Best regards,
>>         Mika
>> 
>
>-- 
>-------------------------------------------------------------
>Rodney M. Bates, retired assistant professor
>Dept. of Computer Science, Wichita State University
>Wichita, KS 67260-0083
>316-978-3922
>rodney.bates at wichita.edu