• SummerOfCode

Google Summer Of Code

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

The official mentoring organization is the GNU project and GCC related projects are performed under its umbrella. However, students still need to find suitable mentors and projects specific to the GCC project. If you have a project idea or want to work on any of the ideas below, you should discuss it as soon as possible (way before the application) via the mailing list or via IRC. For general (non-GCC specific) questions about GSoC, the relevant mailing list is https://lists.gnu.org/mailman/listinfo/summer-of-code

For Mentors

• Around end of March, you have to register your interest in being a mentor with the GNU project admins.

• Do not forget to request slots to GNU for the projects you wish to mentor, otherwise there will be no slots for GCC.

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.

Improving GCC Developer Documentation

• Get yourself familiar with a part of GCC or a specific task and document this process in the form of

  • A tutorial as a (series of) blog posts or a video series (some examples available at Tutorials)

  • Written documentation for the GCC internals manual

• Part of GCC or specific task may include (some content is available at Document GCC Internals)

  • Writing a new language frontent
  • Writing a new backend
  • Writing a new optimization pass
    • On GIMPLE/SSA
    • On RTL
    • For interprocedural optimization

  • Where to find what - GCC source organization (Structure of GCC)

GCC Improvement Projects

• 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

• Promote C++ operator new to alloca when pointer does not escape and user allows non-conformance to C++ standard

• Improve loop unrolling heuristics and enable loop unrolling with default optimization
• Analyze and improve inlining, loop unrolling, reassociation and predictive commoning heuristics for PowerPC architecture
• Use TARGET_EXPAND_TO_RTL_HOOK for pipelined divide on PowerPC
• Support AIX XCOFF file format for LTO and libbacktrace

• GCC Improvement Projects

  • This category of projects deals with a range of changes, from simple to challenging. These projects are of great interest to us, because they address some long-standing architectural issues that we want to fix.

Link-time and interprocedural optimization improvements

Link-time optimization is relatively new infrastructure in GCC and there are many areas how to make it better. (Jan Hubicka, 2015)

• Generate LTO object files directly from GCC (bypassing assembler). Perliminary patch is at https://gcc.gnu.org/ml/gcc/2014-09/msg00340.html. Finishing this would require work on libiberty simple object file handling, in the GCC wrapper and in GCC itsef. If finished, the compile time performance should improve by several percent.

• Implement static code placement pass (function reordering. GCC currently lay down compilation units in the topological order. This is good for optimization, but produce code that execute from the end. With link time optimization it is possible to get a lot better code placement. This would build up on Martin Liska's master thesis. Ask Jan Hubicka for some experimental patches.

• Implement inter-procedural value-range propagation pass. This would be especially useful for deriving loop bounds and optimizing out checks for NULL pointers.
• Implement auto-detection of additional function and variable attributes. GCC currently auto-detect pure, const and nothrow. Many other attributes can be supported
• Work on general scalability and reliability improvements. This would involve testing LTO on new applications (current LTO is tested mostly on GCC itself, Firefox, Libreoffice, Linux kernel and Chromium).
• Implement tree level section anchors to improve code generation at ARM/PPC.

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)

• Implement a basic-block local scheduling pass to improve SSA name coalescing opportunities at RTL expansion time

• Implement a (prototype) addressing mode selection (AMS) pass as a replacement of auto-inc-dec. For more details see PR 56590.

Language front-ends and run-time libraries

• C++11 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 mentors: Janus Weil, Tobias Burnus) by adding missing features, such as:

    • Finalization
    • Parametrized derived types
    • Derived-type I/O

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

    • Coarrays are a PGAS extension, which is part of Fortran 2008.

    • Possible task: Improving the multi-image support, which uses OpenCoarray communication library

    • Implement Fortran 2015 additions (TS18508) additions
  • Run-time argument checking: Uninitialized variables, correctness of arguments
  • Better IEEE support

  • Other Unimplemented Fortran 2003, Fortran 2008 features, TS 29113 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 4.0 runtime improvements: openmp

• GCC Go escape analysis: in Go, taking the address of something means that it lives on the heap--Go has no such thing as a dangling pointer. It is possible to use escape analysis to determine whether the pointer ever escapes its scope. If it does not, then the object whose address is taken can be allocated on the stack rather than the heap, which is more efficient. A particular example is calls to functions like fmt.Printf, which allocate a slice of the arguments passed in. Escape analysis can allocate that slice on the stack rather than the heap.

Other projects

• 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)

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

• Replace libiberty with gnulib. See http://gcc.gnu.org/ml/gcc-patches/2012-08/msg00362.html

• Finish the implementation of a stable introspection plugin API (with the possibility of extending it to cover non-introspection cases)

• Record all GCC optimization decisions and related code "features" at different levels (function, loop, block enumeration) to expose and analyze all internal optimization decisions. Suggestion to use extensible JSON as in Collective Mind framework (c-mind.org). -- G. Fursin, 2014.
• Modify any GCC optimization decisions externally through plugins (see MILEPOST GCC, for example). -- G. Fursin, 2014.
• Systematize learning of optimal optimization decisions for multiple benchmarks, data sets and architectures (see c-mind.org/repo, for example). -- G. Fursin, 2014.
• Extend GCC plugin framework 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. -- G. Fursin, 2014.

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!

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

Accepted GCC Projects

2015

2014

2013

2012

2011

2010

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

2009

2008

2007

2006

Information for GSoC admin

Answers to questionnaire

Organization profiles do not propagate between GSoC programmes of different years and below are answers to the questionnaire as completed in 2014.

• Why is your organization applying to participate in Google Summer of Code 2014? What do you hope to gain by participating?*
  • We want to give computer-science students a chance to work on real-world production compiler in a vibrant development community. Our hope is that the students who like compiler development will return later as active developers of GCC and the rest of GNU toolchain.
• How many potential mentors do you have for this year's program? What criteria did you use to select them?*
  • We plan to have 30 to 70 potential mentors. GCC developers with maintainer responsibilities will be able to volunteer as GSoC mentors.
• What is your plan for dealing with disappearing students?*
  • Ask students to work on a public branches of GCC repository and commit their work-in-progress weekly. Should a student disappear someone else will be able to pick-up this work on next year's GSoC.
• What is your plan for dealing with disappearing mentors?*
  • Find a replacement mentor.
• What steps will you take to encourage students to interact with your project's community before and during the program?*
  • Students will be asked to post questions on IRC channel or mailing list instead of communicating 1-on-1 with their respective mentors. Before starting working on their projects students will be asked to fix a trivial problem to get a feel for patch review process, patch testing, and project infrastructure.
• What will you do to encourage your accepted students to stick with the project after Google Summer of Code concludes?*
  • Ask students to investigate bugs and potential improvements in the area of compiler they were working in during GSoC.
• Are you a new organization who has a Googler or other organization to vouch for you? If so, please list their name(s) here.
  • N/A
• Are you an established or larger organization who would like to vouch for a new organization applying this year? If so, please list their name(s) here.
  • N/A
• If you chose "veteran" in the organization profile dropdown, please summarize your involvement and the successes and challenges of your participation. Please also list your pass/fail rate for each year.
  • The gcc project accepted three proposals in 2013. Two of the students actively engaged in the community and continue to participate today. Those projects were highly successful. The mentor for the third project (Thomas Schwinge) felt that the project was not well-defined and too large in scope. The student was too inexperienced to be successful for that particular project.
• If you are a new organization, have you applied in the past? If so, for what year(s)?
  • N/A
• Is there anything else we should know or you'd like to tell us that doesn't fit anywhere else on the application?
  • N/A