llvm dev - Mar 2016 - EuroLLVM BoF session: Compilers in education

Hi all,

I'm organizing a BoF session during the upcoming EuroLLVM developers 
meeting.  As the subject of this message already shows, this session 
will be on compilers in education.  I'm currently looking for both 
participants to the discussion and input for the actual program of the 
session.  I've already got some ideas which I'll introduce below.

At our university, we mostly come from a hardware and processor design 
background.  In the past we managed to design all kinds of crazy 
architecture ideas and, since we could program them by hand for our 
demonstration cases, we usually assumed that compilers could just 'do 
the trick'.  However, over the years we learned that this usually wasn't
the case.  Looking around for what was actually being taught in compiler 
design we found that the course at our university had been teaching 
mostly the classical frontend parts (parsing etc) and was discontinued 
several years ago.  We decided it was time for us to step up and start 
teaching our students again what is and isn't possible in compilers. 
This time, also with extensions into the layers that relate more closely 
to the hardware so that the course would match our processor 
architecture backgrounds more closely.

In general, the contents of this course are more or less as follows:
  - Backend organization (optimizations, lowering, scheduling, register 
allocation)
  - Code optimization (code analysis, loop optimizations, auto 
vectorization, Polly)
  - Using the compiler (writing optimizer friendly code)
  - Heterogeneous systems and high-level languages (OpenCL, OpenMP, Halide)

Looking further we also found that there aren't many courses that cover 
these topics (while we think that they should be interest to the 
companies hiring our students).

During this BoF, I plan to introduce the topics which we now cover in 
our course and the assignments that we give to our students to go with that.

My long term goal is to make most of the materials for this course 
available to interested parties.  One idea was to transform this into 
some kind of MOOC structure when after we get the lectures tested on our 
own students (currently there are some 70 students attending this 
course).  We've already automated much of the testing and grading for 
the exercises (though improvement is still possibly there).

So, my questions to you:
- Would you be interested in attending this session?
- For industry people:
   * what kind of skills would you like your future (or current) 
employees to have?
   * do you have any educational materials you would be willing to share?
- For other educators: what kind of topics do you cover in your lectures?
   * would you be interested in presenting something about your approach?
- And in general: are there any other things you think that should be 
discussed?

Ok, that's it for now.  I've already heard from a few people that they 
would be interested but I'd love to get some more input!

Best regards,
  Roel Jordans

On Tue, Mar 01, 2016 at 05:27:40PM +0100, Roel Jordans via llvm-dev
wrote:
> So, my questions to you:
> - Would you be interested in attending this session?
Yes, please. That sounds very useful.

Joerg

On 1 Mar 2016, at 16:27, Roel Jordans via llvm-dev <llvm-dev at
lists.llvm.org> wrote:
> 
> - Would you be interested in attending this session?
Yes, I’m looking forward to it.
> - For industry people:
> * what kind of skills would you like your future (or current) employees to
have?
> * do you have any educational materials you would be willing to share?
> - For other educators: what kind of topics do you cover in your lectures?
> * would you be interested in presenting something about your approach?
I’d be happy to talk briefly about the course that I teach, which is the
Masters’ compiler course at Cambridge.  I have some resources online:

http://compilerteaching.github.io

The focus of the course is on real problems and techniques for late-bound
dynamic languages (things a bit like JavaScript and parallel languages (things a
bit like OpenCL C / CUDA).  The students have to do three shortish exercises. 
The first is a small amount of analysis, the second two each involve one of the
toy languages: typically something like adding something like polymorphic inline
caching or type specialisation to MysoreScript (a milder, less bitter
JavaScriptl-like language) and adding either automatic paralellisation or
vectorisation to the cellular automata DSL (which has an mostly parallel
abstract machine, but a reference implementation that is purely sequential). 
They then have to do a miniproject (80% of the mark, producing something in the
structure of a research paper) on something real.  One of my students will be at
EuroLLVM presenting a poster about his miniproject, so he can talk about what
he’s learned.  In previous years I’ve had people do things like adding small
integer support to Pyston, evaluating the LLVM code generation of barriers on
ARM (EuroLLVM 2014), or optimising memory allocation for the PImpl pattern
(EuroLLVM 2015).

David

Hi David,

Great that you're joining as well.  I'd like to hear from your student 
about his experiences, that sounds interesting.

In our course we currently have three main exercises:
- With the AVR backend we have an exercise that fixes some bits of 
instruction selection and adds support for GCC's 
__builtin_avr_delay_cycles intrinsic so that the students can improve 
the code generation for the blinking LED example program.

- In the optimization layer we have an exercise with code analysis, 
estimating instruction-level parallelism by implementing a list 
scheduling algorithm at the IR level.

- Using the compiler to get a small image processing application to 
optimize efficiently.  The main goal here is to get insight in the 
autovectorization capabilities of compilers and what needs to be done to 
allow the compiler to efficiently optimize C code.

I'll make sure to bring some examples also of these assignments.  For us 
the assignments make up 40% of the mark and we plan to have an 
interactive exam for the remaining 60%, in parallel there's a few bonus 
assignments which can (in total) give up to 20% of compensation credits 
for those who ran into the steep learning curve of the assignments.

  Roel



On 02/03/16 10:37, David Chisnall wrote:
> On 1 Mar 2016, at 16:27, Roel Jordans via llvm-dev <llvm-dev at
lists.llvm.org> wrote:
>>
>> - Would you be interested in attending this session?
>
> Yes, I’m looking forward to it.
>
>> - For industry people:
>> * what kind of skills would you like your future (or current) employees
to have?
>> * do you have any educational materials you would be willing to share?
>> - For other educators: what kind of topics do you cover in your
lectures?
>> * would you be interested in presenting something about your approach?
>
> I’d be happy to talk briefly about the course that I teach, which is the
Masters’ compiler course at Cambridge.  I have some resources online:
>
> http://compilerteaching.github.io
>
> The focus of the course is on real problems and techniques for late-bound
dynamic languages (things a bit like JavaScript and parallel languages (things a
bit like OpenCL C / CUDA).  The students have to do three shortish exercises. 
The first is a small amount of analysis, the second two each involve one of the
toy languages: typically something like adding something like polymorphic inline
caching or type specialisation to MysoreScript (a milder, less bitter
JavaScriptl-like language) and adding either automatic paralellisation or
vectorisation to the cellular automata DSL (which has an mostly parallel
abstract machine, but a reference implementation that is purely sequential). 
They then have to do a miniproject (80% of the mark, producing something in the
structure of a research paper) on something real.  One of my students will be at
EuroLLVM presenting a poster about his miniproject, so he can talk about what
he’s learned.  In previous years I’ve had people do things like
adding small integer support to Pyston, evaluating the LLVM code generation of
barriers on ARM (EuroLLVM 2014), or optimising memory allocation for the PImpl
pattern (EuroLLVM 2015).
>
> David
>

Hello,

This looks really interesting! Speaking for those of us that won't be able
to attend the session in person: it would be great if you could share what
was discussed afterwards!

--
Débora.

On Tue, Mar 1, 2016 at 1:27 PM, Roel Jordans via llvm-dev <
llvm-dev at lists.llvm.org> wrote:
> Hi all,
>
> I'm organizing a BoF session during the upcoming EuroLLVM developers
> meeting.  As the subject of this message already shows, this session will
> be on compilers in education.  I'm currently looking for both
participants
> to the discussion and input for the actual program of the session. 
I've
> already got some ideas which I'll introduce below.
>
> At our university, we mostly come from a hardware and processor design
> background.  In the past we managed to design all kinds of crazy
> architecture ideas and, since we could program them by hand for our
> demonstration cases, we usually assumed that compilers could just 'do
the
> trick'.  However, over the years we learned that this usually
wasn't the
> case.  Looking around for what was actually being taught in compiler design
> we found that the course at our university had been teaching mostly the
> classical frontend parts (parsing etc) and was discontinued several years
> ago.  We decided it was time for us to step up and start teaching our
> students again what is and isn't possible in compilers. This time, also
> with extensions into the layers that relate more closely to the hardware so
> that the course would match our processor architecture backgrounds more
> closely.
>
> In general, the contents of this course are more or less as follows:
>  - Backend organization (optimizations, lowering, scheduling, register
> allocation)
>  - Code optimization (code analysis, loop optimizations, auto
> vectorization, Polly)
>  - Using the compiler (writing optimizer friendly code)
>  - Heterogeneous systems and high-level languages (OpenCL, OpenMP, Halide)
>
> Looking further we also found that there aren't many courses that cover
> these topics (while we think that they should be interest to the companies
> hiring our students).
>
> During this BoF, I plan to introduce the topics which we now cover in our
> course and the assignments that we give to our students to go with that.
>
> My long term goal is to make most of the materials for this course
> available to interested parties.  One idea was to transform this into some
> kind of MOOC structure when after we get the lectures tested on our own
> students (currently there are some 70 students attending this course).
> We've already automated much of the testing and grading for the
exercises
> (though improvement is still possibly there).
>
> So, my questions to you:
> - Would you be interested in attending this session?
> - For industry people:
>   * what kind of skills would you like your future (or current) employees
> to have?
>   * do you have any educational materials you would be willing to share?
> - For other educators: what kind of topics do you cover in your lectures?
>   * would you be interested in presenting something about your approach?
> - And in general: are there any other things you think that should be
> discussed?
>
> Ok, that's it for now.  I've already heard from a few people that
they
> would be interested but I'd love to get some more input!
>
> Best regards,
>  Roel Jordans
> _______________________________________________
> LLVM Developers mailing list
> llvm-dev at lists.llvm.org
> http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-dev
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://lists.llvm.org/pipermail/llvm-dev/attachments/20160311/2156eaae/attachment.html>

Hi Débora,

That shouldn't be a problem.  There will be notes taken during the session.

Cheers,
  Roel

On 11/03/16 19:09, Débora Setton Sanches wrote:
> Hello,
>
> This looks really interesting! Speaking for those of us that won't be
> able to attend the session in person: it would be great if you could
> share what was discussed afterwards!
>
> --
> Débora.
>
> On Tue, Mar 1, 2016 at 1:27 PM, Roel Jordans via llvm-dev
> <llvm-dev at lists.llvm.org <mailto:llvm-dev at
lists.llvm.org>> wrote:
>
>     Hi all,
>
>     I'm organizing a BoF session during the upcoming EuroLLVM
developers
>     meeting.  As the subject of this message already shows, this session
>     will be on compilers in education.  I'm currently looking for both
>     participants to the discussion and input for the actual program of
>     the session.  I've already got some ideas which I'll introduce
below.
>
>     At our university, we mostly come from a hardware and processor
>     design background.  In the past we managed to design all kinds of
>     crazy architecture ideas and, since we could program them by hand
>     for our demonstration cases, we usually assumed that compilers could
>     just 'do the trick'.  However, over the years we learned that
this
>     usually wasn't the case.  Looking around for what was actually
being
>     taught in compiler design we found that the course at our university
>     had been teaching mostly the classical frontend parts (parsing etc)
>     and was discontinued several years ago.  We decided it was time for
>     us to step up and start teaching our students again what is and
>     isn't possible in compilers. This time, also with extensions into
>     the layers that relate more closely to the hardware so that the
>     course would match our processor architecture backgrounds more closely.
>
>     In general, the contents of this course are more or less as follows:
>       - Backend organization (optimizations, lowering, scheduling,
>     register allocation)
>       - Code optimization (code analysis, loop optimizations, auto
>     vectorization, Polly)
>       - Using the compiler (writing optimizer friendly code)
>       - Heterogeneous systems and high-level languages (OpenCL, OpenMP,
>     Halide)
>
>     Looking further we also found that there aren't many courses that
>     cover these topics (while we think that they should be interest to
>     the companies hiring our students).
>
>     During this BoF, I plan to introduce the topics which we now cover
>     in our course and the assignments that we give to our students to go
>     with that.
>
>     My long term goal is to make most of the materials for this course
>     available to interested parties.  One idea was to transform this
>     into some kind of MOOC structure when after we get the lectures
>     tested on our own students (currently there are some 70 students
>     attending this course).  We've already automated much of the
testing
>     and grading for the exercises (though improvement is still possibly
>     there).
>
>     So, my questions to you:
>     - Would you be interested in attending this session?
>     - For industry people:
>        * what kind of skills would you like your future (or current)
>     employees to have?
>        * do you have any educational materials you would be willing to
>     share?
>     - For other educators: what kind of topics do you cover in your
>     lectures?
>        * would you be interested in presenting something about your
>     approach?
>     - And in general: are there any other things you think that should
>     be discussed?
>
>     Ok, that's it for now.  I've already heard from a few people
that
>     they would be interested but I'd love to get some more input!
>
>     Best regards,
>       Roel Jordans
>     _______________________________________________
>     LLVM Developers mailing list
>     llvm-dev at lists.llvm.org <mailto:llvm-dev at lists.llvm.org>
>     http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-dev
>
>