World: r4wp

Nicolas: it is very possible that we have forgot to add unit tests 
for that feature. Obsviously, it's a bug, so please report it to 
github tracker so we can fix it asap.

number! is a virtual type used only internally by Red/System compiler.

It looks like a minor type checking bug, so it should be quickly 
fixed.

cool. I'll do that now

We don't have any tests for // for float. I'll look into it.

Red [] 4.0 // 2.0  compiles and runs.

Sorry - Red/System[] 4.0 // 2.0 compiles and runs.

Red/System[] f: 4.0 // 2.0 gives the type mismatch compile error.

Nicolas: issue fixed.

thanks man

Just as a reminder, once we fix the current ARM bugs, we would need 
to add Red to the following page: http://elinux.org/RPi_Programming

(Red/System could already be added though)

I've dropped the C library dependency from all bindings that don't 
strictly need it, to minimise the code base. However, the only binding 
I could get to work somewhat inlined in Red is SQLite, because it's 
little more than the imports

I've implemented floating point support in the SDL binding. This 
is used for audio conversions

I'm fixing the Unicode string printing issues on Linux/ARM...will 
post the fixes tonight.


BTW, I've now an ARMHF image installed, so I'll work very soon on 
supporting ARMHF ABI.

Great

what is this ABI about? Is that about supporting advantage of having 
HW floating point unit available?

I expect it being unrelated to Thumb support?

It's basically unrelated to Thumb. It's not necessarily about hardware 
floating point, either, but it's a different way of supporting it

It's about dealing with different Linux kernel incompatible ABI for 
float support on ARM platforms. Red/System uses the FPU unit (named 
VFP in ARM family) directly, but when having to pass/receive float 
arguments from libc or 3rd-party libs, Red/System needs to do it 
respecting the installed system ABI, which might be `softfp` or `hardfp` 
(there's a third one, but it's for not a concern for us). 


Currently, Red/System floats are passed using the `softfp` convention, 
so it works only on ARMEL platforms (while ARMHF platforms require 
`hardfp` convention). `hardfp` is a much more performant, while `softfp` 
is for legacy  systems or systems with no FPU unit).

BTW, Red or Red/System apps that do not use floats seems to work 
well with both ABI.

So - lots of work to support ARMHF?

And also - do I need to know, which platform I need to support, or 
support can be in one exe, for both worlds?

You can't mix different ABI in one binary.

ARMHF: a little, it's the same work as the one done in IA-32 faster-float 
old branch. In a nutshell, it consists in passing float arguments 
in FPU registers directly instead of using the stack.

We'll provide compilation options and various additional targets 
to deal with those different ABI.

Are there different Android platforms as well?

AFAIK, Android libs uses softfp convention.

Same here, a little tour would be nice. (That is why I picked up 
a documentation check to start with). 

e.g. In actions.reds most of funtions are only present as 'name* 
and some are present as both 'name and 'name*

That was a reply to a post from Pekr from thursday 1.49 PM

Arnold: I certainly won't document nor make "little tour" for internal 
code that is in alpha stage. That would be just a waste of time. 
For the '* suffix for function names, it indicates that the function 
takes arguments from Red stack. But that might be changed in the 
future, like all the rest of the code...until we reach beta stage 
(or even until 1.0 release).

Yeah youre right. I will concentrate on other tasks preparing for 
propagating Red.

Fixed the math library in the C library binding; should now also 
work on OS X and Android

I simplified many of the bindings by using the new get-word functionality 
in Red/System 0.2.6 for getting the address of variables

I'm looking into the ARM callbacks issues you've reported.

Kaj: do you have a simple callback case that's failing on ARM and 
not using floats at all?

Hi Doc, did you plan to integrate some Open CL programming acces 
to Red in any future ? Here is a summary of kernel programming with 
OpenCL - and to me this seems accessible to Red, some day : http://www.manning.com/scarpino2/ch04sample.pdf
 for a larger picture summary of the beast here is the link to the 
book I referred to :  http://www.manning.com/scarpino2/(this is 
the Manning's publiaher deal of the day ,,, that's why I talk abotu 
this now). May be just a new binding and some extensions are required 
- but I would like to know more about the actual modifs required 
- when a small time is affordable for you to answer ?

OpenCL: yes, I have that in mind too, but it's most probably for 
a later version of Red (> v1.0). Also I have other plans to give 
Red access to GPGPU, by directly having a GPU machine code assembler 
and a dialect on top of it. It would be mainly for compiler internal 
use, but such dialect could be exposed for user code if some are 
willing to implement some fast GPU-powered routines.

If you're doubting about such approach, read this article:

 http://www.geeks3d.com/20110317/low-level-gpu-programming-the-future-of-game-development-on-pc/

Nice Doc, Thanks for taking time to answer. I'll "follow the guide" 
as we say here ! Have a nice day. Now I'll go reading  your link.

bOK Doc I agree for the speed factor But then you would do the multi-targets 
road again this time for multiple GPUs , isn't it ?

have to do ...

In between, here is the PyOpenCL lib link for those interested to 
see how the OpenCL API is accessed by other languages - and this 
could pave the way for some Red binding ... http://mathema.tician.de/software/pyopencl

OpenCL is certainly a quicker way to access it. My plan for direct 
GPU access is not only motivated by speed gains, but also by reducing 
complexity, having a simple, lightweight access to GPGPU capabilities.

Also, for direct GPU access, it will only be doable for GPU that 
have all the required specification published (unless drivers provides 
the right API already).

I know the french guy who used OpenCL to automatically parallelize 
some iterators for Scala, so it's definitely something I want to 
try for Red:
 
http://code.google.com/p/scalacl/

(I'm trying to compile Insight debugger on the RPi, compiling since 
half an hour...hope it will finish before tonight)

Ah, of course it ends up earlier with an obscure compilation error...

I haven't isolated any callback case yet, but the existing cases 
don't actively use floats

Thanks Doc - I know your way is the best you can choose for fine 
tuning GPU access without adding much overhead !

Kaj: I've pushed a fix for ARM that should improve the stability, 
can you do some quick tests to see if some of the issues are fixed?