DOCSLIB.ORG

CIS 501 Introduction to Computer Architecture Instruction Set

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text

Load more

Instruction Set Architecture (ISA) Application • What is a good ISA? OS • Aspects of ISAs Compiler Firmware CIS 501 • RISC vs. CISC Introduction to Computer Architecture CPU I/O • Implementing CISC: µISA Memory Digital Circuits Unit 2: Instruction Set Architecture Gates & Transistors CIS 501 (Martin/Roth): Instruction Set Architectures 1 CIS 501 (Martin/Roth): Instruction Set Architectures 2 Readings What Is An ISA? • H+P • ISA (instruction set architecture) • Chapter 2 • A well-define hardware/software interface • Further reading: • Appendix C (RISC) and Appendix D (x86) • The “contract” between software and hardware • Functional definition of operations, modes, and storage • Available from web page locations supported by hardware • Precise description of how to invoke, and access them • Paper • The Evolution of RISC Technology at IBM by John Cocke • No guarantees regarding • How operations are implemented • Much of this chapter will be “on your own reading” • Which operations are fast and which are slow and when • Which operations take more power and which take less • Hard to talk about ISA features without knowing what they do • We will revisit many of these issues in context CIS 501 (Martin/Roth): Instruction Set Architectures 3 CIS 501 (Martin/Roth): Instruction Set Architectures 4 A Language Analogy for ISAs RISC vs CISC Foreshadowing • A ISA is analogous to a human language • Recall performance equation: • Allows communication • (instructions/program) * (cycles/instruction) * (seconds/cycle) • Language: person to person • ISA: hardware to software • CISC (Complex Instruction Set Computing) • Need to speak the same language/ISA • Improve “instructions/program” with “complex” instructions • Many common aspects • Easy for assembly-level programmers, good code density • Part of speech: verbs, nouns, adjectives, adverbs, etc. • Common operations: calculation, control/branch, memory • RISC (Reduced Instruction Set Computing) • Many different languages/ISAs, many similarities, many differences • Improve “cycles/instruction” with many single-cycle instructions • Different structure • Increases “instruction/program”, but hopefully not as much • Both evolve over time • Help from smart compiler • Key differences: ISAs must be unambiguous • Perhaps improve clock cycle time (seconds/cycle) • ISAs are explicitly engineered and extended • via aggressive implementation allowed by simpler instructions CIS 501 (Martin/Roth): Instruction Set Architectures 5 CIS 501 (Martin/Roth): Instruction Set Architectures 6 What Makes a Good ISA? Programmability • Programmability • Easy to express programs efficiently? • Easy to express programs efficiently? • For whom? • Implementability • Easy to design high-performance implementations? • Before 1985: human • More recently • Compilers were terrible, most code was hand-assembled • Easy to design low-power implementations? • Want high-level coarse-grain instructions • Easy to design high-reliability implementations? • As similar to high-level language as possible • Easy to design low-cost implementations? • Compatibility • After 1985: compiler • Easy to maintain programmability (implementability) as languages • Optimizing compilers generate much better code that you or I and programs (technology) evolves? • Want low-level fine-grain instructions • x86 (IA32) generations: 8086, 286, 386, 486, Pentium, PentiumII, PentiumIII, Pentium4,… • Compiler can’t tell if two high-level idioms match exactly or not CIS 501 (Martin/Roth): Instruction Set Architectures 7 CIS 501 (Martin/Roth): Instruction Set Architectures 8 Human Programmability Compiler Programmability • What makes an ISA easy for a human to program in? • What makes an ISA easy for a compiler to program in? • Proximity to a high-level language (HLL) • Low level primitives from which solutions can be synthesized • Closing the “semantic gap” • Wulf: “primitives not solutions” • Semantically heavy (CISC-like) insns that capture complete idioms • Computers good at breaking complex structures to simple ones • “Access array element”, “loop”, “procedure call” • Requires traversal • Example: SPARC save/restore • Not so good at combining simple structures into complex ones • Bad example: x86 rep movsb (copy string) • Requires search, pattern matching (why AI is hard) • Ridiculous example: VAX insque (insert-into-queue) • Easier to synthesize complex insns than to compare them • “Semantic clash”: what if you have many high-level languages? • Rules of thumb • Stranger than fiction • Regularity: “principle of least astonishment” • People once thought computers would execute language directly • Orthogonality & composability • Fortunately, never materialized (but keeps coming back around) • One-vs.-all CIS 501 (Martin/Roth): Instruction Set Architectures 9 CIS 501 (Martin/Roth): Instruction Set Architectures 10 Today’s Semantic Gap Implementability • Popular argument • Every ISA can be implemented • Today’s ISAs are targeted to one language… • Not every ISA can be implemented efficiently • Just so happens that this language is very low level • The C programming language • Classic high-performance implementation techniques • Pipelining, parallel execution, out-of-order execution (more later) • Will ISAs be different when Java/C# become dominant? • Object-oriented? Probably not • Certain ISA features make these difficult • Support for garbage collection? Maybe – Variable instruction lengths/formats: complicate decoding • Support for bounds-checking? Maybe – Implicit state: complicates dynamic scheduling • Why? – Variable latencies: complicates scheduling • Smart compilers transform high-level languages to simple – Difficult to interrupt instructions: complicate many things instructions • Any benefit of tailored ISA is likely small CIS 501 (Martin/Roth): Instruction Set Architectures 11 CIS 501 (Martin/Roth): Instruction Set Architectures 12 Compatibility The Compatibility Trap • No-one buys new hardware… if it requires new software • Easy compatibility requires forethought • Intel was the first company to realize this • Temptation: use some ISA extension for 5% performance gain • ISA must remain compatible, no matter what • Frequent outcome: gain diminishes, disappears, or turns to loss • x86 one of the worst designed ISAs EVER, but survives – Must continue to support gadget for eternity • As does IBM’s 360/370 (the first “ISA family”) • Backward compatibility • Example: register windows (SPARC) • New processors must support old programs (can’t drop features) • Adds difficulty to out-of-order implementations of SPARC • Very important • Details shortly • Forward (upward) compatibility • Old processors must support new programs (with software help) • New processors redefine only previously-illegal opcodes • Allow software to detect support for specific new instructions • Old processors emulate new instructions in low-level software CIS 501 (Martin/Roth): Instruction Set Architectures 13 CIS 501 (Martin/Roth): Instruction Set Architectures 14 The Compatibility Trap Door Aspects of ISAs • Compatibility’s friends • VonNeumann model • Trap: instruction makes low-level “function call” to OS handler • Implicit structure of all modern ISAs • Nop: “no operation” - instructions with no functional semantics • Format • Backward compatibility • Length and encoding • Handle rarely used but hard to implement “legacy” opcodes • Operand model • Define to trap in new implementation and emulate in software • Where (other than memory) are operands stored? • Rid yourself of some ISA mistakes of the past • Datatypes and operations • Problem: performance suffers • Control • Forward compatibility • Reserve sets of trap & nop opcodes (don’t define uses) • Add ISA functionality by overloading traps • Overview only • Release firmware patch to “add” to old implementation • Read about the rest in the book and appendices • Add ISA hints by overloading nops CIS 501 (Martin/Roth): Instruction Set Architectures 15 CIS 501 (Martin/Roth): Instruction Set Architectures 16 The Sequential Model Format • Implicit model of all modern ISAs • Length • Often called VonNeuman, but in ENIAC before • Fixed length Fetch PC • Basic feature: the program counter (PC) • Most common is 32 bits Decode • Defines total order on dynamic instruction + Simple implementation: compute next PC using only PC Read Inputs • Next PC is PC++ unless insn says otherwise – Code density: 32 bits to increment a register by 1? Execute • Order and named storage define computation – x86 can do this in one 8-bit instruction • Value flows from insn X to Y via storage A iff… Write Output • Variable length • X names A as output, Y names A as input… Next PC – Complex implementation • And Y after X in total order + Code density • Processor logically executes loop at left • Compromise: two lengths • Instruction execution assumed atomic • MIPS16 or ARM’s Thumb • Instruction X finishes before insn X+1 starts • Encoding • Alternatives have been proposed… • A few simple encodings simplify decoder implementation CIS 501 (Martin/Roth): Instruction Set Architectures 17 CIS 501 (Martin/Roth): Instruction Set Architectures 18 Example: MIPS Format Operand Model: Memory Only • Length • Where (other than memory) can operands come from? • 32-bits • And how are they specified? • Example: A = B + C • Encoding • Several options • 3 formats, simple encoding • Q: how many instructions can be encoded? A: 127 • Memory only add B,C,A mem[A] = mem[B] + mem[C] R-type Op(6) Rs(5) Rt(5) Rd(5) Sh(5) Func(6) I-type Op(6) Rs(5) Rt(5) Immed(16) J-type Op(6) Target(26)
Recommended publications
  • Pdp11-40.Pdf

    Pdp11-40.Pdf

    processor handbook digital equipment corporation Copyright© 1972, by Digital Equipment Corporation DEC, PDP, UNIBUS are registered trademarks of Digital Equipment Corporation. ii TABLE OF CONTENTS CHAPTER 1 INTRODUCTION 1·1 1.1 GENERAL ............................................. 1·1 1.2 GENERAL CHARACTERISTICS . 1·2 1.2.1 The UNIBUS ..... 1·2 1.2.2 Central Processor 1·3 1.2.3 Memories ........... 1·5 1.2.4 Floating Point ... 1·5 1.2.5 Memory Management .............................. .. 1·5 1.3 PERIPHERALS/OPTIONS ......................................... 1·5 1.3.1 1/0 Devices .......... .................................. 1·6 1.3.2 Storage Devices ...................................... .. 1·6 1.3.3 Bus Options .............................................. 1·6 1.4 SOFTWARE ..... .... ........................................... ............. 1·6 1.4.1 Paper Tape Software .......................................... 1·7 1.4.2 Disk Operating System Software ........................ 1·7 1.4.3 Higher Level Languages ................................... .. 1·7 1.5 NUMBER SYSTEMS ..................................... 1-7 CHAPTER 2 SYSTEM ARCHITECTURE. 2-1 2.1 SYSTEM DEFINITION .............. 2·1 2.2 UNIBUS ......................................... 2-1 2.2.1 Bidirectional Lines ...... 2-1 2.2.2 Master-Slave Relation .. 2-2 2.2.3 Interlocked Communication 2-2 2.3 CENTRAL PROCESSOR .......... 2-2 2.3.1 General Registers ... 2-3 2.3.2 Processor Status Word ....... 2-4 2.3.3 Stack Limit Register 2-5 2.4 EXTENDED INSTRUCTION SET & FLOATING POINT .. 2-5 2.5 CORE MEMORY . .... 2-6 2.6 AUTOMATIC PRIORITY INTERRUPTS .... 2-7 2.6.1 Using the Interrupts . 2-9 2.6.2 Interrupt Procedure 2-9 2.6.3 Interrupt Servicing ............ .. 2-10 2.7 PROCESSOR TRAPS ............ 2-10 2.7.1 Power Failure ..............
  • Configurable RISC-V Softcore Processor for FPGA Implementation

    Configurable RISC-V Softcore Processor for FPGA Implementation

    1 Configurable RISC-V softcore processor for FPGA implementation Joao˜ Filipe Monteiro Rodrigues, Instituto Superior Tecnico,´ Universidade de Lisboa Abstract—Over the past years, the processor market has and development of several programming tools. The RISC-V been dominated by proprietary architectures that implement Foundation controls the RISC-V evolution, and its members instruction sets that require licensing and the payment of fees to are responsible for promoting the adoption of RISC-V and receive permission so they can be used. ARM is an example of one of those companies that sell its microarchitectures to participating in the development of the new ISA. In the list of the manufactures so they can implement them into their own members are big companies like Google, NVIDIA, Western products, and it does not allow the use of its instruction set Digital, Samsung, or Qualcomm. (ISA) in other implementations without licensing. The RISC-V The main goal of this work is the development of a RISC- instruction set appeared proposing the hardware and software V softcore processor to be implemented in an FPGA, using development without costs, through the creation of an open- source ISA. This way, it is possible that any project that im- a non-RISC-V core as the base of this architecture. The plements the RISC-V ISA can be made available open-source or proposed solution is focused on solving the problems and even implemented in commercial products. However, the RISC- limitations identified in the other RISC-V cores that were V solutions that have been developed do not present the needed analyzed in this thesis, especially in terms of the adaptability requirements so they can be included in projects, especially the and flexibility, allowing future modifications according to the research projects, because they offer poor documentation, and their performances are not suitable.
  • Binary and Hexadecimal

    Binary and Hexadecimal

    Binary and Hexadecimal Binary and Hexadecimal Introduction This document introduces the binary (base two) and hexadecimal (base sixteen) number systems as a foundation for systems programming tasks and debugging. In this document, if the base of a number might be ambiguous, we use a base subscript to indicate the base of the value. For example: 45310 is a base ten (decimal) value 11012 is a base two (binary) value 821716 is a base sixteen (hexadecimal) value Why do we need binary? The binary number system (also called the base two number system) is the native language of digital computers. No matter how elegantly or naturally we might interact with today’s computers, phones, and other smart devices, all instructions and data are ultimately stored and manipulated in the computer as binary digits (also called bits, where a bit is either a 0 or a 1). CPUs (central processing units) and storage devices can only deal with information in this form. In a computer system, absolutely everything is represented as binary values, whether it’s a program you’re running, an image you’re viewing, a video you’re watching, or a document you’re writing. Everything, including text and images, is represented in binary. In the “old days,” before computer programming languages were available, programmers had to use sequences of binary digits to communicate directly with the computer. Today’s high level languages attempt to shield us from having to deal with binary at all. However, there are a few reasons why it’s important for programmers to understand the binary number system: 1.
  • Appendix D an Alternative to RISC: the Intel 80X86

    Appendix D an Alternative to RISC: the Intel 80X86

    D.1 Introduction D-2 D.2 80x86 Registers and Data Addressing Modes D-3 D.3 80x86 Integer Operations D-6 D.4 80x86 Floating-Point Operations D-10 D.5 80x86 Instruction Encoding D-12 D.6 Putting It All Together: Measurements of Instruction Set Usage D-14 D.7 Concluding Remarks D-20 D.8 Historical Perspective and References D-21 D An Alternative to RISC: The Intel 80x86 The x86 isn’t all that complex—it just doesn’t make a lot of sense. Mike Johnson Leader of 80x86 Design at AMD, Microprocessor Report (1994) © 2003 Elsevier Science (USA). All rights reserved. D-2 I Appendix D An Alternative to RISC: The Intel 80x86 D.1 Introduction MIPS was the vision of a single architect. The pieces of this architecture fit nicely together and the whole architecture can be described succinctly. Such is not the case of the 80x86: It is the product of several independent groups who evolved the architecture over 20 years, adding new features to the original instruction set as you might add clothing to a packed bag. Here are important 80x86 milestones: I 1978—The Intel 8086 architecture was announced as an assembly language– compatible extension of the then-successful Intel 8080, an 8-bit microproces- sor. The 8086 is a 16-bit architecture, with all internal registers 16 bits wide. Whereas the 8080 was a straightforward accumulator machine, the 8086 extended the architecture with additional registers. Because nearly every reg- ister has a dedicated use, the 8086 falls somewhere between an accumulator machine and a general-purpose register machine, and can fairly be called an extended accumulator machine.
  • Historical Perspective and Further Reading 162.E1

    Historical Perspective and Further Reading 162.E1

    2.21 Historical Perspective and Further Reading 162.e1 2.21 Historical Perspective and Further Reading Th is section surveys the history of in struction set architectures over time, and we give a short history of programming languages and compilers. ISAs include accumulator architectures, general-purpose register architectures, stack architectures, and a brief history of ARMv7 and the x86. We also review the controversial subjects of high-level-language computer architectures and reduced instruction set computer architectures. Th e history of programming languages includes Fortran, Lisp, Algol, C, Cobol, Pascal, Simula, Smalltalk, C+ + , and Java, and the history of compilers includes the key milestones and the pioneers who achieved them. Accumulator Architectures Hardware was precious in the earliest stored-program computers. Consequently, computer pioneers could not aff ord the number of registers found in today’s architectures. In fact, these architectures had a single register for arithmetic instructions. Since all operations would accumulate in one register, it was called the accumulator , and this style of instruction set is given the same name. For example, accumulator Archaic EDSAC in 1949 had a single accumulator. term for register. On-line Th e three-operand format of RISC-V suggests that a single register is at least two use of it as a synonym for registers shy of our needs. Having the accumulator as both a source operand and “register” is a fairly reliable indication that the user the destination of the operation fi lls part of the shortfall, but it still leaves us one has been around quite a operand short. Th at fi nal operand is found in memory.
  • Computer Architecture Research with RISC-‐V

    Computer Architecture Research with RISC-‐V

    Computer Architecture Research with RISC-V Krste Asanovic UC Berkeley, RISC-V Foundaon, & SiFive Inc. [email protected] www.riscv.org CARRV, Boston, MA October 14, 2017 Only Two Big Mistakes Possible when Picking Research ISA § Design your own § Use someone else’s Promise of using commercially popular ISAs for research § Ported applicaons/workloads to study § Standard soRware stacks (compilers, OS) § Real commercial hardware to experiment with § Real commercial hardware to validate models with § ExisAng implementaons to study / modify § Industry is more interested in your results 3 Types of projects and standard ISAs used by me or my group in last 30 years § Experiments on real hardware plaorms: - Transputer arrays, SPARC workstaons, MIPS workstaons, POWER workstaons, ARMv7 handhelds, x86 desktops/ servers § Research chips built around modified MIPS ISA: - T0, IRAM, STC1, Scale, Maven § FPGA prototypes/simulaons using various ISAs: - RAMP Blue (modified Microblaze), RAMP Gold/ DIABLO (SPARC v8) § Experiments using soRware architectural simulators: - SimpleScalar (PISA), SMTsim (Alpha), Simics (SPARC,x86), Bochs (x86), MARSS (x86), Gem5(SPARC), PIN (Itanium, x86), … § And of course, other groups used some others too. RealiMes of using standard ISAs § Everything only works if you don’t change anything - Stock binary applicaons - Stock libraries - Stock compiler - Stock OS - Stock hardware implementaon § Add a new instrucAon, get a new non-standard ISA! - Need source code for the apps and recompile - Impossible for most real interesAng applicaons
  • Computer Organization & Architecture Eie

    Computer Organization & Architecture Eie

    COMPUTER ORGANIZATION & ARCHITECTURE EIE 411 Course Lecturer: Engr Banji Adedayo. Reg COREN. The characteristics of different computers vary considerably from category to category. Computers for data processing activities have different features than those with scientific features. Even computers configured within the same application area have variations in design. Computer architecture is the science of integrating those components to achieve a level of functionality and performance. It is logical organization or designs of the hardware that make up the computer system. The internal organization of a digital system is defined by the sequence of micro operations it performs on the data stored in its registers. The internal structure of a MICRO-PROCESSOR is called its architecture and includes the number lay out and functionality of registers, memory cell, decoders, controllers and clocks. HISTORY OF COMPUTER HARDWARE The first use of the word ‘Computer’ was recorded in 1613, referring to a person who carried out calculation or computation. A brief History: Computer as we all know 2day had its beginning with 19th century English Mathematics Professor named Chales Babage. He designed the analytical engine and it was this design that the basic frame work of the computer of today are based on. 1st Generation 1937-1946 The first electronic digital computer was built by Dr John V. Atanasoff & Berry Cliford (ABC). In 1943 an electronic computer named colossus was built for military. 1946 – The first general purpose digital computer- the Electronic Numerical Integrator and computer (ENIAC) was built. This computer weighed 30 tons and had 18,000 vacuum tubes which were used for processing.
  • A Developer's Guide to the POWER Architecture

    A Developer's Guide to the POWER Architecture

    http://www.ibm.com/developerworks/linux/library/l-powarch/ 7/26/2011 10:53 AM English Sign in (or register) Technical topics Evaluation software Community Events A developer's guide to the POWER architecture POWER programming by the book Brett Olsson , Processor architect, IBM Anthony Marsala , Software engineer, IBM Summary: POWER® processors are found in everything from supercomputers to game consoles and from servers to cell phones -- and they all share a common architecture. This introduction to the PowerPC application-level programming model will give you an overview of the instruction set, important registers, and other details necessary for developing reliable, high performing POWER applications and maintaining code compatibility among processors. Date: 30 Mar 2004 Level: Intermediate Also available in: Japanese Activity: 22383 views Comments: The POWER architecture and the application-level programming model are common across all branches of the POWER architecture family tree. For detailed information, see the product user's manuals available in the IBM® POWER Web site technical library (see Resources for a link). The POWER architecture is a Reduced Instruction Set Computer (RISC) architecture, with over two hundred defined instructions. POWER is RISC in that most instructions execute in a single cycle and typically perform a single operation (such as loading storage to a register, or storing a register to memory). The POWER architecture is broken up into three levels, or "books." By segmenting the architecture in this way, code compatibility can be maintained across implementations while leaving room for implementations to choose levels of complexity for price/performances trade-offs. The levels are: Book I.
  • Computer Organization EECC 550 • Introduction: Modern Computer Design Levels, Components, Technology Trends, Register Transfer Week 1 Notation (RTN)

    Computer Organization EECC 550 • Introduction: Modern Computer Design Levels, Components, Technology Trends, Register Transfer Week 1 Notation (RTN)

    Computer Organization EECC 550 • Introduction: Modern Computer Design Levels, Components, Technology Trends, Register Transfer Week 1 Notation (RTN). [Chapters 1, 2] • Instruction Set Architecture (ISA) Characteristics and Classifications: CISC Vs. RISC. [Chapter 2] Week 2 • MIPS: An Example RISC ISA. Syntax, Instruction Formats, Addressing Modes, Encoding & Examples. [Chapter 2] • Central Processor Unit (CPU) & Computer System Performance Measures. [Chapter 4] Week 3 • CPU Organization: Datapath & Control Unit Design. [Chapter 5] Week 4 – MIPS Single Cycle Datapath & Control Unit Design. – MIPS Multicycle Datapath and Finite State Machine Control Unit Design. Week 5 • Microprogrammed Control Unit Design. [Chapter 5] – Microprogramming Project Week 6 • Midterm Review and Midterm Exam Week 7 • CPU Pipelining. [Chapter 6] • The Memory Hierarchy: Cache Design & Performance. [Chapter 7] Week 8 • The Memory Hierarchy: Main & Virtual Memory. [Chapter 7] Week 9 • Input/Output Organization & System Performance Evaluation. [Chapter 8] Week 10 • Computer Arithmetic & ALU Design. [Chapter 3] If time permits. Week 11 • Final Exam. EECC550 - Shaaban #1 Lec # 1 Winter 2005 11-29-2005 Computing System History/Trends + Instruction Set Architecture (ISA) Fundamentals • Computing Element Choices: – Computing Element Programmability – Spatial vs. Temporal Computing – Main Processor Types/Applications • General Purpose Processor Generations • The Von Neumann Computer Model • CPU Organization (Design) • Recent Trends in Computer Design/performance • Hierarchy
  • Exposing Native Device Apis to Web Apps

    Exposing Native Device Apis to Web Apps

    Exposing Native Device APIs to Web Apps Arno Puder Nikolai Tillmann Michał Moskal San Francisco State University Microsoft Research Microsoft Research Computer Science One Microsoft Way One Microsoft Way Department Redmond, WA 98052 Redmond, WA 98052 1600 Holloway Avenue [email protected] [email protected] San Francisco, CA 94132 [email protected] ABSTRACT language of the respective platform, HTML5 technologies A recent survey among developers revealed that half plan to gain traction for the development of mobile apps [12, 4]. use HTML5 for mobile apps in the future. An earlier survey A recent survey among developers revealed that more than showed that access to native device APIs is the biggest short- half (52%) are using HTML5 technologies for developing mo- coming of HTML5 compared to native apps. Several dif- bile apps [22]. HTML5 technologies enable the reuse of the ferent approaches exist to overcome this limitation, among presentation layer and high-level logic across multiple plat- them cross-compilation and packaging the HTML5 as a na- forms. However, an earlier survey [21] on cross-platform tive app. In this paper we propose a novel approach by using developer tools revealed that access to native device APIs a device-local service that runs on the smartphone and that is the biggest shortcoming of HTML5 compared to native acts as a gateway to the native layer for HTML5-based apps apps. Several different approaches exist to overcome this running inside the standard browser. WebSockets are used limitation. Besides the development of native apps for spe- for bi-directional communication between the web apps and cific platforms, popular approaches include cross-platform the device-local service.
  • Cloud Native Trail Map 2

    Cloud Native Trail Map 2

    1. CONTAINERIZATION • Commonly done with Docker containers • Any size application and dependencies (even PDP-11 code running on an emulator) can be containerized • Over time, you should aspire towards splitting suitable applications and writing future functionality as microservices CLOUD NATIVE TRAIL MAP 2. CI/CD • Setup Continuous Integration/Continuous Delivery (CI/CD) so The Cloud Native Landscape l.cncf.io that changes to your source code automatically result in a new has a large number of options. This Cloud container being built, tested, and deployed to staging and Native Trail Map is a recommended process eventually, perhaps, to production for leveraging open source, cloud native • Setup automated rollouts, roll backs and testing technologies. At each step, you can choose • Argo is a set of Kubernetes-native tools for a vendor-supported offering or do it yourself, deploying and running jobs, applications, and everything after step #3 is optional workflows, and events using GitOps based on your circumstances. 3. ORCHESTRATION & paradigms such as continuous and progressive delivery and MLops CNCF Incubating APPLICATION DEFINITION HELP ALONG THE WAY • Kubernetes is the market-leading orchestration solution • You should select a Certified Kubernetes Distribution, 4. OBSERVABILITY & ANALYSIS Hosted Platform, or Installer: cncf.io/ck A. Training and Certification • Helm Charts help you define, install, and upgrade • Pick solutions for monitoring, logging and tracing Consider training offerings from CNCF even the most complex Kubernetes application • Consider CNCF projects Prometheus for monitoring, and then take the exam to become a Fluentd for logging and Jaeger for Tracing Certified Kubernetes Administrator or a • For tracing, look for an OpenTracing-compatible Certified Kubernetes Application Developer implementation like Jaeger cncf.io/training CNCF Graduated CNCF Graduated B.
  • Phaser 600 Color Printer User Manual

    Phaser 600 Color Printer User Manual

    WELCOME! This is the home page of the Phaser 600 Color Printer User Manual. See Tips on using this guide, or go immediately to the Contents. Phaser® 600 Wide-Format Color Printer Tips on using this guide ■ Use the navigation buttons in Acrobat Reader to move through the document: 1 23 4 5 6 1 and 4 are the First Page and Last Page buttons. These buttons move to the first or last page of a document. 2 and 3 are the Previous Page and Next Page buttons. These buttons move the document backward or forward one page at a time. 5 and 6 are the Go Back and Go Forward buttons. These buttons let you retrace your steps through a document, moving to each page or view in the order visited. ■ For best results, use the Adobe Acrobat Reader version 2.1 to read this guide. Version 2.1 of the Acrobat Reader is supplied on your printer’s CD-ROM. ■ Click on the page numbers in the Contents on the following pages to open the topics you want to read. ■ You can click on the page numbers following keywords in the Index to open topics of interest. ■ You can also use the Bookmarks provided by the Acrobat Reader to navigate through this guide. If the Bookmarks are not already displayed at the left of the window, select Bookmarks and Page from the View menu. ■ If you have difficultly reading any small type or seeing the details in any of the illustrations, you can use the Acrobat Reader’s Magnification feature.