[pypy-svn] rev 2602 - pypy/trunk/doc

[lac at codespeak.net]

Author: lac
Date: Fri Dec 19 18:58:19 2003
New Revision: 2602

Added:
   pypy/trunk/doc/goals.txt
Log:
gleaned from the proposal

Added: pypy/trunk/doc/goals.txt
==============================================================================
--- (empty file)
+++ pypy/trunk/doc/goals.txt	Fri Dec 19 18:58:19 2003
@@ -0,0 +1,177 @@
+**Infrastructure and tools**
+
+Supporting the PyPy project by producing and enhancing the tools. 
+
+Support the development process with reusing existing or developing
+new debugging opensource tools.  
+
+- provide access over http/https and ssh server 
+
+- build extensions for automatic document extraction
+
+- implement a search facility over all content
+
+- maintain and enhance website infrastructure 
+
+- setup a mirror repository which is kept up-to-date and which
+  can be used readonly in case of failure of the main repository.
+  
+- Design a strict backup policy.
+
+- help with automated testing 
+
+	what more do we want to do?
+
+- http-server to present runtime/introspection information aiding 
+  debugging and understanding of PyPy internals
+
+- automated (unit-)testing framework with html/pdf reports 
+
+**Synchronisation with Standard Python**
+
+- Keeping PyPy in sync with potential changes to Standard Python.
+
+- Support a subset of the CPython API for compatibility with extension modules.
+
+- Facilitate porting of extension modules to PyPy.
+
+**Replace PyPy Core**
+
+Building a complete Python interpreter written in Python,
+using a subset of Python that avoids dynamic features
+which would impair the objectives of RPython.
+
+- Design and implement the PyPy bytecode interpreter and
+  build an object space library in RPython.
+  The resulting interpreter must cover the complete Python
+  language specification.  -- mostly done, test coverage.
+
+- Port the built-in Python library to PyPy (functions, types and 
+  modules currently implemented in C) -- types needs refactoring,
+  the rest is mostly done.
+
+- Decide on a case-by-case basis which features are to
+  be implemented using RPython or just general Python. -- moving target.
+
+- Implement a Python parser and bytecode compiler in Python.
+  -- we have soemthing, but it is not well integrated.
+
+- A partial Python implementation that passses 75% of the official
+  Python test suite that don't depend on extension modules.
+  -- write this test and then pass it.
+
+**The PyPy Translation**
+
+- Analysis and translation of the PyPy core into efficient low-level code 
+  (C, Pyrex, Java, others). - moving target
+  
+- Provide a Runtime Library for the translated versions
+  of PyPy. - not even started
+
+- Create a code analysis tool for a subset of the Python
+  language (RPython). Coordinate the definition of RPython
+  being the implementation language of the core.
+
+  - we can analyse functions, but not classes, modules, spaces etc.
+
+- Complete implementation of Python, conforming to the language
+  definition and passing all relevant tests of the official Python 
+  test suite.   -- global goal, which we will think more about when
+  it is very close to being done.
+
+**Stackless Integration  + More Performance Hacks**
+
+- Identification and Implementation of Optimisations through modifications 
+  of the Translator.
+  
+- Enable Massive Parallelism in a Single Thread.
+  
+- Provide support for real-time parallelism.
+  
+- Allow Pickling of a Running Program.
+
+- Enhance the translator to support continuation passing
+  style by integrating technology from the Stackless project.
+   
+- Implement the necessary runtime system to support massive parallelism.
+
+- Implement a single-threaded, pre-emptive scheduler with
+  priorities, complementing the OS threads.
+
+- Study approaches concerning code size vs. speed trade-offs.
+
+- Implement and compare different object layout and memory management 
+  strategy or strategies.
+
+- Enhance multimethod dispatching.
+
+- Implement schemes of pointer tagging.
+
+- Create reports and merge the results back into the optimization effort.
+
+**Psyco Integration**
+
+- Outperform the state-of-the art (Psyco, Stackless).
+
+- Enhance PyPy to dynamically adapt to its run-time environment and
+  to the characteristics of the running program.  Dramatically 
+  increase speed by enabling Just-In-Time compilation and
+  specialization.  
+
+- Address multiple processor architectures.
+
+- Apply and enhance techniques from the Psyco project.  Promote parts
+  of the static translator to be used for run-time specialization.
+
+- Design and implement a back-end component for dynamically emitting
+  machine code for multiple processor architectures.  Enable dynamic
+  foreign function calls.
+
+- Research optimisation heuristics for the Just-In-Time compiler.
+
+
+- A Just-In-Time compiler for PyPy !!! Outperform the
+  state-of-the art (Psyco, Stackless).
+
+**Embed in Specialized Hardware**
+
+if we get funding.
+
+**Implement Security, Distribution and Persistence**
+
+- Research and validate the flexibility of PyPy by building key middleware
+  features into the language itself.
+
+- Analyze and implement security models at the language level.  
+
+- Implement the "RExec" restricted execution model.  (It was removed 
+  from the official Python implementation because it is false security.)
+
+- Analyze and implement distributed execution models at the language level.
+
+- Implement network-transparent execution of Python programs.  (Typical
+  libraries require programs to be aware of the remote execution model.)
+
+- Analyze and implement persistence at the language level.  -- talk to
+  Patrick O'Brien who is really hot for the idea.
+
+- Implement an orthogonally persistent object space for Python programs.  
+  (Persistence is never fully orthogonal without advanced language support.)
+
+**PyPy A la Carte**
+  
+- Develop tools that will allow to chose from available features and runtime 
+  restrictions to build a custom PyPy version. 
+
+- Analyse and integrate all results from the results of other workpackages. 
+  This involves identifying and resolving conflicts which could prevent
+  a combintation of desired optimization goals. 
+
+- Implement user interfaces to select features and runtime restrictions. 
+  Provide a way to automatically build a PyPy custom version for different
+  memory, performance and extension requirements. 
+
+- Make a build- and configuration tool that allows to build custom PyPy 
+  versions suitable for specialized environments such as small or very large 
+  computing devices.
+