[TESTS] Jenkins test flow (#152)

Jenkinsfile

+// -*- mode: groovy -*-
+// Jenkins pipeline
+// See documents at https://jenkins.io/doc/book/pipeline/jenkinsfile/
+
+// tvm libraries
+tvm_lib = 'lib/libtvm.so, lib/libtvm_runtime.so, lib/libtvm.a, HalideIR/lib/libHalideIR.a, config.mk'
+// command to start a docker container
+docker_run = 'tests/ci_build/ci_build.sh'
+// timeout in minutes
+max_time = 60
+
+// initialize source codes
+def init_git() {
+  checkout scm
+  retry(5) {
+    timeout(time: 2, unit: 'MINUTES') {
+      sh 'git submodule update --init'
+    }
+  }
+}
+
+def init_git_win() {
+    checkout scm
+    retry(5) {
+        timeout(time: 2, unit: 'MINUTES') {
+            bat 'git submodule update --init'
+        }
+    }
+}
+
+stage("Sanity Check") {
+  timeout(time: max_time, unit: 'MINUTES') {
+    node('linux') {
+      ws('workspace/tvm/sanity') {
+        init_git()
+        sh "${docker_run} lint  ./tests/scripts/task_lint.sh"
+      }
+    }
+  }
+}
+
+// Run make. First try to do an incremental make from a previous workspace in hope to
+// accelerate the compilation. If something wrong, clean the workspace and then
+// build from scratch.
+def make(docker_type, make_flag) {
+  timeout(time: max_time, unit: 'MINUTES') {
+    try {
+      sh "${docker_run} ${docker_type} make ${make_flag}"
+    } catch (exc) {
+      echo 'Incremental compilation failed. Fall back to build from scratch'
+      sh "${docker_run} ${docker_type} make clean"
+      sh "${docker_run} ${docker_type} make ${make_flag}"
+    }
+  }
+}
+
+// pack libraries for later use
+def pack_lib(name, libs=tvm_lib) {
+  sh """
+     echo "Packing ${libs} into ${name}"
+     echo ${libs} | sed -e 's/,/ /g' | xargs md5sum
+     """
+  stash includes: libs, name: name
+}
+
+
+// unpack libraries saved before
+def unpack_lib(name, libs=tvm_lib) {
+  unstash name
+  sh """
+     echo "Unpacked ${libs} from ${name}"
+     echo ${libs} | sed -e 's/,/ /g' | xargs md5sum
+     """
+}
+
+stage('Build') {
+  parallel 'GPU': {
+    node('GPU' && 'linux') {
+      ws('workspace/tvm/build-gpu') {
+        init_git()
+        sh """
+           cp make/config.mk .
+           echo USE_CUDA=1 >> config.mk
+           echo USE_OPENCL=1 >> config.mk
+           echo LLVM_CONFIG=llvm-config >> config.mk
+           echo USE_RPC=1 >> config.mk
+           echo USE_BLAS=openblas >> config.mk
+           """
+        make('gpu', '-j4')
+        pack_lib('gpu')
+      }
+    }
+  },
+  'CPU': {
+    node('CPU' && 'linux') {
+      ws('workspace/tvm/build-cpu') {
+        init_git()
+        sh """
+           cp make/config.mk .
+           echo USE_CUDA=0 >> config.mk
+           echo USE_OPENCL=0 >> config.mk
+           echo USE_RPC=0 >> config.mk
+           """
+        make('cpu', '-j4')
+        pack_lib('cpu')
+      }
+    }
+  }
+}
+
+stage('Unit Test') {
+  parallel 'python2/3: GPU': {
+    node('GPU' && 'linux') {
+      ws('workspace/tvm/ut-python-gpu') {
+        init_git()
+        unpack_lib('gpu', tvm_lib)
+        timeout(time: max_time, unit: 'MINUTES') {
+          sh "${docker_run} gpu ./tests/scripts/task_python_unittest.sh"
+        }
+      }
+    }
+  },
+  'cpp': {
+    node('linux') {
+      ws('workspace/tvm/ut-cpp') {
+        init_git()
+        unpack_lib('cpu', tvm_lib)
+        timeout(time: max_time, unit: 'MINUTES') {
+          sh "${docker_run} cpu ./tests/scripts/task_cpp_unittest.sh"
+        }
+      }
+    }
+  }
+}
+
+stage('Integration Test') {
+  parallel 'python': {
+    node('GPU' && 'linux') {
+      ws('workspace/tvm/it-python-gpu') {
+        init_git()
+        unpack_lib('gpu')
+        timeout(time: max_time, unit: 'MINUTES') {
+          sh "${docker_run} gpu ./tests/scripts/task_python_integration.sh"
+        }
+      }
+    }
+  },
+  'docs': {
+    node('GPU' && 'linux') {
+      ws('workspace/tvm/docs-python-gpu') {
+        init_git()
+        unpack_lib('gpu')
+        timeout(time: max_time, unit: 'MINUTES') {
+          sh "${docker_run} gpu ./tests/scripts/task_python_docs.sh"
+        }
+      }
+    }
+  }
+}

docs/README.txt

@@ -2,4 +2,4 @@ The documentation of tvm is generated with recommonmark and sphinx.
 
 - pip install sphinx>=1.5.5 sphinx-gallery sphinx_rtd_theme matplotlib Image recommonmark
 - Build tvm first in the root folder.
-- To build locally, you need to enable USE_CUDA, USE_OPENCL, USE_LLVM in config.mk and then type "make html" in this folder.
+- To build locally, you need to enable USE_CUDA, USE_OPENCL, LLVM_CONFIG in config.mk and then type "make html" in this folder.

python/tvm/contrib/rpc.py

@@ -103,10 +103,10 @@ class Server(object):
     def __init__(self, host, port=9091, port_end=9199):
         sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         self.port = None
-        for port in range(port, port_end):
+        for my_port in range(port, port_end):
             try:
-                sock.bind((host, port))
-                self.port = port
+                sock.bind((host, my_port))
+                self.port = my_port
                 break
             except socket.error as sock_err:
                 if sock_err.errno in [98, 48]:

tests/ci_build/Dockerfile.cpu

+# For CPU
+FROM ubuntu:14.04
+
+RUN apt-get update
+
+COPY install/ubuntu_*.sh /install/
+RUN bash /install/ubuntu_install_core.sh
+RUN apt-get update && apt-get install -y python-pip
+RUN bash /install/ubuntu_install_python.sh
+RUN bash /install/ubuntu_install_iverilog.sh

tests/ci_build/Dockerfile.gpu

+FROM nvidia/cuda:cudnn
+
+# Base scripts
+RUN apt-get update
+
+COPY install/ubuntu_*.sh /install/
+RUN bash /install/ubuntu_install_core.sh
+RUN bash /install/ubuntu_install_python.sh
+RUN bash /install/ubuntu_install_llvm.sh
+RUN bash /install/ubuntu_install_opencl.sh
+RUN bash /install/ubuntu_install_iverilog.sh
+
+# Environment variables
+ENV PATH=/usr/local/nvidia/bin:${PATH}
+ENV PATH=/usr/clang+llvm-4.0.0-x86_64-linux-gnu-ubuntu-14.04/bin:${PATH}
+ENV PATH=/usr/local/cuda/bin:${PATH}
+ENV CPLUS_INCLUDE_PATH=/usr/local/cuda/include:${CPLUS_INCLUDE_PATH}
+ENV C_INCLUDE_PATH=/usr/local/cuda/include:${C_INCLUDE_PATH}
+ENV LIBRARY_PATH=/usr/local/cuda/lib64:/usr/local/nvidia/lib64:${LIBRARY_PATH}
+ENV LD_LIBRARY_PATH=/usr/local/cuda/lib64:/usr/local/nvidia/lib64:${LD_LIBRARY_PATH}
\ No newline at end of file

tests/ci_build/Dockerfile.lint

+# For lint test
+FROM ubuntu:14.04
+
+RUN apt-get update && apt-get install -y python-pip
+RUN apt-get install -y doxygen graphviz
+RUN pip install cpplint pylint

tests/ci_build/README.md

+# CI Build Scripts
+
+This directory contains the files and setup instructions to run all tests.
+
+## Run locally
+
+To run locally, we need to first install
+[docker](https://docs.docker.com/engine/installation/) and
+[nvidia-docker](https://github.com/NVIDIA/nvidia-docker/wiki).
+
+Then we can run the tasks defined in the [Jenkinsfile](../../Jenkinsfile) by
+using (`ci_build.sh`)[./ci_build.sh]. For example
+
+- lint the python codes
+
+  ```bash
+  ./ci_build.sh lint make pylint
+  ```
+
+- build codes with CUDA supports
+
+  ```bash
+  ./ci_build.sh gpu make -j$(nproc)
+  ```
+
+- do the python unittest
+
+  ```bash
+  ./ci_build.sh gpu PYTHONPATH=./python/ nosetests --with-timer --verbose tests/python/unittest'
+  ```
+
+- build the documents. The results will be available at `docs/_build/html`
+
+  ```bash
+  tests/ci_build/ci_build.sh gpu make -C docs html
+  ```

tests/ci_build/ci_build.sh

+#!/usr/bin/env bash
+#
+# Execute command within a docker container
+#
+# Usage: ci_build.sh <CONTAINER_TYPE> [--dockerfile <DOCKERFILE_PATH>] [-it]
+#                    <COMMAND>
+#
+# CONTAINER_TYPE: Type of the docker container used the run the build: e.g.,
+#                 (cpu | gpu)
+#
+# DOCKERFILE_PATH: (Optional) Path to the Dockerfile used for docker build.  If
+#                  this optional value is not supplied (via the --dockerfile
+#                  flag), will use Dockerfile.CONTAINER_TYPE in default
+#
+# COMMAND: Command to be executed in the docker container
+#
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+# Get the command line arguments.
+CONTAINER_TYPE=$( echo "$1" | tr '[:upper:]' '[:lower:]' )
+shift 1
+
+# Dockerfile to be used in docker build
+DOCKERFILE_PATH="${SCRIPT_DIR}/Dockerfile.${CONTAINER_TYPE}"
+DOCKER_CONTEXT_PATH="${SCRIPT_DIR}"
+
+if [[ "$1" == "--dockerfile" ]]; then
+    DOCKERFILE_PATH="$2"
+    DOCKER_CONTEXT_PATH=$(dirname "${DOCKERFILE_PATH}")
+    echo "Using custom Dockerfile path: ${DOCKERFILE_PATH}"
+    echo "Using custom docker build context path: ${DOCKER_CONTEXT_PATH}"
+    shift 2
+fi
+
+if [[ "$1" == "-it" ]]; then
+    CI_DOCKER_EXTRA_PARAMS+=('-it')
+    shift 1
+fi
+
+if [[ ! -f "${DOCKERFILE_PATH}" ]]; then
+    echo "Invalid Dockerfile path: \"${DOCKERFILE_PATH}\""
+    exit 1
+fi
+
+COMMAND=("$@")
+
+# Validate command line arguments.
+if [ "$#" -lt 1 ] || [ ! -e "${SCRIPT_DIR}/Dockerfile.${CONTAINER_TYPE}" ]; then
+    supported_container_types=$( ls -1 ${SCRIPT_DIR}/Dockerfile.* | \
+        sed -n 's/.*Dockerfile\.\([^\/]*\)/\1/p' | tr '\n' ' ' )
+      echo "Usage: $(basename $0) CONTAINER_TYPE COMMAND"
+      echo "       CONTAINER_TYPE can be one of [${supported_container_types}]"
+      echo "       COMMAND is a command (with arguments) to run inside"
+      echo "               the container."
+      exit 1
+fi
+
+# Use nvidia-docker if the container is GPU.
+if [[ "${CONTAINER_TYPE}" == *"gpu"* ]]; then
+    DOCKER_BINARY="nvidia-docker"
+else
+    DOCKER_BINARY="docker"
+fi
+
+# Helper function to traverse directories up until given file is found.
+function upsearch () {
+    test / == "$PWD" && return || \
+        test -e "$1" && echo "$PWD" && return || \
+        cd .. && upsearch "$1"
+}
+
+# Set up WORKSPACE and BUILD_TAG. Jenkins will set them for you or we pick
+# reasonable defaults if you run it outside of Jenkins.
+WORKSPACE="${WORKSPACE:-${SCRIPT_DIR}/../../}"
+BUILD_TAG="${BUILD_TAG:-tvm-ci}"
+
+# Determine the docker image name
+DOCKER_IMG_NAME="${BUILD_TAG}.${CONTAINER_TYPE}"
+
+# Under Jenkins matrix build, the build tag may contain characters such as
+# commas (,) and equal signs (=), which are not valid inside docker image names.
+DOCKER_IMG_NAME=$(echo "${DOCKER_IMG_NAME}" | sed -e 's/=/_/g' -e 's/,/-/g')
+
+# Convert to all lower-case, as per requirement of Docker image names
+DOCKER_IMG_NAME=$(echo "${DOCKER_IMG_NAME}" | tr '[:upper:]' '[:lower:]')
+
+# Print arguments.
+echo "WORKSPACE: ${WORKSPACE}"
+echo "CI_DOCKER_EXTRA_PARAMS: ${CI_DOCKER_EXTRA_PARAMS[@]}"
+echo "COMMAND: ${COMMAND[@]}"
+echo "CONTAINER_TYPE: ${CONTAINER_TYPE}"
+echo "BUILD_TAG: ${BUILD_TAG}"
+echo "DOCKER CONTAINER NAME: ${DOCKER_IMG_NAME}"
+echo ""
+
+
+# Build the docker container.
+echo "Building container (${DOCKER_IMG_NAME})..."
+docker build -t ${DOCKER_IMG_NAME} \
+    -f "${DOCKERFILE_PATH}" "${DOCKER_CONTEXT_PATH}"
+
+# Check docker build status
+if [[ $? != "0" ]]; then
+    echo "ERROR: docker build failed."
+    exit 1
+fi
+
+# Run the command inside the container.
+echo "Running '${COMMAND[@]}' inside ${DOCKER_IMG_NAME}..."
+
+# By default we cleanup - remove the container once it finish running (--rm)
+# and share the PID namespace (--pid=host) so the process inside does not have
+# pid 1 and SIGKILL is propagated to the process inside (jenkins can kill it).
+echo ${DOCKER_BINARY}
+${DOCKER_BINARY} run --rm --pid=host \
+    -v ${WORKSPACE}:/workspace \
+    -w /workspace \
+    -e "CI_BUILD_HOME=${WORKSPACE}" \
+    -e "CI_BUILD_USER=$(id -u -n)" \
+    -e "CI_BUILD_UID=$(id -u)" \
+    -e "CI_BUILD_GROUP=$(id -g -n)" \
+    -e "CI_BUILD_GID=$(id -g)" \
+    ${CI_DOCKER_EXTRA_PARAMS[@]} \
+    ${DOCKER_IMG_NAME} \
+    bash tests/ci_build/with_the_same_user \
+    ${COMMAND[@]}

tests/ci_build/install/ubuntu_install_core.sh

+# install libraries for building c++ core on ubuntu
+apt-get install -y --no-install-recommends --force-yes \
+        git make libgtest-dev cmake wget unzip libtinfo-dev libz-dev\
+        libcurl4-openssl-dev libopenblas-dev g++
+
+cd /usr/src/gtest && cmake CMakeLists.txt && make && cp *.a /usr/lib

tests/ci_build/install/ubuntu_install_iverilog.sh

+apt-get install -y --no-install-recommends --force-yes make bison flex
+wget ftp://icarus.com/pub/eda/verilog/v10/verilog-10.1.tar.gz
+tar xf verilog-10.1.tar.gz
+cd verilog-10.1
+./configure --prefix=/usr
+make install -j8
+cd ..
+rm -rf verilog-10.1 verilog-10.1.tar.gz

tests/ci_build/install/ubuntu_install_llvm.sh

+cd /usr
+wget http://releases.llvm.org/4.0.0/clang+llvm-4.0.0-x86_64-linux-gnu-ubuntu-14.04.tar.xz
+tar xf clang+llvm-4.0.0-x86_64-linux-gnu-ubuntu-14.04.tar.xz
+chmod -R a+xr clang+llvm-4.0.0-x86_64-linux-gnu-ubuntu-14.04
+rm clang+llvm-4.0.0-x86_64-linux-gnu-ubuntu-14.04.tar.xz
+cd -

tests/ci_build/install/ubuntu_install_opencl.sh

+# Install OpenCL runtime in nvidia docker.
+apt-get install -y --no-install-recommends --force-yes \
+        ocl-icd-libopencl1 \
+        clinfo && \
+        rm -rf /var/lib/apt/lists/*
+
+mkdir -p /etc/OpenCL/vendors && \
+    echo "libnvidia-opencl.so.1" > /etc/OpenCL/vendors/nvidia.icd
+
+echo "/usr/local/nvidia/lib" >> /etc/ld.so.conf.d/nvidia.conf && \
+    echo "/usr/local/nvidia/lib64" >> /etc/ld.so.conf.d/nvidia.conf

tests/ci_build/install/ubuntu_install_python.sh

+# install libraries for python package on ubuntu
+apt-get update && apt-get install -y python-dev python3-dev
+
+# the version of the pip shipped with ubuntu may be too lower, install a recent version here
+cd /tmp && wget https://bootstrap.pypa.io/get-pip.py && python3 get-pip.py && python2 get-pip.py
+
+pip2 install nose pylint numpy nose-timer cython
+pip3 install nose pylint numpy nose-timer cython
+
+pip install sphinx>=1.5.5 sphinx-gallery sphinx_rtd_theme matplotlib Image recommonmark

tests/ci_build/with_the_same_user

+#!/usr/bin/env bash
+
+# This script is a wrapper creating the same user inside container as the one
+# running the ci_build.sh outside the container. It also set the home directory
+# for the user inside container to match the same absolute path as the workspace
+# outside of container.  Do not run this manually. It does not make sense. It is
+# intended to be called by ci_build.sh only.
+
+set -e
+
+COMMAND=("$@")
+
+if ! touch /this_is_writable_file_system; then
+  echo "You can't write to your filesystem!"
+  echo "If you are in Docker you should check you do not have too many images" \
+      "with too many files in them. Docker has some issue with it."
+  exit 1
+else
+  rm /this_is_writable_file_system
+fi
+
+getent group "${CI_BUILD_GID}" || addgroup --gid "${CI_BUILD_GID}" "${CI_BUILD_GROUP}"
+getent passwd "${CI_BUILD_UID}" || adduser --gid "${CI_BUILD_GID}" --uid "${CI_BUILD_UID}" \
+    --gecos "${CI_BUILD_USER} (generated by with_the_same_user script)" \
+    --disabled-password --home "${CI_BUILD_HOME}" --quiet "${CI_BUILD_USER}"
+usermod -a -G sudo "${CI_BUILD_USER}"
+echo "${CI_BUILD_USER} ALL=(ALL) NOPASSWD:ALL" > /etc/sudoers.d/90-nopasswd-sudo
+
+HOME=${CI_BUILD_HOME}\
+    sudo -u "#${CI_BUILD_UID}" --preserve-env\
+    PATH=${PATH}\
+    LD_LIBRARY_PATH=${LD_LIBRARY_PATH}\
+    HOME=${CI_BUILD_HOME}\
+    ${COMMAND[@]}

tests/python/integration/test_contrib_cblas.py

@@ -28,7 +28,7 @@ def test_matmul_add():
         bb = 10.0
         f(a, b, d, bb)
         np.testing.assert_allclose(
-            d.asnumpy(), np.dot(a.asnumpy(), b.asnumpy()) + bb)
+            d.asnumpy(), np.dot(a.asnumpy(), b.asnumpy()) + bb, rtol=1e-5)
     verify()
 
 

tests/scripts/task_cpp_unittest.sh

+#!/bin/bash
+make test -j8 || exit -1
+for test in tests/cpp/*_test; do
+    ./$test || exit -1
+done

tests/scripts/task_lint.sh

+#!/bin/bash
+echo "Check codestyle of c++ code..."
+make cpplint || exit -1
+echo "Check codestyle of python code..."
+make pylint || exit -1
+echo "Check documentations of c++ code..."
+make doc 2>log.txt
+(cat log.txt| grep -v ENABLE_PREPROCESSING |grep -v "unsupported tag") > logclean.txt
+echo "---------Error Log----------"
+cat logclean.txt
+echo "----------------------------"
+(cat logclean.txt|grep warning) && exit -1
+(cat logclean.txt|grep error) && exit -1
+rm logclean.txt
+rm log.txt

tests/scripts/task_python_docs.sh

+#!/bin/bash
+cd docs
+PYTHONPATH=../python make html

tests/scripts/task_python_integration.sh

+#!/bin/bash
+
+export PYTHONPATH=python
+
+make cython || exit -1
+TVM_FFI=cython python -m nose -v tests/python/integration || exit -1
+TVM_FFI=ctypes python3 -m nose -v tests/python/integration || exit -1

tests/scripts/task_python_unittest.sh

+#!/bin/bash
+
+export PYTHONPATH=python
+
+TVM_FFI=ctypes python -m nose -v tests/python/unittest || exit -1
+TVM_FFI=ctypes python3 -m nose -v tests/python/unittest || exit -1
+make cython || exit -1
+make cython3 || exit -1
+TVM_FFI=cython python -m nose -v tests/python/unittest || exit -1
+TVM_FFI=cython python3 -m nose -v tests/python/unittest || exit -1

tests/scripts/task_verilog_test.sh

+#!/bin/bash
+export PYTHONPATH=python
+make verilog || exit -1
+nosetests -v tests/verilog/unittest || exit -1
+nosetests -v tests/verilog/integration || exit -1

tests/travis/run_test.sh

@@ -2,18 +2,7 @@
 
 if [ ${TASK} == "lint" ] || [ ${TASK} == "all_test" ]; then
     if [ ! ${TRAVIS_OS_NAME} == "osx" ]; then
-        echo "Check codestyle of c++ code..."
-        make cpplint || exit -1
-        echo "Check codestyle of python code..."
-        make pylint || exit -1
-        echo "Check documentations of c++ code..."
-        make doc 2>log.txt
-        (cat log.txt| grep -v ENABLE_PREPROCESSING |grep -v "unsupported tag") > logclean.txt
-        echo "---------Error Log----------"
-        cat logclean.txt
-        echo "----------------------------"
-        (cat logclean.txt|grep warning) && exit -1
-        (cat logclean.txt|grep error) && exit -1
+        ./tests/scripts/task_lint.sh || exit -1
     fi
 fi
 
@@ -34,32 +23,21 @@ fi
 
 if [ ${TASK} == "verilog_test" ] || [ ${TASK} == "all_test" ]; then
     if [ ! ${TRAVIS_OS_NAME} == "osx" ]; then
-        echo ${PATH}
-        make -f tests/travis/packages.mk iverilog
-        make verilog || exit -1
+        make -f tests/scripts/packages.mk iverilog
         make all || exit -1
-        nosetests -v tests/verilog/unittest || exit -1
-        nosetests -v tests/verilog/integration || exit -1
+        ./tests/scripts/task_verilog_test.sh || exit -1
     fi
 fi
 
 if [ ${TASK} == "cpp_test" ] || [ ${TASK} == "all_test" ]; then
     make -f dmlc-core/scripts/packages.mk gtest
-    make test || exit -1
-    for test in tests/cpp/*_test; do
-        ./$test || exit -1
-    done
+    ./tests/scripts/task_cpp_unittest.sh || exit -1
 fi
 
 if [ ${TASK} == "python_test" ] || [ ${TASK} == "all_test" ]; then
     make all || exit -1
     if [ ${TRAVIS_OS_NAME} == "osx" ]; then
-        python -m nose -v tests/python/unittest || exit -1
-        python3 -m nose -v tests/python/unittest || exit -1
-        make cython || exit -1
-        make cython3 || exit -1
-        TVM_FFI=cython python -m nose -v tests/python/unittest || exit -1
-        TVM_FFI=cython python3 -m nose -v tests/python/unittest || exit -1
+        ./tests/scripts/task_python_unittest.sh || exit -1
     else
         nosetests -v tests/python/unittest || exit -1
         nosetests3 -v tests/python/unittest || exit -1

tutorials/python/extern_op.py

@@ -60,7 +60,7 @@ d = tvm.nd.array(np.zeros((n, m), dtype=D.dtype), ctx)
 bb = 10.0
 f(a, b, d, bb)
 np.testing.assert_allclose(
-    d.asnumpy(), np.dot(a.asnumpy(), b.asnumpy()) + 10)
+    d.asnumpy(), np.dot(a.asnumpy(), b.asnumpy()) + 10, rtol=1e-5)
 
 ######################################################################
 # Extern Contrib Wrappers
@@ -98,7 +98,7 @@ f = tvm.build(s, [A, B], "llvm")
 a = tvm.nd.array(np.random.uniform(size=(n,)).astype(A.dtype), ctx)
 b = tvm.nd.array(np.random.uniform(size=(n,)).astype(B.dtype), ctx)
 f(a, b)
-np.testing.assert_allclose(b.asnumpy(), a.asnumpy() + 1)
+np.testing.assert_allclose(b.asnumpy(), a.asnumpy() + 1, rtol=1e-5)
 
 ######################################################################
 # Summary