Peer to Patent, Community Patent Review

LATEST PRIOR ART

Date	Title	Reviewer

12/03/07	Dynamic Feedback: An Effective Technique for Adaptive Computing	Steven Pearson

10/22/07	A patent on optimized software execution based on hardware attributes	Ryan McBeth

10/20/07	A Framework for Remote Dynamic Program Optimization	Rob Cameron

DISCUSSION

View All Discussion

L Zhang (10 months ago)

As an particular example, FFTW (www.fftw.org) does exactly as the patent described. In FFTW's terminology, the source code contains a series of codelets, different codelets are optimized for different input sizes and different arhchitectures, and the sequence of codelets to use is constructed in a plan. FFTW automatically selects the (optimla) plan for each given input on each given architecture. In same cases, it involves running many small codelets on a system and then choose the best ones to use. "FFTW: An Adaptive Software Architecture for the FFT", M. Frigo and S. G. Johnson, 1998 ICASSP conference proceedings (vol. 3, pp. 1381-1384); "A Fast Fourier Transform Compiler," Matteo Frigo, in the Proceedings of the 1999 ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI '99).

Mark Aufflick (7 months ago)

Another parallel is with Erlang's HiPE compiler. Normally erlang code is compiled into BEAM bytecode. When HiPE is used, the single file contains both bytecode and optimised native code for each function. The file format also contains indications about where in the file the various versions of the function are. At run time, the platform is tested and if an available optimised native code version is found, that is executed - if not the platform independant BEAM bytecode is used as a fallback. There are various papers dating back to 1996 describing this: http://www.it.uu.se/research/group/hipe/publications.shtml I haven't been involved in peer to patent before - please let me know if you think this is relevant prior art and I will choose the most appropriate paper and extract the appropriate synopsis.

Bruce Badger (8 months ago)

Looking at illustration #0, this seems to be pretty much how a Smalltalk or Self virtual machine works. Java and other languages also follow a similar VM based approach. Taking Smalltalk as an example and referring to the terms in the illustration, the code written by the programmer (Source Code) is compiled to byte codes (Intermediate Representation). This intermediate code is then compiled to binary executable code by the virtual machine. In the more advanced VMs the story continues with the virtual machine continually monitoring and recompiling the code to make the most of the platform. (this giving us multiple versions of ExecutableCode). At any one time only one arrangement of the binary code is being executed (the Executable Code Module).

PEER TO PATENT ACTIVITY

All

Discuss Patent Applications
13 comments posted

Size of Community: 12

Upload + Explain Prior Art
3 submitted

Annotate and Evaluate Prior Art
3 prior art ratings
3 citations

Research Prior Art
0 research notes