btw i've been thinking of buying a PS3 and use a linux compilation on it. check the specs. It seems awfully nice, doesn't it
The only thing stopping me is that you don't seem to be able to upgrade the memory. Maybe you can work around it using CompactFlash. I don't know?
CPU: Cell Processor
* PowerPC-base Core @3.2GHz
* 1 VMX vector unit per core
* 512KB L2 cache
* 7 x SPE @3.2GHz
* 7 x 128b 128 SIMD GPRs
* 7 x 256KB SRAM for SPE
* * 1 of 8 SPEs reserved for redundancy total floating point performance: 218 GFLOPS
GPU: RSX @550MHz
* 1.8 TFLOPS floating point performance
* Full HD (up to 1080p) x 2 channels
* Multi-way programmable parallel floating point shader pipelines
Sound: Dolby 5.1ch, DTS, LPCM, etc. (Cell-base processing)
Memory:
* 256MB XDR Main RAM @3.2GHz
* 256MB GDDR3 VRAM @700MHz
System Bandwidth:
* Main RAM: 25.6GB/s
* VRAM: 22.4GB/s
* RSX: 20GB/s (write) + 15GB/s (read)
* SB: 2.5GB/s (write) + 2.5GB/s (read)
System Floating Point Performance: 2 TFLOPS
Storage:
* HDD
* Detachable 2.5” HDD slot x 1
I/O:
* USB: Front x 4, Rear x 2 (USB2.0)
* Memory Stick: standard/Duo, PRO x 1
* SD: standard/mini x 1
* CompactFlash: (Type I, II) x 1
Communication: Ethernet (10BASE-T, 100BASE-TX, 1000BASE-T) x3 (input x 1 + output x 2)
Wi-Fi: IEEE 802.11 b/g
Bluetooth: Bluetooth 2.0 (EDR)
Controller:
* Bluetooth (up to 7)
* USB2.0 (wired)
* Wi-Fi (PSP®)
* Network (over IP)
AV Output:
* Screen size: 480i, 480p, 720p, 1080i, 1080p
* HDMI: HDMI out x 2
* Analog: AV MULTI OUT x 1
* Digital audio: DIGITAL OUT (OPTICAL) x 1
CD Disc media (read only):
* PlayStation CD-ROM
* PlayStation 2 CD-ROM
* CD-DA (ROM), CD-R, CD-RW
* SACD Hybrid (CD layer), SACD HD
* DualDisc (audio side), DualDisc (DVD side)
DVD Disc media (read only):
* PlayStation 2 DVD-ROM
* PLAYSTATION 3 DVD-ROM
* DVD-Video: DVD-ROM, DVD-R, DVD-RW, DVD+R, DVD+RW
Blu-ray Disc media (read only):
* PLAYSTATION 3 BD-ROM
* BD-Video: BD-ROM, BD-R, BD-RE
I like the way you think. That's not a bad idea (and I bet you'd never have to worry about getting a virus either
)
El_Machinae
13th July 2007 - 01:04 PM
Okay, so if I have a teenager who's thinking about being a programmer (and is bright enough to realise that parallel programming is the future) then he's going to want to start exposing himself to certain flavours of mathematics. This would be to start encouraging a certain type of mathematical thinking which would be conducive to being able to design parallel programs.
I'm wonder what mathematical flavours would be helpful seeds in getting the most useful type of thinking?
StevenA
13th July 2007 - 05:22 PM
QUOTE (El_Machinae+Jul 13 2007, 01:04 PM)
Okay, so if I have a teenager who's thinking about being a programmer (and is bright enough to realise that parallel programming is the future) then he's going to want to start exposing himself to certain flavours of mathematics. This would be to start encouraging a certain type of mathematical thinking which would be conducive to being able to design parallel programs.
I'm wonder what mathematical flavours would be helpful seeds in getting the most useful type of thinking?
That's a good question. Well, to take full advantage of digital electronics (not that we'll necessarily always be working with binary, but not likely to be supplanted soon but taking advantage of the analog characteristics of transistors, for example, can give large boosts in computational power for some applications), a good background in digital arithmetic and logic is very useful (for example here's the structure of a typical rather general purpose computational unit in terms of binary logic
http://en.wikipedia.org/wiki/Arithmetic_logic_unit). For an easy way to design such circuits without spending tens of thousands of dollars to design a custom integrated circuit, there's programmable logic
http://en.wikipedia.org/wiki/Programmable_logic of which CPLDs and FPGAs are the current best options.
In terms of high performance computation, a good buzzword is "Digital Signal Processing" or DSPs (
http://en.wikipedia.org/wiki/Digital_signal_processing), in order to make these algorithms efficient in hardware, as this thread is about, parallel processing techniques can be applied in various ways like systolic arrays
http://en.wikipedia.org/wiki/Systolic_array (though ultimately we're likely to see 3 dimensional arrays, for now hardware technology is generally restricted to 2 dimensional arrays). A few applications that are both very general purpose and amenable to most all of these are 1) artificial neural networks 2) genetic, stochastic and Boltzmann algorithms and 3) matrix multiplication. It's very interesting that these closely match 'natural' forms of computation (though not unexpected).
Here's a link to a goodle search of "FPGA systolic pipelined algorithms"
http://www.google.com/search?hl=en&q=FPGA+...G=Google+Search. You basically see a ton of whitepapers on research in these areas as they tend to be the most efficient forms of computation with current silicon technology.
A good subject that's not often recognized as related is Computational Geometry
http://www.google.com/search?hl=en&q=FPGA+...G=Google+Search. It's not directly related but computing naturally occurs within some physical environment and algorithms that specifically work with geometric structures are often easily converted into large arrays of computing elements.
Another very interesting possibility is for computation being performed on even finer scales using Cellular Automata
http://www.google.com/search?hl=en&q=Cellu...ata&btnG=Search - these are just vast seas of very small and indentical computing elements but with each having a specific state stored and only communicating with nearby elements .... blazing fast in terms of computations per second, but limited in what algorithms they can easily compute. Part of the trick is in finding ways of mapping typical algorithms into something compatible with such an architecture (the nice thing with programmable logic is that you can implement quite a variety of architectures and make tradeoffs where desired. There isn't any specific architecture that's best for all forms of computation, but that's part of the challenge in finding the what physical structures operate best for different forms of computation and usually they fall in to a few classes of architectures)
yor_on
13th July 2007 - 09:33 PM
How old would that teenager be? If he want's to build in software just to test his ideas :) I think there are programs for that on the net. At least they exist for sound devices in linux. And they are for 'real', even though you create them in software. I have a feeling that someone :) on this forum would be able to point you to a 'proper' program.
Insert a she instead of a he if that's the case.
El_Machinae
14th July 2007 - 09:29 PM
Well, there aren't that many types of parallel processors to currently practice on. I think that it will require an entirely different style of thinking than we're currently familiar with programming in. Just like calculus helps early physics make sense, and matrices helps statistics make sense ... I'm sure there's mathematical fields which will be useful, because they encourage a different style of thinking.
Zephir
14th July 2007 - 10:31 PM
The parallel computing is more widespread, then you can even imagine. The computation of shader effects in computer games is mostly a parallel computing application. You can check the
CODA project of NVidia Corp, or the smaller one
Microsoft Research Accelerator. project for practical implementation of parallel operations with the large 2D arrays, which is using the parallel GPU units of modern graphics cards for such purpose. Bellow is the generic example of shader solution of Laplace equation in VB.NET - the parallel program is marked by blue color.
CODE
Imports System, System.Drawing, System.Windows.Forms, Microsoft.DirectX, Microsoft.DirectX.Direct3D
Class FMain: Inherits Form
Shared F As FMain, D As Device, E As Effect, S As Sprite, T As Texture, N% = 256
Shared Sub Main()
F = New FMain: F.ClientSize = New Size(N, N): F.Show()
Dim PP As New PresentParameters: PP.Windowed = 1: PP.SwapEffect = 1: PP.PresentationInterval = PresentInterval.Immediate
D = New Device(0, 1, F.Handle, 32, PP): S = New Sprite(D)
E = E.FromString(D, _
"float dx, dy; sampler2D S;" & _
"float4 Blur(float2 T: TEXCOORD0): COLOR {" & _
" float4 L = tex2D(S, float2(T.x - dx, T.y));" & _
" float4 R = tex2D(S, float2(T.x + dx, T.y));" & _
" float4 B = tex2D(S, float2(T.x, T.y - dy));" & _
" float4 N = tex2D(S, float2(T.x, T.y + dy));" & _
" return ((L + R + B + N) / 4.0f);" & _
"}" & _ "technique Simulace {" & _
" pass P0 {" & _
" PixelShader = compile ps_2_0 Blur();" & _
"}}", Nothing, 0, Nothing)
E.Technique = E.GetTechnique("Simulace")
E.SetValue(EffectHandle.FromString("dx"), 1! / N): E.SetValue(EffectHandle.FromString("dy"), 1! / N)
T = New Texture(D, N, N, 1, 1, Format.A16B16G16R16F, 0)
F.Render2Texture(New Texture(D, New Bitmap(N, N), 0, 1), T)
E.Begin(0)
While F.Created
F.Render2Texture(T, T, 0)
D.BeginScene
S.Begin(0): S.Draw2D(T, Nothing, 0, New Point(0, 0), Color.White): S.End
D.EndScene
D.Present: Application.DoEvents
End While
E.End: S.Dispose: D.Dispose
End Sub
Sub Render2Texture(tSrc As Texture, tDst As Texture, Optional iPass% = -1)
Dim sOld As Surface = D.GetRenderTarget(0)
D.SetRenderTarget(0, tDst.GetSurfaceLevel(0))
D.BeginScene(): S.Begin(0)
If iPass >= 0 Then E.BeginPass(iPass)
S.Draw2D(tSrc, Nothing, 0, New Point(0, 0), Color.White)
If iPass >= 0 Then E.EndPass
S.End: D.EndScene
D.SetRenderTarget(0, sOld)
End Sub
End Class[/color]
The principle of shader parallel computing si simple: the rectangular area of bixels (i.e. 2D bitmaps) is rendered by GPU, but not on the screen, but to the off-screen buffer. During rendering the shader microprogram is applied to the color of each pixel. After rendering the addresses of off-screen and on screen buffers are switched, so that the shader microcode is applied to the resulting texture, repetitively. The usage of Accelerator/CODA wrappers simplifies the parrallel computing significantly. Bellow is the example of usage of MS Accelerator PCL:
CODE
FPA fpa = new FPA(3.0f, new int[] {2, 3}); // Creates a 2x3 constant array
using (DFPA a = new DFPA(1.0f, 2.0f, 3.0f, 4.0f, 5.0f)) {
float[] result;
FPA scale = FPA.MaxVal(FPA.Abs(a));
scale = FPA.Cmp(scale, scale, 1.0f);
FPA s = a / scale.Replicate(a.Shape);
s = scale * FPA.Sqrt(FPA.Sum(s * s));
s.ToArray(out result);
}
The power of GPU computing is significant, in general case its speed is 20 - 50 times higher, then the speed of C/C++ CPU code on common computer. Due the enhancements of shader programming language in recent time, the shaders routines can be written is human readable syntax, similar to the C language. In the form of graphics accelerator, nearly everybody can have a single-chip scalar supercomputer array in his kitchen, ready for your supercomputing experiments! You can check for example the
particle engine or
3D Fluid simulation project as a practical illustration of parallel GPU computing.
yor_on
15th July 2007 - 01:05 AM
Cool Zephir, i just knew there was someone, this is a good forum.