Conquering the Complexity Mountain: Full-stack atm26/pubs/markettos-ewme-2016.pdfConquering the Complexity Mountain: Full-stack Computer Architecture teaching with FPGAs A. Theodore

  • View

  • Download

Embed Size (px)

Text of Conquering the Complexity Mountain: Full-stack atm26/pubs/markettos-ewme-2016.pdfConquering the...

  • Conquering the Complexity Mountain: Full-stackComputer Architecture teaching with FPGAs

    A. Theodore Markettos, Simon W. Moore, Brian D. Jones, Roy Spliet, Vlad A. GavrilaComputer Laboratory, University of Cambridge, UK

    AbstractModern computer systems are exceedingly complex,and increasingly so. This makes it challenging for students withno background in computer systems to climb the mountain of40 years of design, particularly within a constrained teachingtimetable. Through the medium of FPGAs, we have designedan 8-week course to take students from basic digital electronicsthrough to processor design, modern software tools, applications,system-on-chip integration and electronics manufacturing. Werecount our experiences with rapidly bringing students up tospeed with the modern world of computing systems, and some ofthe lessons we, as course designers, were taught by the process.

    I. INTRODUCTIONAll problems in computer science can be solved by another

    layer of indirection, except for the problem of too many layersof indirection. David Wheelers aphorism has never been truertoday, where we take for granted many layers of abstractionfrom cloud computing that just happens (somewhere, some-how) to consumer products that sit atop vast piles of standards,commoditised components, and decades of evolution undermarket pressures.

    For a student, who has only had some limited experiencewith software development, this can be a daunting mountainto climb. They have not had the experience their professorsmight, of living through evolution as it happens and acceptingdevelopments one by one. Even ask someone in industry andthey might reminisce about System/360, VAX, DOS, Windows95 or XP, based on whatever date they came into the business and anything before their time is taken for granted.

    The Raspberry Pi, a cheap simplified computer for teach-ing is anything but simple. It has a 25mm2 system-on-chip [1]in a 40 nm process, approximately 50 million gates [2]. It runsan operating system kernel with 17 million lines of code [3].While you can do simple things with it, there is a lot ofcomplexity hidden behind the scenes.

    This means that a course designed to teach modern com-puter architecture must teach the many abstractions that goup to make modern systems, treading a fine line betweenoversimplifying and providing so much detail that it becomesoverwhelming.

    We have designed a course with these principles in mind,taking students with minimal hardware knowledge into modernsystems design in a short period.

    II. BACKGROUNDThis course was designed for second-year university stu-

    dents who are studying exclusively Computer Science (CS).Students arrive at university with diverse backgrounds and

    the course is structured so that they need have no prior experi-ence with CS before admission. While complete beginners arerare, many will have ad-hoc CS experience rather than formal

    Fig. 1. Our teaching board running a students code (courtesy Jamie Wood)

    education. Such experience is frequently at the applicationlevel - designing mobile apps or websites - rather than systems-level programming or hardware.

    The first year course is intended to build foundations of CS:there are courses in functional programming, object-orientedprogamming, algorithms, mathematics and operating systems.They are also taught elementary digital electronics: the useof logic gates, clocked logic, state machines, and a smallamount of transistor behaviour. The most complex structuresthey are exposed to are shift registers, RAMs and elementaryprogrammable logic (PALs).

    In designing the ECAD and Architecture course, theobjective was to introduce the second year students to modernprogrammable hardware (FPGAs), to the Electronic CAD(ECAD) tools used to design for it (Alteras Quartus II suite),and to modern computer architecture. The class has about 100students, and the course consists of 24 hours of laboratorysessions over an 8 week teaching period. It is concurrent witha Computer Design course consisting of 18 hours of lectures.Each week we ran two 3-hour afternoon laboratory sessions,with a student expected to attend one session or performequivalent work at home. Experienced staff and PhD studentsare present at the laboratory sessions to help out with problems.

    In our department we choose not to grade practical workin favour of encouraging collaboration and learning from theexperience. However all students are expected to complete thework and they are penalised if they do not. Thus the coursemust be designed so that all students can achieve the goals,which are assessed by an oral interview and demonstration.The goals are not thus objectives in themselves but a structurefor their learning.978-1-4673-8584-8/16/$31.00 c2016 IEEE

  • III. COURSE DESIGNAllied with the Computer Design lectures, we wished to

    introduce students to a number of concepts:Hardware description languagesLarge scale logic design Modern EDA toolsLogic simulation Test-driven developmentBehavioural modelling Processor architectureAssembly programming C programmingModern compiler/assemblertoolchains

    Unix development environ-ment

    System-on-chip construction Whole-system evaluationRelationship to mainstream architectures like x86

    In addition, as a byproduct of our approach, we also intro-duced students to modern hardware manufacturing techniquesthough this did not form a formal part of the course. In doingso we also challenged the view that computer scientists aredownstream consumers of electronics from large tech firms,that it is possible to design your own.

    Constraints on our course design included the restrictedtimetable, concurrency with the lecture course meaing materialcould not be used before being lectured, the assessmentrequirement requiring exercises that students of all abilitiescould complete, and the need for a primarily bring-your-own-device (BYOD) environment to support students working athome on their own laptops with varied hardware and software(and encourage students to explore beyond the course).

    IV. FPGA BOARD SELECTIONThe original motivation for redesigning the course was that

    the class size had grown such that we had insufficient hardwareto run our previous course. This used Terasic tPad boards,consisting of a DE2-115 board with an Altera Cyclone IVFPGA and a touchscreen display that are no longer sold.

    One feature of this course is we believe each student shouldhave their own board that they can take home and keep for theacademic year. This means they can do development in theirown time, not having to rely entirely on class hours. Theydo not have to share equipment that would have to remainin the lab. They can also usefully overlap FPGA build timeswith other activities. By keeping the board beyond their coursesubmission they are encouraged to explore further than thetaught materials.

    We looked for other low-cost FPGA boards of a compara-ble role. We were particularly attracted by Terasics DE1-SoCboard, which combined a Cyclone V FPGA that has an ARMprocessor onboard. The ARM processor can run Linux andhas a good collection of hard peripherals (Ethernet, USB, SDcard) that are necessary for modern computing but awkwardto build in FPGA. The ARM and FPGA fabrics each havededicated on-chip memory, while sharing a cache-coherentmemory interconnect between ARM and FPGA. The FPGAcan be used standlone, or the ARM used standalone, or theARM can be used with FPGA-built hardware plugged intoits memory map to build innovative peripherals. The board iscompetetively priced and in a small form factor that studentscan carry around. Thanks to a generous contribution fromAltera we were able to purchase 130 DE1-SoC boards.

    V. ADD-ON HARDWARE DEVELOPMENTDuring FPGA board selection we identified a gap in the

    marketplace. Many beginner boards contain small FPGAsthat limit scope of what may be achieved. Boards with larger

    FPGAs have peripherals that are often very complex makingthem a daunting prospect for students. USB, for example,appears to the nave to be simple, but is highly complex withdata rates ranging from 1.5Mb/s to 10Gb/s, complex protocolsand a frequent need to deal with bugs in devices.

    Additionally, the simpler devices provided on many boards(VGA output, PS/2 keyboard) typically require external hard-ware that students lack (keyboards are now USB, most studentsuse laptops and dont have their own monitors) and cannot beeasily carried around. Other boards were not portable enough.

    The DE1-SoC lacks such simple onboard input/output(I/O): there are switches and LEDs, but not much more thatcan be used without either a complex hardware/software stackor external hardware plugged in. After surveying the marketfor possible other options we decided that we could build ourown add-on board containing simpler peripherals that we couldpackage with the DE1-SoC into a handheld unit.

    We wished to allow students to design hardware for usefuldevices without delving into too much complexity. We selecteda number of devices for them to drive:Serial output frequently requires high performance hard se-rializer/deserializer (SERDES) blocks. To reduce complexityand add a visual component, we included some LEDs capableof 24b colour individually controlled via a serial protocol(the Shenzhen Worldsemi WS2812B branded by Adafruit asNeoPixels). Whilst it is possible to use software-based bitbashing to produce a valid serial stream, a simple Verilog serialoutput module makes timing reliable.Rotary shaft encoder requires debouncing and state ma-chines.Serial input was explored as both a teaching goal and a board-design necessity. Push buttons and a joystick were connectedto a shift register chip which was used to serialise the 13-bitinput over a restricted number of wires. Verilog on the FPGAcould