[erlang-questions] Parallel Shootout & a style question

[Mats Cronqvist]

Gleb Peregud wrote:
>
> Sorry if I'm talking truisms, just ignore the message in this case :)
>   
  "truism" was a bit snide. sorry.

  anyway, i feel a bit frustrated by my inability to formulate my point 
of view clearly. so i'll just quote some random guy off the internets;

David Padua, University of Illinois at Urbana-Champaign

With the coming of age of multiprocessors, program performance and 
efficiency has become more important and difficult to achieve. 
Furthermore, the applications of today must also be scalable so that 
they can make effective use of the additional parallelism introduced by 
newer generations of machines. To achieve strong and scalable 
performance, programmers must do all the work traditionally required for 
sequential tuning and in addition address the complex optimization 
issues introduced by parallelism. This difficulty is likely to increase 
even further if, as it is expected, multicores become heterogeneous or 
their overall organization changes significanly over time. However, even 
assuming homogeneous and stable organizations, programmer productivity 
is bound to suffer due to the initial cost of tuning for multiprocessors 
and the need for adaptation as the number of processors increase.

In this talk, I will discuss future directions for programming language 
design, compiler technology, and the emerging autotuning strategies in 
the context of parallel programming. I will argue that advances in 
languages, compilers, and autotuning techniques will be necessary to 
recover the ground in productivity that has been lost with the advent of 
multicores. I will also argue that these tree components of a 
programming environment must be designed jointly to facilitate program 
tuning. The ultimate goal is for tuning to be accomplished without 
requiring the programmer to be concerned with the details of the target 
machine. It is expected that languages, compilers and autotuning 
techniques will evolve into a methodology that will dramatically reduce 
and perhaps eliminate in some cases the cost of porting programs across 
machine generations and machine classes. The availability of such 
methodology should not only help programmer productivity but also give 
machine designers more freedom to innovate.