Intel DL boostを使おうとした続き

先日の記事ですが、問題解決できました。

#include <immintrin.h>
#include <stdio.h>

int main()
{
    int8_t __attribute__((aligned(64)))   op1_int8[64];
    int8_t __attribute__((aligned(64)))    op2_int8[64];
    int    __attribute__((aligned(64)))   op3_int[16];
    int    __attribute__((aligned(64)))   presult[16];

    int16_t __attribute__((aligned(64)))   op4_int16[32];
    int16_t __attribute__((aligned(64)))   op5_int16[32];

    __m512i  v1_int8;
    __m512i  v2_int8;
    __m512i  v3_int;
    __m512i  v4_int16;
    __m512i  v5_int16;

    for (int i = 0;i < 64;i++) {
        op1_int8[i] = i;
        op2_int8[i] = i;
    }
    for (int i = 0;i < 16;i++) {
        op3_int[i] = 0;
    }
    for (int i = 0;i < 32;i++) {
        op4_int16[i] = i;
        op5_int16[i] = i;
    }

    v1_int8 = _mm512_load_si512(&op1_int8);
    v2_int8 =_mm512_load_si512(&op2_int8);
    v3_int = _mm512_load_si512(&op3_int);
    v4_int16 = _mm512_load_si512(&op4_int16);
    v5_int16 = _mm512_load_si512(&op5_int16);


    printf("vpdpbusds\n");

    __m512i result = _mm512_dpbusds_epi32(v3_int, v1_int8, v2_int8);
    _mm512_store_si512(presult, result);

    for (int i = 0; i < 16; i++) {
        int val = presult[i];
        printf("%d = %d\n", i, val);
    }

    printf("vpmaddwd + vpaddd\n");
    result = _mm512_madd_epi16(v4_int16, v5_int16);
    result = _mm512_add_epi32(result, v3_int);
    _mm512_store_si512(presult, result);
    for (int i = 0; i < 16; i++) {
        int val = presult[i];
        printf("%d = %d\n", i, val);
    }


    return 0;
}

実行結果

vpdpbusds
0 = 14
1 = 126
2 = 366
3 = 734
4 = 1230
5 = 1854
6 = 2606
7 = 3486
8 = 4494
9 = 5630
10 = 6894
11 = 8286
12 = 9806
13 = 11454
14 = 13230
15 = 15134
vpmaddwd + vpaddd
0 = 1
1 = 13
2 = 41
3 = 85
4 = 145
5 = 221
6 = 313
7 = 421
8 = 545
9 = 685
10 = 841
11 = 1013
12 = 1201
13 = 1405
14 = 1625
15 = 1861

なんか vpmaddwd + vpaddd の使い方間違っている気がしますが、気にしない方針で

Intel DL boostを使おうとしたけど

EC2 c5.12xlarge インスタンスでは使えるはずと思って試しました。 Intelのサイトを参考に

sudo apt install gcc-8 clang-8

#include <immintrin.h>
#include <stdio.h>

int main()
{
    int8_t __attribute__((aligned(64)))   op1_int8[64];
    int8_t __attribute__((aligned(64)))    op2_int8[64];
    int    __attribute__((aligned(64)))   op3_int[16];
    int16_t __attribute__((aligned(64)))   op4_int16[32];

    __m512i  v1_int8;
    __m512i  v2_int8;
    __m512i  v3_int;
    __m512i  v4_int16;

    printf("size of int8_t is %zu\n", sizeof(int8_t));
    printf("size of int is %zu\n", sizeof(int));
    printf("size of int16_t is %zu\n", sizeof(int16_t));

    for (int i = 0;i < 64;i++) {
        op1_int8[i] = i;
        op2_int8[i] = i;
    }
    for (int i = 0;i < 16;i++) {
        v3_int[i] = 0;
    }
    for (int i = 0;i < 32;i++) {
        v4_int16[i] = 0;
    }

    v1_int8 =_mm512_load_si512(&op1_int8);
    v2_int8 =_mm512_load_si512(&op2_int8);
    v3_int =_mm512_load_si512(&op3_int);
    v4_int16 =_mm512_load_si512(&op4_int16);

    __m512i result = _mm512_dpbusds_epi32(v3_int, v1_int8, v2_int8);
    int* presult = (int*) &result;

    for (int i = 0; i < 16; i++) {
        printf("%d = %d\n", i, presult[i]);
    }

    return 0;
}

gccでコンパイル

gcc-8 -mavx512f -march=icelake-server  main.c -o main

実行結果が以下の通り

size of int8_t is 1
size of int is 4
size of int16_t is 2
0 = 15
1 = 126
2 = 1135245462
3 = 33463
4 = 1135244750
5 = 34583
6 = 2607
7 = 3486
8 = 1135208014
9 = 38359
10 = 1133029965
11 = 41015
12 = 1135254878
13 = 44183
14 = 13230
15 = 15134

明らかに計算結果が違っています。 原因調査中・・・

AVX-512 Vector Neural Network Instructions (VNNI) - x86 - WikiChip

「線形代数の基礎」をJavaで実装してみる2

「線形代数の基礎」はこちらのページです。 https://tutorials.chainer.org/ja/05_Basics_of_Linear_Algebra.html

スカラ値の乗算

ベクトル

    public Vector multiply(float scalar) {
        float[] scalars = new float[this.scalars.length];
        for (int i = 0;i < this.scalars.length;i++) {
            scalars[i] = this.scalars[i] * scalar;
        }
        return new Vector(scalars);
    }

行列

    public Matrix multiply(float scalar) {
        float[][] o2scalars = new float[this.o2scalars.length][this.o2scalars[0].length];

        for (int i = 0;i < this.o2scalars.length;i++) {
            for (int j = 0;j < this.o2scalars[i].length;j++) {
                o2scalars[i][j] = this.o2scalars[i][j] * scalar;
            }
        }
        return new Matrix(o2scalars);
    }

各要素にスカラ値を掛けます。

Vector v1 = new Vector(new float[] {1, 2, 3});
Vector v2 = v1.multiply(10);
System.out.println(v2);

Matrix m1 = new Matrix(new float[][] {
        {1, 2, 3},
        {4, 5, 6},
});
Matrix m2 = m1.multiply(10);
System.out.println(m2);

実行結果

[10.0, 20.0, 30.0]
2 x 3
| 10.0| 20.0| 30.0|
| 40.0| 50.0| 60.0|

次はベクトルの内積です

    public float innerProduct(Vector object) {
        if (this.isVertical || !object.isVertical) {
            throw new RuntimeException("vertical error");
        }

        float sum = 0;
        for (int i = 0;i < scalars.length;i++) {
            sum += scalars[i] * object.scalars[i];
        }

        return sum;
    }

内積は横ベクトルと縦ベクトルの積の場合可能です。

        Vector v10 = new Vector(new float[] {1, 2, 3}, false);
        Vector v11 = new Vector(new float[] {4, 5, 6}, true);
        float result = v10.innerProduct(v11);
        System.out.println(result);

実行結果

32.0

こちらが行列積になります。

    public Matrix matrixMultiplication(Matrix object) {
        final float[][] our = o2scalars;
        float[][] newScalars = new float[our.length][our[0].length];
        for (int i = 0;i < our.length;i++) {
            for (int j = 0;j < our[0].length;j++) {

                float sum = 0;
                for (int k = 0;k < our.length;k++) {
                    sum += our[i][k] * object.o2scalars[k][j];
                }
                newScalars[i][j] = sum;
            }
        }

        return new Matrix(newScalars);
    }

        Matrix m10 = new Matrix(new float[][] {
                {1, 2},
                {3, 4},
        });
        Matrix m11 = new Matrix(new float[][] {
                {5, 6},
                {7, 8},
        });
        System.out.println(m10.matrixMultiplication(m11));

結果

2 x 2
| 19.0| 22.0|
| 43.0| 50.0|

積算の実装については以上です。

「線形代数の基礎」をJavaで実装してみる

「線形代数の基礎」はこちらのページです。 https://tutorials.chainer.org/ja/05_Basics_of_Linear_Algebra.html

テンソル

public class Tensor {
    protected final int order;
    public Tensor(int order) {
        this.order = order;
    }
}

public class LinearAlgebraTest {
    public static void main(String[] args) {
        Tensor o1 = new Tensor(1); // 1階のテンソル
        Tensor o2 = new Tensor(2); // 2階のテンソル
    }
}

order は N階のテンソルを表します。 Java的にはN次元の配列ということになります。

ベクトル

ベクトルクラスを定義します。

public class Vector extends Tensor {
    private final float[] scalars;
    public Vector(float[] scalars) {
        super(1); // ベクトルは1階のテンソル
        this.scalars = scalars;
    }
}

ベクトルはテンソルを継承して、order は 1 固定です。

加算を実装します。

Vectorに以下を追加

    public Vector add(Vector object) {
        float[] scalars = new float[this.scalars.length];
        for (int i = 0;i < this.scalars.length;i++) {
            scalars[i] = this.scalars[i] + object.scalars[i];
        }
        return new Vector(scalars);
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        if (scalars.length > 0) {
            sb.append(scalars[0]);
            for (int i = 1;i < scalars.length;i++) {
                sb.append(", ").append(scalars[i]);
            }
        }
        sb.append("]");
        return sb.toString();
    }

呼び出し

        Vector v1 = new Vector(new float[]{1, 2, 3});
        Vector v2 = new Vector(new float[]{4, 5, 6});

        System.out.println(v1);
        System.out.println(v2);

        Vector v3 = v1.add(v2);
        System.out.println(v3);

実行結果

[1.0, 2.0, 3.0]
[4.0, 5.0, 6.0]
[5.0, 7.0, 9.0]

行列

こんな感じの実装にしてみます。

public class Matrix extends Tensor {
    private final float[][] o2scalars;
    public Matrix(float[][] o2scalars) {
        super(2); // 行列は2階のテンソル
        this.o2scalars = o2scalars;
    }
}

加算を実装してみます。

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append(o2scalars.length).append(" x ").append(o2scalars[0].length).append("\n");
        for (int i = 0;i < o2scalars.length;i++) {
            sb.append("|");
            for (int j = 0;j < o2scalars[i].length;j++) {
                sb.append(String.format("% 5.1f|", o2scalars[i][j]));
            }
            sb.append("\n");
        }
        return sb.toString();
    }

    public Matrix add(Matrix object) {
        float[][] o2scalars = new float[this.o2scalars.length][this.o2scalars[0].length];

        for (int i = 0;i < this.o2scalars.length;i++) {
            for (int j = 0;j < this.o2scalars[i].length;j++) {
                o2scalars[i][j] = this.o2scalars[i][j] + object.o2scalars[i][j];
            }
        }
        return new Matrix(o2scalars);
    }

        Matrix m1 = new Matrix(new float[][] {
                {1,2,3},
                {4,5,6},
        });
        Matrix m2 = new Matrix(new float[][] {
                {7,8,9},
                {10,11,12},
        });
        System.out.println(m1);
        System.out.println(m2);

        Matrix m3 = m1.add(m2);
        System.out.println(m3);

実行結果です。

2 x 3
|  1.0|  2.0|  3.0|
|  4.0|  5.0|  6.0|

2 x 3
|  7.0|  8.0|  9.0|
| 10.0| 11.0| 12.0|

2 x 3
|  8.0| 10.0| 12.0|
| 14.0| 16.0| 18.0|

次回は行列の積を実装してみたいと思います。

近似計算の比較

計算をするときいくつかの処理を高速化のために近似値計算で済ます方法があります。 こちらのブログで計算方法が紹介されているので拝借します。 https://martin.ankerl.com/2007/10/04/optimized-pow-approximation-for-java-and-c-c/

package math;

import org.apache.commons.math3.util.FastMath;

public class PowTest1 {
    public static void main(String[] args) {
        for (int i = 0;i < 3;i++) {
            long start;
            double sum = 0;
            start = System.currentTimeMillis();
            for (int j = 0;j < 1000000;j++) {
                sum += Math.pow(j, 2);
            }
            System.out.format("%-13s sum= %8.0f %dms\n", "Math.pow", sum, (System.currentTimeMillis() - start));
        }
        for (int i = 0;i < 3;i++) {
            long start;
            double sum = 0;
            start = System.currentTimeMillis();
            for (int j = 0;j < 1000000;j++) {
                sum += FastMath.pow(j, 2);
            }
            System.out.format("%-13s sum= %8.0f %dms\n", "FastMath.pow", sum, (System.currentTimeMillis() - start));
        }

        for (int i = 0;i < 3;i++) {
            long start;
            double sum = 0;
            start = System.currentTimeMillis();
            for (int j = 0;j < 1000000;j++) {
                sum += pow1(j, 2);
            }
            System.out.format("%-13s sum= %8.0f %dms\n", "pow1", sum, (System.currentTimeMillis() - start));
        }

        for (int i = 0;i < 3;i++) {
            long start;
            double sum = 0;
            start = System.currentTimeMillis();
            for (int j = 0;j < 1000000;j++) {
                sum += pow2(j, 2);
            }
            System.out.format("%-13s sum= %8.0f %dms\n", "pow2", sum, (System.currentTimeMillis() - start));
        }

        for (int i = 0;i < 3;i++) {
            long start;
            double sum = 0;
            start = System.currentTimeMillis();
            for (int j = 0;j < 1000000;j++) {
                sum += pow3(j, 2);
            }
            System.out.format("%-13s sum= %8.0f %dms\n", "pow3", sum, (System.currentTimeMillis() - start));
        }

        for (int i = 0;i < 3;i++) {
            long start;
            double sum = 0;
            start = System.currentTimeMillis();
            for (int j = 0;j < 1000000;j++) {
                sum += pow4(j, 2);
            }
            System.out.format("%-13s sum= %8.0f %dms\n", "pow4", sum, (System.currentTimeMillis() - start));
        }
    }

    public static double pow1(final double a, final double b) {
        final int x = (int) (Double.doubleToLongBits(a) >> 32);
        final int y = (int) (b * (x - 1072632447) + 1072632447);
        return Double.longBitsToDouble(((long) y) << 32);
    }

    public static double pow2(final double a, final double b) {
        final long tmp = Double.doubleToLongBits(a);
        final long tmp2 = (long)(b * (tmp - 4606921280493453312L)) + 4606921280493453312L;
        return Double.longBitsToDouble(tmp2);
    }

    public static double pow3(final double a, final double b) {
        final double x = (Double.doubleToLongBits(a) >> 32);
        final long tmp2 = (long) (1512775 * (x - 1072632447) / 1512775 * b + (1072693248 - 60801));
        return Double.longBitsToDouble(tmp2 << 32);
    }
    public static double pow4(final double a, final double b) {
        final int tmp = (int) (Double.doubleToLongBits(a) >> 32);
        final int tmp2 = (int) (b * (tmp - 1072632447) + 1072632447);
        return Double.longBitsToDouble(((long) tmp2) << 32);
    }
}

macOS Oracle JDK 12.0.2で実行しました。

Math.pow      sum= 333332833333127550 7ms
Math.pow      sum= 333332833333127550 5ms
Math.pow      sum= 333332833333127550 4ms
FastMath.pow  sum= 333332833333127550 165ms
FastMath.pow  sum= 333332833333127550 148ms
FastMath.pow  sum= 333332833333127550 144ms
pow1          sum= 332595653188566270 10ms
pow1          sum= 332595653188566270 9ms
pow1          sum= 332595653188566270 9ms
pow2          sum= 332595653188566270 9ms
pow2          sum= 332595653188566270 7ms
pow2          sum= 332595653188566270 8ms
pow3          sum= 332595653188566270 16ms
pow3          sum= 332595653188566270 16ms
pow3          sum= 332595653188566270 15ms
pow4          sum= 332595653188566270 10ms
pow4          sum= 332595653188566270 10ms
pow4          sum= 332595653188566270 10ms

Math.powが最速でした。FastMath.powはかなり遅いです。 pow1 ~ pow4は計算結果は変わらないですが、速度に差が出ています。

次はexpです。

package math;

import org.apache.commons.math3.util.FastMath;

public class ExpTest1 {
    public static void main(String[] args) {
        for (int i = 0;i < 5;i++) {
            long start;
            double sum = 0;
            start = System.currentTimeMillis();
            for (int j = 0;j < 1000000;j++) {
                sum += Math.exp(j * 0.0001f);
            }
            System.out.format("%-13s sum= %8.0f %dms\n", "Math.exp", sum, (System.currentTimeMillis() - start));
        }

        for (int i = 0;i < 5;i++) {
            long start;
            double sum = 0;
            start = System.currentTimeMillis();
            for (int j = 0;j < 1000000;j++) {
                sum += FastMath.exp(j * 0.0001f);
            }
            System.out.format("%-13s sum= %8.0f %dms\n", "FastMath.exp", sum, (System.currentTimeMillis() - start));
        }

        for (int i = 0;i < 5;i++) {
            long start;
            double sum = 0;
            start = System.currentTimeMillis();
            for (int j = 0;j < 1000000;j++) {
                sum += exp1(j * 0.0001f);
            }
            System.out.format("%-13s sum= %8.0f %dms\n", "exp1", sum, (System.currentTimeMillis() - start));
        }
    }
    public static double exp1(double val) {
        final long tmp = (long) (1512775 * val + (1072693248 - 60801));
        return Double.longBitsToDouble(tmp << 32);
    }
}

結果です。

Math.exp      sum= 268797601492947300000000000000000000000000000000 15ms
Math.exp      sum= 268797601492947300000000000000000000000000000000 24ms
Math.exp      sum= 268797601492947300000000000000000000000000000000 23ms
Math.exp      sum= 268797601492947300000000000000000000000000000000 23ms
Math.exp      sum= 268797601492947300000000000000000000000000000000 23ms
FastMath.exp  sum= 268797601492947300000000000000000000000000000000 45ms
FastMath.exp  sum= 268797601492947300000000000000000000000000000000 30ms
FastMath.exp  sum= 268797601492947300000000000000000000000000000000 30ms
FastMath.exp  sum= 268797601492947300000000000000000000000000000000 31ms
FastMath.exp  sum= 268797601492947300000000000000000000000000000000 31ms
exp1          sum= 267998235537123060000000000000000000000000000000 9ms
exp1          sum= 267998235537123060000000000000000000000000000000 9ms
exp1          sum= 267998235537123060000000000000000000000000000000 8ms
exp1          sum= 267998235537123060000000000000000000000000000000 8ms
exp1          sum= 267998235537123060000000000000000000000000000000 9ms

今回はexp1が最速でした。FastMath.expの結果は悪く無いですが、一番遅かったです。

最後はsqrtです

package math;

import org.apache.commons.math3.util.FastMath;

public class SqrtTest1 {
    public static void main(String[] args) {
        for (int i = 0;i < 4;i++) {
            long start;
            double sum = 0;
            start = System.currentTimeMillis();
            for (int j = 0;j < 1000000;j++) {
                sum += Math.sqrt(j);
            }
            System.out.format("%-13s sum= %8.0f %dms\n", "Math.exp", sum, (System.currentTimeMillis() - start));
        }

        for (int i = 0;i < 4;i++) {
            long start;
            double sum = 0;
            start = System.currentTimeMillis();
            for (int j = 0;j < 1000000;j++) {
                sum += FastMath.sqrt(j);
            }
            System.out.format("%-13s sum= %8.0f %dms\n", "FastMath.sqrt", sum, (System.currentTimeMillis() - start));
        }

        for (int i = 0;i < 4;i++) {
            long start;
            double sum = 0;
            start = System.currentTimeMillis();
            for (int j = 0;j < 1000000;j++) {
                sum += sqrt1(j);
            }
            System.out.format("%-13s sum= %8.0f %dms\n", "sqrt1", sum, (System.currentTimeMillis() - start));
        }
    }
    public static double sqrt1(final double a) {
        final long x = Double.doubleToLongBits(a) >> 32;
        double y = Double.longBitsToDouble((x + 1072632448) << 31);
        return y;
    }
}

結果です。

Math.exp      sum= 666666166 7ms
Math.exp      sum= 666666166 9ms
Math.exp      sum= 666666166 5ms
Math.exp      sum= 666666166 3ms
FastMath.sqrt sum= 666666166 10ms
FastMath.sqrt sum= 666666166 8ms
FastMath.sqrt sum= 666666166 7ms
FastMath.sqrt sum= 666666166 4ms
sqrt1         sum= 666888545 4ms
sqrt1         sum= 666888545 4ms
sqrt1         sum= 666888545 4ms
sqrt1         sum= 666888545 4ms

最速はMath.expでした。 アルゴリズム的には似通ったものになるのか差はほとんどありませんでした。

GraalVMのnative-imageを試す

https://www.graalvm.org/docs/getting-started/

こちらの手順に沿ってダウンロードして、エイリアスの設定

alias java8=~/graalvm-ce-19.2.0.1/Contents/Home/bin/java
alias javac8=~/graalvm-ce-19.2.0.1/Contents/Home/bin/javac

以下のソースで実験

// VectorTest3.java
public class VectorTest3 {
    private final static int NUM = 100 * 1000 * 1000;

    private static float dotProduct(float[] vec_a, float[] vec_b) {
        float sum = 0;
        for (int i = 0; i < vec_a.length; i++) {
            sum += vec_a[i] * vec_b[i];
        }
        return sum;
    }

    private static void bench1() {
        float[] vec_a = new float[NUM];
        float[] vec_b = new float[NUM];
        for (int i = 0;i < NUM;i++) {
            vec_a[i] = (float)Math.random();
            vec_b[i] = (float)Math.random();
        }
        long start = System.currentTimeMillis();
        float sum = dotProduct(vec_a, vec_b);
        System.out.format("bench1 - %d ms\n", (System.currentTimeMillis() - start));
    }
    public static void main(String[] args) {
        for(int i = 0;i < 10;i++) {
            bench1();
        }
    }
}

前回のpanamaビルドで実行

$ javac14 src/main/java/VectorTest3.java \
                                          -d out/
$ java14 -cp out/ VectorTest3
bench1 - 137 ms
bench1 - 124 ms
bench1 - 130 ms
bench1 - 112 ms
bench1 - 121 ms
bench1 - 130 ms
bench1 - 120 ms
bench1 - 120 ms
bench1 - 122 ms
bench1 - 117 ms

最速で117msです。 GraalVMの方では

$ javac8 src/main/java/VectorTest3.java \
                                          -d out/
$ java8 -cp out/ VectorTest3
bench1 - 131 ms
bench1 - #
# A fatal error has been detected by the Java Runtime Environment:
#
#  Internal Error (deoptimization.cpp:808), pid=62160, tid=0x0000000000001603
#  fatal error: java/lang/Long$LongCache must be initialized

クラッシュ...

native-imageをします。

# インストール
$ ~/graalvm-ce-19.2.0.1/Contents/Home/bin/gu install native-image

$  ~/graalvm-ce-19.2.0.1/Contents/Home/bin/native-image -cp out/ VectorTest3
Build on Server(pid: 44023, port: 50514)
[vectortest3:44023]    classlist:     143.75 ms
[vectortest3:44023]        (cap):   2,228.31 ms
[vectortest3:44023]        setup:   3,358.35 ms
[vectortest3:44023]   (typeflow):   2,793.14 ms
[vectortest3:44023]    (objects):   2,172.78 ms
[vectortest3:44023]   (features):     170.70 ms
[vectortest3:44023]     analysis:   5,226.55 ms
[vectortest3:44023]     (clinit):      96.69 ms
[vectortest3:44023]     universe:     324.64 ms
[vectortest3:44023]      (parse):     432.65 ms
[vectortest3:44023]     (inline):     969.11 ms
[vectortest3:44023]    (compile):   4,320.70 ms
[vectortest3:44023]      compile:   6,017.41 ms
[vectortest3:44023]        image:     490.40 ms
[vectortest3:44023]        write:     184.50 ms
[vectortest3:44023]      [total]:  15,869.97 ms

$ ls -la vectortest3
-rwxr-xr-x  1 tak  staff  4496880 Oct  5 11:00 vectortest3

約4MBの実行ファイルが生成されました。 実行します。

$ ./vectortest3
bench1 - 127 ms
bench1 - 130 ms
bench1 - 125 ms
bench1 - 126 ms
bench1 - 126 ms
bench1 - 127 ms
bench1 - 136 ms
bench1 - 126 ms
bench1 - 129 ms
bench1 - 129 ms

なんか遅くなっている気がします。

$ otool -L vectortest3
vectortest3:
    /usr/lib/libSystem.B.dylib (compatibility version 1.0.0, current version 1281.0.0)
    /System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation (compatibility version 150.0.0, current version 1670.10.0)
    /usr/lib/libz.1.dylib (compatibility version 1.0.0, current version 1.2.11)

静的リンクはlibzが必要そうです。

objdump -d vectortest3  | grep vfmadd

vfmaddでgrepしましたが特に使われていないのでベクトルができていない模様

Chainer 6.4.0 リリース

6.4.0

https://github.com/chainer/chainer/releases/tag/v6.4.0

現在は7.0.0の開発がメインのようで主に7.0.0からのバックポートとなっています。