Categories:
Audio (13)
Biotech (29)
Bytecode (36)
Database (77)
Framework (7)
Game (7)
General (507)
Graphics (53)
I/O (35)
IDE (2)
JAR Tools (101)
JavaBeans (21)
JDBC (121)
JDK (426)
JSP (20)
Logging (108)
Mail (58)
Messaging (8)
Network (84)
PDF (97)
Report (7)
Scripting (84)
Security (32)
Server (121)
Servlet (26)
SOAP (24)
Testing (54)
Web (15)
XML (309)
Collections:
Other Resources:
JDK 17 jdk.incubator.vector.jmod - JDK Incubator Vector
JDK 17 jdk.incubator.vector.jmod is the JMOD file for JDK 17 HTTP Server module.
JDK 17 Incubator Vector module compiled class files are stored in \fyicenter\jdk-17.0.5\jmods\jdk.incubator.vector.jmod.
JDK 17 Incubator Vector module compiled class files are also linked and stored in the \fyicenter\jdk-17.0.5\lib\modules JImage file.
JDK 17 Incubator Vector module source code files are stored in \fyicenter\jdk-17.0.5\lib\src.zip\jdk.incubator.vector.
You can click and view the content of each source code file in the list below.
✍: FYIcenter
⏎ jdk/incubator/vector/package-info.java
/* * Copyright (c) 2017, 2020, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * * * * * * * * * * * * * * * * * * * * */ /** * {@Incubating} * <p> * This package provides * classes to express vector computations that, given suitable hardware * and runtime ability, are accelerated using vector hardware instructions. * * <p> A {@linkplain Vector <em>vector</em>} is a * * <!-- The following paragraphs are shared verbatim * -- between Vector.java and package-info.java --> * sequence of a fixed number of <em>lanes</em>, * all of some fixed * {@linkplain Vector#elementType() <em>element type</em>} * such as {@code byte}, {@code long}, or {@code float}. * Each lane contains an independent value of the element type. * Operations on vectors are typically * <a href="Vector.html#lane-wise"><em>lane-wise</em></a>, * distributing some scalar operator (such as * {@linkplain Vector#add(Vector) addition}) * across the lanes of the participating vectors, * usually generating a vector result whose lanes contain the various * scalar results. When run on a supporting platform, lane-wise * operations can be executed in parallel by the hardware. This style * of parallelism is called <em>Single Instruction Multiple Data</em> * (SIMD) parallelism. * * <p> In the SIMD style of programming, most of the operations within * a vector lane are unconditional, but the effect of conditional * execution may be achieved using * <a href="Vector.html#masking"><em>masked operations</em></a> * such as {@link Vector#blend(Vector,VectorMask) blend()}, * under the control of an associated {@link VectorMask}. * Data motion other than strictly lane-wise flow is achieved using * <a href="Vector.html#cross-lane"><em>cross-lane</em></a> * operations, often under the control of an associated * {@link VectorShuffle}. * Lane data and/or whole vectors can be reformatted using various * kinds of lane-wise * {@linkplain Vector#convert(VectorOperators.Conversion,int) conversions}, * and byte-wise reformatting * {@linkplain Vector#reinterpretShape(VectorSpecies,int) reinterpretations}, * often under the control of a reflective {@link VectorSpecies} * object which selects an alternative vector format different * from that of the input vector. * * <p> {@code Vector<E>} declares a set of vector operations (methods) * that are common to all element types. These common operations * include generic access to lane values, data selection and movement, * reformatting, and certain arithmetic and logical operations (such as addition * or comparison) that are common to all primitive types. * * <p> <a href="Vector.html#subtypes">Public subtypes of {@code Vector}</a> * correspond to specific * element types. These declare further operations that are specific * to that element type, including unboxed access to lane values, * bitwise operations on values of integral element types, or * transcendental operations on values of floating point element * types. * * <p> Some lane-wise operations, such as the {@code add} operator, are defined as * a full-service named operation, where a corresponding method on {@code Vector} * comes in masked and unmasked overloadings, and (in subclasses) also comes in * covariant overrides (returning the subclass) and additional scalar-broadcast * overloadings (both masked and unmasked). * * Other lane-wise operations, such as the {@code min} operator, are defined as a * partially serviced (not a full-service) named operation, where a corresponding * method on {@code Vector} and/or a subclass provide some but all possible * overloadings and overrides (commonly the unmasked varient with scalar-broadcast * overloadings). * * Finally, all lane-wise operations (those named as previously described, * or otherwise unnamed method-wise) have a corresponding * {@link VectorOperators.Operator operator token} * declared as a static constant on {@link VectorOperators}. * Each operator token defines a symbolic Java expression for the operation, * such as {@code a + b} for the * {@link VectorOperators#ADD ADD} operator token. * General lane-wise operation-token accepting methods, such as for a * {@linkplain Vector#lanewise(VectorOperators.Unary) unary lane-wise} * operation, are provided on {@code Vector} and come in the same variants as * a full-service named operation. * * <p>This package contains a public subtype of {@link Vector} * corresponding to each supported element type: * {@link ByteVector}, {@link ShortVector}, * {@link IntVector}, {@link LongVector}, * {@link FloatVector}, and {@link DoubleVector}. * * <!-- The preceding paragraphs are shared verbatim * -- between Vector.java and package-info.java --> * * <p> * Here is an example of multiplying elements of two float arrays * {@code a} and {@code b} using vector computation * and storing result in array {@code c}. * * <pre>{@code * static final VectorSpecies<Float> SPECIES = FloatVector.SPECIES_PREFERRED; * * void vectorMultiply(float[] a, float[] b, float[] c) { * // It is assumed array arguments are of the same size * for (int i = 0; i < a.length; i += SPECIES.length()) { * VectorMask<Float> m = SPECIES.indexInRange(i, a.length); * FloatVector va = FloatVector.fromArray(SPECIES, a, i, m); * FloatVector vb = FloatVector.fromArray(SPECIES, b, i, m); * FloatVector vc = va.mul(vb) * vc.intoArray(c, i, m); * } * } * }</pre> * * In the above example, we use masks, generated by * {@link VectorSpecies#indexInRange indexInRange()}, * to prevent reading/writing past the array length. * The first {@code a.length / SPECIES.length()} iterations will have a mask * with all lanes set. Only the final iteration (if {@code a.length} * is not a multiple of {@code SPECIES.length()} will have a mask with * the first {@code a.length % SPECIES.length()} lanes set. * * Since a mask is used in all iterations, the above implementation * may not achieve optimal performance (for large array lengths). The * same computation can be implemented without masks as follows: * * <pre>{@code * static final VectorSpecies<Float> SPECIES = FloatVector.SPECIES_PREFERRED; * * void vectorMultiply(float[] a, float[] b, float[] c) { * int i = 0; * // It is assumed array arguments are of the same size * for (; i < SPECIES.loopBound(a.length); i += SPECIES.length()) { * FloatVector va = FloatVector.fromArray(SPECIES, a, i); * FloatVector vb = FloatVector.fromArray(SPECIES, b, i); * FloatVector vc = va.mul(vb) * vc.intoArray(c, i); * } * * for (; i < a.length; i++) { * c[i] = a[i] * b[i]; * } * } * }</pre> * * The scalar computation after the vector computation is required to * process a <em>tail</em> of {@code TLENGTH} array elements, where * {@code TLENGTH < SPECIES.length()} for the vector species. * * The examples above use the preferred species ({@code FloatVector.SPECIES_PREFERRED}), * ensuring code dynamically adapts to optimal shape for the platform * on which it runs. * * <p> The helper method {@link VectorSpecies#loopBound(int) loopBound()} * is used in the above code to find the end of the vector loop. * A primitive masking expression such as * {@code (a.length & ~(SPECIES.length() - 1))} might also be used * here, since {@code SPECIES.length()} is known to be 8, which * is a power of two. But this is not always a correct assumption. * For example, if the {@code FloatVector.SPECIES_PREFERRED} turns * out to have the platform-dependent shape * {@link VectorShape#S_Max_BIT S_Max_BIT}, * and that shape has some odd hypothetical size such as 384 (which is * a valid vector size according to some architectures), then the * hand-tweaked primitive masking expression may produce surprising * results. * * <h2> Performance notes </h2> * * This package depends on the runtime's ability to dynamically * compile vector operations into optimal vector hardware * instructions. There is a default scalar implementation for each * operation which is used if the operation cannot be compiled to * vector instructions. * * <p>There are certain things users need to pay attention to for * generating optimal vector machine code: * * <ul> * <li> The shape of vectors used should be supported by the underlying * platform. For example, code written using {@link IntVector} of * {@link VectorShape} {@link VectorShape#S_512_BIT S_512_BIT} will not be * compiled to vector instructions on a platform which supports only * 256 bit vectors. Instead, the default scalar implementation will be * used. For this reason, it is recommended to use the preferred * species as shown above to write generically sized vector * computations. * * <li> Most classes defined in this package should be treated as * <a href="{@docRoot}/java.base/java/lang/doc-files/ValueBased.html">value-based</a> classes. * This classification applies to {@link Vector} and its subtypes, * {@link VectorMask}, {@link VectorShuffle}, and {@link VectorSpecies}. * * With these types, * * <!-- The following paragraph is shared verbatim * -- between Vector.java and package-info.java --> * identity-sensitive operations such as {@code ==} may yield * unpredictable results, or reduced performance. Oddly enough, * {@link Vector#equals(Object) v.equals(w)} is likely to be faster * than {@code v==w}, since {@code equals} is <em>not</em> an identity * sensitive method. * * Also, these objects can be stored in locals and parameters and as * {@code static final} constants, but storing them in other Java * fields or in array elements, while semantically valid, will may * incur performance risks. * <!-- The preceding paragraph is shared verbatim * -- between Vector.java and package-info.java --> * * </ul> * * <p> * For every class in this package, * unless specified otherwise, any method arguments of reference * type must not be null, and any null argument will elicit a * {@code NullPointerException}. This fact is not individually * documented for methods of this API. */ package jdk.incubator.vector;
⏎ jdk/incubator/vector/package-info.java
Or download all of them as a single archive file:
File name: jdk.incubator.vector-17.0.5-src.zip File size: 350622 bytes Release date: 2022-09-13 Download
⇒ JDK 17 jdk.internal.ed.jmod - Internal Editor Module
2023-10-04, 4052👍, 0💬
Popular Posts:
JDK 11 jdk.hotspot.agent.jmod is the JMOD file for JDK 11 Hotspot Agent module. JDK 11 Hotspot Agent...
JDOM provides a solution for using XML from Java that is as simple as Java itself. There is no compe...
Apache Avalon began in 1999 as the Java Apache Server Framework and in late 2002 separated from the ...
Apache Log4j 1.2 Bridge allows applications coded to use Log4j 1.2 API to use Log4j 2 instead. Bytec...
What Is HttpComponents httpclient-4.2.2.jar? HttpComponents httpclient-4.2.2.jar is the JAR file for...