[pypy-dev] Heidelberg Sprint Report

Carl Friedrich Bolz cfbolz at gmx.de
Thu Aug 25 11:50:48 CEST 2005

Hi PyPy-Dev!

Some notes about what's going on in Heidelberg:

People arrived on Saturday and Sunday but we started hacking on Monday 
morning. First we had to solve all sorts of network problems because the 
computing center of the University of Heidelberg imposes a kind of 
restrictive setup. After this was done we had a planning meeting, 
distributed the work and started.

    - Samuele and Carl worked on refactoring the parts of genc that are
      responsible for the use of refcounting in the translation to make
      it possible to compile in a different GC. It turned out that
      refcounting is kind of deeply embedded into genc so it took a lot
      of time to introduce sensible hooks that other GCs could use.

    - Armin and Richard started to change genc so that it can handle the
      new external objects that Armin had to introduce to implement
      threading in PyPy. For now we have a simple GIL but it is not
      really deeply implanted in the interpreter so we should be able to
      change that later. After two days of hacking the were finished.
      Despite that it is still not possible to translate PyPy with
      threading because we are missing dictionaries with int keys on the
      RPython level.

    - Holger started preparing the release that is planned to happen
      during the sprint. Then he refactored our website so that all the
      websites are now generated statically and use a saner URL scheme.
      He then spent quite some time to make redirections from the old
      URLs work. See this mail for details:


    - Anders L. and Jacob worked on compliancy: they fixed various
      failing tests that are in some ways related to unicode.

    - Ludovic and Nik worked on making more parts of our compiler

    - Laura continued working on a docstring exctraction tool that she
      started to work on at the Gothenburg sprint. The tool takes the
      docstrings of types out of CPython and puts them in the relevant
      places of the PyPy codebase. With this we now have the correct
      docstrings for the builtin types.

    - Arre and Christian worked on compliancy. Christian feeled that the
      compliancy tests were taking to long on the interpreted PyPy so he
      tried making them run on the translated PyPy. This also involved
      problems since the compiler of the translated PyPy runs on applevel
      which means that running scripts involves a big startup overhead
      before it actually gets faster. Therefore he tried to introduce a
      hack so that the compiled PyPy uses CPython to translate its stuff
      and then run it. In the meantime Arre looked at the tests and
      started to reclassify core tests: he identified some tests that are
      in core but really shouldn't be there and the other way round.

    - Samuele, Carl, Richard, Holger and Armin continued to work on the
      stuff they started on Monday.

    - Nik worked on his 'Summer of Code'-project: he tried to move more
      parts of _sre to interplevel and make them annotatable.
      Additionally he worked on compliancy and fixed some tests.

    - Arre, Anders L., Jacob worked on compliancy

This day was supposed to be devoted entirely to compliancy work. Some 
exceptions were allowed, though.

    - Richard and Eric (who arrived on Tuesday afternoon) started working
      on genllvm to bring it into a shape where it can translate PyPy
      better (they had already reached the translation goal a few days
      ago -- great work guys!). They kept finding some small bugs in
      LLVM. Still some external functions are missing as well and their
      goal was not to write them by hand but autogenerate them out of C
      code that already exists for genc.

    - Carl and Samuele used the garbage collection hooks they had
      introduced on Monday and Tuesday to make the Boehm garbage
      collector usable for genc as well (genllvm already uses it as their
      default (and only) collector). This was compared to factoring out
      refcounting relatively easy and was finished after a few hours and
      started working on compliancy afterwards.

    - Ludovic continued working on the compiler

    - Basically everybody else worked on compliancy tests. A lot of tests
      were recategorized to be non-core tests. Quite some failures are
      related to compiler issues. In the afternoon Holger, Samuele and
      later Armin started to dive into strange bugs of the compiler
      module that are related to nested scopes and that made some tests

These are the parts that I remember, corrections/additions welcome.


Carl Friedrich

More information about the Pypy-dev mailing list