On Dec 14, 2011, at 3:42 PM, Adam Strzelecki wrote:

> I guess this discussion is going nowhere. Since I am always wrong I give up.
> 

I would consider understanding/learning a more productive approach than 
surrender, but it's up to you ;).

>From the beginning you were confusing several entirely unrelated topics (plus 
>unrelated subject), so I'll try for the last time to make it more clear and 
>separate them properly and address them again:

a) 3-way fat R.app (your proposal) vs 2-way fat R.app + 1-way R64.app (CRAN 
release).
This is entirely a choice of convention and we have decided to separate 32-bit 
binaries from the 64-bit binary for convenience of the user. As I said there 
are several reason for this. Whether you like it or not is quite irrelevant - 
it may not be what Safari does but then Safari is not a stat computing 
language. Whether you use lipo to add the 64-bit binary to R.app or not is 
purely cosmetic, it doesn't change the fundamental functionality (except that 
with R.app+R64.app you can run them in parallel and start the desired 
architecture more easily - and the user knows what he gets and doesn't need to 
guess - less relevant for Safari, more so for R).


b) multi-lib approach in R itself: (for packages, modules etc.). This is 
deliberate and I was illustrating that it is very common even in OS X as you 
can see in the gcc example. The main reason is portability because this way the 
build system needs to be implemented only once for all platforms. This is 
hidden from the user so you should not care. If you do, you may need to read up 
on it.


c) decision to run 32-bit vs 64-bit binaries. This we leave entirely to the 
user. You may not be familiar with the details (the link you quoted below is 
quite irrelevant in the sense that the biggest waste of memory is not on the 
stack - unless you use deep recursion), but each of the architectures has its 
weaknesses and advantages. For low-memory machines it is often advisable to use 
32-bit binary as the benefits of the 64-bit instruction set are really not that 
big (and the numerical stability is different, some would say worse). 64-bit 
binary *always* uses more memory, by definition, that's not even a question. 
The question is only how much more, and in some practical settings it can be 
close to 100% more. But, again, we leave this to the user.


d) "How to make Mac 64-bit version feature complete?" Well, the CRAN 64-bit 
version of R *is* feature complete so the question goes off an invalid 
assumption. Later you mentioned rgl, but that is not part of R.



> I say having both R.app, R64.app is doubtful (talking about apps from users 
> perspective), you justify that with dumps of some GCC directories from Xcode 
> developer tools (talking about developer tools directories from developer 
> perspective). Can you find me single other app for Mac that comes as two .app 
> packages for each architecture from one install?
> 
> I say installing R in 64-bit Linux and launching R GUI app

There is no such thing on Linux. R.app exists only on OS X. Windows has Rgui 
and it has two of them as well (32-bit and 64-bit) and they also come with two 
separate icons, same as on OS X. Go figure :).


> launches 64-bit version (talking how Linux hides its internals), you say I am 
> wrong because you can launch 32-bit app using --arch param. Yes you can, does 
> it prove it is wrong what I said? Typing "R" in OSX command line also 
> launches R in 64-bit, why not 32-bit then?
> 

Because this decision is made at install time depending on your OS X version - 
it is 32-bit for Leopard, for example. Whether this is the right thing to do is 
up for discussion (when installed from source you'll get the last installed 
architecture). R.app doesn't need to make that decision, since it is always 
32-bit - easy.

I hope that helps understanding it a bit better. If not, please, consider 
learning more about R.

Cheers,
Simon


> I say 64-bit code is faster (haven't used "always", but intentionally used 
> word "code" not "program" or "libraries", because these can be badly ported 
> to 64-bit due old compiler or 32-bit only hand optimized assembly code not 
> working for 64-bits, I refer to the machine code that has more wider 
> registers than in 32-bit mode), you say it is not; because it can be slower 
> of faster depending on task, huh :/
> 

Yep. If you know a bit more about CPUs, you'll realize that we width of the 
register is quite irrelevant until you actually use it - which is not very 
often the case (there are very few actual 64-bit operations). The most time you 
use it is with pointers where you would have used 32-bit on x86 anyway so you 
don't gain anything, rather to the contrary. You can gain from having more 
registers, but only for functions with larger number of arguments (register 
passing) or functions that are complex enough (fn body). Also larger objects 
(due to double the size of pointers) mean more very slow operations 
(out-of-cache memory I/O) and thus slower performance. Most gains you see are 
in fact due to something different - the fact that x86_64 CPUs can be assumed 
to have extensions that some old x86 CPUs did not have (various SIMD 
instructions etc.) which can be used instead of the FPU.

Even if you don't know much about Intel CPU architecture, just run some 
benchmarks in R - you'll see that it goes either way - you'll have tasks that 
are slower in 64-bit and you'll have other tasks that are faster in 64-bit (you 
may be able to dig up examples from this list). It really depends on things 
like the memory I/O load + data size, types of vectors you operate on, 
proportion of interpreted code etc. Since R is an interpreter, you'll see 
bigger negative impact due to increased 64-bit pointer size than you would see 
in native code (the most vulnerable are generic vectors, lists, environments 
and character vectors - which are incidentally the most used objects).


> You say 64-bit code always use more memory, then you've probably read that: 
> http://software.intel.com/en-us/blogs/2010/07/01/the-reasons-why-64-bit-programs-require-more-stack-memory/
> 
> Altogether I am just plain wrong :)
> 
> Thank you,
> -- 
> Adam Strzelecki
> 

_______________________________________________
R-SIG-Mac mailing list
[email protected]
https://stat.ethz.ch/mailman/listinfo/r-sig-mac

Reply via email to