Slashdot Mirror

OTOH, reading Bellard's FAQ on his latest result does seem like he was interested more in fast algorithms and not in Pi. So I stand corrected. Still.. he's not some random programmer to us. :P Following links from his FAQ, I found two cool books:

• Modern Computer Arithmetic by Richard Brent and Paul Zimmermann
• Matters Computational

Yeah even I thought the summary doesn't do justice to him. He found algorithmically faster ways to compute Pi. I doubt this was just to 'prove his efficient coding abilities.' He's someone to be honored for giving us LZEXE, FFMpeg and QEMU. The summary treats him as some random guy, which is weird.. this being Slashdot and all.

Chuck Norris can emit a TV signal just by displaying something on his screen. Or was it Fabrice Bellard?

http://bellard.org/
He's also the guy who launched ffmpeg and is working on Qemu, among other things...

On his page with extracts of the digits of Pi, in the third column of the 799,999,951th digits, he's got a 2 where I think it should be a 5.

^_^

He will be releasing the program he created for Windows (64bit only) and Linux

PS: Not the source

He also wrote the Obfuscated Tiny C Compiler (http://bellard.org/otcc/) in 2002 for the Obfuscated C contest, where otcc could compile itself. This became the Tiny C Compiler (TCC) which was picked up by Robert Landley (but subsequently dropped a while later) that is a capable, fast C90/C99 compiler.

His projects page (http://bellard.org/) and the older projects (http://bellard.org/projects.html) contain a lot of interesting projects.

Also of note: Fabrice achieved the record for Pi computation in 1997 as well:
      http://bellard.org/pi/pi_hexa.html
      http://bellard.org/pi-challenge/announce220997.html
      http://bellard.org/pi/

He also wrote the Obfuscated Tiny C Compiler (http://bellard.org/otcc/) in 2002 for the Obfuscated C contest, where otcc could compile itself. This became the Tiny C Compiler (TCC) which was picked up by Robert Landley (but subsequently dropped a while later) that is a capable, fast C90/C99 compiler.

His projects page (http://bellard.org/) and the older projects (http://bellard.org/projects.html) contain a lot of interesting projects.

Also of note: Fabrice achieved the record for Pi computation in 1997 as well:
      http://bellard.org/pi/pi_hexa.html
      http://bellard.org/pi-challenge/announce220997.html
      http://bellard.org/pi/

He also wrote the Obfuscated Tiny C Compiler (http://bellard.org/otcc/) in 2002 for the Obfuscated C contest, where otcc could compile itself. This became the Tiny C Compiler (TCC) which was picked up by Robert Landley (but subsequently dropped a while later) that is a capable, fast C90/C99 compiler.

His projects page (http://bellard.org/) and the older projects (http://bellard.org/projects.html) contain a lot of interesting projects.

Also of note: Fabrice achieved the record for Pi computation in 1997 as well:
      http://bellard.org/pi/pi_hexa.html
      http://bellard.org/pi-challenge/announce220997.html
      http://bellard.org/pi/

I didn't read the article, only the summery but it made me wonder.

Do they verify these numbers somehow? Anyone can write down a series of a numbers and claim it's a specific sequence.

Not saying these numbers aren't correct, just a thought.

Perhaps this is why you should read the article. The press release answers this question directly.

The binary result was verified with a formula found by the author with the Bailey-Borwein-Plouffe algorithm which directly gives the n'th hexadecimal digits of Pi. With this algorithm, the last 50 hexadecimal digits of the binary result were checked. A checksum modulo a 64 bit prime number done in the last multiplication of the Chudnovsky formula evaluation ensured a negligible probability of error.

The conversion from binary to base 10 was verified with a checksum modulo a 64 bit prime number.

For those not previously familiar with Fabrice Bellard, he's known for:

• LZEXE, very popular in the early 1990s as the first EXE-shrinker for DOS, or at least the first widely available one
• ffmpeg, video decoding library which he started and headed for a number of years
• QEMU, dynamic-translating generic emulator

From the FAQ

"How does your record compares to the previous one ?
The previous Pi computation record of about 2577 billion decimal digits was published by Daisuke Takahashi on August 17th 2009. The main computation lasted 29 hours and used 640 nodes of a T2K Open Supercomputer (Appro Xtreme-X3 Server). Each node contains 4 Opteron Quad Core CPUs at 2.3 GHz, giving a peak processing power of 94.2 Tflops (trillion floating point operations per second).

My computation used a single Core i7 Quad Core CPU at 2.93 GHz giving a peak processing power of 46.9 Gflops. So the supercomputer is about 2000 times faster than my computer. However, my computation lasted 116 days, which is 96 times slower than the supercomputer for about the same number of digits. So my computation is roughly 20 times more efficient. It can be explained by the following facts:

        * The Pi computation is I/O bound, so it needs very high communication speed between the nodes on a parallel supercomputer. So the full power of the supercomputer cannot really be used.
        * The algorithm I used (Chudnovsky series evaluated using the binary splitting algorithm) is asymptotically slower than the Arithmetic-Geometric Mean algorithm used by Daisuke Takahashi, but it makes a more efficient use of the various CPU caches, so in practice it can be faster. Moreover, some mathematical tricks were used to speed up the binary splitting. " ( http://bellard.org/pi/pi2700e9/faq.html )

Mathematical and Programming Ownage.

Last year Rob Landley was working on getting the Tiny C Compiler to build the kernel unmodified (again by adding gccisms to tcc) - here's an OLS video of the Landley talking about changing tcc to compile the kernel. Alas, from what I gather this effort has stalled for now.

It is unlikely that you will see the kernel adopting anything that makes the build process much more complicated. Operating system glue layers (e.g. abstractions in code for drivers that are supposed to run on other platforms) are already already frowned upon in drivers. Any new dependencies on tools like autoconf or cmake would most likely be rejected with a "what are we gaining?" complaint. My understanding is that patches that convert gccisms to their C99 equivalents are generally accepted but people are not willing to maintain glue for other compilers because it makes the default case painful. That's their choice - there are always other OSes like NetBSD that can be "compiler portable".

I have a question. When you use GPL code in your project don't you have to share the source,or was that all FUD? The reason I was asking was that I was going to say that MobaLiveCD should have been on the list,because it is one of the coolest things I have come across in ages. A fully functional virtual environment that doesn't need ANY install,just double click to launch and pick your live CD and give it a try! But when I went to their website the code isn't there. It says right on the website that they based it on Qemu which is open source,yet all you find at their website is some kind of funky freeware license that gives them the right to go proprietary any time they want. So does that mean they are in violation of GPL? Sorry if this comes off as a newbie but IANAL and contracts are one area I know less than zip about. We can't all be experts in everything,right?

I don't have a machine to spare right now to experiment with.

That's why setagllib recommends firing up a VM.

QEMU is a good place to start.

If this is new to you, this is a good place to start reading.

i use freebsd on a laptop with a 500Mhz amd k6, 128M on RAM. it runs gnome, vlc and can even run winXP on qemu pretty acceptable

Something like the Tiny C Compiler (and libtcc which allows you to compile C on the fly)?

http://bellard.org/tcc/

Trying to retrofit C into Tamarin seems bizarre. Why not use an on-the-fly sandboxing native C compiler? Tiny C (tcc) would seem like a good start.

http://bellard.org/tcc/

I hope this will be treated with caution until it can be ascertained to be fully legitimate...

QEMU does something similar... it uses a just-in-time-translation approach to emulate different CPUs (currently x86, ARM, SPARC and PowerPC).

For x86-on-x86 emulation, it's only about 4 to 6 times slower than the host CPU.

It can emulate a PC complete with network card, hard drives, graphics, etc. Best of all, it automatically provides a firewall and DHCP server on the emulated network connection, so an operating system running in the emulation can access the "outside" network painlessly.

Apart from emulating complete systems, it's also able to launch binaries compiled for another CPU. In that case it uses dynamic loader tricks to translate library calls to native calls.

I believe the Darwine project plans to use it in conjunction with Wine to run Windows applications on MacOS X.

It's really really cool stuff!

Implementing PDP-11 and VAX in QEMU will achieve unprecedented (in a free emulator) speeds.