Requirements of Programming Models

● Requirements never change: Programmability Performance

● Satisfying these requirements, of course is a function of the underlying platforms

● Hardware platforms, of course, change

Challenges from Emerging Platforms

● Scenario 1: Emerging platforms are no different

● Multicore = SMP● Solution: program using MPI/posix

● Scenario 2: Emerging platforms pose significant challenges

● Scalable multicore: cache fragmentation● Heterogeneous multicore: FPU/GPU/FPGAs● Integrated hardware services

Network is closer than the memory

Scenario2: Unplugged

● How do we achieve programmability and performance? OpenMP (unless heavily retooled) is certainly not

the answer Performance today results from

messaging/posix/CUDA – hardly a high-productivity environment

Cache fragmentation (cooperative caching) is an algorithmic challenge (with expressiveness and support from the model)

Emerging Applications

● Upscaling of desktop applications● Gaming, virtual/synthetic environments● Enterprise applications● HPC applications

Upscaling Desktop Applications

● Multimedia Becomes a Major Application Multiple streams of HD media can challenge most

systems Emphasis here is not simply on the CPU, but on

management of other resources as well (downstream from the memory subsystem)

Most programming models have limited support for such applications (I/O, streaming).

Upscaling Desktop Applications

● Gaming and Distributed Gaming Tighter integration of graphics hardware,

networking, and processing OpenMP/CUDA is hardly the solution here

Servers/Data Centers

● Immediate future sees large scale media servers The resources that underly such infrastructure are

vastly different from those OpenMP is targeted to.

HPC Applications

● Conventional HPC applications scale down to the desktop In my opinion, this is a bigger trend than pushing

the envelope at the top end (because of a number of modeling/ analytical issues)

● In the short term, this leads to a cottage industry of hand-tuned codes for FPGAs, GPUs, heterogeneous multicores.

● In the longer term, application development in these environments is entirely unsupported

HPC Applications

● Tighter integration of networks is certainly a major benefit for data-intensive applications

● Is there a seamless way to integrate services deeper into the language?

Is there need for anything beyond the very familiar?

● Very much so – Posix and messaging only take you so far

● In the short term, much of the development will continue to be in Posix/xxx

● In the longer term, we do need something a lot more friendly

● In my opinion, OpenMP, in its current form, is certainly not the answer, neither is posix/MPI/CUDA/....