[Timber] 64 bit?

Thu Jun 4 10:28:24 EDT 2009

I see. I'm happy to implement whatever we come up with. I have no
experience, however, in language design. I would certainly like to come up
with a method for representing large scalars, but I haven't a clue as to a
solution that would be elegant and flexible in the face of change. The only
one is, as you mentioned, boxing. However, that seems to cancel out the
whole point of compiling to efficient C code.

I can build a new patch which will lock Int at 32 bit. That isn't a problem.
Compiling on 64 bit machines and maintaining consistent behavior is good
enough for now.

I am traveling for a bit and am not sure that I can accomplish much on my
macbook. I'll see what I can do.

On Thu, Jun 4, 2009 at 7:57 AM, Johan Nordlander <johan.nordlander at ltu.se>wrote:

> There are two issues here.
>
> Firstly, I think the strategy should be to identify the purely rts-internal
> uses of Int that really ought to be platform-dependent, or rather to match
> the size of pointers.  I don't think there are too many of these, as most
> uses of Int in the current .c files correspond to the Timber type Int which
> we really want to keep at 32 bits on all platforms (see my arguments in the
> quoted text below on why platform-independent Int semantics is a good
> thing).  This makes the majority of the Int->WORD changes in the patch go in
> the wrong dorection, I think, although I'm sure that some changes are indeed
> called for (where the rts uses internal loop counters, for example).  For
> the same reason one should unconditionally typedef Int as a int32_t in
> rts.h, in contrast to the definition of WORD which may vary between
> platforms.
>
> Secondly, while the addition of a BITS64 type is both desirable and
> principally correct, we have an implementation problem that must be resolved
> before such a type can be safely supported on platforms with pointers
> smaller than 64 bits.  The problem occurs because polymorphic values are
> implemented as void pointers in the C code, and all concrete values (heap
> allocated values as well as scalars) are assumed to be castable to void
> pointers without loss of information.  This is the main reason why we don't
> yet support the Double type, or target platforms with pointer sizes less
> than 32 bits.  However, there are known solutions to this problem (e.g.,
> using boxing as a last resort, perhaps in combination with code
> specialization), we just haven't investigated which approach that would suit
> us best.
>
> So for the time being I'm reluctant to check in the patch, as it would make
> the platform-dependent Int semantics even more manifest and lead to
> incorrect results when BITS64 values are used with polymorphic functions or
> data structures.  A patch that fixes the Int type to int32_t but changes all
> internal counters etc to use WORD would be more useful at this stage.  Then
> we could try to devise a implementation technique for polymorphism with big
> scalars in general, which would make the addition of a BITS64 type (as well
> as Double and even Int64) straightforward.
>
> That said, I see no reason why the proposed patch should work on a 64-bit
> machine.  So if you just want to get past the type error, you should change
> the type signature for showh to
>
>  showh :: a -> Int -> String \\ BitsOp a
>
> The reason being that showh doesn't work for any choice of type a, just the
> choices for which there exists a BitsOp instance.
>
> -- Johan
>
>
>  -- this message was sent to the moderators due to size constraints, so I'm
>> resending it, this time with a gzipped attachment.
>> Sorry for the slow response. Been slammed at work, can only work on this
>> on the weekends recently.
>> I have made changes to allow for 64 bit everywhere. I have made what I
>> think might be a fix to BitOps but I can't get it to compile.
>>
>> I have attached the darcs patch for my repository.
>>
>> I changed showh / showHex to this:
>>
>> showh :: a -> Int -> String
>> showh a 0 = ""
>> showh a n = ( hex (toInt((a `bsrl` (4 * n1)) `band` 0xF)) ) : str
>>    where n1 = n - 1
>>          str = showh a n1
>>
>> typeclass ShowHex a where
>>    showhex :: a -> String
>>
>> instance showHBits64 :: ShowHex BITS64 where
>>    showhex a = "0x" ++ showh a 16
>>
>> instance showHBits32 :: ShowHex BITS32 where
>>    showhex a = "0x" ++ showh a 8
>>
>> instance showHBits16 :: ShowHex BITS16 where
>>    showhex a = "0x" ++ showh a 4
>>
>> instance showHBits8 :: ShowHex BITS8 where
>>    showhex a = "0x" ++ showh a 2
>>
>>
>> But get the error:
>> Type error close to line 182, column 9
>> Cannot solve typing constraint BitsOp a
>>
>>
>>
>> On Tue, May 26, 2009 at 3:05 PM, Johan Nordlander <
>> johan.nordlander at ltu.se> wrote:
>> Also, since this is supposed to be a bit of a bare metal run time system,
>> wouldn't it make sense to have Int match the size of the architecture? It
>> would remove a superfluous (IMO) abstraction.
>>
>> It is reasonable, although the big drawback is that the meaning of
>> programs will then be platform-dependent in a very unfortunate way.  For
>> example, the expression 60000 + 10000 > 60000 will be true on some platforms
>> but false on 16-bit architectures.  I have no problem with the wrap-around
>> semantics for integers (it's what we want!), but it should be specified by
>> the language to mean the same thing on all platforms.  Programs written with
>> the specific aim to fit well on smaller/bigger architectures should instead
>> indicate this by using integer types with other wrap-around limits (we ought
>> to add Int8, Int16 and Int64 as primitives).
>>
>> Using the machine-dependent WORD type when casting to and from pointers is
>> a different thing -- this change doesn't affect the meaning of any Timber
>> programs.
>>
>> -- Johan
>>
>>
>> On Sun, May 24, 2009 at 10:54 AM, Johan Nordlander <
>> johan.nordlander at ltu.se> wrote:
>> Some experiments have been made (although no code were checked in), and
>> they mostly involved fixing rts.h.  The underlying problem is, though, that
>> there's a risk parts of the code silently assume that an Int is of the same
>> size as a polymorphic parameter (that is, the size of a pointer).  And
>> ideally we would like to keep the Int size at 32 bits in order to preserve
>> platform independence, and introduce an Int64 type for those cases this size
>> is needed.
>>
>> So it's essentially a matter of searching the source code for any such
>> size dependencies, and perhaps also extended it with Int types of other
>> common sizes.  I can't foresee any deep technical difficulies, it's just
>> tedious work.
>>
>> You're welcome to give it a try!
>>
>> -- Johan
>>
>>
>> I haven't looked too deeply into the source, but it would appear that the
>> bulk of the 64-bit problems are relegated to rts.h.
>> Is there any effort under way to address this? If not, I will take a whack
>> at correcting it. If there is some experimental code out there, I'd be happy
>> to test it on my 64 bit fedora machine.
>>
>> --
>> We can't solve problems by using the same kind of thinking we used when we
>> created them.
>>  - A. Einstein
>> _______________________________________________
>> Timber mailing list
>> Timber at haskell.org
>> http://www.haskell.org/mailman/listinfo/timber
>>
>> _______________________________________________
>> Timber mailing list
>> Timber at haskell.org
>> http://www.haskell.org/mailman/listinfo/timber
>>
>>
>>
>> --
>> We can't solve problems by using the same kind of thinking we used when we
>> created them.
>>  - A. Einstein
>> _______________________________________________
>> Timber mailing list
>> Timber at haskell.org
>> http://www.haskell.org/mailman/listinfo/timber
>>
>> _______________________________________________
>> Timber mailing list
>> Timber at haskell.org
>> http://www.haskell.org/mailman/listinfo/timber
>>
>>
>>
>> --
>> "The greatest obstacle to discovering the shape of the earth, the
>> continents, and the oceans was not ignorance but the illusion of knowledge."
>> - Daniel J. Boorstin
>>
>>
>>
>>
>> --
>> "The greatest obstacle to discovering the shape of the earth, the
>> continents, and the oceans was not ignorance but the illusion of knowledge."
>> - Daniel J. Boorstin
>>
>> <64bit.diff.gz>_______________________________________________
>> Timber mailing list
>> Timber at haskell.org
>> http://www.haskell.org/mailman/listinfo/timber
>>
>
> _______________________________________________
> Timber mailing list
> Timber at haskell.org
> http://www.haskell.org/mailman/listinfo/timber
>

-- 
"The greatest obstacle to discovering the shape of the earth, the
continents, and the oceans was not ignorance but the illusion of knowledge."

- Daniel J. Boorstin
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://www.haskell.org/pipermail/timber/attachments/20090604/de918212/attachment.html