DOCSLIB.ORG

CERE: LLVM Based Codelet Extractor and Replayer for Piecewise Benchmarking and Optimization

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
CERE: LLVM Based Codelet Extractor and Replayer for Piecewise Benchmarking and Optimization CERE: LLVM based Codelet Extractor and REplayer for Piecewise Benchmarking and Optimization Chadi Akel, P. de Oliveira Castro, M. Popov, E. Petit, W. Jalby University of Versailles { Exascale Computing Research EuroLLVM 2016 C ER E Motivation I Finding best application parameters is a costly iterative process I CodeletExtractor andREplayer I Break an application into standalone codelets I Make costly analysis affordable: I Focus on single regions instead of whole applications I Run a single representative by clustering similar codelets C ER E 1 / 16 Codelet Extraction I Extract codelets as standalone microbenchmarks codelets can be recompiled C or Fortran application and run independently . capture machine state state dump . for (i = 0; i < N; i ++) { + for (j = 0; j < N; j ++) { codelet wrapper a[i][j] += b[i]*c[j]; IR for (i = 0; i < N; i ++) { Region } } for (j = 0; j < N; j ++) { a[i][j] += b[i]*c[j]; . } . } . 2 / 16 CERE Workflow Invocation Region Working set LLVM IR Region & Applications and cache Capture outlining Codelet capture subsetting Change: number of threads, affinity, Working sets Codelet runtime parameters memory dump Replay Fast Warmup Generate Retarget for: performance + codelets different architecture prediction Replay wrapper different optimizations CERE can extract codelets from: I Hot Loops I OpenMP non-nested parallel regions [Popov et al. 2015] 3 / 16 Outline Extracting and Replaying Codelets Faithful Retargetable Applications Architecture selection Compiler flags tuning Scalability prediction Demo Capture and replay in NAS BT Simple flag replay for NAS FT Conclusion 4 / 16 Capturing codelets at Intermediate Representation I Faithful: behaves similarly to the original region I Retargetable: modify runtime and compilation parameters same assembly 6= assembly [Akel et al. 2013] hard to retarget (compiler, ISA) easy to retarget costly support various ISA costly support various languages I LLVM Intermediate Representation is a good tradeoff 5 / 16 Faithful capture I Required for semantically accurate replay: I Register state I Memory state I OS state: locks, file descriptors, sockets I No support for OS state except for locks. CERE captures fully from userland: no kernel modules required. I Required for performance accurate replay: I Preserve code generation I Cache state I NUMA ownership I Other warmup state (eg. branch predictor) 6 / 16 Faithful capture: memory Capture access at page granularity: coarse but fast region protect static and currently allocated to capture process memory (/proc/self/maps) memory allocation intercept memory allocation functions with LD_PRELOAD a = malloc(256); 1 allocate memory 2 protect memory and return to user program memory segmentation access fault handler a[i]++; 1 dump accessed memory to disk 2 unlock accessed page and return to user program I Small dump footprint: only touched pages are saved I Warmup cache: replay trace of most recently touched pages I NUMA: detect first touch of each page 7 / 16 Outline Extracting and Replaying Codelets Faithful Retargetable Applications Architecture selection Compiler flags tuning Scalability prediction Demo Capture and replay in NAS BT Simple flag replay for NAS FT Conclusion 8 / 16 Selecting Representative Codelets I Key Idea: Applications have redundancies I Same codelet called multiple times I Codelets sharing similar performance signatures I Detect redundancies and keep only one representative 8e+07 6e+07 4e+07 Cycles 2e+07 0e+00 0 1000 2000 3000 replay invocation Figure : SPEC tonto make [email protected]:1133 execution trace. 90% of NAS codelets can be reduced to four or less representatives. 9 / 16 Performance Signature Clustering SP Static & Dynamic Profiling f1 Vectorization ratio f2 FLOPS/s Maqao Clustering f3 Cache Misses BT [... ] ... Likwid Step B: Using the proximity between feature Step A: Perform static and dynamic analysis on a reference vectors we cluster similar codelets and select one architecture to capture codelet's feature vectors. representative per cluster. Sandy Bridge Step C: CERE extracts the Atom representatives as standalone Full codelets. A model extrapolates full Model Benchmarks benchmark results. Core2 Results [Oliveira Castro et al. 2014] 10 / 16 Codelet Based Architecture Selection 1.55 1.59 1.5 Real Speedup Predicted Speedup 1.0 0.83 0.83 0.5 0.15 0.12 Nehalem Reference: Geometric mean speedup 0.0 Atom Core 2 Sandy Bridge Figure : Benchmarking NAS serial on three architectures I real: speedup when benchmarking original applications I predicted: speedup predicted with representative codelets I CERE 31× cheaper than running the full benchmarks. 11 / 16 Autotuning LLVM middle-end optimizations I LLVM middle-end offers more than 50 optimization passes. I Codelet replay enable per-region fast optimization tuning. original 1.2e+08 replay O3 1.0e+08 8.0e+07 6.0e+07 Cycles (Ivybridge 3.4GHz) 0 200 400 600 Id of LLVM middle−end optimization passes combination Figure : NAS SP ysolve codelet. 1000 schedules of random passes combinations explored based on O3 passes. CERE 149× cheaper than running the full benchmark ( 27× cheaper when tuning codelets covering 75% of SP) 12 / 16 Fast Scalability Benchmarking with OpenMP Codelets 1e8 SP compute rhs on Sandy Bridge 6 Real Predicted 5 4 3 Runtime cycles 2 1 0 1 2 4 8 16 32 Threads Core2 Nehalem Sandy Bridge Ivy Bridge Accuracy 98.2% 97.1% 92.6% 97.2% Acceleration × 25.2 × 27.4 × 23.7 × 23.7 Figure : Varying thread number at replay in SP and average results over OMP NAS [Popov et al. 2015] 13 / 16 Outline Extracting and Replaying Codelets Faithful Retargetable Applications Architecture selection Compiler flags tuning Scalability prediction Demo Capture and replay in NAS BT Simple flag replay for NAS FT Conclusion 14 / 16 Conclusion I CERE breaks an application into faithful and retargetable codelets I Piece-wise autotuning: I Different architecture I Compiler optimizations I Scalability I Other exploration costly analysis ? I Limitations: I No support for codelets performing IO (OS state not captured) I Cannot explore source-level optimizations I Tied to LLVM I Full accuracy reports on NAS and SPEC'06 FP available at benchmark-subsetting.github.io/cere/#Reports 15 / 16 Thanks for your attention! https://benchmark-subsetting.github.io/cere/ distributed under the LGPLv3 C ER E 16 / 16 BibliographyI Akel, Chadi et al. (2013). \Is Source-code Isolation Viable for Performance Characterization?" In: 42nd International Conference on Parallel Processing Workshops. IEEE. Gao, Xiaofeng et al. (2005). \Reducing overheads for acquiring dynamic memory traces". In: Workload Characterization Symposium, 2005. Proceedings of the IEEE International. IEEE, pp. 46{55. Liao, Chunhua et al. (2010). “Effective source-to-source outlining to support whole program empirical optimization". In: Languages and Compilers for Parallel Computing. Springer, pp. 308{322. Oliveira Castro, Pablo de et al. (2014). \Fine-grained Benchmark Subsetting for System Selection". In: Proceedings of Annual IEEE/ACM International Symposium on Code Generation and Optimization. ACM, p. 132. Popov, Mihail et al. (2015). \PCERE: Fine-grained Parallel Benchmark Decomposition for Scalability Prediction". In: Proceedings of the 29th IEEE International Parallel and Distributed Processing Symposium IPDPS. IEEE. 17 / 16 Retargetable replay: register state I Issue: Register state is non-portable between architectures. I Solution: capture at a function call boundary I No shared state through registers except function arguments I Get arguments directly through portable IR code I Register agnostic capture I Portable across Atom, Core 2, Haswell, Ivybridge, Nehalem, Sandybridge I Preliminar portability tests between x86 and ARM 32 bits 18 / 16 Retargetable replay: outlining regions Step 1: Outline the region to capture using CodeExtractor pass original: define internal void @outlined( %0= load i32* %i, align4 i32* %i, i32* %s.addr, %1= load i32* %s.addr, align4 i32** %a.addr){ %cmp= icmp slt i32 %0, %1 call void @start_capture(i32* %i, br i1 %cmp, ; loop branch here i32* %s.addr, i32** %a.addr) label %for.body, %0= load i32* %i, align4 label %for.exitStub ... ... ret void } original: call void @outlined(i32* %i, i32* %s.addr, i32** %a.addr) Step 2: Call start capture just after the function call Step 3: At replay, reinlining and variable cloning [Liao et al. 2010] steps ensure that the compilation context is close to original 19 / 16 Comparison to other Code Isolating tools Code Astex Codelet SimPoint CERE Isolator Finder Support Language C(++), Fortran C, Fortran C(++), assembly Fortran, ... Fortran Extraction IR source source source assembly Indirections yes no no yes yes Replay Simulator yes yes yes yes yes Hardware yes yes yes yes no Reduction Capture size reduced reduced reduced full - Instances yes manual manual manual yes Code sign. yes no no no yes 20 / 16 accurate replay codelet coverage Core2 Haswell 100 Accuracy Summary: NAS SER 75 NAS.A 50 25 % of Exec. Time % of Exec. 0 lu ft bt is lu ft bt is cg mg sp ep cg mg sp ep Figure : The Coverage the percentage of the execution time captured by codelets. The Accurate Replay is the percentage of execution time replayed with an error less than 15%. 21 / 16 Accuracy Summary: SPEC FP 2006 Haswell 100 75 SPECFP06 50 25 % of Exec. Time % of Exec. 0 wrf lbm tonto milc dealII povray soplex namd gamesssphinx3 calculix leslie3d zeusmp bwaves gromacs gemsfdtdspecrand cactusADM Figure : The Coverage is the percentage of the execution time captured by codelets. The Accurate Replay is the percentage of execution time replayed with an error less than 15%. I low coverage (sphinx3, wrf, povray): < 2000 cycles or IO I low matching (soplex, calculix, gamess): warmup \bugs" 22 / 16 CERE page capture dump size full dump (Codelet Finder) page granularity dump (CERE) 200 367 472 150 131 117 106 94 101 96 100 89 51 Size (MB) Size 46 50 27 26 22 1 8 0 bt cg ep ft is lu mg sp Figure : Comparison between the page capture and full dump size on NAS.A benchmarks.
Load more

Recommended publications
  • An Execution Model for Serverless Functions at the Edge
    An Execution Model for Serverless Functions at the Edge Adam Hall Umakishore Ramachandran Georgia Institute of Technology Georgia Institute of Technology Atlanta, Georgia Atlanta, Georgia ach@gatech:edu rama@gatech:edu ABSTRACT 1 INTRODUCTION Serverless computing platforms allow developers to host single- Enabling next generation technologies such as self-driving cars or purpose applications that automatically scale with demand. In con- smart cities via edge computing requires us to reconsider the way trast to traditional long-running applications on dedicated, virtu- we characterize and deploy the services supporting those technolo- alized, or container-based platforms, serverless applications are gies. Edge/fog environments consist of many micro data centers intended to be instantiated when called, execute a single function, spread throughout the edge of the network. This is in stark contrast and shut down when finished. State-of-the-art serverless platforms to the cloud, where we assume the notion of unlimited resources achieve these goals by creating a new container instance to host available in a few centralized data centers. These micro data center a function when it is called and destroying the container when it environments must support large numbers of Internet of Things completes. This design allows for cost and resource savings when (IoT) devices on limited hardware resources, processing the mas- hosting simple applications, such as those supporting IoT devices sive amounts of data those devices generate while providing quick at the edge of the network. However, the use of containers intro- decisions to inform their actions [44]. One solution to supporting duces some overhead which may be unsuitable for applications emerging technologies at the edge lies in serverless computing.
    [Show full text]
  • Toward IFVM Virtual Machine: a Model Driven IFML Interpretation
    Toward IFVM Virtual Machine: A Model Driven IFML Interpretation Sara Gotti and Samir Mbarki MISC Laboratory, Faculty of Sciences, Ibn Tofail University, BP 133, Kenitra, Morocco Keywords: Interaction Flow Modelling Language IFML, Model Execution, Unified Modeling Language (UML), IFML Execution, Model Driven Architecture MDA, Bytecode, Virtual Machine, Model Interpretation, Model Compilation, Platform Independent Model PIM, User Interfaces, Front End. Abstract: UML is the first international modeling language standardized since 1997. It aims at providing a standard way to visualize the design of a system, but it can't model the complex design of user interfaces and interactions. However, according to MDA approach, it is necessary to apply the concept of abstract models to user interfaces too. IFML is the OMG adopted (in March 2013) standard Interaction Flow Modeling Language designed for abstractly expressing the content, user interaction and control behaviour of the software applications front-end. IFML is a platform independent language, it has been designed with an executable semantic and it can be mapped easily into executable applications for various platforms and devices. In this article we present an approach to execute the IFML. We introduce a IFVM virtual machine which translate the IFML models into bytecode that will be interpreted by the java virtual machine. 1 INTRODUCTION a fundamental standard fUML (OMG, 2011), which is a subset of UML that contains the most relevant The software development has been affected by the part of class diagrams for modeling the data apparition of the MDA (OMG, 2015) approach. The structure and activity diagrams to specify system trend of the 21st century (BRAMBILLA et al., behavior; it contains all UML elements that are 2014) which has allowed developers to build their helpful for the execution of the models.
    [Show full text]
  • A Brief History of Just-In-Time Compilation
    A Brief History of Just-In-Time JOHN AYCOCK University of Calgary Software systems have been using “just-in-time” compilation (JIT) techniques since the 1960s. Broadly, JIT compilation includes any translation performed dynamically, after a program has started execution. We examine the motivation behind JIT compilation and constraints imposed on JIT compilation systems, and present a classification scheme for such systems. This classification emerges as we survey forty years of JIT work, from 1960–2000. Categories and Subject Descriptors: D.3.4 [Programming Languages]: Processors; K.2 [History of Computing]: Software General Terms: Languages, Performance Additional Key Words and Phrases: Just-in-time compilation, dynamic compilation 1. INTRODUCTION into a form that is executable on a target platform. Those who cannot remember the past are con- What is translated? The scope and na- demned to repeat it. ture of programming languages that re- George Santayana, 1863–1952 [Bartlett 1992] quire translation into executable form covers a wide spectrum. Traditional pro- This oft-quoted line is all too applicable gramming languages like Ada, C, and in computer science. Ideas are generated, Java are included, as well as little lan- explored, set aside—only to be reinvented guages [Bentley 1988] such as regular years later. Such is the case with what expressions. is now called “just-in-time” (JIT) or dy- Traditionally, there are two approaches namic compilation, which refers to trans- to translation: compilation and interpreta- lation that occurs after a program begins tion. Compilation translates one language execution. into another—C to assembly language, for Strictly speaking, JIT compilation sys- example—with the implication that the tems (“JIT systems” for short) are com- translated form will be more amenable pletely unnecessary.
    [Show full text]
  • A Parallel Program Execution Model Supporting Modular Software Construction
    A Parallel Program Execution Model Supporting Modular Software Construction Jack B. Dennis Laboratory for Computer Science Massachusetts Institute of Technology Cambridge, MA 02139 U.S.A. [email protected] Abstract as a guide for computer system design—follows from basic requirements for supporting modular software construction. A watershed is near in the architecture of computer sys- The fundamental theme of this paper is: tems. There is overwhelming demand for systems that sup- port a universal format for computer programs and software The architecture of computer systems should components so users may benefit from their use on a wide reflect the requirements of the structure of pro- variety of computing platforms. At present this demand is grams. The programming interface provided being met by commodity microprocessors together with stan- should address software engineering issues, in dard operating system interfaces. However, current systems particular, the ability to practice the modular do not offer a standard API (application program interface) construction of software. for parallel programming, and the popular interfaces for parallel computing violate essential principles of modular The positions taken in this presentation are contrary to or component-based software construction. Moreover, mi- much conventional wisdom, so I have included a ques- croprocessor architecture is reaching the limit of what can tion/answer dialog at appropriate places to highlight points be done usefully within the framework of superscalar and of debate. We start with a discussion of the nature and VLIW processor models. The next step is to put several purpose of a program execution model. Our Parallelism processors (or the equivalent) on a single chip.
    [Show full text]
  • CNT6008 Network Programming Module - 11 Objectives
    CNT6008 Network Programming Module - 11 Objectives Skills/Concepts/Assignments Objectives ASP.NET Overview • Learn the Framework • Understand the different platforms • Compare to Java Platform Final Project Define your final project requirements Section 21 – Web App Read Sections 21 and 27, pages 649 to 694 and 854 Development and ASP.NET to 878. Section 27 – Web App Development with ASP.NET Overview of ASP.NET Section Goals Goal Course Presentation Understanding Windows Understanding .NET Framework Foundation Project Concepts Creating a ASP.NET Client and Server Application Understanding the Visual Creating a ASP Project Studio Development Environment .NET – What Is It? • Software platform • Language neutral • In other words: • .NET is not a language (Runtime and a library for writing and executing written programs in any compliant language) What Is .NET • .Net is a new framework for developing web-based and windows-based applications within the Microsoft environment. • The framework offers a fundamental shift in Microsoft strategy: it moves application development from client-centric to server- centric. .NET – What Is It? .NET Application .NET Framework Operating System + Hardware Framework, Languages, And Tools VB VC++ VC# JScript … Common Language Specification Visual Studio.NET Visual ASP.NET: Web Services Windows and Web Forms Forms ADO.NET: Data and XML Base Class Library Common Language Runtime The .NET Framework .NET Framework Services • Common Language Runtime • Windows Communication Framework (WCF) • Windows® Forms • ASP.NET (Active Server Pages) • Web Forms • Web Services • ADO.NET, evolution of ADO • Visual Studio.NET Common Language Runtime (CLR) • CLR works like a virtual machine in executing all languages. • All .NET languages must obey the rules and standards imposed by CLR.
    [Show full text]
  • The CLR's Execution Model
    C01621632.fm Page 3 Thursday, January 12, 2006 3:49 PM Chapter 1 The CLR’s Execution Model In this chapter: Compiling Source Code into Managed Modules . 3 Combining Managed Modules into Assemblies . 6 Loading the Common Language Runtime. 8 Executing Your Assembly’s Code. 11 The Native Code Generator Tool: NGen.exe . 19 Introducing the Framework Class Library . 22 The Common Type System. 24 The Common Language Specification . 26 Interoperability with Unmanaged Code. 30 The Microsoft .NET Framework introduces many new concepts, technologies, and terms. My goal in this chapter is to give you an overview of how the .NET Framework is designed, intro- duce you to some of the new technologies the framework includes, and define many of the terms you’ll be seeing when you start using it. I’ll also take you through the process of build- ing your source code into an application or a set of redistributable components (files) that contain types (classes, structures, etc.) and then explain how your application will execute. Compiling Source Code into Managed Modules OK, so you’ve decided to use the .NET Framework as your development platform. Great! Your first step is to determine what type of application or component you intend to build. Let’s just assume that you’ve completed this minor detail; everything is designed, the specifications are written, and you’re ready to start development. Now you must decide which programming language to use. This task is usually difficult because different languages offer different capabilities. For example, in unmanaged C/C++, you have pretty low-level control of the system.
    [Show full text]
  • Executing UML Models
    Executing UML Models Miguel Pinto Luz1, Alberto Rodrigues da Silva1 1Instituto Superior Técnico Av. Rovisco Pais 1049-001 Lisboa – Portugal {miguelluz, alberto.silva}@acm.org Abstract. Software development evolution is a history of permanent seeks for raising the abstraction level to new limits overcoming new frontiers. Executable UML (xUML) comes this way as the expectation to achieve the next level in abstraction, offering the capability of deploying a xUML model in a variety of software environments and platforms without any changes. This paper comes as a first expedition inside xUML, exploring the main aspects of its specification including the action languages support and the fundamental MDA compliance. In this paper is presented a future new xUML tool called XIS-xModels that gives Microsoft Visio new capabilities of running and debugging xUML models. This paper is an outline of the capabilities and main features of the future application. Keywords: UML, executable UML, Model Debugging, Action Language. 1. Introduction In a dictionary we find that an engineer is a person who uses scientific knowledge to solve practical problems, planning and directing, but an information technology engineer is someone that spends is time on implementing lines of code, instead of being focus on planning and projecting. Processes, meetings, models, documents, or even code are superfluous artifacts for organizations: all they need is well design and fast implemented working system, that moves them towards a new software development paradigm, based on high level executable models. According this new paradigm it should be possible to reduce development time and costs, and to bring new product quality warranties, only reachable by executing, debugging and testing early design stages (models).
    [Show full text]
  • Performance Analyses and Code Transformations for MATLAB Applications Patryk Kiepas
    Performance analyses and code transformations for MATLAB applications Patryk Kiepas To cite this version: Patryk Kiepas. Performance analyses and code transformations for MATLAB applications. Computa- tion and Language [cs.CL]. Université Paris sciences et lettres, 2019. English. NNT : 2019PSLEM063. tel-02516727 HAL Id: tel-02516727 https://pastel.archives-ouvertes.fr/tel-02516727 Submitted on 24 Mar 2020 HAL is a multi-disciplinary open access L’archive ouverte pluridisciplinaire HAL, est archive for the deposit and dissemination of sci- destinée au dépôt et à la diffusion de documents entific research documents, whether they are pub- scientifiques de niveau recherche, publiés ou non, lished or not. The documents may come from émanant des établissements d’enseignement et de teaching and research institutions in France or recherche français ou étrangers, des laboratoires abroad, or from public or private research centers. publics ou privés. Préparée à MINES ParisTech Analyses de performances et transformations de code pour les applications MATLAB Performance analyses and code transformations for MATLAB applications Soutenue par Composition du jury : Patryk KIEPAS Christine EISENBEIS Le 19 decembre 2019 Directrice de recherche, Inria / Paris 11 Présidente du jury João Manuel Paiva CARDOSO Professeur, University of Porto Rapporteur Ecole doctorale n° 621 Erven ROHOU Ingénierie des Systèmes, Directeur de recherche, Inria Rennes Rapporteur Matériaux, Mécanique, Michel BARRETEAU Ingénieur de recherche, THALES Examinateur Énergétique Francois GIERSCH Ingénieur de recherche, THALES Invité Spécialité Claude TADONKI Informatique temps-réel, Chargé de recherche, MINES ParisTech Directeur de thèse robotique et automatique Corinne ANCOURT Maître de recherche, MINES ParisTech Co-directrice de thèse Jarosław KOŹLAK Professeur, AGH UST Co-directeur de thèse 2 Abstract MATLAB is an interactive computing environment with an easy programming language and a vast library of built-in functions.
    [Show full text]
  • An Executable Formal Semantics of PHP with Applications to Program Analysis
    Imperial College London Department of Computing An Executable Formal Semantics of PHP with Applications to Program Analysis Daniele Filaretti Submitted in part fulfilment of the requirements for the degree of Doctor of Philosophy in Computing of the Imperial College London and the Diploma of the Imperial College, 2015 Abstract Nowadays, many important activities in our lives involve the web. However, the software and protocols on which web applications are based were not designed with the appropriate level of security in mind. Many web applications have reached a level of complexity for which testing, code reviews and human inspection are no longer sufficient quality-assurance guarantees. Tools that employ static analysis techniques are needed in order to explore all possible execution paths through an application and guarantee the absence of undesirable behaviours. To make sure that an analysis captures the properties of interest, and to navigate the trade-offs between efficiency and precision, it is necessary to base the design and the development of static analysis tools on a firm understanding of the language to be analysed. When this underlying knowledge is missing or erroneous, tools can’t be trusted no matter what advanced techniques they use to perform their task. In this Thesis, we introduce KPHP, the first executable formal semantics of PHP, one of the most popular languages for server-side web programming. Then, we demonstrate its practical relevance by developing two verification tools, of increasing complexity, on top of it - a simple verifier based on symbolic execution and LTL model checking and a general purpose, fully configurable and extensible static analyser based on Abstract Interpretation.
    [Show full text]
  • CUDA C++ Programming Guide
    CUDA C++ Programming Guide Design Guide PG-02829-001_v11.4 | September 2021 Changes from Version 11.3 ‣ Added Graph Memory Nodes. ‣ Formalized Asynchronous SIMT Programming Model. CUDA C++ Programming Guide PG-02829-001_v11.4 | ii Table of Contents Chapter 1. Introduction........................................................................................................ 1 1.1. The Benefits of Using GPUs.....................................................................................................1 1.2. CUDA®: A General-Purpose Parallel Computing Platform and Programming Model....... 2 1.3. A Scalable Programming Model.............................................................................................. 3 1.4. Document Structure................................................................................................................. 5 Chapter 2. Programming Model.......................................................................................... 7 2.1. Kernels.......................................................................................................................................7 2.2. Thread Hierarchy...................................................................................................................... 8 2.3. Memory Hierarchy...................................................................................................................10 2.4. Heterogeneous Programming................................................................................................11 2.5. Asynchronous
    [Show full text]
  • Programming Languages: Classification, Execution Model, and Errors
    Programming Fundamentals Dr. Raaid Alubady –4th Lecture Programming Languages: Classification, Execution Model, and Errors 4th Lecture 1. Introduction As the involvement of computer, automation and robotics growing in our daily life, programming becomes highly required to control all of them. To control all of these systems and machines and take desired output by them skilled programming languages is necessary. However, the area of programming language becomes how much wide but it will be under one of the two categories of programming languages (i.e., Low-level language and High-level language). In the early days of computing, language design was heavily influenced by the decision to use compiling or interpreting as a mode of execution. Depending on tools such as compilation and interpretation in order to get our written code into a form that the computer can execute. Code can either be executed natively through the operating system after it is converted to machine code (via compilation) or can be evaluated line by line through another program which handles executing the code instead of the operating system itself (via interpretation). 2. Classification of Programming Languages Programming languages are basically classified into two main categories – Low- level language and High-level language. Every programming language belongs to one of these categories and sub-category. 2.1. Low level languages Low-level languages are used to write programs that relate to the specific architecture and hardware of a particular type of computer. They are closer to the native language of a computer (binary), making them harder for programmers to understand. Programs written in low-level languages are fast and memory efficient.
    [Show full text]
  • The Design and Implementation of a Bytecode for Optimization On
    Trinity University Digital Commons @ Trinity Computer Science Honors Theses Computer Science Department 4-20-2012 The esiD gn and Implementation of a Bytecode for Optimization on Heterogeneous Systems Kerry A. Seitz Trinity University, [email protected] Follow this and additional works at: http://digitalcommons.trinity.edu/compsci_honors Part of the Computer Sciences Commons Recommended Citation Seitz, Kerry A., "The eD sign and Implementation of a Bytecode for Optimization on Heterogeneous Systems" (2012). Computer Science Honors Theses. 28. http://digitalcommons.trinity.edu/compsci_honors/28 This Thesis open access is brought to you for free and open access by the Computer Science Department at Digital Commons @ Trinity. It has been accepted for inclusion in Computer Science Honors Theses by an authorized administrator of Digital Commons @ Trinity. For more information, please contact [email protected]. The Design and Implementation of a Bytecode for Optimization on Heterogeneous Systems Kerry Allen Seitz, Jr. Abstract As hardware architectures shift towards more heterogeneous platforms with different vari- eties of multi- and many-core processors and graphics processing units (GPUs) by various manufacturers, programmers need a way to write simple and highly optimized code without worrying about the specifics of the underlying hardware. To meet this need, I have designed a virtual machine and bytecode around the goal of optimized execution on highly variable, heterogeneous hardware, instead of having goals such as small bytecodes as was the ob- jective of the JavaR Virtual Machine. The approach used here is to combine elements of the DalvikR virtual machine with concepts from the OpenCLR heterogeneous computing platform, along with an annotation system so that the results of complex compile time analysis can be available to the Just-In-Time compiler.
    [Show full text]