DOCSLIB.ORG

LWN: Porting Device Drivers to the 2.6 Kernel

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
LWN: Porting Device Drivers to the 2.6 Kernel LWN: Porting device drivers to the 2.6 kernel Home Weekly edition Kernel Security Distributions Archives Search Penguin Gallery Calendar LWN.net FAQ Subscriptions Advertise Write for LWN Contact us Privacy Porting device drivers to the 2.6 kernel The 2.6 kernel contains a long list of changes which affect device driver writers. As part of the task of porting the Linux Device Drivers sample code to 2.6, your humble LWN Kernel Page author is producing a set of articles describing the changes which must be made. The articles are Kernel Page as they are written; they will also be collected here. With luck, this page will be a useful reference for those who must port drivers to the new kernel. The creation of these articles is funded by LWN.net subscribers. If you find this material useful, please consider subscribing to LWN to help ensure that more of it gets written. Except when otherwise specified, all of the articles below are written by LWN editor Jonathan Corbet. The date and kernel version attached to each article notes when the article was last updated. Recent changes The most recent changes to this series are: • (November 25, 2003) The entire set of articles has been updated to reflect the 2.6.0−test10 kernel. • (Oct. 29, 2003) Examining a kobject hierarchy added. • (Oct. 23, 2003) kobject and sysfs added. • (Oct. 7, 2003) kobjects and hotplug events added. • (Oct. 1, 2003) The zen of kobjects added. • Getting started Porting 'hello world' (February, 2003); which covers the changes required to update the simplest possible module to the 2.5 kernel. Compiling external modules (November, 2003; 2.6.0−test9); how to build modules with the new module loader and kernel build scheme. More module changes (November, 2003, 2.6.0−test9) covers other changes to the module loading subsystem, including module parameters, use count management, exporting symbols, and more. Miscellaneous changes is a collection point for changes which are too small to justify their own article. Currently covered topics include kdev_t, designated initializers, and min() and max(). It was last updated on November 3, 2003 (2.6.0−test9). Porting device drivers to the 2.6 kernel 1 LWN: Porting device drivers to the 2.6 kernel Support interfaces Char drivers and large dev_t (November 2003, 2.6.0−test9); registration and management of char drivers in the new, large dev_t environment. The seq_file interface (September 2003; 2.6.0−test6); the easy way to implement virtual files correctly. A standalone example module is provided to demonstrate the use of this interface. Low−level memory allocation (November, 2003; 2.6.0−test9); changes to functions for allocating chunks of memory and pages, and a description of the new mempool interface. Per−CPU variables (November, 2003; 2.6.0−test9); the 2.6 interface for maintaining per−CPU data structures. Timekeeping changes (November, 2003; 2.6.0−test9); changes to how the kernel manages time and time−related events. The workqueue interface (November, 2003; 2.6.0−test9); a description of the new deferred execution mechanism which replaces task queues (and bottom halves in general). Creating virtual filesystems with libfs (November, 2003; 2.6.0−test9). This article, which looks at how a kernel module can create its own virtual filesystem, predates the driver porting series but fits in well with it. DMA Changes (November, 2003, 2.6.0−test9); changes to the DMA support layer. There is also a quick reference page for the new generic DMA API. Sleeping and mutual exclusion Mutual exclusion with seqlocks (November, 2003, 2.6.0−test9); a description of how to use the seqlock (formerly frlock) capability which was merged into 2.5.60. The preemptible kernel (November, 2003; 2.6.0−test9); a look at how kernel preemption affects driver code and what can be done to work safely in the preemptible environment. Sleeping and waking up (November, 2003; 2.6.0−test9); new ways of putting processes to sleep with better performance and without race conditions. Completion events (November, 2003; 2.6.0−test9); documentation for the completion event mechanism. Using read−copy−update (November, 2003; 2.6.0−test9); working with the read−copy−update mutual exclusion scheme. Advanced driver tasks Dealing with interrupts (November, 2003; 2.6.0−test9); interrupt handling changes which are visible to device drivers. Supporting asynchronous I/O (November, 2003; 2.6.0−test9); how to write drivers which support the 2.6 asynchronous I/O interface. Support interfaces 2 LWN: Porting device drivers to the 2.6 kernel Network drivers (November 2003, 2.6.0−test9); porting network drivers, with an emphasis on the new dynamic net_device allocation functions and NAPI support. USB driver API changes (July 2003; 2.5.75); how USB drivers have changed in the 2.5 development series. This article was contributed by USB maintainer Greg Kroah−Hartman. Block drivers Block layer overview (November, 2003; 2.6.0−test9). The block layer has seen extensive changes in the 2.5 development series; this article gives an overview of what has been done while deferring the details for subsequent articles. A simple block driver (November, 2003; 2.6.0−test9); this article presents the simplest possible block driver (a basic ramdisk implementation) with discussion of how the basic block interfaces have changed in 2.6. Full source to a working driver is included. The gendisk interface (November, 2003; 2.6.0−test9); how to work with the new generic disk interface, which takes on a rather larger role in 2.6. The BIO structure (November, 2003; 2.6.0−test9); the new low−level structure representing block I/O operations. Request queues I (November, 2003; 2.6.0−test9); the basics of block request queues in 2.6, including request processing, request preparation control, and DMA support. Request queues II (November, 2003, 2.6.0−test9); advanced request queue topics, including command preparation, tagged command queueing, and the "make request" mode of operation. Memory management Supporting mmap() (November, 2003 − 2.6.0−test9); changes in how device drivers support the mmap() system call. Zero−copy user−space access (November, 2003 − 2.6.0−test9); how to get direct−access to user space to perform zero−copy I/O. If you used the kiobuf interface for this purpose in 2.4, you'll want to look here for the 2.6 equivalent. Atomic kmaps (November, 2003; 2.6.0−test9); quick access to high−memory via kmap_atomic(). Device model A device model overview (November, 2003; 2.6.0−test10); an introductory look at the Linux device model and sysfs, with definitions of some commonly encountered terms. The zen of kobjects (October, 2003; 2.6.0−test6); an attempt to demystify the kobject abstraction and its use in the kernel. kobjects and sysfs (October, 2003; 2.6.0−test8); a description of the interaction between the kobject type and its representation in sysfs. Block drivers 3 LWN: Porting device drivers to the 2.6 kernel kobjects and hotplug events (October, 2003; 2.6.0−test6); an explanation of the kset hotplug operations and how they can be used to control how hotplug events are reported to user space. This article was written by Greg Kroah−Hartman. Examining a kobject hierarchy (October, 2003; 2.6.0−test9); a visual exploration of the device model data structures behind /sys/block. Device classes (November, 2003; 2.6.0−test10); how the device class mechanism works. Post a comment Porting device drivers to the 2.5 kernel (Posted Feb 12, 2003 1:55 UTC (Wed) by fdesloges) (Post reply) Wow! This is highly valuable stuff. Are you certain you want to give this away for free after only a few days ? This alone would be a very good reason to subscribe. And as reference stuff it will still be valuable many months down the road. Maybe it could fit in a "available to non−subsciber 4 months later" category ? Or make only a few articles available (and the index of course to hook subscribers) ? Whatever you do, thanks! FD Porting device drivers to the 2.5 kernel (Posted Feb 12, 2003 9:58 UTC (Wed) by KotH) (Post reply) I wouldnt do that. LWN has a very good reputation as information source around the open source community. A "closed for all but subscribed ppl" policy would surely destroy that reputation. Yes, i know that LWN doesnt have as much subscribers as it should have :( but this is IMHO not the right way to get more. Porting device drivers to the 2.5 kernel (Posted Feb 12, 2003 11:00 UTC (Wed) by bruno) (Post reply) Do you work for nothing? Do you give all your time to other in exchange of nothing? You can't pretend that other people do that, the people have childrens, wives, mortgages... and work in exchange of money to pay their bills. Sometimes you have a bussiness plan that lets you to give away your work and get money from other sources, sometimes you need to put a price or close the shop. Block drivers 4 LWN: Porting device drivers to the 2.6 kernel Porting device drivers to the 2.5 kernel (Posted Feb 12, 2003 14:14 UTC (Wed) by Webexcess) (Post reply) Do you work for nothing? Do you give all your time to other in exchange of nothing? I think you're oversimplifying a bit. The excellent writing at lwn.net is both its product and its advertising. How will potential subscribers be enticed if they can't see what lwn.net has to offer? Also, the target audience largely consists of enthusiasts, many of whom are students and/or live in parts of the world where american dollars are very expensive.
Load more

Recommended publications
  • Undefined Behaviour in the C Language
    FAKULTA INFORMATIKY, MASARYKOVA UNIVERZITA Undefined Behaviour in the C Language BAKALÁŘSKÁ PRÁCE Tobiáš Kamenický Brno, květen 2015 Declaration Hereby I declare, that this paper is my original authorial work, which I have worked out by my own. All sources, references, and literature used or excerpted during elaboration of this work are properly cited and listed in complete reference to the due source. Vedoucí práce: RNDr. Adam Rambousek ii Acknowledgements I am very grateful to my supervisor Miroslav Franc for his guidance, invaluable help and feedback throughout the work on this thesis. iii Summary This bachelor’s thesis deals with the concept of undefined behavior and its aspects. It explains some specific undefined behaviors extracted from the C standard and provides each with a detailed description from the view of a programmer and a tester. It summarizes the possibilities to prevent and to test these undefined behaviors. To achieve that, some compilers and tools are introduced and further described. The thesis contains a set of example programs to ease the understanding of the discussed undefined behaviors. Keywords undefined behavior, C, testing, detection, secure coding, analysis tools, standard, programming language iv Table of Contents Declaration ................................................................................................................................ ii Acknowledgements .................................................................................................................. iii Summary .................................................................................................................................
    [Show full text]
  • ACCU 2015 “New” Features in C
    "New" Features in C ACCU 2015 “New” Features in C Dan Saks Saks & Associates www.dansaks.com 1 Abstract The first international standard for the C programming language was C90. Since then, two newer standards have been published, C99 and C11. C99 introduced a significant number of new features. C11 introduced a few more, some of which have been available in compilers for some time. Curiously, many of these added features don’t seem to have caught on. Many C programmers still program in C90. This session explains many of these “new” features, including declarations in for-statements, typedef redefinitions, inline functions, complex arithmetic, extended integer types, variable- length arrays, flexible array members, compound literals, designated initializers, restricted pointers, type-qualified array parameters, anonymous structures and unions, alignment support, non-returning functions, and static assertions. 2 Copyright © 2015 by Daniel Saks 1 "New" Features in C About Dan Saks Dan Saks is the president of Saks & Associates, which offers training and consulting in C and C++ and their use in developing embedded systems. Dan has written columns for numerous print publications including The C/C++ Users Journal , The C++ Report , Software Development , and Embedded Systems Design . He currently writes the online “Programming Pointers” column for embedded.com . With Thomas Plum, he wrote C++ Programming Guidelines , which won a 1992 Computer Language Magazine Productivity Award . He has also been a Microsoft MVP. Dan has taught thousands of programmers around the world. He has presented at conferences such as Software Development and Embedded Systems , and served on the advisory boards for those conferences.
    [Show full text]
  • Software II: Principles of Programming Languages
    Software II: Principles of Programming Languages Lecture 6 – Data Types Some Basic Definitions • A data type defines a collection of data objects and a set of predefined operations on those objects • A descriptor is the collection of the attributes of a variable • An object represents an instance of a user- defined (abstract data) type • One design issue for all data types: What operations are defined and how are they specified? Primitive Data Types • Almost all programming languages provide a set of primitive data types • Primitive data types: Those not defined in terms of other data types • Some primitive data types are merely reflections of the hardware • Others require only a little non-hardware support for their implementation The Integer Data Type • Almost always an exact reflection of the hardware so the mapping is trivial • There may be as many as eight different integer types in a language • Java’s signed integer sizes: byte , short , int , long The Floating Point Data Type • Model real numbers, but only as approximations • Languages for scientific use support at least two floating-point types (e.g., float and double ; sometimes more • Usually exactly like the hardware, but not always • IEEE Floating-Point Standard 754 Complex Data Type • Some languages support a complex type, e.g., C99, Fortran, and Python • Each value consists of two floats, the real part and the imaginary part • Literal form real component – (in Fortran: (7, 3) imaginary – (in Python): (7 + 3j) component The Decimal Data Type • For business applications (money)
    [Show full text]
  • Intel ® Fortran Programmer's Reference
    ® Intel Fortran Programmer’s Reference Copyright © 1996-2003 Intel Corporation All Rights Reserved Issued in U.S.A. Version Number: FWL-710-02 World Wide Web: http://developer.intel.com Information in this document is provided in connection with Intel products. No license, express or implied, by estoppel or otherwise, to any intellectual property rights is granted by this document. EXCEPT AS PROVIDED IN INTEL’S TERMS AND CONDITIONS OF SALE FOR SUCH PRODUCTS, INTEL ASSUMES NO LIABILITY WHATSO- EVER, AND INTEL DISCLAIMS ANY EXPRESS OR IMPLIED WARRANTY, RELATING TO SALE AND/OR USE OF INTEL PRODUCTS INCLUDING LIABILITY OR WARRANTIES RELATING TO FITNESS FOR A PAR- TICULAR PURPOSE, MERCHANTABILITY, OR INFRINGEMENT OF ANY PATENT, COPYRIGHT OR OTHER INTELLECTUAL PROPERTY RIGHT. Intel products are not intended for use in medical, life saving, or life sustaining applications. This Intel® Fortran Programmer’s Reference as well as the software described in it is furnished under license and may only be used or copied in accordance with the terms of the license. The information in this manual is furnished for infor- mational use only, is subject to change without notice, and should not be construed as a commitment by Intel Corpora- tion. Intel Corporation assumes no responsibility or liability for any errors or inaccuracies that may appear in this document or any software that may be provided in association with this document. Designers must not rely on the absence or characteristics of any features or instructions marked "reserved" or "unde- fined." Intel reserves these for future definition and shall have no responsibility whatsoever for conflicts or incompatibil- ities arising from future changes to them.
    [Show full text]
  • Eliminating Scope and Selection Restrictions in Compiler Optimizations
    ELIMINATING SCOPE AND SELECTION RESTRICTIONS IN COMPILER OPTIMIZATION SPYRIDON TRIANTAFYLLIS ADISSERTATION PRESENTED TO THE FACULTY OF PRINCETON UNIVERSITY IN CANDIDACY FOR THE DEGREE OF DOCTOR OF PHILOSOPHY RECOMMENDED FOR ACCEPTANCE BY THE DEPARTMENT OF COMPUTER SCIENCE SEPTEMBER 2006 c Copyright by Spyridon Triantafyllis, 2006. All Rights Reserved Abstract To meet the challenges presented by the performance requirements of modern architectures, compilers have been augmented with a rich set of aggressive optimizing transformations. However, the overall compilation model within which these transformations operate has remained fundamentally unchanged. This model imposes restrictions on these transforma- tions’ application, limiting their effectiveness. First, procedure-based compilation limits code transformations within a single proce- dure’s boundaries, which may not present an ideal optimization scope. Although aggres- sive inlining and interprocedural optimization can alleviate this problem, code growth and compile time considerations limit their applicability. Second, by applying a uniform optimization process on all codes, compilers cannot meet the particular optimization needs of each code segment. Although the optimization process is tailored by heuristics that attempt to a priori judge the effect of each transfor- mation on final code quality, the unpredictability of modern optimization routines and the complexity of the target architectures severely limit the accuracy of such predictions. This thesis focuses on removing these restrictions through two novel compilation frame- work modifications, Procedure Boundary Elimination (PBE) and Optimization-Space Ex- ploration (OSE). PBE forms compilation units independent of the original procedures. This is achieved by unifying the entire application into a whole-program control-flow graph, allowing the compiler to repartition this graph into free-form regions, making analysis and optimization routines able to operate on these generalized compilation units.
    [Show full text]
  • C and C++ Programming for the Vector Processor
    C AND C++ PROGRAMMING FOR THE VECTOR PROCESSOR Geir Johansen, Cray Inc., Mendota Heights, Minnesota, USA Abstract: The Cray Standard C and C++ compilers have the ability to perform many types of optimizations to improve the performance of the code. This paper outlines strategies for C and C++ programming that will give the Cray Standard C and C++ compilers a greater opportunity to generate optimized code. 1.0 Scope of the Paper PDGCS (Program Dependence Graph Compiling System) is the area of the compiler The purpose of this is to give guidance to C that performs most of the optimization of the and C++ developers in writing code, so that the code. PDGCS has been a part of the compiler Cray compiler will produce better optimized since the Cray YMP. The Cray C/C++ compiler code. An algorithm can be coded in several greatly benefits from the fact that PDGCS is also different ways; however, the Cray compiler can the backend for the Cray Fortran compiler. The more easily optimize certain styles of coding. Cray C/C++ compiler leverages the extensive The more optimization that is initially performed testing and development to PDGCS for the Cray by the compiler, the less time the user needs to Fortran compiler. Optimizations that PDGCS spend on analyzing and manually optimizing the perform include: code. The paper is not intended for a specific Cray architecture, so in general, machine specific ∑ Reduction loops optimization issues such as memory contention ∑ Loop fusing are not discussed. Also, the paper does not ∑ Loop unrolling discuss optimization techniques, such as loop ∑ Loop unwinding fusing, that can be performed by the compiler.
    [Show full text]
  • Towards Restrict-Like Aliasing Semantics for C++ Abstract
    Document Number: N3988 Date: 2014-05-23 Authors: Hal Finkel, [email protected] Hubert Tong, [email protected] Chandler Carruth, [email protected], Clark Nelson, [email protected], Daveed Vandevoode, [email protected], Michael Wong, [email protected] Project: Programming Language C++, EWG Reply to: [email protected] Revision: 1 Towards restrict-like aliasing semantics for C++ Abstract This paper is a follow-on to N3635 after a design discussion with many compiler implementers at Issaquah, and afterwards by telecon, and specifically proposes a new alias_set attribute as a way to partition type-based aliasing to enable more fine grain control, effectively giving C++ a more complete restrict-like aliasing syntax and semantics. Changes from previous papers: N3988: this paper updates with syntax and semantics N3635: Outlined initial idea on AliasGroup which became alias_set. The alternative of newType was rejected as too heavy weight of a solution. 1. Problem Domain There is no question that the restrict qualifier benefits compiler optimization in many ways, notably allowing improved code motion and elimination of loads and stores. Since the introduction of C99 restrict, it has been provided as a C++ extension in many compilers. But the feature is brittle in C++ without clear rules for C++ syntax and semantics. Now with the introduction of C++11, functors are being replaced with lambdas and users have begun asking how to use restrict in the presence of lambdas. Given the existing compiler support, we need to provide a solution with well-defined C++ semantics, before use of some common subset of C99 restrict becomes widely used in combination with C++11 constructs.
    [Show full text]
  • TMS320C6000 Optimizing Compiler V8.2.X User's Guide (Rev. B)
    TMS320C6000 Optimizing Compiler v8.2.x User's Guide Literature Number: SPRUI04B May 2017 Contents Preface....................................................................................................................................... 11 1 Introduction to the Software Development Tools.................................................................... 14 1.1 Software Development Tools Overview ................................................................................. 15 1.2 Compiler Interface.......................................................................................................... 16 1.3 ANSI/ISO Standard ........................................................................................................ 16 1.4 Output Files ................................................................................................................. 17 1.5 Utilities ....................................................................................................................... 17 2 Getting Started with the Code Generation Tools .................................................................... 18 2.1 How Code Composer Studio Projects Use the Compiler ............................................................. 18 2.2 Compiling from the Command Line ..................................................................................... 19 3 Using the C/C++ Compiler ................................................................................................... 20 3.1 About the Compiler........................................................................................................
    [Show full text]
  • C User's Guide
    C User’s Guide SunSoft, Inc. A Sun Microsystems, Inc. Business 2550 Garcia Avenue Mountain View, CA 94043 USA 415 960-1300 fax 415 969-9131 Part No.: 802-5777-10 Revision A, December 1996 Copyright 1996 Sun Microsystems, Inc., 2550 Garcia Avenue, Mountain View, California 94043-1100 U.S.A. All rights reserved. This product or document is protected by copyright and distributed under licenses restricting its use, copying, distribution, and decompilation. No part of this product or document may be reproduced in any form by any means without prior written authorization of Sun and its licensors, if any. Portions of this product may be derived from the UNIX® system, licensed from Novell, Inc., and from the Berkeley 4.3 BSD system, licensed from the University of California. UNIX is a registered trademark in the United States and other countries and is exclusively licensed by X/Open Company Ltd. Third-party software, including font technology in this product, is protected by copyright and licensed from Sun’s suppliers. RESTRICTED RIGHTS: Use, duplication, or disclosure by the U.S. Government is subject to restrictions of FAR 52.227- 14(g)(2)(6/87) and FAR 52.227-19(6/87), or DFAR 252.227-7015(b)(6/95) and DFAR 227.7202-3(a). Sun, Sun Microsystems, the Sun logo, SunSoft, Solaris, OpenWindows, and Sun WorkShop are trademarks or registered trademarks of Sun Microsystems, Inc. in the United States and other countries. All SPARC trademarks are used under license and are trademarks or registered trademarks of SPARC International, Inc. in the United States and other countries.
    [Show full text]
  • Type Qualifiers As Composable Language Extensions
    Type Qualifiers as Composable Language Extensions Travis Carlson Eric Van Wyk Computer Science and Engineering Computer Science and Engineering University of Minnesota University of Minnesota Minneapolis, MN, USA Minneapolis, MN, USA [email protected] [email protected] Abstract 1 Introduction and Motivation This paper reformulates type qualifiers as language exten- Type qualifiers in C and C++, such as const or restrict, sions that can be automatically and reliably composed. Type enable the programmer to disallow certain operations on qualifiers annotate type expressions to introduce new sub- qualified types and to indicate simple subtype relationships typing relations and are powerful enough to detect many between types. For example, only initializing assignments kinds of errors. Type qualifiers, as illustrated in our ableC are allowed on a variable declared with a const qualifier, extensible language framework for C, can introduce rich and a function with an argument declaration int *x cannot forms of concrete syntax, can generate dynamic checks on be passed a value of type const int * as this would allow data when static checks are infeasible or not appropriate, and changes to the const int via the pointer. The type int * inject code that affects the program’s behavior, for example is considered to be a subtype of const int *. for conversions of data or logging. In their seminal paper “A Theory of Type Qualifiers”, Fos- ableC language extensions to C are implemented as at- ter et al.[12] formalize this subtyping relationship and show tribute grammar fragments and provide an expressive mech- how user-defined type qualifiers can be added to a language anism for type qualifier implementations to check for ad- to perform additional kinds of checking.
    [Show full text]
  • Clarifying the Restrict Keyword Introduction Drafts of the Proposal
    Clarifying the restrict Keyword Doc. No.: WG14/N2237 Date: 2018-04-26 Author 1: Troy A. Johnson Email: [email protected] Author 2: Bill Homer Email: [email protected] Introduction Drafts of the proposal to add the restrict qualifier to the C standard contained more examples than were eventually included in the standard. The examples that were included were limited to cases in which all pointers were restricted, which are most helpful to a translator. The examples that were not included served to show what the formal definition implied in cases in which not all pointers were restricted. The absence of those additional examples may have been intended to avoid encouraging usages that are needlessly challenging for a translator, but they have also apparently lead to confusion about how to interpret the formal definition in such cases. That confusion has resulted in translators that infer non-aliasing in cases where the standard does not imply it, and so make unsafe optimizations. This proposal seeks to clarify the restrict keyword, both for programmers and for implementers of translators, by adding examples in which only a single pointer is restrict-qualified. They illustrate that the formal definition can effectively imply non-aliasing in such cases, but only with a careful analysis that considerably exceeds what is necessary for the examples currently in the standard. Accompanying text makes it clear that a translator may reasonably decline to attempt such analysis, and so programs meant to be portable should avoid relying on such usages. Problem Consider these functions: void f1(int *p, int *q) { ..
    [Show full text]
  • How to Use C/C++ Compiler for Vector Engine
    How to Use C/C++ Compiler for Vector Engine 2nd Edition, November 2019 1 © NEC Corporation 2019 Table of Contents How to Use C/C++ Compiler - Performance Analysis - Debugging Automatic Vectorization - Extended Vectorization Features - Program Tuning - Tuning Techniques - Notes on Using Vectorization Automatic Parallelization and OpenMP C/C++ - OpenMP Parallelization - Automatic Parallelization - Behavior of Parallelized Program - Tuning Parallelized Program - Notes on Using Parallelization The information disclosed in this document is the property of NEC Corporation (NEC) and/or its licensors. NEC and/or its licensors, as appropriate, reserve all patent, copyright and other proprietary rights to this document, including all design, manufacturing, reproduction, use and sales rights thereto, except to the extent said rights are expressly granted to others. The information in this document is subject to change at any time, without notice. In this document, “parallel processing” stands for automatic parallelization of compiler or shared memory parallel processing with OpenMP C/C++. All product, brand, or trade names in this publication are the trademarks or registered trademarks of their respective owners. NEC C/C++ Compiler for Vector Engine ▌Product Name: NEC C/C++ Compiler for Vector Engine Conforming Language Standards • ISO/IEC 9899:2011 Programming languages – C • ISO/IEC 14882:2014 Programming languages – C++ • OpenMP Version 4.5 Major Features • Automatic Vectorization • Automatic Parallelization and OpenMP C/C++ • Automatic Inline
    [Show full text]