Alright. I have the posix rts building successfully with no ptr size mismatches. It also seems to be correct where the env uses the timber generated C. The roadblock I'm at is where the generated code is unsafe. For instance, switches for, what I'm guessing are empty list cases cast a LIST ptr to an Int in a switch statement.. I'm guessing one could address these kinds of issues in the kindle code by changing the address to int cast use WORD instead of Int. I haven't been able to track down where this happens, (can someone who knows this code better point me in the right direction?) For now I have Int defined the same as WORD and have added the appropriate BitOps for 64 bit. It compiles but there are still a handfull (<10) warnings. I'll fix those in the morning and test. On Sun, May 24, 2009 at 11:17 PM, Rick R wrote:

I've added a switch to define WORD in terms of architecture. Now I'm chasing down all of the ptr size mismatch warnings. Most of the time this is caused by casting to int (not Int), when I see such cases, I assume it is safe to cast to WORD.

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.

On Sun, May 24, 2009 at 10:54 AM, Johan Nordlander < johan.nordlander@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@haskell.org http://www.haskell.org/mailman/listinfo/timber

_______________________________________________ Timber mailing list Timber@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

-- We can't solve problems by using the same kind of thinking we used when we created them. - A. Einstein

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

...

wrote: Some experiments have been made (although no code were checked in), and they mostly involved fixing rts.h. The underlying problem is,

On Sun, May 24, 2009 at 10:54 AM, Johan Nordlander

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@haskell.org http://www.haskell.org/mailman/listinfo/timber

_______________________________________________ Timber mailing list Timber@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@haskell.org http://www.haskell.org/mailman/listinfo/timber

-- 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 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@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@haskell.org http://www.haskell.org/mailman/listinfo/timber

_______________________________________________ Timber mailing list Timber@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@haskell.org http://www.haskell.org/mailman/listinfo/timber

_______________________________________________ Timber mailing list Timber@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

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 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@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@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@haskell.org http://www.haskell.org/mailman/listinfo/timber

_______________________________________________ Timber mailing list Timber@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@haskell.org http://www.haskell.org/mailman/listinfo/timber

_______________________________________________ Timber mailing list Timber@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@haskell.org http://www.haskell.org/mailman/listinfo/timber

_______________________________________________ Timber mailing list Timber@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