DOCSLIB.ORG

Half-Precision Floating-Point Formats for Pagerank: Opportunities and Challenges

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Half-Precision Floating-Point Formats for Pagerank: Opportunities and Challenges Half-Precision Floating-Point Formats for PageRank: Opportunities and Challenges Molahosseini, A. S., & Vandierendonck, H. (2020). Half-Precision Floating-Point Formats for PageRank: Opportunities and Challenges. In 2020 IEEE High Performance Extreme Computing Conference, HPEC 2020 [9286179] (IEEE High Performance Extreme Computing Conference: Proceedings). Institute of Electrical and Electronics Engineers Inc.. https://doi.org/10.1109/HPEC43674.2020.9286179 Published in: 2020 IEEE High Performance Extreme Computing Conference, HPEC 2020 Document Version: Peer reviewed version Queen's University Belfast - Research Portal: Link to publication record in Queen's University Belfast Research Portal Publisher rights Copyright 2020 IEEE. This work is made available online in accordance with the publisher’s policies. Please refer to any applicable terms of use of the publisher. General rights Copyright for the publications made accessible via the Queen's University Belfast Research Portal is retained by the author(s) and / or other copyright owners and it is a condition of accessing these publications that users recognise and abide by the legal requirements associated with these rights. Take down policy The Research Portal is Queen's institutional repository that provides access to Queen's research output. Every effort has been made to ensure that content in the Research Portal does not infringe any person's rights, or applicable UK laws. If you discover content in the Research Portal that you believe breaches copyright or violates any law, please contact [email protected]. Download date:28. Sep. 2021 Half-Precision Floating-Point Formats for PageRank: Opportunities and Challenges Amir Sabbagh Molahosseini Hans Vandierendonck EEECS School EEECS School Queen’s University Belfast Queen’s University Belfast Belfast, United Kingdom Belfast, United Kingdom [email protected] [email protected] Abstract—Mixed-precision computation has been proposed as exponent and 9 bits mantissa is customized for deep learning a means to accelerate iterative algorithms as it can reduce the applications [12]. Although these 16-bit data formats have been memory bandwidth and cache effectiveness. This paper aims for reported to be efficient for deep learning training, and [11] further memory traffic reduction via introducing new half- predicted the industry-wide adoption of BFloat16 format for precision (16 bit) data formats customized for PageRank. We many applications, narrow floating-point formats are highly develop two formats. A first format builds on the observation that sensitive to the application characteristics. For instance, [13] the exponents of about 99% of PageRank values are tightly proposed a 16-bit format for PageRank that captures the top two distributed around the exponent of the inverse of the number of bytes of FP64. This makes conversion to/from FP64 efficient. vertices. A second format builds on the observation that 6 However, they could execute only the first iteration of the power exponent bits are sufficient to capture the full dynamic range of iteration method using this format. We conclude that narrow PageRank values. Our floating-point formats provide less precision compared to standard IEEE 754 formats, but sufficient floating-point formats must be customized to the application. dynamic range for PageRank. The experimental results on various This paper defines novel half-precision floating-point size graphs show that the proposed formats can achieve an formats customized to PageRank. This goal involves two accuracy of 1e-4, which is an improvement over the state of the aspects. First, we need to understand the requirements of art. Due to random memory access patterns in the algorithm, PageRank on dynamic range and precision. Analysis of performance improvements over our highly tuned baseline are PageRank values, as well as the PageRank values divided by 1.5% at best. vertex degree, demonstrates that the exponents of these values Keywords—Graph Processing, Customized Floating-Point Data are tightly clustered around a specific value that relates to the Format, PageRank, Transprecision Computing. size of the graph. Based on this observation, we propose a half- precision format where the exponent is encoded tightly in 3 bits, I. INTRODUCTION leaving 13 bits for the mantissa (a sign bit is not required for storing PageRank values). This format poses challenges, as a Graph processing plays an important role in big data analysis very small fraction of values cannot be encoded in this format such as applied to social networks [1] and web search [2]. and require a wider representation. We present also a second Processing of large graphs poses significant performance format as we demonstrate that 6 bits of exponent are sufficient challenges. Inherent seemingly-random memory access to encode all PageRank values, even in very large graphs. patterns, exacerbated by skewed-degree distributions, cause poor cache utilization and significant exposure to memory A second concern in the use of custom floating-point formats bandwidth limits and memory access delay [3, 4]. For instance, is the efficient implementation of arithmetic. Floating-point over 60 percent of energy consumed in a communication-bound computation is fairly complex to emulate as bit-wise operations graph algorithm such as PageRank (PR) is due to memory [5]. on a general-purpose instruction set [14]. It is more efficient to For iterative algorithms like PageRank, which are based on convert compact storage formats to a format for which floating-point computations, reduced-precision and mixed- arithmetic is supported by hardware, typically FP32 or FP64 [7, precision computation has been shown to reduce memory 13]. Conversions include changes in the bit width of the pressure [6, 7]. exponent and rounding of the mantissa. Including bit shifting and masking, conversion operations can easily add 10--16 For many applications, standard floating-point (FP) formats instructions on a general-purpose instruction set. Our formats such as the IEEE-754 FP32 and FP64 formats are wider than are designed to support efficient conversion in as few as 4 x86- necessary. The IEEE FP16 format, implemented by NVidia 64 and AVX assembly instructions. We discuss the challenges since CUDA7.5 [8] and more recently by Intel [9], provides a that need to be overcome to achieve this. suitable format for workloads such as image processing. However, FP16 sacrifices both dynamic range and precision The remainder of this paper is organized as follows. Section compared to FP32. Moreover, conversion between FP16 and II briefly reviews the PageRank algorithm and mixed-precision FP32 may incur under/overflow problems. BFloat16 [10] was PageRank. Section III introduces novel number formats. Section introduced for deep learning applications [11] and has the same IV presents an evaluation of convergence and performance. exponent size as the FP32. This eliminates the under/overflow Finally, Section V concludes the paper. concerns during conversion. The DLFloat16 format with 6 bits II. BACKGROUND the estimate using increasingly higher precision. Mixed- PageRank models the behavior of a random surfer on the precision arithmetic could potentially incrementally increase the internet as a stochastic process whereby links from one webpage precision by adding 1 or 2 bits to the mantissa at a time [19]. to another are followed at random [15]. This formulation results Mixed-precision arithmetic was previously investigated for in a linear equation where the eigenvector corresponding to the PageRank [13]. Efficient arithmetic is ensured through efficient largest eigenvalue of a column-stochastic matrix describes the conversion to hardware-supported arithmetic, in this case FP64. relative importance or relevance of each web page. This Three reduced-precision formats are proposed containing the top eigenvector is the solution of the PageRank problem. It is most 16, 32 or 48 bits of the FP64 number: the sign bit, 11 exponent commonly computed using the power iteration method. Here, an bits and a slice of the most significant mantissa bits to fill up the initial estimate of the eigenvector is iteratively improved by format. It is, however, worthwhile to use this 16-bit format only multiplying the column-stochastic matrix with the previous during the first power iteration [13]. After this, the format estimate of the eigenvector. This iteration is repeated until the switches to 32 bits. We will show that 6 exponent bits are residual error (the norm-1 difference between subsequent sufficient to hold PageRank values for very large graphs. As estimates) is less than a pre-defined threshold. such, the 32-bit format with 11 exponent bits is fundamentally Calculating the PageRank vector is highly sensitive to inferior to FP32 with 8 exponent bits for the PageRank problem. rounding errors due to finite-precision calculations. Gleich [16] As we find that convergence is possible with FP32 using presents an account of the challenges that occur. We use his Gleich’s algorithm, there is no need to consider the 48-bit of recommended algorithm as our baseline algorithm, depicted as FP64 formats for PageRank. Algorithm 1. This algorithm takes a graph G=(V,E) as input, Apart from a few works which have implemented PageRank where V is a set of vertices and E is a set of edges. The with applications-specific integrated circuits (ASIC) [20] and parameters d and Threshold represent the damping factor and field-programmable-gate arrays
Load more

Recommended publications
  • Exploring C Semantics and Pointer Provenance
    Exploring C Semantics and Pointer Provenance KAYVAN MEMARIAN, University of Cambridge VICTOR B. F. GOMES, University of Cambridge BROOKS DAVIS, SRI International STEPHEN KELL, University of Cambridge ALEXANDER RICHARDSON, University of Cambridge ROBERT N. M. WATSON, University of Cambridge PETER SEWELL, University of Cambridge The semantics of pointers and memory objects in C has been a vexed question for many years. C values cannot be treated as either purely abstract or purely concrete entities: the language exposes their representations, 67 but compiler optimisations rely on analyses that reason about provenance and initialisation status, not just runtime representations. The ISO WG14 standard leaves much of this unclear, and in some respects differs with de facto standard usage — which itself is difficult to investigate. In this paper we explore the possible source-language semantics for memory objects and pointers, in ISO C and in C as it is used and implemented in practice, focussing especially on pointer provenance. We aim to, as far as possible, reconcile the ISO C standard, mainstream compiler behaviour, and the semantics relied on by the corpus of existing C code. We present two coherent proposals, tracking provenance via integers and not; both address many design questions. We highlight some pros and cons and open questions, and illustrate the discussion with a library of test cases. We make our semantics executable as a test oracle, integrating it with the Cerberus semantics for much of the rest of C, which we have made substantially more complete and robust, and equipped with a web-interface GUI. This allows us to experimentally assess our proposals on those test cases.
    [Show full text]
  • Timur Doumler @Timur Audio
    Type punning in modern C++ version 1.1 Timur Doumler @timur_audio C++ Russia 30 October 2019 Image: ESA/Hubble Type punning in modern C++ 2 How not to do type punning in modern C++ 3 How to write portable code that achieves the same effect as type punning in modern C++ 4 How to write portable code that achieves the same effect as type punning in modern C++ without causing undefined behaviour 5 6 7 � 8 � (�) 9 10 11 12 struct Widget { virtual void doSomething() { printf("Widget"); } }; struct Gizmo { virtual void doSomethingCompletelyDifferent() { printf("Gizmo"); } }; int main() { Gizmo g; Widget* w = (Widget*)&g; w->doSomething(); } Example from Luna @lunasorcery 13 struct Widget { virtual void doSomething() { printf("Widget"); } }; struct Gizmo { virtual void doSomethingCompletelyDifferent() { printf("Gizmo"); } }; int main() { Gizmo g; Widget* w = (Widget*)&g; w->doSomething(); } Example from Luna @lunasorcery 14 15 Don’t use C-style casts. 16 struct Widget { virtual void doSomething() { printf("Widget"); } }; struct Gizmo { virtual void doSomethingCompletelyDifferent() { printf("Gizmo"); } }; int main() { Gizmo g; Widget* w = (Widget*)&g; w->doSomething(); } Example from Luna @lunasorcery 17 18 19 20 float F0 00 80 01 int F0 00 80 01 21 float F0 00 80 01 int F0 00 80 01 float F0 00 80 01 char* std::byte* F0 00 80 01 22 float F0 00 80 01 int F0 00 80 01 float F0 00 80 01 char* std::byte* F0 00 80 01 Widget F0 00 80 01 01 BD 83 E3 float[2] F0 00 80 01 01 BD 83 E3 23 float F0 00 80 01 int F0 00 80 01 float F0 00 80 01 char* std::byte*
    [Show full text]
  • Effective Types: Examples (P1796R0) 2 3 4 PETER SEWELL, University of Cambridge 5 KAYVAN MEMARIAN, University of Cambridge 6 VICTOR B
    1 Effective types: examples (P1796R0) 2 3 4 PETER SEWELL, University of Cambridge 5 KAYVAN MEMARIAN, University of Cambridge 6 VICTOR B. F. GOMES, University of Cambridge 7 JENS GUSTEDT, INRIA 8 HUBERT TONG 9 10 11 This is a collection of examples exploring the semantics that should be allowed for objects 12 and subobjects in allocated regions – especially, where the defined/undefined-behaviour 13 boundary should be, and how that relates to compiler alias analysis. The examples are in 14 C, but much should be similar in C++. We refer to the ISO C notion of effective types, 15 but that turns out to be quite flawed. Some examples at the end (from Hubert Tong) show 16 that existing compiler behaviour is not consistent with type-changing updates. 17 This is an updated version of part of n2294 C Memory Object Model Study Group: 18 Progress Report, 2018-09-16. 19 1 INTRODUCTION 20 21 Paragraphs 6.5p{6,7} of the standard introduce effective types. These were added to 22 C in C99 to permit compilers to do optimisations driven by type-based alias analysis, 23 by ruling out programs involving unannotated aliasing of references to different types 24 (regarding them as having undefined behaviour). However, this is one of the less clear, 25 less well-understood, and more controversial aspects of the standard, as one can see from 1 2 26 various GCC and Linux Kernel mailing list threads , blog postings , and the responses to 3 4 27 Questions 10, 11, and 15 of our survey . See also earlier committee discussion .
    [Show full text]
  • Aliasing Restrictions of C11 Formalized in Coq
    Aliasing restrictions of C11 formalized in Coq Robbert Krebbers Radboud University Nijmegen December 11, 2013 @ CPP, Melbourne, Australia int f(int *p, int *q) { int x = *p; *q = 314; return x; } If p and q alias, the original value n of *p is returned n p q Optimizing x away is unsound: 314 would be returned Alias analysis: to determine whether pointers can alias Aliasing Aliasing: multiple pointers referring to the same object Optimizing x away is unsound: 314 would be returned Alias analysis: to determine whether pointers can alias Aliasing Aliasing: multiple pointers referring to the same object int f(int *p, int *q) { int x = *p; *q = 314; return x; } If p and q alias, the original value n of *p is returned n p q Alias analysis: to determine whether pointers can alias Aliasing Aliasing: multiple pointers referring to the same object int f(int *p, int *q) { int x = *p; *q = 314; return x *p; } If p and q alias, the original value n of *p is returned n p q Optimizing x away is unsound: 314 would be returned Aliasing Aliasing: multiple pointers referring to the same object int f(int *p, int *q) { int x = *p; *q = 314; return x; } If p and q alias, the original value n of *p is returned n p q Optimizing x away is unsound: 314 would be returned Alias analysis: to determine whether pointers can alias It can still be called with aliased pointers: x union { int x; float y; } u; y u.x = 271; return h(&u.x, &u.y); &u.x &u.y C89 allows p and q to be aliased, and thus requires it to return 271 C99/C11 allows type-based alias analysis: I A compiler
    [Show full text]
  • SATE V Ockham Sound Analysis Criteria
    NISTIR 8113 SATE V Ockham Sound Analysis Criteria Paul E. Black Athos Ribeiro This publication is available free of charge from: https://doi.org/10.6028/NIST.IR.8113 NISTIR 8113 SATE V Ockham Sound Analysis Criteria Paul E. Black Software and Systems Division Information Technology Laboratory Athos Ribeiro Department of Computer Science University of Sao˜ Paulo Sao˜ Paulo, SP Brazil This publication is available free of charge from: https://doi.org/10.6028/NIST.IR.8113 March 2016 Including updates as of June 2017 U.S. Department of Commerce Wilbur L. Ross, Jr., Secretary National Institute of Standards and Technology Kent Rochford, Acting NIST Director and Under Secretary of Commerce for Standards and Technology Abstract Static analyzers examine the source or executable code of programs to find problems. Many static analyzers use heuristics or approximations to handle programs up to millions of lines of code. We established the Ockham Sound Analysis Criteria to recognize static analyzers whose findings are always correct. In brief the criteria are (1) the analyzer’s findings are claimed to always be correct, (2) it produces findings for most of a program, and (3) even one incorrect finding disqualifies an analyzer. This document begins by explaining the background and requirements of the Ockham Criteria. In Static Analysis Tool Exposition (SATE) V, only one tool was submitted to be re- viewed. Pascal Cuoq and Florent Kirchner ran the August 2013 development version of Frama-C on pertinent parts of the Juliet 1.2 test suite. We divided the warnings into eight classes, including improper buffer access, NULL pointer dereference, integer overflow, and use of uninitialized variable.
    [Show full text]
  • A Formal C Memory Model for Separation Logic
    Journal of Automated Reasoning manuscript No. (will be inserted by the editor) A Formal C Memory Model for Separation Logic Robbert Krebbers Received: n/a Abstract The core of a formal semantics of an imperative programming language is a memory model that describes the behavior of operations on the memory. Defining a memory model that matches the description of C in the C11 standard is challenging because C allows both high-level (by means of typed expressions) and low-level (by means of bit manipulation) memory accesses. The C11 standard has restricted the interaction between these two levels to make more effective compiler optimizations possible, at the expense of making the memory model complicated. We describe a formal memory model of the (non-concurrent part of the) C11 stan- dard that incorporates these restrictions, and at the same time describes low-level memory operations. This formal memory model includes a rich permission model to make it usable in separation logic and supports reasoning about program transfor- mations. The memory model and essential properties of it have been fully formalized using the Coq proof assistant. Keywords ISO C11 Standard · C Verification · Memory Models · Separation Logic · Interactive Theorem Proving · Coq 1 Introduction A memory model is the core of a semantics of an imperative programming language. It models the memory states and describes the behavior of memory operations. The main operations described by a C memory model are: – Reading a value at a given address. – Storing a value at a given address. – Allocating a new object to hold a local variable or storage obtained via malloc.
    [Show full text]
  • Low−Level C Topic for CS2263 Alumni −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− People Who Have Taken CS2617 Should Instead Read the Full Set of Notes (Cnotes)
    Low−level C Topic for CS2263 Alumni −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− People who have taken CS2617 should instead read the full set of notes (cnotes). Note: 2nd ed of textbook was for C−89 (classic "ANSI−C". Third is based on the 2018 revision. There were many changes in 30 years. C−11 and C−99 are also in widespread use. A new version (currently called C−2X) is expected in 2021 or 2022. Change look fairly small (new "decimal floats", if you care.) The Preprocessor −−−−−−−−−−−−−−−− Unlike Java, the C compiler has a "preprocessor" that does textual substitutions and "conditional compilation" before the "real compiler" runs. This was borrowed from assembly languages. Fancy uses of preprocessor are often deprecated, especially since C99. Still commonly used use for defining constants and in doing the C equivalent to Java’s "import". Preprocessor "directives" start with #. No ’;’ at end Macros in the C Preprocessor −−−−−−−−−−−−−−−−−−−−−−−−−−−−− #define FOO 12*2 thereafter, wherever the symbol FOO occurs in your code, it is textually replaced by 12*2 . Think find−and−replace. Macro can have parameters #define BAR(x) 12*x If we have BAR(3*z) in your code, it is textually replaced by 12*3*z #undef BAR will "undefine" BAR. After this, BAR(3*z) remains as is. Perils of Macros −−−−−−−−−−−−−−−−− #define SQUARE(x) ((x)*(x)) used much later with int x = 0; int y = SQUARE(x++); What value for x is expected by a programmer looking only at these lines? What value does x actually have? Making Strings and Concatenating Tokens −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− (optional fancy topic) In a macro definition, the # operator puts quote marks around a macro argument.
    [Show full text]
  • Exploring C Semantics and Pointer Provenance
    Exploring C Semantics and Pointer Provenance KAYVAN MEMARIAN, University of Cambridge, UK VICTOR B. F. GOMES, University of Cambridge, UK BROOKS DAVIS, SRI International, USA STEPHEN KELL, University of Cambridge, UK ALEXANDER RICHARDSON, University of Cambridge, UK ROBERT N. M. WATSON, University of Cambridge, UK PETER SEWELL, University of Cambridge, UK The semantics of pointers and memory objects in C has been a vexed question for many years. C values cannot be treated as either purely abstract or purely concrete entities: the language exposes their representations, 67 but compiler optimisations rely on analyses that reason about provenance and initialisation status, not just runtime representations. The ISO WG14 standard leaves much of this unclear, and in some respects differs with de facto standard usage — which itself is difficult to investigate. In this paper we explore the possible source-language semantics for memory objects and pointers, in ISO C and in C as it is used and implemented in practice, focussing especially on pointer provenance. We aim to, as far as possible, reconcile the ISO C standard, mainstream compiler behaviour, and the semantics relied on by the corpus of existing C code. We present two coherent proposals, tracking provenance via integers and not; both address many design questions. We highlight some pros and cons and open questions, and illustrate the discussion with a library of test cases. We make our semantics executable as a test oracle, integrating it with the Cerberus semantics for much of the rest of C, which we have made substantially more complete and robust, and equipped with a web-interface GUI.
    [Show full text]
  • Lenient Execution of C on a JVM How I Learned to Stop Worrying and Execute the Code
    Lenient Execution of C on a JVM How I Learned to Stop Worrying and Execute the Code Manuel Rigger Roland Schatz Johannes Kepler University Linz, Austria Oracle Labs, Austria [email protected] [email protected] Matthias Grimmer Hanspeter M¨ossenb¨ock Oracle Labs, Austria Johannes Kepler University Linz, Austria [email protected] [email protected] ABSTRACT that rely on undefined behavior risk introducing bugs that Most C programs do not strictly conform to the C standard, are hard to find, can result in security vulnerabilities, or and often show undefined behavior, e.g., on signed integer remain as time bombs in the code that explode after compiler overflow. When compiled by non-optimizing compilers, such updates [31, 44, 45]. programs often behave as the programmer intended. However, While bug-finding tools help programmers to find and optimizing compilers may exploit undefined semantics for eliminate undefined behavior in C programs, the majority more aggressive optimizations, thus possibly breaking the of C code will still contain at least some occurrences of non- code. Analysis tools can help to find and fix such issues. Alter- portable code. This includes unspecified and implementation- natively, one could define a C dialect in which clear semantics defined patterns, which do not render the whole program are defined for frequent program patterns whose behavior invalid, but can still cause surprising results. To address would otherwise be undefined. In this paper, we present such this, it has been advocated to come up with a more lenient a dialect, called Lenient C, that specifies semantics for behav- C dialect, that better suits the programmers' needs and ior that the standard left open for interpretation.
    [Show full text]
  • C Memory Object and Value Semantics: the Space of De Facto and ISO Standards
    DRAFT – WORK IN PROGRESS C memory object and value semantics: the space of de facto and ISO standards [This revises and extends WG14 N2013] Revision: 1571 2016-03-17 David Chisnall Justus Matthiesen Kayvan Memarian Peter Sewell Robert N. M. Watson University of Cambridge http://www.cl.cam.ac.uk/~pes20/cerberus/ Contents 2.3.1 Q8. Should intra-object pointer sub- traction give provenance-free inte- 1 Introduction5 ger results?............. 15 1.1 Experimental Testing............6 2.3.2 Q9. Can one make a usable off- 1.2 Summary of answers............7 set between two separately allocated objects by inter-object subtraction 2 Abstract Pointers7 (using either pointer or integer arith- 2.1 Pointer Provenance.............7 metic), to make a usable pointer to the second by adding the offset to 2.1.1 Q1. Must the pointer used for the first?............... 16 a memory access have the right provenance, i.e. be derived from 2.3.3 Q10. Presuming that one can the pointer to the original alloca- have valid pointers with multiple tion (with undefined behaviour oth- provenances, does an inter-object erwise)? (This lets compilers do pointer subtraction give a value with provenance-based alias analysis)..7 explicitly-unknown provenance or 2.1.2 Q2. Can equality testing on pointers something more specific?...... 18 be affected by pointer provenance 2.3.4 Q11. Is the XOR linked list idiom information?............9 supported?............. 18 2.1.3 GCC and ISO C11 differ on the re- 2.3.5 Q12. For arithmetic over prove- sult of a == comparison on a one- nanced integer values, is the prove- past pointer............
    [Show full text]
  • Overload Journal
    A ower Language Nee s Power Tools Smart editor Reliable with full language support refactorings Support for C++03/C++ll, Rename, Extract Function -:(r):- Boost andlibc++,C++ 7 Constant/ Variable, templates and macros. Change8ignature, & more Code generation Profound and navigation code analysis Generate menu, On-the-f y, analysis Find context usages, with Gluick-fixes& dozens 0 Go to Symbol, and more ofsmart checks GET A C++ DEVELOPMENT,:rOOL THAT YOU DESERV ReSharper C++ AppCode CLion Visual Studio Extension IDE for iOS Cross-platform IDE for C•• developers and OS X development for C and C•• developers Start a free 30-day trial jb.gg/cpp-accu Find out more at www.qbssoftware.com QBS SOFTWARE OVERLOAD CONTENTS OVERLOAD 160 December 2020 Overload is a publication of the ACCU ISSN 1354-3172 For details of the ACCU, our publications Editor and activities, visit the ACCU website: Frances Buontempo [email protected] www.accu.org Advisors Ben Curry [email protected] Mikael Kilpeläinen [email protected] 4 Questions on the Form of Software Steve Love Lucian Radu Teodorescu considers whether the [email protected] difficulties in writing software are rooted in the Chris Oldwood essence of development. [email protected] Roger Orr 8 Building g++ from the [email protected] Balog Pal GCC Modules Branch [email protected] Roger Orr demonstrates how to get a compiler that Tor Arve Stangeland supports modules up and running. [email protected] Anthony Williams 10 Consuming the uk-covid19 API [email protected] Donald Hernik demonstrates how to wrangle data Advertising enquiries out of the UK API.
    [Show full text]
  • Anglia Ruskin University a Type-Safe Apparatus
    ANGLIA RUSKIN UNIVERSITY A TYPE-SAFE APPARATUS EXECUTING HIGHER ORDER FUNCTIONS IN CONJUNCTION WITH HARDWARE ERROR TOLERANCE JONATHAN RICHARD ROBERT KIMMITT A thesis in partial fulfilment of the requirements of Anglia Ruskin University for the degree of Doctor of Philosophy This research programme was carried out in collaboration with The University of Cambridge Submitted: October 2015 Acknowledgements This dissertation was self-funded and prepared in part fulfilment of the requirements of the degree of Doctor of Philosophy under the supervision of Dr David Greaves of The University of Cambridge, and Dr George Wilson and Professor Marcian Cirstea at Anglia Ruskin University, without whose help this dissertation would not have been possible. I am grateful to Dr John O’Donnell of The University of Glasgow and Dr Anil Madhavapeddy of The University of Cambridge for their willingness to examine the degree. Dedication Dedicated to my wife Christine Kimmitt i ANGLIA RUSKIN UNIVERSITY ABSTRACT FACULTY OF SCIENCE AND TECHNOLOGY DOCTOR OF PHILOSOPHY A TYPE-SAFE APPARATUS EXECUTING HIGHER ORDER FUNCTIONS IN CONJUNCTION WITH HARDWARE ERROR TOLERANCE JONATHAN RICHARD ROBERT KIMMITT October 2015 The increasing commoditization of computers in modern society has exceeded the pace of associated developments in reliability. Although theoretical computer science has advanced greatly in the last thirty years, many of the best techniques have yet to find their way into embedded computers, and their failure can have a great potential for disrupting society.
    [Show full text]