Exposing Abstraction-Level Interactions with a Parallel Ray Tracer

For students of any Computer Engineering program, attaining an integrated vision of the different abstraction levels is paramount to fully understand and exploit a computer system, especially when tough topics such as parallelism, concurrency, consistency, or atomicity are involved at the hardware-software frontiers. However, the structure of typical engineering programs leads to the creation of self-contained courses, where a single level of abstraction is studied and the overall picture is lost. This paper provides a practical approach to show actual interactions between abstraction levels. This is achieved by implementing multiple components of a parallel ray tracer from the algorithmic level of the tracer to the atomic instructions required to guarantee atomicity. The students implement the full project throughout laboratories of different courses. Each lab focuses on a single abstraction level, but shows students the interactions with the rest of the levels. In addition, the hardware and software requirements of the approach are introduced, leading to the conclusion that Raspberry Pi is a suitable single-board computer for this project. Finally, this work also includes a preliminary assessment study of the proposed approach through the analysis of pre/post surveys filled out by the students.

[1]  Barry Wilkinson,et al.  Toward Using Higher-Level Abstractions to Teach Parallel Computing , 2013, 2013 IEEE International Symposium on Parallel & Distributed Processing, Workshops and Phd Forum.

[2]  Javier Cuenca,et al.  A Parallel Programming Course Based on an Execution Time-Energy Consumption Optimization Problem , 2016, 2016 IEEE International Parallel and Distributed Processing Symposium Workshops (IPDPSW).

[3]  Greg Humphreys,et al.  Physically Based Rendering: From Theory to Implementation , 2004 .

[4]  Remzi H. Arpaci-Dusseau Operating Systems: Three Easy Pieces , 2015, login Usenix Mag..

[5]  Ralph Roberts,et al.  Learning Computer Architecture with Raspberry Pi , 2016 .

[6]  Anthony Williams,et al.  C++ Concurrency in Action: Practical Multithreading , 2012 .

[7]  Ulrich Drepper,et al.  Futexes Are Tricky , 2004 .

[8]  Abraham Silberschatz,et al.  Operating System Concepts , 1983 .

[9]  Jeff Kramer,et al.  Is abstraction the key to computing? , 2007, CACM.

[10]  Suzanne J. Matthews,et al.  Portable Parallel Computing with the Raspberry Pi , 2018, SIGCSE.

[11]  T. J. Watson,et al.  Fuss , Futexes and Furwocks : Fast Userlevel Locking in Linux Hubertus Franke IBM , 2005 .

[12]  Gregory R. Andrews,et al.  Concurrent programming - principles and practice , 1991 .

[13]  Gareth Halfacree,et al.  Raspberry Pi User Guide , 2012 .

[14]  Ulrich Drepper,et al.  The Native POSIX Thread Library for Linux , 2002 .

[15]  William Stallings,et al.  Operating Systems: Internals and Design Principles , 1991 .

[16]  David A. Wood,et al.  A Primer on Memory Consistency and Cache Coherence , 2012, Synthesis Lectures on Computer Architecture.

[17]  David Ginat,et al.  Multiple Levels of Abstraction in Algorithmic Problem Solving , 2017, SIGCSE.

[18]  Leonidas J. Guibas,et al.  Robust Monte Carlo methods for light transport simulation , 1997 .