• SummerOfCode

Google's Summer Of Code

Thanks for your interest in the GNU Compiler Collection as your mentoring organization in Google's Summer of Code.

Summer of Code 2011 Accepted GCC Projects

Application

The Drupal project has a great page on How to write an SOC application. A gcc Summer of Code participant for 2006, Laurynas Biveinis, wrote a blog about it.

A former GCC Summer of Code student has written an excellent page reporting important advices for students : 5 advices to get your Google Summer of Code proposal accepted.

You should also have a copyright assignment filed with the Free Software Foundation. Otherwise, we will not be able to accept your contributions. See the legal prerequisites for details.

Some guidelines are:

• Do not copy text verbatim from the GCC wiki to your proposals. That gives a feeling of carelessness. If you don't understand some proposal or need more information, ask in the mailing list gcc@gcc.gnu.org .

• Provide a plan and a timeline with your proposal. A proposal without this is probably overestimating or underestimating the effort.
• Provide clearly defined goals in your proposal. Vague proposals give the impression that the student does not actually know sufficient about the topic to spend time efficiently.
• Be honest and realistic. We prefer a small, simple project with clearly defined goals that doesn't require much prior knowledge, than a far-reaching but vague proposal that is never going to be finished by the student.

• Present your project in the mailing list gcc@gcc.gnu.org (or, if applicable, at fortran@gcc.gnu.org or java@gcc.gnu.org ) to be sure it is a good idea.

• Students that have already participated in GCC or submitted good patches give a better impression to reviewers.

• Starting with some small patch for the area you are interested in before the proposal submittal period can help (ask for guidance and a simple enough project): It helps you to get the code known and to decide whether you really want to do the project, it shows how the development procedure is, and helps potential mentors to judge the proposal based on actual work. Besides: Also small fixes are good and getting people known by email (or IRC) exchange is nice by itself

Project Ideas

There are several pages with general ideas for GCC. These ideas are not just one project but many different projects linked here for easy of access.

Relatively simple tasks:

• Ideas for speeding up GCC

• Improvements to GCC on Windows

• Partial_Transitions

• Improve the regression testing system, for example to detect places where the generated code changed (useful for refactoring).
• Fix -ftrapv so that it works.

• Improve GCC Diagnostics

New optimization passes:

• Implement code motion of stores towards entry (and use this to improve code for int to float conversion on rs6000-based targets)
• Implement a prototype for early instruction selection
• Propagate interprocedural dataflow from GIMPLE to RTL
• Add Factored Use-Def (FUD) chains to RTL

• Loop optimizations and automatic parallelization based on Graphite ( Graphite Summer of Code ideas)

Language front-ends and run-time libraries:

• C++0x Support in GCC and libstdc++

• gcj, libgcj, and GNU Classpath ideas

• libstdc++ todo (Broken Link!)

• libstdc++ ideas

• Refactor libstdc++ for optional smaller footprint configuration, e.g., iostreams without templates

• Fortran front end:

  • Extend OOP support (possible mentor: Janus Weil)

    • Fortran supports polymorphism, but some parts are still missing such as: finalization (destructor), polymorphic array variables (CLASS arrays), unlimited polymorphism, ...

  • coarray support for SMP and distributed memory systems (possible mentor: Tobias Burnus)

    • Coarrays is a PGAS extension, which is part of Fortran 2008. The parsing support is mostly implemented.
    • Possible task: Creating of a communication library, based on some other library such as Message Passing Interface (MPI) - or GASNet, ARMCI/Global Array.
    • Possible task: Implementation of a shared-memory version
  • Run-time argument checking: Uninitialized variables, correctness of arguments
  • Better IEEE support

  • Other Unimplemented Fortran 2003 and Fortran 2008 features

  • Asynchronous IO support. Currently F2003 asynchronous IO syntax is supported, but all IO is done synchronously.
  • IO optimization. Currently formatted scalar IO is quite slow and uses lots of stack space.
  • F2003 intrinsics support. As of F2003 many intrinsics must support arbitrary kinds.

• OpenMP 3.0 support and other runtime improvements: openmp

• Port GCC's implementation of the Google Go programming language to GNU/Hurd.

  • For discussing your application, please cross-post the emails to both gcc@gcc.gnu.org and bug-hurd@gnu.org . Presumably less work will be needed on the language's frontend itself, but rather on the supporting libraries. As time permits, this task can also involve enhancing the port for GNU/Hurd specialities, like Remote Procedure Calls to Hurd servers, and so on.

Other projects:

• Develop XML format to represent GCC optimization flow (function, loop, block enumeration) and IDE/visualization environment for fine-grain program optimization or tuning of the default GCC optimization heuristic

• Extend GCC generic function cloning to be able to create static binaries adaptable to different architectures at run-time (including multiple ISA generation). Cupertino Miranda has been extending this work recently and we may need to sync on that ... GCC function adaptation, GCC function specific optimization

• Extend GCC plugin framework/ICI/MILEPOST framework to enable fine-grain transformation parameter tuning. Currently we can perform search for good combination of passes, their orders and parameter tuning on function level and we would like to be able to do it for each individual transformation to tune optimization heuristic for Graphite loop transformations, loop vectorization, inlining, unrolling, etc. Maybe the project can be separated in several sub-projects to focus on some specific optimizations such as GRAPHITE/vectorization optimization heuristic tuning.

• Extend GCC plugin framework/ICI to enable code instrumentation (insert calls to external function after individual instructions) for dynamic code analysis. We need it to extend our TM/TLS models.
• Port and stabilize GCC4NET to the trunk together with the plugin system.
• Converting different program representation levels of GCC back to the source code. It's not a trivial task but I saw substantial interest to that recently.

• GCC projects page

• Separate the frontends from the middle-end (near bottom of page)

• Make -O2 (and other -On options) be a sum of individual -f* options, by adding a -fother-O2-optimizations (and same for other -On levels)
• Separate frontend folder from middle-end folder
• Emit debug information about types and declarations early (needed for LTO)

• Diagnostics XML output for IDEs (there is a prototype available).

If you are interested in learning your way around the GCC codebase, the Partial_Transitions is a good place to start.

Other project ideas can be found in the bug database. Look for old bugs which are still open.

Or invent your own project. We're always open to good ideas. But note that we are probably not too interested in projects to add new extensions to the C or C++ languages. We've found over time that these tend to introduce more problems than they solve.

Thanks, and we look forward to your submissions!

Summer of Code 2010 Accepted GCC Projects

The source code for finished projects can be found at Google's code hosting site and their respective SVN branches.

Summer of Code 2009 Accepted GCC Projects

Summer of Code 2008 Accepted GCC Projects

Summer of Code 2007 Accepted GCC Projects

Summer of Code 2006 Accepted GCC Projects