Package apple.metalperformanceshaders

Class MPSMatrixMultiplication

  • All Implemented Interfaces:
    NSCoding, NSCopying, NSSecureCoding, NSObject
    public class MPSMatrixMultiplication
extends MPSKernel
    MPSMatrixMultiplication [@dependency] This depends on Metal.framework. A matrix multiplication kernel. A MPSMatrixMultiplication object computes: C = alpha * op(A) * op(B) + beta * C A, B, and C are matrices which are represented by MPSMatrix objects. alpha and beta are scalar values (of the same data type as values of C) which are applied as shown above. A and B may each have an optional transposition operation applied. A, B, and C (also referred to in later discussions as the left input matrix, the right input matrix, and the result matrix respectively). A MPSMatrixMultiplication object is initialized with the transpose operators to apply to A and B, sizes for the operation to perform, and the scalar values alpha and beta.

    • Constructor Detail

      • MPSMatrixMultiplication

        protected MPSMatrixMultiplication​(org.moe.natj.general.Pointer peer)

    • Method Detail

      • accessInstanceVariablesDirectly

        public static boolean accessInstanceVariablesDirectly()

      • allocWithZone

        public static java.lang.Object allocWithZone​(org.moe.natj.general.ptr.VoidPtr zone)

      • automaticallyNotifiesObserversForKey

        public static boolean automaticallyNotifiesObserversForKey​(java.lang.String key)

      • cancelPreviousPerformRequestsWithTarget

        public static void cancelPreviousPerformRequestsWithTarget​(java.lang.Object aTarget)

      • cancelPreviousPerformRequestsWithTargetSelectorObject

        public static void cancelPreviousPerformRequestsWithTargetSelectorObject​(java.lang.Object aTarget,
                                                                         org.moe.natj.objc.SEL aSelector,
                                                                         java.lang.Object anArgument)

      • classFallbacksForKeyedArchiver

        public static NSArray<java.lang.String> classFallbacksForKeyedArchiver()

      • classForKeyedUnarchiver

        public static org.moe.natj.objc.Class classForKeyedUnarchiver()

      • debugDescription_static

        public static java.lang.String debugDescription_static()

      • description_static

        public static java.lang.String description_static()

      • hash_static

        public static long hash_static()

      • instanceMethodSignatureForSelector

        public static NSMethodSignature instanceMethodSignatureForSelector​(org.moe.natj.objc.SEL aSelector)

      • instancesRespondToSelector

        public static boolean instancesRespondToSelector​(org.moe.natj.objc.SEL aSelector)

      • isSubclassOfClass

        public static boolean isSubclassOfClass​(org.moe.natj.objc.Class aClass)

      • keyPathsForValuesAffectingValueForKey

        public static NSSet<java.lang.String> keyPathsForValuesAffectingValueForKey​(java.lang.String key)

      • new_objc

        public static java.lang.Object new_objc()

      • resolveClassMethod

        public static boolean resolveClassMethod​(org.moe.natj.objc.SEL sel)

      • resolveInstanceMethod

        public static boolean resolveInstanceMethod​(org.moe.natj.objc.SEL sel)

      • setVersion_static

        public static void setVersion_static​(long aVersion)

      • superclass_static

        public static org.moe.natj.objc.Class superclass_static()

      • version_static

        public static long version_static()

      • encodeToCommandBufferLeftMatrixRightMatrixResultMatrix

        public void encodeToCommandBufferLeftMatrixRightMatrixResultMatrix​(MTLCommandBuffer commandBuffer,
                                                                   MPSMatrix leftMatrix,
                                                                   MPSMatrix rightMatrix,
                                                                   MPSMatrix resultMatrix)
        Encode a MPSMatrixMultiplication object to a command buffer. Certain constraints apply to the sizes of the matrices depending on the transposition operations and sizes requested at initialization time as well as the origins at the time this routine is called: The left input matrix must be large enough to hold an array of size resultRows x interiorColumns elements beginning at leftMatrixOrigin. The right input matrix must be large enough to hold an array of size interiorColumns x resultColumns elements beginning at rightMatrixOrigin. The result matrix must be large enough to hold an array of size resultRows x resultColumns elements beginning at resultMatrixOrigin. Each matrix within the range specified by batchStart and batchSize, which also specifies a valid set of matrices within leftMatrix, rightMatrix, and resultMatrix, will be processed.
        Parameters:
        commandBuffer - A valid MTLCommandBuffer to receive the encoded kernel.
        leftMatrix - A valid MPSMatrix object which specifies the left input matrix.
        rightMatrix - A valid MPSMatrix object which specifies the right input matrix.
        resultMatrix - A valid MPSMatrix object which specifies the addend matrix which will also be overwritten by the result.

      • initWithDevice

        public MPSMatrixMultiplication initWithDevice​(java.lang.Object device)
        Description copied from class: MPSKernel
        Standard init with default properties per filter type
        Overrides:
        initWithDevice in class MPSKernel
        Parameters:
        device - The device that the filter will be used on. May not be NULL.
        Returns:
        a pointer to the newly initialized object. This will fail, returning nil if the device is not supported. Devices must be MTLFeatureSet_iOS_GPUFamily2_v1 or later.

      • initWithDeviceTransposeLeftTransposeRightResultRowsResultColumnsInteriorColumnsAlphaBeta

        public MPSMatrixMultiplication initWithDeviceTransposeLeftTransposeRightResultRowsResultColumnsInteriorColumnsAlphaBeta​(MTLDevice device,
                                                                                                                        boolean transposeLeft,
                                                                                                                        boolean transposeRight,
                                                                                                                        long resultRows,
                                                                                                                        long resultColumns,
                                                                                                                        long interiorColumns,
                                                                                                                        double alpha,
                                                                                                                        double beta)
        Initialize an MPSMatrixMultiplication object on a device for a given size and desired transpose and scale values.
        Parameters:
        device - The device on which the kernel will execute.
        transposeLeft - A boolean value which indicates if the left input matrix should be used in transposed form. If 'YES' then op(A) = A**T, otherwise op(A) = A.
        transposeRight - A boolean value which indicates if the right input matrix should be used in transposed form. If 'YES' then op(B) = B**T, otherwise op(B) = B.
        resultRows - The number of rows in the result matrix, M in BLAS GEMM description.
        resultColumns - The number of columns in the result matrix, N in BLAS GEMM description.
        interiorColumns - The number of columns of the left input matrix after the appropriate transpose operation has been applied. K in BLAS GEMM description.
        alpha - The scale factor to apply to the product. Specified in double precision. Will be converted to the appropriate precision in the implementation subject to rounding and/or clamping as necessary.
        beta - The scale factor to apply to the initial values of C. Specified in double precision. Will be converted to the appropriate precision in the implementation subject to rounding and/or clamping as necessary.
        Returns:
        A valid MPSMatrixMultiplication object or nil, if failure.

      • leftMatrixOrigin

        public MTLOrigin leftMatrixOrigin()
        [@property] leftMatrixOrigin The origin, relative to [0, 0] in the left input matrix, at which to start reading values. This property is modifiable and defaults to [0, 0] at initialization time. If a different origin is desired then this should be modified prior to encoding the kernel. The z value must be 0.

      • resultMatrixOrigin

        public MTLOrigin resultMatrixOrigin()
        [@property] resultMatrixOrigin The origin, relative to [0, 0] in the result matrix, at which to start writing (and reading if necessary) results. This property is modifiable and defaults to [0, 0] at initialization time. If a different origin is desired then this should be modified prior to encoding the kernel. The z value must be 0.

      • rightMatrixOrigin

        public MTLOrigin rightMatrixOrigin()
        [@property] rightMatrixOrigin The origin, relative to [0, 0] in the right input matrix, at which to start reading values. This property is modifiable and defaults to [0, 0] at initialization time. If a different origin is desired then this should be modified prior to encoding the kernel. The z value must be 0.

      • setLeftMatrixOrigin

        public void setLeftMatrixOrigin​(MTLOrigin value)
        [@property] leftMatrixOrigin The origin, relative to [0, 0] in the left input matrix, at which to start reading values. This property is modifiable and defaults to [0, 0] at initialization time. If a different origin is desired then this should be modified prior to encoding the kernel. The z value must be 0.

      • setResultMatrixOrigin

        public void setResultMatrixOrigin​(MTLOrigin value)
        [@property] resultMatrixOrigin The origin, relative to [0, 0] in the result matrix, at which to start writing (and reading if necessary) results. This property is modifiable and defaults to [0, 0] at initialization time. If a different origin is desired then this should be modified prior to encoding the kernel. The z value must be 0.

      • setRightMatrixOrigin

        public void setRightMatrixOrigin​(MTLOrigin value)
        [@property] rightMatrixOrigin The origin, relative to [0, 0] in the right input matrix, at which to start reading values. This property is modifiable and defaults to [0, 0] at initialization time. If a different origin is desired then this should be modified prior to encoding the kernel. The z value must be 0.

      • batchSize

        public long batchSize()
        [@property] batchSize The number of matrices in the batch to process. This property is modifiable and by default allows all matrices available at encoding time to be processed.

      • batchStart

        public long batchStart()
        [@property] batchStart The index of the first matrix in the batch. This property is modifiable and defaults to 0 at initialization time. If batch processing should begin at a different matrix this value should be modified prior to encoding the kernel.

      • initWithCoderDevice

        public MPSMatrixMultiplication initWithCoderDevice​(NSCoder aDecoder,
                                                   java.lang.Object device)
        Description copied from class: MPSKernel
        NSSecureCoding compatability While the standard NSSecureCoding/NSCoding method -initWithCoder: should work, since the file can't know which device your data is allocated on, we have to guess and may guess incorrectly. To avoid that problem, use initWithCoder:device instead.
        Overrides:
        initWithCoderDevice in class MPSKernel
        Parameters:
        aDecoder - The NSCoder subclass with your serialized MPSKernel
        device - The MTLDevice on which to make the MPSKernel
        Returns:
        A new MPSKernel object, or nil if failure.

      • initWithDeviceResultRowsResultColumnsInteriorColumns

        public MPSMatrixMultiplication initWithDeviceResultRowsResultColumnsInteriorColumns​(MTLDevice device,
                                                                                    long resultRows,
                                                                                    long resultColumns,
                                                                                    long interiorColumns)
        Convenience initialization for a matrix-matrix multiplication with no transpositions, unit scaling of the product, and no accumulation of the result. The scaling factors alpha and beta are taken to be 1.0 and 0.0 respectively.
        Parameters:
        device - The device on which the kernel will execute.
        resultRows - The number of rows in the result matrix, M in BLAS GEMM description.
        resultColumns - The number of columns in the result matrix, N in BLAS GEMM description.
        interiorColumns - The number of columns of the left input matrix. K in BLAS GEMM description.
        Returns:
        A valid MPSMatrixMultiplication object or nil, if failure.

      • setBatchSize

        public void setBatchSize​(long value)
        [@property] batchSize The number of matrices in the batch to process. This property is modifiable and by default allows all matrices available at encoding time to be processed.

      • setBatchStart

        public void setBatchStart​(long value)
        [@property] batchStart The index of the first matrix in the batch. This property is modifiable and defaults to 0 at initialization time. If batch processing should begin at a different matrix this value should be modified prior to encoding the kernel.

      • supportsSecureCoding

        public static boolean supportsSecureCoding()

      • _supportsSecureCoding

        public boolean _supportsSecureCoding()
        Description copied from interface: NSSecureCoding
        This property must return YES on all classes that allow secure coding. Subclasses of classes that adopt NSSecureCoding and override initWithCoder: must also override this method and return YES. The Secure Coding Guide should be consulted when writing methods that decode data.
        Specified by:
        _supportsSecureCoding in interface NSSecureCoding
        Overrides:
        _supportsSecureCoding in class MPSKernel