Intel: Software needs to heed Moore's Law

TalkBack 36 of 36:

« Previous

• Thread View
• Flat View

All is about optimization

Since too long, all eforts of optimiations were left to the compilers, trying to solve performance problems by limited knowledge of the application, and nothing about the final machine on which the compiled application would run.

Given the Moore's Law, many programmers have felt that it was unnecessary to optimize their programs, but rather compile them in a way that was just fast enough to run for a few years with limited features, waiting for faster processors to add functionalities.

This time is over, it's high time to think about howwe build softwares, and compilers: programs should no more be compiled statically for a theoretical system that is not found in practice, but only implemented with compatibility as the only option, so that programmers never needed to think about how the program would be finally deployed.

Things are changing radically now, because systems are part of a large network of arbitrary size, which is heterogeneous by nature;Running exactly the same piece of precompiled binary code on every part of the network is really underoptimal.

This gives a large place for implmenting effectively the theoretical system, instead of trying to emulate it in static compilers. That's the benefit of virtual machines: something that Java has widely demonstrated, where it can often outperform on lots of systems what a genericly precompiled binary application can do. Virtual machines, that are compiling programs directly on the physical machine on which they will run, have much better optimizations possible that a generic compiler cannot perform because of compatibility constraints, and complete lack of knowledge of the other programs running concurrently on the system.

If we really want better performance, it's high time to simplify the design of processors, by designing them so that they will run with the best performance programs that virtual machines (running on them) will compile.

It's not up to program compilers to make decisions about the environment: we do need heterogeneity for scalability, and deployment on variouskinds ofnetworks, with different constraints, including varaible distance between system components. it's up to the virtual machine to evaluate the network capabilities, distribute the workload on it, and perform statistic-based optimizations, given the same specification: i.e. a preparsed binary code that is very simple to map onto one or more local or remote processors.

Tomorrow's computer will be the network. For this, we need new languages that are designed to run independantly of the location, and that can be relocated anywhere; compiled programs just need to describe the problems to solve, specify their constraints in a way that is easily parsable and compact, but programs no longer need to remain on a single computer. The issue is how we can specify in a language the needed security constraints, in a way that is both open to multiple security mechanisms, but also multiple networking environments and protocols.

So where must the industry focus their searches:
* in the back-end native compiler of virtual machines: these compilers will not need all those many instructions that are typically implemented in RISC processors, and are difficult to use from a generic VM binary code because they are too much mchine-specific.
* in languages that simplify the specification of parallelism; the programmer will just compile this into an intermediate binary code where humane things like variable names and syntaxic structures, and semantics are preparsed into a solid binary model, but not finalized for a particular system; the intermediate code will still need to contain all the information about datatype onstraints, time constraints, data flows.
* in processors designed to implement only the features needed to make a very performant backend native compiler that is part of the VM
* in OS'es that can locate and secure system components that make up an application; the application is no longer a simple file on a host, but a distributed system component that can move freely within parts of the network where thy are accessible
* in networking protocols that can not only transport data or program files, but also discovering the capability of each peer, and allowing load-balancing. Managing the security in this network should be independant and transparent for the programmer in the program source.
* in a network OS that is used to control the distribution and manage the load of every part of the systemaccording to constraints

Additionnaly, it's clear that now we depend more on processors designed to handle not only data, but general processing of the signal, including analogic signals and computing statistic predictions. A language that can be used to run aswell on a DSP or on a generic processor willl be needed. It's up to the VM to determine if a DSP is really needed, and to locate it somewhere in the network, or to emulate it on ageneric processor. The intermediate binary code generated by the precompiler must be able to describe tasks that will run on DSP's, or on FPLA's,or on generic processors.

We also needa standard description language to describe each processor capabilities (including for the management of energy use, and their native performancesto run each kind of intermediate binary code).

But finally, we must teach again to programmers howto design a program and how to reuse the best generic algorithms and data structures, using a description language using these componentized elements.

In other words, this requires a development framework: it's much less important to write code that implement these components, than to design the system in a way that facilitate the reusability of code. In most programs, instead of writing linear code, we would explicit only the constraints and we would reuse other components.

For nowIstill have doubts that the geneic intermediate binary code in Java or .Net VM's are enough expressive to completely describe a problem in matter of constraints instead of serial code: this is what gives the most work in VM's as they have to try guessing what the programmer wanted.

Finally, programmers that felt today that optimization of algorithms was not needed should rethink their programs in terms of implementation, andcorrect descrition of these constraints.

Posted by: PhilippeV   Posted on: 06/01/07 You are currently: a Guest | Members login | Terms of Use

Alert moderator to an offensive message

Subscribe to this discussion via Email or RSS

SponsoredWhite Papers, Webcasts, and Downloads

• Building the Virtualized Enterprise with VMware Infrastructure VMware VMware virtualization software has been adopted by over 120,000 enterprise ... Download Now
• Why Isn't Server Virtualization Saving Us More? A Few Small Changes May Dramatically Increase Your Efficiency VMware Companies have rapidly adopted server virtualization over the past few ... Download Now
• Virtualization: Architectural Considerations And Other Evaluation Criteria VMware Of the many approaches to x86 systems virtualization available in the ... Download Now