add python 3.8 workaround

Summary: Pull Request resolved: https://github.com/pytorch/pytorch/pull/31798

Differential Revision: D19272332

Pulled By: zou3519

fbshipit-source-id: 954d086a7b9f1a719e0dac303a4253bf7ec8e9f4

.circleci/README.md

@@ -340,12 +340,12 @@ Libtorch packages are built in the wheel build scripts: manywheel/build_*.sh for
 
 All linux builds occur in docker images. The docker images are
 
-* soumith/conda-cuda
+* pytorch/conda-cuda
     * Has ALL CUDA versions installed. The script pytorch/builder/conda/switch_cuda_version.sh sets /usr/local/cuda to a symlink to e.g. /usr/local/cuda-10.0 to enable different CUDA builds
     * Also used for cpu builds
-* soumith/manylinux-cuda90
-* soumith/manylinux-cuda92
-* soumith/manylinux-cuda100
+* pytorch/manylinux-cuda90
+* pytorch/manylinux-cuda92
+* pytorch/manylinux-cuda100
     * Also used for cpu builds
 
 The Dockerfiles are available in pytorch/builder, but there is no circleci job or script to build these docker images, and they cannot be run locally (unless you have the correct local packages/paths). Only Soumith can build them right now.
@@ -411,7 +411,7 @@ You can build Linux binaries locally easily using docker.
 
 ```
 # Run the docker
-# Use the correct docker image, soumith/conda-cuda used here as an example
+# Use the correct docker image, pytorch/conda-cuda used here as an example
 #
 # -v path/to/foo:path/to/bar makes path/to/foo on your local machine (the
 #    machine that you're running the command on) accessible to the docker
@@ -426,7 +426,7 @@ docker run \
     -v your/pytorch/repo:/pytorch \
     -v your/builder/repo:/builder \
     -v where/you/want/packages/to/appear:/final_pkgs \
-    -it soumith/conda-cuda /bin/bash
+    -it pytorch/conda-cuda /bin/bash
 
 # Export whatever variables are important to you. All variables that you'd
 # possibly need are in .circleci/scripts/binary_populate_env.sh

.circleci/cimodel/data/binary_build_data.py

@@ -1,5 +1,3 @@
-#!/usr/bin/env python3
-
 """
 This module models the tree of configuration variants
 for "smoketest" builds.

.circleci/cimodel/data/binary_build_definitions.py

@@ -1,11 +1,8 @@
-#!/usr/bin/env python3
-
 from collections import OrderedDict
 
 import cimodel.data.binary_build_data as binary_build_data
 import cimodel.lib.conf_tree as conf_tree
 import cimodel.lib.miniutils as miniutils
-import cimodel.lib.visualization as visualization
 
 
 class Conf(object):
@@ -27,7 +24,7 @@ class Conf(object):
 
     def gen_docker_image(self):
         if self.gcc_config_variant == 'gcc5.4_cxx11-abi':
-            return miniutils.quote("soumith/conda-cuda-cxx11-ubuntu1604:latest")
+            return miniutils.quote("pytorch/conda-cuda-cxx11-ubuntu1604:latest")
 
         docker_word_substitution = {
             "manywheel": "manylinux",
@@ -36,18 +33,23 @@ class Conf(object):
 
         docker_distro_prefix = miniutils.override(self.pydistro, docker_word_substitution)
 
-        # The cpu nightlies are built on the soumith/manylinux-cuda100 docker image
+        # The cpu nightlies are built on the pytorch/manylinux-cuda100 docker image
         alt_docker_suffix = self.cuda_version or "100"
         docker_distro_suffix = "" if self.pydistro == "conda" else alt_docker_suffix
-        return miniutils.quote("soumith/" + docker_distro_prefix + "-cuda" + docker_distro_suffix)
+        if self.cuda_version == "101":
+            return "soumith/manylinux-cuda101@sha256:5d62be90d5b7777121180e6137c7eed73d37aaf9f669c51b783611e37e0b4916"
+        return miniutils.quote("pytorch/" + docker_distro_prefix + "-cuda" + docker_distro_suffix)
 
     def get_name_prefix(self):
         return "smoke" if self.smoke else "binary"
 
-    def gen_build_name(self, build_or_test):
+    def gen_build_name(self, build_or_test, nightly):
 
         parts = [self.get_name_prefix(), self.os] + self.gen_build_env_parms()
 
+        if nightly:
+            parts.append("nightly")
+
         if self.libtorch_variant:
             parts.append(self.libtorch_variant)
 
@@ -57,17 +59,22 @@ class Conf(object):
         joined = "_".join(parts)
         return joined.replace(".", "_")
 
-    def gen_workflow_job(self, phase, upload_phase_dependency=None):
+    def gen_workflow_job(self, phase, upload_phase_dependency=None, nightly=False):
         job_def = OrderedDict()
-        job_def["name"] = self.gen_build_name(phase)
+        job_def["name"] = self.gen_build_name(phase, nightly)
         job_def["build_environment"] = miniutils.quote(" ".join(self.gen_build_env_parms()))
         job_def["requires"] = ["setup"]
-        job_def["filters"] = {"branches": {"only": "nightly"}}
+        if self.smoke:
+            job_def["requires"].append("update_s3_htmls_for_nightlies")
+            job_def["requires"].append("update_s3_htmls_for_nightlies_devtoolset7")
+            job_def["filters"] = {"branches": {"only": "postnightly"}}
+        else:
+            job_def["filters"] = {"branches": {"only": "nightly"}}
         if self.libtorch_variant:
             job_def["libtorch_variant"] = miniutils.quote(self.libtorch_variant)
         if phase == "test":
             if not self.smoke:
-                job_def["requires"].append(self.gen_build_name("build"))
+                job_def["requires"].append(self.gen_build_name("build", nightly))
             if not (self.smoke and self.os == "macos"):
                 job_def["docker_image"] = self.gen_docker_image()
 
@@ -82,7 +89,7 @@ class Conf(object):
                 job_def["resource_class"] = "gpu.medium"
         if phase == "upload":
             job_def["context"] = "org-member"
-            job_def["requires"] = ["setup", self.gen_build_name(upload_phase_dependency)]
+            job_def["requires"] = ["setup", self.gen_build_name(upload_phase_dependency, nightly)]
 
         os_name = miniutils.override(self.os, {"macos": "mac"})
         job_name = "_".join([self.get_name_prefix(), os_name, phase])
@@ -127,7 +134,7 @@ def get_nightly_uploads():
     mylist = []
     for conf in configs:
         phase_dependency = "test" if predicate_exclude_nonlinux_and_libtorch(conf) else "build"
-        mylist.append(conf.gen_workflow_job("upload", phase_dependency))
+        mylist.append(conf.gen_workflow_job("upload", phase_dependency, nightly=True))
 
     return mylist
 
@@ -138,32 +145,25 @@ def get_nightly_tests():
 
     tests = []
     for conf_options in filtered_configs:
-        yaml_item = conf_options.gen_workflow_job("test")
+        yaml_item = conf_options.gen_workflow_job("test", nightly=True)
         tests.append(yaml_item)
 
     return tests
 
 
-def add_jobs_and_render(jobs_dict, toplevel_key, smoke, cron_schedule):
-
-    jobs_list = ["setup"]
-
+def get_jobs(toplevel_key, smoke):
+    jobs_list = []
     configs = gen_build_env_list(smoke)
     phase = "build" if toplevel_key == "binarybuilds" else "test"
     for build_config in configs:
-        jobs_list.append(build_config.gen_workflow_job(phase))
+        jobs_list.append(build_config.gen_workflow_job(phase, nightly=True))
 
-    jobs_dict[toplevel_key] = OrderedDict(
-        jobs=jobs_list,
-    )
-
-    graph = visualization.generate_graph(get_root(smoke, toplevel_key))
-    graph.draw(toplevel_key + "-config-dimensions.png", prog="twopi")
+    return jobs_list
 
 
-def add_binary_build_jobs(jobs_dict):
-    add_jobs_and_render(jobs_dict, "binarybuilds", False, "5 5 * * *")
+def get_binary_build_jobs():
+    return get_jobs("binarybuilds", False)
 
 
-def add_binary_smoke_test_jobs(jobs_dict):
-    add_jobs_and_render(jobs_dict, "binarysmoketests", True, "15 16 * * *")
+def get_binary_smoke_test_jobs():
+    return get_jobs("binarysmoketests", True)

.circleci/cimodel/data/caffe2_build_data.py

@@ -1,38 +1,11 @@
-#!/usr/bin/env python3
-
-from cimodel.lib.conf_tree import ConfigNode, X, XImportant
+from cimodel.lib.conf_tree import ConfigNode, XImportant
 from cimodel.lib.conf_tree import Ver
 
 
 CONFIG_TREE_DATA = [
-    (Ver("ubuntu", "14.04"), [
-        (Ver("gcc", "4.8"), [X("py2")]),
-        (Ver("gcc", "4.9"), [X("py2")]),
-    ]),
     (Ver("ubuntu", "16.04"), [
-        (Ver("cuda", "9.0"), [
-            # TODO make explicit that this is a "secret TensorRT build"
-            #  (see https://github.com/pytorch/pytorch/pull/17323#discussion_r259446749)
-            # TODO Uh oh, were we supposed to make this one important?!
-            X("py2"),
-            XImportant("cmake"),
-        ]),
-        (Ver("cuda", "10.1"), [XImportant("py3.5")]),  # TensorRT 6 build
-        (Ver("mkl"), [XImportant("py2")]),
-        (Ver("gcc", "5"), [XImportant("onnx_py2")]),
-        (Ver("clang", "3.8"), [X("py2")]),
-        (Ver("clang", "3.9"), [X("py2")]),
-        (Ver("clang", "7"), [XImportant("py2"), XImportant("onnx_py3.6")]),
-        (Ver("android"), [XImportant("py2")]),
-    ]),
-    (Ver("centos", "7"), [
-        (Ver("cuda", "9.0"), [X("py2")]),
-    ]),
-    (Ver("macos", "10.13"), [
-        # TODO ios and system aren't related. system qualifies where the python comes
-        #  from (use the system python instead of homebrew or anaconda)
-        (Ver("ios"), [X("py2")]),
-        (Ver("system"), [XImportant("py2")]),
+        ([Ver("gcc", "5")], [XImportant("onnx_py2")]),
+        ([Ver("clang", "7")], [XImportant("onnx_py3.6")]),
     ]),
 ]
 
@@ -56,13 +29,12 @@ class TreeConfigNode(ConfigNode):
     def is_build_only(self):
         if str(self.find_prop("language_version")) == "onnx_py3.6":
             return False
-        return str(self.find_prop("compiler_version")) in [
-            "gcc4.9",
+        return set(str(c) for c in self.find_prop("compiler_version")).intersection({
             "clang3.8",
             "clang3.9",
             "clang7",
             "android",
-        ] or self.find_prop("distro_version").name == "macos"
+        }) or self.find_prop("distro_version").name == "macos"
 
 
 class TopLevelNode(TreeConfigNode):

.circleci/cimodel/data/caffe2_build_definitions.py

@@ -1,5 +1,3 @@
-#!/usr/bin/env python3
-
 from collections import OrderedDict
 
 import cimodel.data.dimensions as dimensions
@@ -14,23 +12,29 @@ from dataclasses import dataclass
 
 DOCKER_IMAGE_PATH_BASE = "308535385114.dkr.ecr.us-east-1.amazonaws.com/caffe2/"
 
-DOCKER_IMAGE_VERSION = 315
+DOCKER_IMAGE_VERSION = 345
 
 
 @dataclass
 class Conf:
     language: str
     distro: Ver
-    compiler: Ver
+    # There could be multiple compiler versions configured (e.g. nvcc
+    # for gpu files and host compiler (gcc/clang) for cpu files)
+    compilers: [Ver]
     build_only: bool
     is_important: bool
 
+    @property
+    def compiler_names(self):
+        return [c.name for c in self.compilers]
+
     # TODO: Eventually we can probably just remove the cudnn7 everywhere.
     def get_cudnn_insertion(self):
 
         omit = self.language == "onnx_py2" \
             or self.language == "onnx_py3.6" \
-            or self.compiler.name in ["android", "mkl", "clang"] \
+            or set(self.compiler_names).intersection({"android", "mkl", "clang"}) \
             or str(self.distro) in ["ubuntu14.04", "macos10.13"]
 
         return [] if omit else ["cudnn7"]
@@ -42,7 +46,7 @@ class Conf:
         ] + self.get_build_name_middle_parts()
 
     def get_build_name_middle_parts(self):
-        return [str(self.compiler)] + self.get_cudnn_insertion() + [str(self.distro)]
+        return [str(c) for c in self.compilers] + self.get_cudnn_insertion() + [str(self.distro)]
 
     def construct_phase_name(self, phase):
         root_parts = self.get_build_name_root_parts()
@@ -82,11 +86,11 @@ class Conf:
 
         build_env_name = "-".join(parts)
         parameters["build_environment"] = miniutils.quote(build_env_name)
-        if self.compiler.name == "ios":
+        if "ios" in self.compiler_names:
             parameters["build_ios"] = miniutils.quote("1")
         if phase == "test":
             # TODO cuda should not be considered a compiler
-            if self.compiler.name == "cuda":
+            if "cuda" in self.compiler_names:
                 parameters["use_cuda_docker_runtime"] = miniutils.quote("1")
 
         if self.distro.name != "macos":
@@ -94,7 +98,7 @@ class Conf:
             if self.build_only:
                 parameters["build_only"] = miniutils.quote("1")
         if phase == "test":
-            resource_class = "large" if self.compiler.name != "cuda" else "gpu.medium"
+            resource_class = "large" if "cuda" not in self.compiler_names else "gpu.medium"
             parameters["resource_class"] = resource_class
 
         return parameters
@@ -127,11 +131,10 @@ def instantiate_configs():
     root = get_root()
     found_configs = conf_tree.dfs(root)
     for fc in found_configs:
-
         c = Conf(
             language=fc.find_prop("language_version"),
             distro=fc.find_prop("distro_version"),
-            compiler=fc.find_prop("compiler_version"),
+            compilers=fc.find_prop("compiler_version"),
             build_only=fc.find_prop("build_only"),
             is_important=fc.find_prop("important"),
         )
@@ -145,12 +148,8 @@ def get_workflow_jobs():
 
     configs = instantiate_configs()
 
-    # TODO Why don't we build this config?
-    # See https://github.com/pytorch/pytorch/pull/17323#discussion_r259450540
-    filtered_configs = filter(lambda x: not (str(x.distro) == "ubuntu14.04" and str(x.compiler) == "gcc4.9"), configs)
-
     x = []
-    for conf_options in filtered_configs:
+    for conf_options in configs:
 
         phases = ["build"]
         if not conf_options.build_only:

.circleci/cimodel/data/dimensions.py

@@ -1,6 +1,3 @@
-#!/usr/bin/env python3
-
-
 PHASES = ["build", "test"]
 
 CUDA_VERSIONS = [

.circleci/cimodel/data/pytorch_build_data.py

@@ -1,5 +1,3 @@
-#!/usr/bin/env python3
-
 from cimodel.lib.conf_tree import ConfigNode, X, XImportant
 
 
@@ -12,27 +10,25 @@ CONFIG_TREE_DATA = [
             X("nightly"),
         ]),
         ("gcc", [
-            ("4.8", [X("3.6")]),
             ("5.4", [  # All this subtree rebases to master and then build
                 XImportant("3.6"),
                 ("3.6", [
-                    ("namedtensor", [XImportant(True)]),
+                    ("parallel_tbb", [XImportant(True)]),
+                    ("parallel_native", [XImportant(True)]),
                 ]),
             ]),
+            # TODO: bring back libtorch test
             ("7", [X("3.6")]),
         ]),
         ("clang", [
             ("5", [
                 XImportant("3.6"),  # This is actually the ASAN build
-                ("3.6", [
-                    ("namedtensor", [XImportant(True)]),  # ASAN
-                ]),
-            ]),
-            ("7", [
-                ("3.6", [
-                    ("xla", [XImportant(True)]),
-                ]),
             ]),
+            # ("7", [
+            #     ("3.6", [
+            #         ("xla", [XImportant(True)]),
+            #     ]),
+            # ]),
         ]),
         ("cuda", [
             ("9", [
@@ -43,10 +39,9 @@ CONFIG_TREE_DATA = [
                 # and
                 # https://github.com/pytorch/pytorch/blob/master/.jenkins/pytorch/build.sh#L153
                 # (from https://github.com/pytorch/pytorch/pull/17323#discussion_r259453144)
-                X("2.7"),
                 XImportant("3.6"),
-                ("2.7", [
-                    ("namedtensor", [XImportant(True)]),
+                ("3.6", [
+                    ("libtorch", [XImportant(True)])
                 ]),
             ]),
             ("9.2", [X("3.6")]),
@@ -129,7 +124,9 @@ class ExperimentalFeatureConfigNode(TreeConfigNode):
 
         next_nodes = {
             "xla": XlaConfigNode,
-            "namedtensor": NamedTensorConfigNode,
+            "parallel_tbb": ParallelTBBConfigNode,
+            "parallel_native": ParallelNativeConfigNode,
+            "libtorch": LibTorchConfigNode,
             "important": ImportantConfigNode,
             "android_abi": AndroidAbiConfigNode,
         }
@@ -146,13 +143,32 @@ class XlaConfigNode(TreeConfigNode):
     def child_constructor(self):
         return ImportantConfigNode
 
-
-class NamedTensorConfigNode(TreeConfigNode):
+class ParallelTBBConfigNode(TreeConfigNode):
     def modify_label(self, label):
-        return "NAMEDTENSOR=" + str(label)
+        return "PARALLELTBB=" + str(label)
 
     def init2(self, node_name):
-        self.props["is_namedtensor"] = node_name
+        self.props["parallel_backend"] = "paralleltbb"
+
+    def child_constructor(self):
+        return ImportantConfigNode
+
+class ParallelNativeConfigNode(TreeConfigNode):
+    def modify_label(self, label):
+        return "PARALLELNATIVE=" + str(label)
+
+    def init2(self, node_name):
+        self.props["parallel_backend"] = "parallelnative"
+
+    def child_constructor(self):
+        return ImportantConfigNode
+
+class LibTorchConfigNode(TreeConfigNode):
+    def modify_label(self, label):
+        return "BUILD_TEST_LIBTORCH=" + str(label)
+
+    def init2(self, node_name):
+        self.props["is_libtorch"] = node_name
 
     def child_constructor(self):
         return ImportantConfigNode

.circleci/cimodel/data/pytorch_build_definitions.py

@@ -1,5 +1,3 @@
-#!/usr/bin/env python3
-
 from collections import OrderedDict
 
 from cimodel.data.pytorch_build_data import TopLevelNode, CONFIG_TREE_DATA
@@ -15,7 +13,7 @@ DOCKER_IMAGE_PATH_BASE = "308535385114.dkr.ecr.us-east-1.amazonaws.com/pytorch/"
 
 # ARE YOU EDITING THIS NUMBER?  MAKE SURE YOU READ THE GUIDANCE AT THE
 # TOP OF .circleci/config.yml
-DOCKER_IMAGE_VERSION = 347
+DOCKER_IMAGE_VERSION = 405
 
 
 @dataclass
@@ -33,8 +31,9 @@ class Conf:
     gpu_resource: Optional[str] = None
     dependent_tests: List = field(default_factory=list)
     parent_build: Optional['Conf'] = None
-    is_namedtensor: bool = False
+    is_libtorch: bool = False
     is_important: bool = False
+    parallel_backend: Optional[str] = None
 
     # TODO: Eliminate the special casing for docker paths
     # In the short term, we *will* need to support special casing as docker images are merged for caffe2 and pytorch
@@ -47,8 +46,10 @@ class Conf:
         leading.append("pytorch")
         if self.is_xla and not for_docker:
             leading.append("xla")
-        if self.is_namedtensor and not for_docker:
-            leading.append("namedtensor")
+        if self.is_libtorch and not for_docker:
+            leading.append("libtorch")
+        if self.parallel_backend is not None and not for_docker:
+            leading.append(self.parallel_backend)
 
         cuda_parms = []
         if self.cuda_version:
@@ -159,7 +160,7 @@ def gen_dependent_configs(xenial_parent_config):
 
         configs.append(c)
 
-    for x in ["pytorch_short_perf_test_gpu", "pytorch_python_doc_push", "pytorch_cpp_doc_push"]:
+    for x in ["pytorch_python_doc_push", "pytorch_cpp_doc_push"]:
         configs.append(HiddenConf(x, parent_build=xenial_parent_config))
 
     return configs
@@ -209,6 +210,7 @@ def instantiate_configs():
             android_abi = fc.find_prop("android_abi")
             parms_list_ignored_for_docker_image.append(android_abi)
             restrict_phases = ["build"]
+            fc.props["is_important"] = True
 
         elif compiler_name:
             gcc_version = compiler_name + (fc.find_prop("compiler_version") or "")
@@ -224,8 +226,9 @@ def instantiate_configs():
             # TODO The gcc version is orthogonal to CUDA version?
             parms_list.append("gcc7")
 
-        is_namedtensor = fc.find_prop("is_namedtensor") or False
+        is_libtorch = fc.find_prop("is_libtorch") or False
         is_important = fc.find_prop("is_important") or False
+        parallel_backend = fc.find_prop("parallel_backend") or None
 
         gpu_resource = None
         if cuda_version and cuda_version != "10":
@@ -240,22 +243,24 @@ def instantiate_configs():
             is_xla,
             restrict_phases,
             gpu_resource,
-            is_namedtensor=is_namedtensor,
+            is_libtorch=is_libtorch,
             is_important=is_important,
+            parallel_backend=parallel_backend,
         )
 
-        if cuda_version == "9" and python_version == "3.6":
+        if cuda_version == "9" and python_version == "3.6" and not is_libtorch:
             c.dependent_tests = gen_dependent_configs(c)
 
         if (compiler_name == "gcc"
                 and compiler_version == "5.4"
-                and not is_namedtensor):
+                and not is_libtorch
+                and parallel_backend is None):
             bc_breaking_check = Conf(
                 "backward-compatibility-check",
                 [],
                 is_xla=False,
                 restrict_phases=["test"],
-                is_namedtensor=False,
+                is_libtorch=False,
                 is_important=True,
                 parent_build=c,
             )

.circleci/cimodel/lib/conf_tree.py

@@ -1,6 +1,3 @@
-#!/usr/bin/env python3
-
-
 from dataclasses import dataclass, field
 from typing import Optional, Dict
 

.circleci/cimodel/lib/miniutils.py

@@ -1,6 +1,3 @@
-#!/usr/bin/env python3
-
-
 def quote(s):
     return sandwich('"', s)
 

.circleci/cimodel/lib/miniyaml.py

@@ -1,6 +1,3 @@
-#!/usr/bin/env python3
-
-
 from collections import OrderedDict
 
 

.circleci/cimodel/lib/visualization.py

@@ -1,5 +1,3 @@
-#!/usr/bin/env python3
-
 """
 This module encapsulates dependencies on pygraphviz
 """

.circleci/docker/README.md

@@ -0,0 +1,19 @@
+# Docker images for Jenkins
+
+This directory contains everything needed to build the Docker images
+that are used in our CI
+
+The Dockerfiles located in subdirectories are parameterized to
+conditionally run build stages depending on build arguments passed to
+`docker build`. This lets us use only a few Dockerfiles for many
+images. The different configurations are identified by a freeform
+string that we call a _build environment_. This string is persisted in
+each image as the `BUILD_ENVIRONMENT` environment variable.
+
+See `build.sh` for valid build environments (it's the giant switch).
+
+## Contents
+
+* `build.sh` -- dispatch script to launch all builds
+* `common` -- scripts used to execute individual Docker build stages
+* `ubuntu-cuda` -- Dockerfile for Ubuntu image with CUDA support for nvidia-docker

.circleci/docker/android/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest package="org.pytorch.deps" />

.circleci/docker/android/build.gradle

@@ -0,0 +1,68 @@
+buildscript {
+    ext {
+        minSdkVersion = 21
+        targetSdkVersion = 28
+        compileSdkVersion = 28
+        buildToolsVersion = '28.0.3'
+
+        coreVersion = "1.2.0"
+        extJUnitVersion = "1.1.1"
+        runnerVersion = "1.2.0"
+        rulesVersion = "1.2.0"
+        junitVersion = "4.12"
+    }
+
+    repositories {
+        google()
+        mavenLocal()
+        mavenCentral()
+        jcenter()
+    }
+
+    dependencies {
+        classpath 'com.android.tools.build:gradle:3.3.2'
+        classpath "com.jfrog.bintray.gradle:gradle-bintray-plugin:1.8.0"
+        classpath "com.github.dcendents:android-maven-gradle-plugin:2.1"
+        classpath "org.jfrog.buildinfo:build-info-extractor-gradle:4.9.8"
+    }
+}
+
+repositories {
+    google()
+    jcenter()
+}
+
+apply plugin: 'com.android.library'
+
+android {
+    compileSdkVersion rootProject.compileSdkVersion
+    buildToolsVersion rootProject.buildToolsVersion
+
+    defaultConfig {
+        minSdkVersion minSdkVersion
+        targetSdkVersion targetSdkVersion
+    }
+
+    sourceSets {
+        main {
+            manifest.srcFile 'AndroidManifest.xml'
+        }
+    }
+}
+
+dependencies {
+    implementation 'com.android.support:appcompat-v7:28.0.0'
+    implementation 'androidx.appcompat:appcompat:1.0.0'
+    implementation 'com.facebook.fbjni:fbjni-java-only:0.0.3'
+    implementation 'com.google.code.findbugs:jsr305:3.0.1'
+    implementation 'com.facebook.soloader:nativeloader:0.8.0'
+
+    implementation 'junit:junit:' + rootProject.junitVersion
+    implementation 'androidx.test:core:' + rootProject.coreVersion
+
+    implementation 'junit:junit:' + rootProject.junitVersion
+    implementation 'androidx.test:core:' + rootProject.coreVersion
+    implementation 'androidx.test.ext:junit:' + rootProject.extJUnitVersion
+    implementation 'androidx.test:rules:' + rootProject.rulesVersion
+    implementation 'androidx.test:runner:' + rootProject.runnerVersion
+}

.circleci/docker/build.sh

@@ -0,0 +1,275 @@
+#!/bin/bash
+
+set -ex
+
+image="$1"
+shift
+
+if [ -z "${image}" ]; then
+  echo "Usage: $0 IMAGE"
+  exit 1
+fi
+
+# TODO: Generalize
+OS="ubuntu"
+DOCKERFILE="${OS}/Dockerfile"
+if [[ "$image" == *-cuda* ]]; then
+  DOCKERFILE="${OS}-cuda/Dockerfile"
+fi
+
+if [[ "$image" == *-trusty* ]]; then
+  UBUNTU_VERSION=14.04
+elif [[ "$image" == *-xenial* ]]; then
+  UBUNTU_VERSION=16.04
+elif [[ "$image" == *-artful* ]]; then
+  UBUNTU_VERSION=17.10
+elif [[ "$image" == *-bionic* ]]; then
+  UBUNTU_VERSION=18.04
+fi
+
+# It's annoying to rename jobs every time you want to rewrite a
+# configuration, so we hardcode everything here rather than do it
+# from scratch
+case "$image" in
+  pytorch-linux-bionic-clang9-thrift-llvmdev)
+    CLANG_VERSION=9
+    THRIFT=yes
+    LLVMDEV=yes
+    PROTOBUF=yes
+    ;;
+  pytorch-linux-xenial-py2.7.9)
+    TRAVIS_PYTHON_VERSION=2.7.9
+    GCC_VERSION=7
+    # Do not install PROTOBUF, DB, and VISION as a test
+    ;;
+  pytorch-linux-xenial-py2.7)
+    TRAVIS_PYTHON_VERSION=2.7
+    GCC_VERSION=7
+    PROTOBUF=yes
+    DB=yes
+    VISION=yes
+    ;;
+  pytorch-linux-xenial-py3.5)
+    TRAVIS_PYTHON_VERSION=3.5
+    GCC_VERSION=7
+    # Do not install PROTOBUF, DB, and VISION as a test
+    ;;
+  pytorch-linux-xenial-py3.6-gcc4.8)
+    ANACONDA_PYTHON_VERSION=3.6
+    GCC_VERSION=4.8
+    PROTOBUF=yes
+    DB=yes
+    VISION=yes
+    ;;
+  pytorch-linux-xenial-py3.6-gcc5.4)
+    ANACONDA_PYTHON_VERSION=3.6
+    GCC_VERSION=5
+    PROTOBUF=yes
+    DB=yes
+    VISION=yes
+    ;;
+  pytorch-linux-xenial-py3.6-gcc7.2)
+    ANACONDA_PYTHON_VERSION=3.6
+    GCC_VERSION=7
+    # Do not install PROTOBUF, DB, and VISION as a test
+    ;;
+  pytorch-linux-xenial-py3.6-gcc7)
+    ANACONDA_PYTHON_VERSION=3.6
+    GCC_VERSION=7
+    PROTOBUF=yes
+    DB=yes
+    VISION=yes
+    ;;
+  pytorch-linux-xenial-pynightly)
+    TRAVIS_PYTHON_VERSION=nightly
+    GCC_VERSION=7
+    PROTOBUF=yes
+    DB=yes
+    VISION=yes
+    ;;
+  pytorch-linux-xenial-cuda8-cudnn7-py2)
+    CUDA_VERSION=8.0
+    CUDNN_VERSION=7
+    ANACONDA_PYTHON_VERSION=2.7
+    PROTOBUF=yes
+    DB=yes
+    VISION=yes
+    ;;
+  pytorch-linux-xenial-cuda8-cudnn7-py3)
+    CUDA_VERSION=8.0
+    CUDNN_VERSION=7
+    ANACONDA_PYTHON_VERSION=3.6
+    PROTOBUF=yes
+    DB=yes
+    VISION=yes
+    ;;
+  pytorch-linux-xenial-cuda9-cudnn7-py2)
+    CUDA_VERSION=9.0
+    CUDNN_VERSION=7
+    ANACONDA_PYTHON_VERSION=2.7
+    PROTOBUF=yes
+    DB=yes
+    VISION=yes
+    ;;
+  pytorch-linux-xenial-cuda9-cudnn7-py3)
+    CUDA_VERSION=9.0
+    CUDNN_VERSION=7
+    ANACONDA_PYTHON_VERSION=3.6
+    PROTOBUF=yes
+    DB=yes
+    VISION=yes
+    KATEX=yes
+    ;;
+  pytorch-linux-xenial-cuda9.2-cudnn7-py3-gcc7)
+    CUDA_VERSION=9.2
+    CUDNN_VERSION=7
+    ANACONDA_PYTHON_VERSION=3.6
+    GCC_VERSION=7
+    PROTOBUF=yes
+    DB=yes
+    VISION=yes
+    ;;
+  pytorch-linux-xenial-cuda10-cudnn7-py3-gcc7)
+    CUDA_VERSION=10.0
+    CUDNN_VERSION=7
+    ANACONDA_PYTHON_VERSION=3.6
+    GCC_VERSION=7
+    PROTOBUF=yes
+    DB=yes
+    VISION=yes
+    ;;
+  pytorch-linux-xenial-cuda10.1-cudnn7-py3-gcc7)
+    CUDA_VERSION=10.1
+    CUDNN_VERSION=7
+    ANACONDA_PYTHON_VERSION=3.6
+    GCC_VERSION=7
+    PROTOBUF=yes
+    DB=yes
+    VISION=yes
+    ;;
+  pytorch-linux-xenial-py3-clang5-asan)
+    ANACONDA_PYTHON_VERSION=3.6
+    CLANG_VERSION=5.0
+    PROTOBUF=yes
+    DB=yes
+    VISION=yes
+    ;;
+  pytorch-linux-xenial-py3-clang5-android-ndk-r19c)
+    ANACONDA_PYTHON_VERSION=3.6
+    CLANG_VERSION=5.0
+    PROTOBUF=yes
+    ANDROID=yes
+    ANDROID_NDK_VERSION=r19c
+    GRADLE_VERSION=4.10.3
+    CMAKE_VERSION=3.7.0
+    NINJA_VERSION=1.9.0
+    ;;
+  pytorch-linux-xenial-py3.6-clang7)
+    ANACONDA_PYTHON_VERSION=3.6
+    CLANG_VERSION=7
+    PROTOBUF=yes
+    DB=yes
+    VISION=yes
+    ;;
+esac
+
+# Set Jenkins UID and GID if running Jenkins
+if [ -n "${JENKINS:-}" ]; then
+  JENKINS_UID=$(id -u jenkins)
+  JENKINS_GID=$(id -g jenkins)
+fi
+
+tmp_tag="tmp-$(cat /dev/urandom | tr -dc 'a-z' | fold -w 32 | head -n 1)"
+
+# Build image
+docker build \
+       --no-cache \
+       --build-arg "BUILD_ENVIRONMENT=${image}" \
+       --build-arg "PROTOBUF=${PROTOBUF:-}" \
+       --build-arg "THRIFT=${THRIFT:-}" \
+       --build-arg "LLVMDEV=${LLVMDEV:-}" \
+       --build-arg "DB=${DB:-}" \
+       --build-arg "VISION=${VISION:-}" \
+       --build-arg "EC2=${EC2:-}" \
+       --build-arg "JENKINS=${JENKINS:-}" \
+       --build-arg "JENKINS_UID=${JENKINS_UID:-}" \
+       --build-arg "JENKINS_GID=${JENKINS_GID:-}" \
+       --build-arg "UBUNTU_VERSION=${UBUNTU_VERSION}" \
+       --build-arg "CLANG_VERSION=${CLANG_VERSION}" \
+       --build-arg "ANACONDA_PYTHON_VERSION=${ANACONDA_PYTHON_VERSION}" \
+       --build-arg "TRAVIS_PYTHON_VERSION=${TRAVIS_PYTHON_VERSION}" \
+       --build-arg "GCC_VERSION=${GCC_VERSION}" \
+       --build-arg "CUDA_VERSION=${CUDA_VERSION}" \
+       --build-arg "CUDNN_VERSION=${CUDNN_VERSION}" \
+       --build-arg "ANDROID=${ANDROID}" \
+       --build-arg "ANDROID_NDK=${ANDROID_NDK_VERSION}" \
+       --build-arg "GRADLE_VERSION=${GRADLE_VERSION}" \
+       --build-arg "CMAKE_VERSION=${CMAKE_VERSION:-}" \
+       --build-arg "NINJA_VERSION=${NINJA_VERSION:-}" \
+       --build-arg "KATEX=${KATEX:-}" \
+       -f $(dirname ${DOCKERFILE})/Dockerfile \
+       -t "$tmp_tag" \
+       "$@" \
+       .
+
+function drun() {
+  docker run --rm "$tmp_tag" $*
+}
+
+if [[ "$OS" == "ubuntu" ]]; then
+  if !(drun lsb_release -a 2>&1 | grep -qF Ubuntu); then
+    echo "OS=ubuntu, but:"
+    drun lsb_release -a
+    exit 1
+  fi
+  if !(drun lsb_release -a 2>&1 | grep -qF "$UBUNTU_VERSION"); then
+    echo "UBUNTU_VERSION=$UBUNTU_VERSION, but:"
+    drun lsb_release -a
+    exit 1
+  fi
+fi
+
+if [ -n "$TRAVIS_PYTHON_VERSION" ]; then
+  if [[ "$TRAVIS_PYTHON_VERSION" != nightly ]]; then
+    if !(drun python --version 2>&1 | grep -qF "Python $TRAVIS_PYTHON_VERSION"); then
+      echo "TRAVIS_PYTHON_VERSION=$TRAVIS_PYTHON_VERSION, but:"
+      drun python --version
+      exit 1
+    fi
+  else
+    echo "Please manually check nightly is OK:"
+    drun python --version
+  fi
+fi
+
+if [ -n "$ANACONDA_PYTHON_VERSION" ]; then
+  if !(drun python --version 2>&1 | grep -qF "Python $ANACONDA_PYTHON_VERSION"); then
+    echo "ANACONDA_PYTHON_VERSION=$ANACONDA_PYTHON_VERSION, but:"
+    drun python --version
+    exit 1
+  fi
+fi
+
+if [ -n "$GCC_VERSION" ]; then
+  if !(drun gcc --version 2>&1 | grep -q " $GCC_VERSION\\W"); then
+    echo "GCC_VERSION=$GCC_VERSION, but:"
+    drun gcc --version
+    exit 1
+  fi
+fi
+
+if [ -n "$CLANG_VERSION" ]; then
+  if !(drun clang --version 2>&1 | grep -qF "clang version $CLANG_VERSION"); then
+    echo "CLANG_VERSION=$CLANG_VERSION, but:"
+    drun clang --version
+    exit 1
+  fi
+fi
+
+if [ -n "$KATEX" ]; then
+  if !(drun katex --version); then
+    echo "KATEX=$KATEX, but:"
+    drun katex --version
+    exit 1
+  fi
+fi

.circleci/docker/build_docker.sh

@@ -0,0 +1,49 @@
+#!/bin/bash
+
+set -ex
+
+retry () {
+    $*  || (sleep 1 && $*) || (sleep 2 && $*)
+}
+
+# If UPSTREAM_BUILD_ID is set (see trigger job), then we can
+# use it to tag this build with the same ID used to tag all other
+# base image builds. Also, we can try and pull the previous
+# image first, to avoid rebuilding layers that haven't changed.
+
+#until we find a way to reliably reuse previous build, this last_tag is not in use
+# last_tag="$(( CIRCLE_BUILD_NUM - 1 ))"
+tag="${CIRCLE_WORKFLOW_ID}"
+
+
+registry="308535385114.dkr.ecr.us-east-1.amazonaws.com"
+image="${registry}/pytorch/${IMAGE_NAME}"
+
+login() {
+  aws ecr get-authorization-token --region us-east-1 --output text --query 'authorizationData[].authorizationToken' |
+    base64 -d |
+    cut -d: -f2 |
+    docker login -u AWS --password-stdin "$1"
+}
+
+# Retry on timeouts (can happen on job stampede).
+retry login "${registry}"
+
+# Logout on exit
+trap "docker logout ${registry}" EXIT
+
+# export EC2=1
+# export JENKINS=1
+
+# Try to pull the previous image (perhaps we can reuse some layers)
+# if [ -n "${last_tag}" ]; then
+#   docker pull "${image}:${last_tag}" || true
+# fi
+
+# Build new image
+./build.sh ${IMAGE_NAME} -t "${image}:${tag}"
+
+docker push "${image}:${tag}"
+
+docker save -o "${IMAGE_NAME}:${tag}.tar" "${image}:${tag}"
+aws s3 cp "${IMAGE_NAME}:${tag}.tar" "s3://ossci-linux-build/pytorch/base/${IMAGE_NAME}:${tag}.tar" --acl public-read

.circleci/docker/common/install_android.sh

@@ -0,0 +1,129 @@
+#!/bin/bash
+
+set -ex
+
+[ -n "${ANDROID_NDK}" ]
+
+apt-get update
+apt-get install -y --no-install-recommends autotools-dev autoconf unzip
+apt-get autoclean && apt-get clean
+rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
+
+pushd /tmp
+curl -Os https://dl.google.com/android/repository/android-ndk-${ANDROID_NDK}-linux-x86_64.zip
+popd
+_ndk_dir=/opt/ndk
+mkdir -p "$_ndk_dir"
+unzip -qo /tmp/android*.zip -d "$_ndk_dir"
+_versioned_dir=$(find "$_ndk_dir/" -mindepth 1 -maxdepth 1 -type d)
+mv "$_versioned_dir"/* "$_ndk_dir"/
+rmdir "$_versioned_dir"
+rm -rf /tmp/*
+
+# Install OpenJDK
+# https://hub.docker.com/r/picoded/ubuntu-openjdk-8-jdk/dockerfile/
+
+sudo apt-get update && \
+    apt-get install -y openjdk-8-jdk && \
+    apt-get install -y ant && \
+    apt-get clean && \
+    rm -rf /var/lib/apt/lists/* && \
+    rm -rf /var/cache/oracle-jdk8-installer;
+
+# Fix certificate issues, found as of
+# https://bugs.launchpad.net/ubuntu/+source/ca-certificates-java/+bug/983302
+
+sudo apt-get update && \
+    apt-get install -y ca-certificates-java && \
+    apt-get clean && \
+    update-ca-certificates -f && \
+    rm -rf /var/lib/apt/lists/* && \
+    rm -rf /var/cache/oracle-jdk8-installer;
+
+export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64/
+
+# Installing android sdk
+# https://github.com/circleci/circleci-images/blob/staging/android/Dockerfile.m4
+
+_sdk_version=sdk-tools-linux-3859397.zip
+_android_home=/opt/android/sdk
+
+rm -rf $_android_home
+sudo mkdir -p $_android_home
+curl --silent --show-error --location --fail --retry 3 --output /tmp/$_sdk_version https://dl.google.com/android/repository/$_sdk_version
+sudo unzip -q /tmp/$_sdk_version -d $_android_home
+rm /tmp/$_sdk_version
+
+sudo chmod -R 777 $_android_home
+
+export ANDROID_HOME=$_android_home
+export ADB_INSTALL_TIMEOUT=120
+
+export PATH="${ANDROID_HOME}/emulator:${ANDROID_HOME}/tools:${ANDROID_HOME}/tools/bin:${ANDROID_HOME}/platform-tools:${PATH}"
+echo "PATH:${PATH}"
+alias sdkmanager="$ANDROID_HOME/tools/bin/sdkmanager"
+
+sudo mkdir ~/.android && sudo echo '### User Sources for Android SDK Manager' > ~/.android/repositories.cfg
+sudo chmod -R 777 ~/.android
+
+yes | sdkmanager --licenses
+yes | sdkmanager --update
+
+sdkmanager \
+  "tools" \
+  "platform-tools" \
+  "emulator"
+
+sdkmanager \
+  "build-tools;28.0.3" \
+  "build-tools;29.0.2"
+
+sdkmanager \
+  "platforms;android-28" \
+  "platforms;android-29"
+sdkmanager --list
+
+# Installing Gradle
+echo "GRADLE_VERSION:${GRADLE_VERSION}"
+_gradle_home=/opt/gradle
+sudo rm -rf $gradle_home
+sudo mkdir -p $_gradle_home
+
+wget --no-verbose --output-document=/tmp/gradle.zip \
+"https://services.gradle.org/distributions/gradle-${GRADLE_VERSION}-bin.zip"
+
+sudo unzip -q /tmp/gradle.zip -d $_gradle_home
+rm /tmp/gradle.zip
+
+sudo chmod -R 777 $_gradle_home
+
+export GRADLE_HOME=$_gradle_home/gradle-$GRADLE_VERSION
+alias gradle="${GRADLE_HOME}/bin/gradle"
+
+export PATH="${GRADLE_HOME}/bin/:${PATH}"
+echo "PATH:${PATH}"
+
+gradle --version
+
+mkdir /var/lib/jenkins/gradledeps
+cp build.gradle /var/lib/jenkins/gradledeps
+cp AndroidManifest.xml /var/lib/jenkins/gradledeps
+
+pushd /var/lib/jenkins
+
+export GRADLE_LOCAL_PROPERTIES=gradledeps/local.properties
+rm -f $GRADLE_LOCAL_PROPERTIES
+echo "sdk.dir=/opt/android/sdk" >> $GRADLE_LOCAL_PROPERTIES
+echo "ndk.dir=/opt/ndk" >> $GRADLE_LOCAL_PROPERTIES
+
+chown -R jenkins /var/lib/jenkins/gradledeps
+chgrp -R jenkins /var/lib/jenkins/gradledeps
+
+sudo -H -u jenkins $GRADLE_HOME/bin/gradle -p /var/lib/jenkins/gradledeps -g /var/lib/jenkins/.gradle --refresh-dependencies --debug --stacktrace assemble
+
+chown -R jenkins /var/lib/jenkins/.gradle
+chgrp -R jenkins /var/lib/jenkins/.gradle
+
+popd
+
+rm -rf /var/lib/jenkins/.gradle/daemon

.circleci/docker/common/install_base.sh

@@ -0,0 +1,75 @@
+#!/bin/bash
+
+set -ex
+
+if [[ "$UBUNTU_VERSION" == "14.04" ]]; then
+  # cmake 2 is too old
+  cmake3=cmake3
+else
+  cmake3=cmake
+fi
+
+if [[ "$UBUNTU_VERSION" == "18.04" ]]; then
+  cmake3="cmake=3.10*"
+else
+  cmake3="${cmake3}=3.5*"
+fi
+
+# Install common dependencies
+apt-get update
+# TODO: Some of these may not be necessary
+# TODO: libiomp also gets installed by conda, aka there's a conflict
+ccache_deps="asciidoc docbook-xml docbook-xsl xsltproc"
+numpy_deps="gfortran"
+apt-get install -y --no-install-recommends \
+  $ccache_deps \
+  $numpy_deps \
+  ${cmake3} \
+  apt-transport-https \
+  autoconf \
+  automake \
+  build-essential \
+  ca-certificates \
+  curl \
+  git \
+  libatlas-base-dev \
+  libc6-dbg \
+  libiomp-dev \
+  libyaml-dev \
+  libz-dev \
+  libjpeg-dev \
+  libasound2-dev \
+  libsndfile-dev \
+  python \
+  python-dev \
+  python-setuptools \
+  python-wheel \
+  software-properties-common \
+  sudo \
+  wget \
+  vim
+
+# Install Valgrind separately since the apt-get version is too old.
+mkdir valgrind_build && cd valgrind_build
+if ! wget http://valgrind.org/downloads/valgrind-3.14.0.tar.bz2
+then
+  wget https://sourceware.org/ftp/valgrind/valgrind-3.14.0.tar.bz2
+fi
+tar -xjf valgrind-3.14.0.tar.bz2
+cd valgrind-3.14.0
+./configure --prefix=/usr/local
+make
+sudo make install
+cd ../../
+rm -rf valgrind_build
+alias valgrind="/usr/local/bin/valgrind"
+
+# TODO: THIS IS A HACK!!!
+# distributed nccl(2) tests are a bit busted, see https://github.com/pytorch/pytorch/issues/5877
+if dpkg -s libnccl-dev; then
+  apt-get remove -y libnccl-dev libnccl2 --allow-change-held-packages
+fi
+
+# Cleanup package manager
+apt-get autoclean && apt-get clean
+rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*

.circleci/docker/common/install_cache.sh

@@ -0,0 +1,35 @@
+#!/bin/bash
+
+set -ex
+
+mkdir -p /opt/cache/bin
+mkdir -p /opt/cache/lib
+sed -e 's|PATH="\(.*\)"|PATH="/opt/cache/bin:\1"|g' -i /etc/environment
+export PATH="/opt/cache/bin:$PATH"
+
+# Setup compiler cache
+curl https://s3.amazonaws.com/ossci-linux/sccache -o /opt/cache/bin/sccache
+chmod a+x /opt/cache/bin/sccache
+
+function write_sccache_stub() {
+  printf "#!/bin/sh\nexec sccache $(which $1) \$*" > "/opt/cache/bin/$1"
+  chmod a+x "/opt/cache/bin/$1"
+}
+
+write_sccache_stub cc
+write_sccache_stub c++
+write_sccache_stub gcc
+write_sccache_stub g++
+write_sccache_stub clang
+write_sccache_stub clang++
+
+if [ -n "$CUDA_VERSION" ]; then
+  # TODO: This is a workaround for the fact that PyTorch's FindCUDA
+  # implementation cannot find nvcc if it is setup this way, because it
+  # appears to search for the nvcc in PATH, and use its path to infer
+  # where CUDA is installed.  Instead, we install an nvcc symlink outside
+  # of the PATH, and set CUDA_NVCC_EXECUTABLE so that we make use of it.
+
+  printf "#!/bin/sh\nexec sccache $(which nvcc) \"\$@\"" > /opt/cache/lib/nvcc
+  chmod a+x /opt/cache/lib/nvcc
+fi

.circleci/docker/common/install_clang.sh

@@ -0,0 +1,44 @@
+#!/bin/bash
+
+set -ex
+
+if [ -n "$CLANG_VERSION" ]; then
+
+  if [[ $CLANG_VERSION == 7 && $UBUNTU_VERSION == 16.04 ]]; then
+    wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
+    sudo apt-add-repository "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-7 main"
+  elif [[ $CLANG_VERSION == 9 && $UBUNTU_VERSION == 18.04 ]]; then
+    sudo apt-get update
+    # gpg-agent is not available by default on 18.04
+    sudo apt-get install  -y --no-install-recommends gpg-agent
+    wget --no-check-certificate -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add  -
+    apt-add-repository "deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-${CLANG_VERSION} main"
+  fi
+
+  sudo apt-get update
+  apt-get install -y --no-install-recommends clang-"$CLANG_VERSION"
+  apt-get install -y --no-install-recommends llvm-"$CLANG_VERSION"
+
+  # Install dev version of LLVM.
+  if [ -n "$LLVMDEV" ]; then
+    sudo apt-get install -y --no-install-recommends llvm-"$CLANG_VERSION"-dev
+  fi
+
+  # Use update-alternatives to make this version the default
+  # TODO: Decide if overriding gcc as well is a good idea
+  # update-alternatives --install /usr/bin/gcc gcc /usr/bin/clang-"$CLANG_VERSION" 50
+  # update-alternatives --install /usr/bin/g++ g++ /usr/bin/clang++-"$CLANG_VERSION" 50
+  update-alternatives --install /usr/bin/clang clang /usr/bin/clang-"$CLANG_VERSION" 50
+  update-alternatives --install /usr/bin/clang++ clang++ /usr/bin/clang++-"$CLANG_VERSION" 50
+
+  # clang's packaging is a little messed up (the runtime libs aren't
+  # added into the linker path), so give it a little help
+  clang_lib=("/usr/lib/llvm-$CLANG_VERSION/lib/clang/"*"/lib/linux")
+  echo "$clang_lib" > /etc/ld.so.conf.d/clang.conf
+  ldconfig
+
+  # Cleanup package manager
+  apt-get autoclean && apt-get clean
+  rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
+
+fi

.circleci/docker/common/install_cmake.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+
+set -ex
+
+[ -n "$CMAKE_VERSION" ]
+
+# Turn 3.6.3 into v3.6
+path=$(echo "${CMAKE_VERSION}" | sed -e 's/\([0-9].[0-9]\+\).*/v\1/')
+file="cmake-${CMAKE_VERSION}-Linux-x86_64.tar.gz"
+
+# Download and install specific CMake version in /usr/local
+pushd /tmp
+curl -Os "https://cmake.org/files/${path}/${file}"
+tar -C /usr/local --strip-components 1 --no-same-owner -zxf cmake-*.tar.gz
+rm -f cmake-*.tar.gz
+popd

.circleci/docker/common/install_conda.sh

@@ -0,0 +1,94 @@
+#!/bin/bash
+
+set -ex
+
+# Optionally install conda
+if [ -n "$ANACONDA_PYTHON_VERSION" ]; then
+  BASE_URL="https://repo.continuum.io/miniconda"
+
+  MAJOR_PYTHON_VERSION=$(echo "$ANACONDA_PYTHON_VERSION" | cut -d . -f 1)
+
+  case "$MAJOR_PYTHON_VERSION" in
+    2)
+      CONDA_FILE="Miniconda2-latest-Linux-x86_64.sh"
+    ;;
+    3)
+      CONDA_FILE="Miniconda3-latest-Linux-x86_64.sh"
+    ;;
+    *)
+      echo "Unsupported ANACONDA_PYTHON_VERSION: $ANACONDA_PYTHON_VERSION"
+      exit 1
+      ;;
+  esac
+
+  mkdir /opt/conda
+  chown jenkins:jenkins /opt/conda
+
+  as_jenkins() {
+    # NB: unsetting the environment variables works around a conda bug
+    # https://github.com/conda/conda/issues/6576
+    # NB: Pass on PATH and LD_LIBRARY_PATH to sudo invocation
+    # NB: This must be run from a directory that jenkins has access to,
+    # works around https://github.com/conda/conda-package-handling/pull/34
+    sudo -H -u jenkins env -u SUDO_UID -u SUDO_GID -u SUDO_COMMAND -u SUDO_USER env "PATH=$PATH" "LD_LIBRARY_PATH=$LD_LIBRARY_PATH" $*
+  }
+
+  pushd /tmp
+  wget -q "${BASE_URL}/${CONDA_FILE}"
+  chmod +x "${CONDA_FILE}"
+  as_jenkins ./"${CONDA_FILE}" -b -f -p "/opt/conda"
+  popd
+
+  # NB: Don't do this, rely on the rpath to get it right
+  #echo "/opt/conda/lib" > /etc/ld.so.conf.d/conda-python.conf
+  #ldconfig
+  sed -e 's|PATH="\(.*\)"|PATH="/opt/conda/bin:\1"|g' -i /etc/environment
+  export PATH="/opt/conda/bin:$PATH"
+
+  # Ensure we run conda in a directory that jenkins has write access to
+  pushd /opt/conda
+
+  # Track latest conda update
+  as_jenkins conda update -n base conda
+
+  # Install correct Python version
+  as_jenkins conda install python="$ANACONDA_PYTHON_VERSION"
+
+  conda_install() {
+    # Ensure that the install command don't upgrade/downgrade Python
+    # This should be called as
+    #   conda_install pkg1 pkg2 ... [-c channel]
+    as_jenkins conda install -q -y python="$ANACONDA_PYTHON_VERSION" $*
+  }
+
+  # Install PyTorch conda deps, as per https://github.com/pytorch/pytorch README
+  # DO NOT install cmake here as it would install a version newer than 3.5, but
+  # we want to pin to version 3.5.
+  conda_install numpy pyyaml mkl mkl-include setuptools cffi typing future six
+  if [[ "$CUDA_VERSION" == 8.0* ]]; then
+    conda_install magma-cuda80 -c pytorch
+  elif [[ "$CUDA_VERSION" == 9.0* ]]; then
+    conda_install magma-cuda90 -c pytorch
+  elif [[ "$CUDA_VERSION" == 9.1* ]]; then
+    conda_install magma-cuda91 -c pytorch
+  elif [[ "$CUDA_VERSION" == 9.2* ]]; then
+    conda_install magma-cuda92 -c pytorch
+  elif [[ "$CUDA_VERSION" == 10.0* ]]; then
+    conda_install magma-cuda100 -c pytorch
+  elif [[ "$CUDA_VERSION" == 10.1* ]]; then
+    conda_install magma-cuda101 -c pytorch
+  fi
+
+  # TODO: This isn't working atm
+  conda_install nnpack -c killeent
+
+  # Install some other packages
+  # TODO: Why is scipy pinned
+  # numba & llvmlite is pinned because of https://github.com/numba/numba/issues/4368
+  # scikit-learn is pinned because of
+  # https://github.com/scikit-learn/scikit-learn/issues/14485 (affects gcc 5.5
+  # only)
+  as_jenkins pip install --progress-bar off pytest scipy==1.1.0 scikit-learn==0.20.3 scikit-image librosa>=0.6.2 psutil numba==0.43.1 llvmlite==0.28.0
+
+  popd
+fi

.circleci/docker/common/install_db.sh

@@ -0,0 +1,61 @@
+#!/bin/bash
+
+set -ex
+
+# This function installs protobuf 2.6
+install_protobuf_26() {
+  pb_dir="/usr/temp_pb_install_dir"
+  mkdir -p $pb_dir
+
+  # On the nvidia/cuda:9-cudnn7-devel-centos7 image we need this symlink or
+  # else it will fail with
+  #   g++: error: ./../lib64/crti.o: No such file or directory
+  ln -s /usr/lib64 "$pb_dir/lib64"
+
+  curl -LO "https://github.com/google/protobuf/releases/download/v2.6.1/protobuf-2.6.1.tar.gz"
+  tar -xvz -C "$pb_dir" --strip-components 1 -f protobuf-2.6.1.tar.gz
+  pushd "$pb_dir" && ./configure && make && make check && sudo make install && sudo ldconfig
+  popd
+  rm -rf $pb_dir
+}
+
+install_ubuntu() {
+  apt-get update
+  apt-get install -y --no-install-recommends \
+          libhiredis-dev \
+          libleveldb-dev \
+          liblmdb-dev \
+          libsnappy-dev
+
+  # Cleanup
+  apt-get autoclean && apt-get clean
+  rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
+}
+
+install_centos() {
+  # Need EPEL for many packages we depend on.
+  # See http://fedoraproject.org/wiki/EPEL
+  yum --enablerepo=extras install -y epel-release
+
+  yum install -y \
+      hiredis-devel \
+      leveldb-devel \
+      lmdb-devel \
+      snappy-devel
+
+  # Cleanup
+  yum clean all
+  rm -rf /var/cache/yum
+  rm -rf /var/lib/yum/yumdb
+  rm -rf /var/lib/yum/history
+}
+
+# Install base packages depending on the base OS
+if [ -f /etc/lsb-release ]; then
+  install_ubuntu
+elif [ -f /etc/os-release ]; then
+  install_centos
+else
+  echo "Unable to determine OS..."
+  exit 1
+fi

.circleci/docker/common/install_gcc.sh

@@ -0,0 +1,19 @@
+#!/bin/bash
+
+set -ex
+
+if [ -n "$GCC_VERSION" ]; then
+
+  # Need the official toolchain repo to get alternate packages
+  add-apt-repository ppa:ubuntu-toolchain-r/test
+  apt-get update
+  apt-get install -y g++-$GCC_VERSION
+
+  update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-"$GCC_VERSION" 50
+  update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-"$GCC_VERSION" 50
+
+  # Cleanup package manager
+  apt-get autoclean && apt-get clean
+  rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
+
+fi

.circleci/docker/common/install_jni.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+
+set -ex
+
+mkdir -p /usr/local/include
+cp jni.h /usr/local/include

.circleci/docker/common/install_katex.sh

@@ -0,0 +1,20 @@
+#!/bin/bash
+
+set -ex
+
+if [ -n "$KATEX" ]; then
+
+  curl -sL https://deb.nodesource.com/setup_12.x | sudo -E bash -
+  sudo apt-get install -y nodejs
+
+  curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | sudo apt-key add -
+  echo "deb https://dl.yarnpkg.com/debian/ stable main" | sudo tee /etc/apt/sources.list.d/yarn.list
+
+  apt-get update
+  apt-get install -y --no-install-recommends yarn
+  yarn global add katex --prefix /usr/local
+
+  apt-get autoclean && apt-get clean
+  rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
+
+fi

.circleci/docker/common/install_ninja.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+
+set -ex
+
+[ -n "$NINJA_VERSION" ]
+
+url="https://github.com/ninja-build/ninja/releases/download/v${NINJA_VERSION}/ninja-linux.zip"
+
+pushd /tmp
+wget --no-verbose --output-document=ninja-linux.zip "$url"
+unzip ninja-linux.zip -d /usr/local/bin
+rm -f ninja-linux.zip
+popd

.circleci/docker/common/install_protobuf.sh

@@ -0,0 +1,56 @@
+#!/bin/bash
+
+set -ex
+
+# This function installs protobuf 2.6
+install_protobuf_26() {
+  pb_dir="/usr/temp_pb_install_dir"
+  mkdir -p $pb_dir
+
+  # On the nvidia/cuda:9-cudnn7-devel-centos7 image we need this symlink or
+  # else it will fail with
+  #   g++: error: ./../lib64/crti.o: No such file or directory
+  ln -s /usr/lib64 "$pb_dir/lib64"
+
+  curl -LO "https://github.com/google/protobuf/releases/download/v2.6.1/protobuf-2.6.1.tar.gz"
+  tar -xvz -C "$pb_dir" --strip-components 1 -f protobuf-2.6.1.tar.gz
+  pushd "$pb_dir" && ./configure && make && make check && sudo make install && sudo ldconfig
+  popd
+  rm -rf $pb_dir
+}
+
+install_ubuntu() {
+  # Ubuntu 14.04 ships with protobuf 2.5, but ONNX needs protobuf >= 2.6
+  # so we install that here if on 14.04
+  # Ubuntu 14.04 also has cmake 2.8.12 as the default option, so we will
+  # install cmake3 here and use cmake3.
+  apt-get update
+  if [[ "$UBUNTU_VERSION" == 14.04 ]]; then
+    apt-get install -y --no-install-recommends cmake3
+    install_protobuf_26
+  else
+    apt-get install -y --no-install-recommends \
+            libprotobuf-dev \
+            protobuf-compiler
+  fi
+
+  # Cleanup
+  apt-get autoclean && apt-get clean
+  rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
+}
+
+install_centos() {
+  # Centos7 ships with protobuf 2.5, but ONNX needs protobuf >= 2.6
+  # so we always install install that here
+  install_protobuf_26
+}
+
+# Install base packages depending on the base OS
+if [ -f /etc/lsb-release ]; then
+  install_ubuntu
+elif [ -f /etc/os-release ]; then
+  install_centos
+else
+  echo "Unable to determine OS..."
+  exit 1
+fi

.circleci/docker/common/install_thrift.sh

@@ -0,0 +1,14 @@
+apt-get update
+apt-get install -y sudo wget libboost-dev libboost-test-dev libboost-program-options-dev libboost-filesystem-dev libboost-thread-dev libevent-dev automake libtool flex bison pkg-config g++ libssl-dev
+wget https://www-us.apache.org/dist/thrift/0.12.0/thrift-0.12.0.tar.gz
+tar -xvf thrift-0.12.0.tar.gz
+cd thrift-0.12.0
+for file in ./compiler/cpp/Makefile*; do
+  sed -i 's/\-Werror//' $file
+done
+./bootstrap.sh
+./configure --without-php --without-java --without-python --without-nodejs --without-go --without-ruby
+sudo make
+sudo make install
+cd ..
+rm thrift-0.12.0.tar.gz

.circleci/docker/common/install_travis_python.sh

@@ -0,0 +1,94 @@
+#!/bin/bash
+
+set -ex
+
+as_jenkins() {
+  # NB: Preserve PATH and LD_LIBRARY_PATH changes
+  sudo -H -u jenkins env "PATH=$PATH" "LD_LIBRARY_PATH=$LD_LIBRARY_PATH" $*
+}
+
+if [ -n "$TRAVIS_PYTHON_VERSION" ]; then
+
+  mkdir -p /opt/python
+  chown jenkins:jenkins /opt/python
+
+  # Download Python binary from Travis
+  pushd tmp
+  as_jenkins wget --quiet https://s3.amazonaws.com/travis-python-archives/binaries/ubuntu/14.04/x86_64/python-$TRAVIS_PYTHON_VERSION.tar.bz2
+  # NB: The tarball also comes with /home/travis virtualenv that we
+  # don't care about.  (Maybe we should, but we've worked around the
+  # "how do I install to python" issue by making this entire directory
+  # user-writable "lol")
+  # NB: Relative ordering of opt/python and flags matters
+  as_jenkins tar xjf python-$TRAVIS_PYTHON_VERSION.tar.bz2 --strip-components=2 --directory /opt/python opt/python
+  popd
+
+  echo "/opt/python/$TRAVIS_PYTHON_VERSION/lib" > /etc/ld.so.conf.d/travis-python.conf
+  ldconfig
+  sed -e 's|PATH="\(.*\)"|PATH="/opt/python/'"$TRAVIS_PYTHON_VERSION"'/bin:\1"|g' -i /etc/environment
+  export PATH="/opt/python/$TRAVIS_PYTHON_VERSION/bin:$PATH"
+
+  python --version
+  pip --version
+
+  # Install pip from source.
+  # The python-pip package on Ubuntu Trusty is old
+  # and upon install numpy doesn't use the binary
+  # distribution, and fails to compile it from source.
+  pushd tmp
+  as_jenkins curl -L -O https://pypi.python.org/packages/11/b6/abcb525026a4be042b486df43905d6893fb04f05aac21c32c638e939e447/pip-9.0.1.tar.gz
+  as_jenkins tar zxf pip-9.0.1.tar.gz
+  pushd pip-9.0.1
+  as_jenkins python setup.py install
+  popd
+  rm -rf pip-9.0.1*
+  popd
+
+  # Install pip packages
+  as_jenkins pip install --upgrade pip
+
+  pip --version
+
+  if [[ "$TRAVIS_PYTHON_VERSION" == nightly ]]; then
+      # These two packages have broken Cythonizations uploaded
+      # to PyPi, see:
+      #
+      #  - https://github.com/numpy/numpy/issues/10500
+      #  - https://github.com/yaml/pyyaml/issues/117
+      #
+      # Furthermore, the released version of Cython does not
+      # have these issues fixed.
+      #
+      # While we are waiting on fixes for these, we build
+      # from Git for now.  Feel free to delete this conditional
+      # branch if things start working again (you may need
+      # to do this if these packages regress on Git HEAD.)
+      as_jenkins pip install git+https://github.com/cython/cython.git
+      as_jenkins pip install git+https://github.com/numpy/numpy.git
+      as_jenkins pip install git+https://github.com/yaml/pyyaml.git
+  else
+      as_jenkins pip install numpy pyyaml
+  fi
+
+  as_jenkins pip install \
+      future \
+      hypothesis \
+      protobuf \
+      pytest \
+      pillow \
+      typing
+
+  as_jenkins pip install mkl mkl-devel
+
+  # SciPy does not support Python 3.7 or Python 2.7.9
+  if [[ "$TRAVIS_PYTHON_VERSION" != nightly ]] && [[ "$TRAVIS_PYTHON_VERSION" != "2.7.9" ]]; then
+      as_jenkins pip install scipy==1.1.0 scikit-image librosa>=0.6.2
+  fi
+
+  # Install psutil for dataloader tests
+  as_jenkins pip install psutil
+
+  # Cleanup package manager
+  apt-get autoclean && apt-get clean
+  rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
+fi

.circleci/docker/common/install_user.sh

@@ -0,0 +1,20 @@
+#!/bin/bash
+
+set -ex
+
+# Mirror jenkins user in container
+echo "jenkins:x:1014:1014::/var/lib/jenkins:" >> /etc/passwd
+echo "jenkins:x:1014:" >> /etc/group
+
+# Create $HOME
+mkdir -p /var/lib/jenkins
+chown jenkins:jenkins /var/lib/jenkins
+mkdir -p /var/lib/jenkins/.ccache
+chown jenkins:jenkins /var/lib/jenkins/.ccache
+
+# Allow writing to /usr/local (for make install)
+chown jenkins:jenkins /usr/local
+
+# Allow sudo
+# TODO: Maybe we shouldn't
+echo 'jenkins ALL=(ALL) NOPASSWD:ALL' > /etc/sudoers.d/jenkins

.circleci/docker/common/install_vision.sh

@@ -0,0 +1,57 @@
+#!/bin/bash
+
+set -ex
+
+# This function installs protobuf 2.6
+install_protobuf_26() {
+  pb_dir="/usr/temp_pb_install_dir"
+  mkdir -p $pb_dir
+
+  # On the nvidia/cuda:9-cudnn7-devel-centos7 image we need this symlink or
+  # else it will fail with
+  #   g++: error: ./../lib64/crti.o: No such file or directory
+  ln -s /usr/lib64 "$pb_dir/lib64"
+
+  curl -LO "https://github.com/google/protobuf/releases/download/v2.6.1/protobuf-2.6.1.tar.gz"
+  tar -xvz -C "$pb_dir" --strip-components 1 -f protobuf-2.6.1.tar.gz
+  pushd "$pb_dir" && ./configure && make && make check && sudo make install && sudo ldconfig
+  popd
+  rm -rf $pb_dir
+}
+
+install_ubuntu() {
+  apt-get update
+  apt-get install -y --no-install-recommends \
+          libopencv-dev \
+          libavcodec-dev
+
+  # Cleanup
+  apt-get autoclean && apt-get clean
+  rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
+}
+
+install_centos() {
+  # Need EPEL for many packages we depend on.
+  # See http://fedoraproject.org/wiki/EPEL
+  yum --enablerepo=extras install -y epel-release
+
+  yum install -y \
+      opencv-devel \
+      ffmpeg-devel
+
+  # Cleanup
+  yum clean all
+  rm -rf /var/cache/yum
+  rm -rf /var/lib/yum/yumdb
+  rm -rf /var/lib/yum/history
+}
+
+# Install base packages depending on the base OS
+if [ -f /etc/lsb-release ]; then
+  install_ubuntu
+elif [ -f /etc/os-release ]; then
+  install_centos
+else
+  echo "Unable to determine OS..."
+  exit 1
+fi

.circleci/docker/ubuntu-cuda/Dockerfile

@@ -0,0 +1,85 @@
+ARG UBUNTU_VERSION
+ARG CUDA_VERSION
+ARG CUDNN_VERSION
+
+FROM nvidia/cuda:${CUDA_VERSION}-cudnn${CUDNN_VERSION}-devel-ubuntu${UBUNTU_VERSION}
+
+ARG UBUNTU_VERSION
+ARG CUDA_VERSION
+ARG CUDNN_VERSION
+
+ENV DEBIAN_FRONTEND noninteractive
+
+# Install common dependencies (so that this step can be cached separately)
+ARG EC2
+ADD ./common/install_base.sh install_base.sh
+RUN bash ./install_base.sh && rm install_base.sh
+
+# Install user
+ADD ./common/install_user.sh install_user.sh
+RUN bash ./install_user.sh && rm install_user.sh
+
+# Install katex
+ARG KATEX
+ADD ./common/install_katex.sh install_katex.sh
+RUN bash ./install_katex.sh && rm install_katex.sh
+
+# Install conda
+ENV PATH /opt/conda/bin:$PATH
+ARG ANACONDA_PYTHON_VERSION
+ADD ./common/install_conda.sh install_conda.sh
+RUN bash ./install_conda.sh && rm install_conda.sh
+
+# Install gcc
+ARG GCC_VERSION
+ADD ./common/install_gcc.sh install_gcc.sh
+RUN bash ./install_gcc.sh && rm install_gcc.sh
+
+# Install non-standard Python versions (via Travis binaries)
+ARG TRAVIS_PYTHON_VERSION
+ENV PATH /opt/python/$TRAVIS_PYTHON_VERSION/bin:$PATH
+ADD ./common/install_travis_python.sh install_travis_python.sh
+RUN bash ./install_travis_python.sh && rm install_travis_python.sh
+
+# (optional) Install protobuf for ONNX
+ARG PROTOBUF
+ADD ./common/install_protobuf.sh install_protobuf.sh
+RUN if [ -n "${PROTOBUF}" ]; then bash ./install_protobuf.sh; fi
+RUN rm install_protobuf.sh
+ENV INSTALLED_PROTOBUF ${PROTOBUF}
+
+# (optional) Install database packages like LMDB and LevelDB
+ARG DB
+ADD ./common/install_db.sh install_db.sh
+RUN if [ -n "${DB}" ]; then bash ./install_db.sh; fi
+RUN rm install_db.sh
+ENV INSTALLED_DB ${DB}
+
+# (optional) Install vision packages like OpenCV and ffmpeg
+ARG VISION
+ADD ./common/install_vision.sh install_vision.sh
+RUN if [ -n "${VISION}" ]; then bash ./install_vision.sh; fi
+RUN rm install_vision.sh
+ENV INSTALLED_VISION ${VISION}
+
+# Install ccache/sccache (do this last, so we get priority in PATH)
+ADD ./common/install_cache.sh install_cache.sh
+ENV PATH /opt/cache/bin:$PATH
+RUN bash ./install_cache.sh && rm install_cache.sh
+ENV CUDA_NVCC_EXECUTABLE=/opt/cache/lib/nvcc
+
+# Add jni.h for java host build
+ADD ./common/install_jni.sh install_jni.sh
+ADD ./java/jni.h jni.h
+RUN bash ./install_jni.sh && rm install_jni.sh
+
+# Include BUILD_ENVIRONMENT environment variable in image
+ARG BUILD_ENVIRONMENT
+ENV BUILD_ENVIRONMENT ${BUILD_ENVIRONMENT}
+
+# AWS specific CUDA build guidance
+ENV TORCH_CUDA_ARCH_LIST Maxwell
+ENV TORCH_NVCC_FLAGS "-Xfatbin -compress-all"
+
+USER jenkins
+CMD ["bash"]

.circleci/docker/ubuntu/Dockerfile

@@ -0,0 +1,114 @@
+ARG UBUNTU_VERSION
+
+FROM ubuntu:${UBUNTU_VERSION}
+
+ARG UBUNTU_VERSION
+
+ENV DEBIAN_FRONTEND noninteractive
+
+# Install common dependencies (so that this step can be cached separately)
+ARG EC2
+ADD ./common/install_base.sh install_base.sh
+RUN bash ./install_base.sh && rm install_base.sh
+
+# Install clang
+ARG LLVMDEV
+ARG CLANG_VERSION
+ADD ./common/install_clang.sh install_clang.sh
+RUN bash ./install_clang.sh && rm install_clang.sh
+
+# (optional) Install thrift.
+ARG THRIFT
+ADD ./common/install_thrift.sh install_thrift.sh
+RUN if [ -n "${THRIFT}" ]; then bash ./install_thrift.sh; fi
+RUN rm install_thrift.sh
+ENV INSTALLED_THRIFT ${THRIFT}
+
+# Install user
+ADD ./common/install_user.sh install_user.sh
+RUN bash ./install_user.sh && rm install_user.sh
+
+# Install katex
+ARG KATEX
+ADD ./common/install_katex.sh install_katex.sh
+RUN bash ./install_katex.sh && rm install_katex.sh
+
+# Install conda
+ENV PATH /opt/conda/bin:$PATH
+ARG ANACONDA_PYTHON_VERSION
+ADD ./common/install_conda.sh install_conda.sh
+RUN bash ./install_conda.sh && rm install_conda.sh
+
+# Install gcc
+ARG GCC_VERSION
+ADD ./common/install_gcc.sh install_gcc.sh
+RUN bash ./install_gcc.sh && rm install_gcc.sh
+
+# Install non-standard Python versions (via Travis binaries)
+ARG TRAVIS_PYTHON_VERSION
+ENV PATH /opt/python/$TRAVIS_PYTHON_VERSION/bin:$PATH
+ADD ./common/install_travis_python.sh install_travis_python.sh
+RUN bash ./install_travis_python.sh && rm install_travis_python.sh
+
+# (optional) Install protobuf for ONNX
+ARG PROTOBUF
+ADD ./common/install_protobuf.sh install_protobuf.sh
+RUN if [ -n "${PROTOBUF}" ]; then bash ./install_protobuf.sh; fi
+RUN rm install_protobuf.sh
+ENV INSTALLED_PROTOBUF ${PROTOBUF}
+
+# (optional) Install database packages like LMDB and LevelDB
+ARG DB
+ADD ./common/install_db.sh install_db.sh
+RUN if [ -n "${DB}" ]; then bash ./install_db.sh; fi
+RUN rm install_db.sh
+ENV INSTALLED_DB ${DB}
+
+# (optional) Install vision packages like OpenCV and ffmpeg
+ARG VISION
+ADD ./common/install_vision.sh install_vision.sh
+RUN if [ -n "${VISION}" ]; then bash ./install_vision.sh; fi
+RUN rm install_vision.sh
+ENV INSTALLED_VISION ${VISION}
+
+# (optional) Install Android NDK
+ARG ANDROID
+ARG ANDROID_NDK
+ARG GRADLE_VERSION
+ADD ./common/install_android.sh install_android.sh
+ADD ./android/AndroidManifest.xml AndroidManifest.xml
+ADD ./android/build.gradle build.gradle
+RUN if [ -n "${ANDROID}" ]; then bash ./install_android.sh; fi
+RUN rm install_android.sh
+RUN rm AndroidManifest.xml
+RUN rm build.gradle
+ENV INSTALLED_ANDROID ${ANDROID}
+
+# (optional) Install non-default CMake version
+ARG CMAKE_VERSION
+ADD ./common/install_cmake.sh install_cmake.sh
+RUN if [ -n "${CMAKE_VERSION}" ]; then bash ./install_cmake.sh; fi
+RUN rm install_cmake.sh
+
+# (optional) Install non-default Ninja version
+ARG NINJA_VERSION
+ADD ./common/install_ninja.sh install_ninja.sh
+RUN if [ -n "${NINJA_VERSION}" ]; then bash ./install_ninja.sh; fi
+RUN rm install_ninja.sh
+
+# Install ccache/sccache (do this last, so we get priority in PATH)
+ADD ./common/install_cache.sh install_cache.sh
+ENV PATH /opt/cache/bin:$PATH
+RUN bash ./install_cache.sh && rm install_cache.sh
+
+# Add jni.h for java host build
+ADD ./common/install_jni.sh install_jni.sh
+ADD ./java/jni.h jni.h
+RUN bash ./install_jni.sh && rm install_jni.sh
+
+# Include BUILD_ENVIRONMENT environment variable in image
+ARG BUILD_ENVIRONMENT
+ENV BUILD_ENVIRONMENT ${BUILD_ENVIRONMENT}
+
+USER jenkins
+CMD ["bash"]

.circleci/generate_config_yml.py

@@ -88,17 +88,18 @@ YAML_SOURCES = [
     File("job-specs-custom.yml"),
     File("binary_update_htmls.yml"),
     File("binary-build-tests.yml"),
+    File("docker_build_job.yml"),
     File("workflows.yml"),
     Listgen(pytorch_build_definitions.get_workflow_jobs, 3),
     File("workflows-pytorch-macos-builds.yml"),
     File("workflows-pytorch-android-gradle-build.yml"),
     File("workflows-pytorch-ios-builds.yml"),
+    File("workflows-pytorch-mobile-builds.yml"),
+    File("workflows-pytorch-ge-config-tests.yml"),
     Listgen(caffe2_build_definitions.get_workflow_jobs, 3),
     File("workflows-binary-builds-smoke-subset.yml"),
-    Header("Daily smoke test trigger"),
-    Treegen(binary_build_definitions.add_binary_smoke_test_jobs, 1),
-    Header("Daily binary build trigger"),
-    Treegen(binary_build_definitions.add_binary_build_jobs, 1),
+    Listgen(binary_build_definitions.get_binary_smoke_test_jobs, 3),
+    Listgen(binary_build_definitions.get_binary_build_jobs, 3),
     File("workflows-nightly-ios-binary-builds.yml"),
     File("workflows-nightly-android-binary-builds.yml"),
     Header("Nightly tests"),
@@ -106,6 +107,7 @@ YAML_SOURCES = [
     File("workflows-nightly-uploads-header.yml"),
     Listgen(binary_build_definitions.get_nightly_uploads, 3),
     File("workflows-s3-html.yml"),
+    File("workflows-docker-builder.yml")
 ]
 
 

.circleci/scripts/binary_ios_build.sh

@@ -1,8 +1,8 @@
 #!/bin/bash
-set -eux -o pipefail
+set -ex -o pipefail
 
 echo ""
-echo "PWD: ${PWD}"
+echo "DIR: $(pwd)"
 WORKSPACE=/Users/distiller/workspace
 PROJ_ROOT=/Users/distiller/project
 export TCLLIBPATH="/usr/local/lib" 

.circleci/scripts/binary_ios_test.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+set -ex -o pipefail
+
+echo ""
+echo "DIR: $(pwd)"
+PROJ_ROOT=/Users/distiller/project
+cd ${PROJ_ROOT}/ios/TestApp
+# install fastlane
+sudo gem install bundler && bundle install
+# install certificates
+echo "${IOS_CERT_KEY}" >> cert.txt
+base64 --decode cert.txt -o Certificates.p12
+rm cert.txt
+bundle exec fastlane install_cert
+# install the provisioning profile
+PROFILE=TestApp_CI.mobileprovision
+PROVISIONING_PROFILES=~/Library/MobileDevice/Provisioning\ Profiles
+mkdir -pv "${PROVISIONING_PROFILES}"
+cd "${PROVISIONING_PROFILES}"
+echo "${IOS_SIGN_KEY}" >> cert.txt
+base64 --decode cert.txt -o ${PROFILE}
+rm cert.txt
+# run the ruby build script
+if ! [ -x "$(command -v xcodebuild)" ]; then
+    echo 'Error: xcodebuild is not installed.'
+    exit 1
+fi 
+PROFILE=TestApp_CI
+ruby ${PROJ_ROOT}/scripts/xcode_build.rb -i ${PROJ_ROOT}/build_ios/install -x ${PROJ_ROOT}/ios/TestApp/TestApp.xcodeproj -p ${IOS_PLATFORM} -c ${PROFILE} -t ${IOS_DEV_TEAM_ID}

.circleci/scripts/binary_ios_upload.sh

@@ -1,8 +1,8 @@
 #!/bin/bash
-set -eux -o pipefail
+set -ex -o pipefail
 
 echo ""
-echo "PWD: $(pwd)"
+echo "DIR: $(pwd)"
 WORKSPACE=/Users/distiller/workspace
 PROJ_ROOT=/Users/distiller/project
 ARTIFACTS_DIR=${WORKSPACE}/ios

.circleci/scripts/binary_linux_test.sh

@@ -11,6 +11,8 @@ if [[ "$PACKAGE_TYPE" == conda ]]; then
   source activate testenv >/dev/null
 elif [[ "$DESIRED_PYTHON" == 2.7mu ]]; then
   export PATH="/opt/python/cp27-cp27mu/bin:\$PATH"
+elif [[ "$DESIRED_PYTHON" == 3.8m ]]; then
+  export PATH="/opt/python/cp38-cp38/bin:\$PATH"
 elif [[ "$PACKAGE_TYPE" != libtorch ]]; then
   python_nodot="\$(echo $DESIRED_PYTHON | tr -d m.u)"
   export PATH="/opt/python/cp\$python_nodot-cp\${python_nodot}m/bin:\$PATH"

.circleci/scripts/binary_macos_test.sh

@@ -5,26 +5,30 @@ source "/Users/distiller/project/env"
 export "PATH=$workdir/miniconda/bin:$PATH"
 pkg="$workdir/final_pkgs/$(ls $workdir/final_pkgs)"
 
-# Don't test libtorch
-# TODO we should test libtorch
-if [[ "$PACKAGE_TYPE" == libtorch ]]; then
-  exit 0
-fi
-
 # Create a new test env
 # TODO cut all this out into a separate test job and have an entirely different
 # miniconda
-source deactivate || true
-conda create -qyn test python="$DESIRED_PYTHON"
-source activate test >/dev/null
+if [[ "$PACKAGE_TYPE" != libtorch ]]; then
+  source deactivate || true
+  conda create -qyn test python="$DESIRED_PYTHON"
+  source activate test >/dev/null
+fi
 
 # Install the package
-if [[ "$PACKAGE_TYPE" == conda ]]; then
+if [[ "$PACKAGE_TYPE" == libtorch ]]; then
+  pkg="$(ls $workdir/final_pkgs/*-latest.zip)"
+  unzip "$pkg" -d /tmp
+  cd /tmp/libtorch
+elif [[ "$PACKAGE_TYPE" == conda ]]; then
   conda install -y "$pkg" --offline
 else
   pip install "$pkg" --no-index --no-dependencies -v
 fi
 
 # Test
-pushd "$workdir/pytorch"
-$workdir/builder/run_tests.sh "$PACKAGE_TYPE" "$DESIRED_PYTHON" "$DESIRED_CUDA"
+if [[ "$PACKAGE_TYPE" == libtorch ]]; then
+  $workdir/builder/check_binary.sh
+else
+  pushd "$workdir/pytorch"
+  $workdir/builder/run_tests.sh "$PACKAGE_TYPE" "$DESIRED_PYTHON" "$DESIRED_CUDA"
+fi

.circleci/scripts/binary_populate_env.sh

@@ -32,11 +32,11 @@ fi
 export DOCKER_IMAGE=${DOCKER_IMAGE:-}
 if [[ -z "$DOCKER_IMAGE" ]]; then
   if [[ "$PACKAGE_TYPE" == conda ]]; then
-    export DOCKER_IMAGE="soumith/conda-cuda"
+    export DOCKER_IMAGE="pytorch/conda-cuda"
   elif [[ "$DESIRED_CUDA" == cpu ]]; then
-    export DOCKER_IMAGE="soumith/manylinux-cuda100"
+    export DOCKER_IMAGE="pytorch/manylinux-cuda100"
   else
-    export DOCKER_IMAGE="soumith/manylinux-cuda${DESIRED_CUDA:2}"
+    export DOCKER_IMAGE="pytorch/manylinux-cuda${DESIRED_CUDA:2}"
   fi
 fi
 
@@ -55,13 +55,34 @@ fi
 
 # We put this here so that OVERRIDE_PACKAGE_VERSION below can read from it
 export DATE="$(date -u +%Y%m%d)"
-if [[ "$(uname)" == 'Darwin' ]] || [[ "$DESIRED_CUDA" == "cu100" ]] || [[ "$PACKAGE_TYPE" == conda ]]; then
-  export PYTORCH_BUILD_VERSION="1.3.0.dev$DATE"
+if [[ "$(uname)" == 'Darwin' ]] || [[ "$DESIRED_CUDA" == "cu101" ]] || [[ "$PACKAGE_TYPE" == conda ]]; then
+  export PYTORCH_BUILD_VERSION="1.4.0.dev$DATE"
 else
-  export PYTORCH_BUILD_VERSION="1.3.0.dev$DATE+$DESIRED_CUDA"
+  export PYTORCH_BUILD_VERSION="1.4.0.dev$DATE+$DESIRED_CUDA"
 fi
 export PYTORCH_BUILD_NUMBER=1
 
+
+JAVA_HOME=
+BUILD_JNI=OFF
+if [[ "$PACKAGE_TYPE" == libtorch ]]; then
+  POSSIBLE_JAVA_HOMES=()
+  POSSIBLE_JAVA_HOMES+=(/usr/local)
+  POSSIBLE_JAVA_HOMES+=(/usr/lib/jvm/java-8-openjdk-amd64)
+  POSSIBLE_JAVA_HOMES+=(/Library/Java/JavaVirtualMachines/*.jdk/Contents/Home)
+  for JH in "${POSSIBLE_JAVA_HOMES[@]}" ; do
+    if [[ -e "$JH/include/jni.h" ]] ; then
+      echo "Found jni.h under $JH"
+      JAVA_HOME="$JH"
+      BUILD_JNI=ON
+      break
+    fi
+  done
+  if [ -z "$JAVA_HOME" ]; then
+    echo "Did not find jni.h"
+  fi
+fi
+
 cat >>"$envfile" <<EOL
 # =================== The following code will be executed inside Docker container ===================
 export TZ=UTC
@@ -75,7 +96,7 @@ export BUILD_PYTHONLESS="${BUILD_PYTHONLESS:-}"
 export DESIRED_DEVTOOLSET="$DESIRED_DEVTOOLSET"
 
 export DATE="$DATE"
-export NIGHTLIES_DATE_PREAMBLE=1.3.0.dev
+export NIGHTLIES_DATE_PREAMBLE=1.4.0.dev
 export PYTORCH_BUILD_VERSION="$PYTORCH_BUILD_VERSION"
 export PYTORCH_BUILD_NUMBER="$PYTORCH_BUILD_NUMBER"
 export OVERRIDE_PACKAGE_VERSION="$PYTORCH_BUILD_VERSION"
@@ -85,6 +106,8 @@ export TORCH_PACKAGE_NAME='torch'
 export TORCH_CONDA_BUILD_FOLDER='pytorch-nightly'
 
 export USE_FBGEMM=1
+export JAVA_HOME=$JAVA_HOME
+export BUILD_JNI=$BUILD_JNI
 export PIP_UPLOAD_FOLDER="$PIP_UPLOAD_FOLDER"
 export DOCKER_IMAGE="$DOCKER_IMAGE"
 

.circleci/scripts/binary_run_in_docker.sh

@@ -18,9 +18,9 @@ chmod +x /home/circleci/project/ci_test_script.sh
 
 # Run the docker
 if [ -n "${USE_CUDA_DOCKER_RUNTIME:-}" ]; then
-  export id=$(docker run --runtime=nvidia -t -d "${DOCKER_IMAGE}")
+  export id=$(docker run --cap-add=SYS_PTRACE --security-opt seccomp=unconfined --runtime=nvidia -t -d "${DOCKER_IMAGE}")
 else
-  export id=$(docker run -t -d "${DOCKER_IMAGE}")
+  export id=$(docker run --cap-add=SYS_PTRACE --security-opt seccomp=unconfined -t -d "${DOCKER_IMAGE}")
 fi
 
 # Copy the envfile and script with all the code to run into the docker.

.circleci/scripts/build_android_gradle.sh

@@ -4,6 +4,8 @@ set -eux -o pipefail
 export ANDROID_NDK_HOME=/opt/ndk
 export ANDROID_HOME=/opt/android/sdk
 
+# Must be in sync with GRADLE_VERSION in docker image for android
+# https://github.com/pietern/pytorch-dockerfiles/blob/master/build.sh#L155
 export GRADLE_VERSION=4.10.3
 export GRADLE_HOME=/opt/gradle/gradle-$GRADLE_VERSION
 export GRADLE_PATH=$GRADLE_HOME/bin/gradle
@@ -45,15 +47,39 @@ fi
 env
 echo "BUILD_ENVIRONMENT:$BUILD_ENVIRONMENT"
 
+GRADLE_PARAMS="-p android assembleRelease --debug --stacktrace"
+if [[ "${BUILD_ENVIRONMENT}" == *-gradle-build-only-x86_32* ]]; then
+    GRADLE_PARAMS+=" -PABI_FILTERS=x86"
+fi
+
+if [ -n "{GRADLE_OFFLINE:-}" ]; then
+    GRADLE_PARAMS+=" --offline"
+fi
+
+# touch gradle cache files to prevent expiration
+while IFS= read -r -d '' file
+do
+  touch "$file" || true
+done < <(find /var/lib/jenkins/.gradle -type f -print0)
+
+env
+
 export GRADLE_LOCAL_PROPERTIES=~/workspace/android/local.properties
 rm -f $GRADLE_LOCAL_PROPERTIES
 echo "sdk.dir=/opt/android/sdk" >> $GRADLE_LOCAL_PROPERTIES
 echo "ndk.dir=/opt/ndk" >> $GRADLE_LOCAL_PROPERTIES
+echo "cmake.dir=/usr/local" >> $GRADLE_LOCAL_PROPERTIES
 
-if [[ "${BUILD_ENVIRONMENT}" == *-gradle-build-only-x86_32* ]]; then
-    $GRADLE_PATH -PABI_FILTERS=x86 -p ~/workspace/android/ assembleRelease
-else
-    $GRADLE_PATH -p ~/workspace/android/ assembleRelease
-fi
+$GRADLE_PATH $GRADLE_PARAMS
+
+find . -type f -name "*.a" -exec ls -lh {} \;
+
+while IFS= read -r -d '' file
+do
+  echo
+  echo "$file"
+  ls -lah "$file"
+  zipinfo -l "$file"
+done < <(find . -type f -name '*.aar' -print0)
 
 find . -type f -name *aar -print | xargs tar cfvz ~/workspace/android/artifacts.tgz

.circleci/scripts/cpp_doc_push_script.sh

@@ -53,7 +53,7 @@ sudo apt-get -y install doxygen
 # Generate ATen files
 pushd "${pt_checkout}"
 pip install -r requirements.txt
-time GEN_TO_SOURCE=1 python aten/src/ATen/gen.py \
+time python aten/src/ATen/gen.py \
   -s aten/src/ATen \
   -d build/aten/src/ATen \
   aten/src/ATen/Declarations.cwrap \

.circleci/scripts/should_run_job.py

@@ -18,6 +18,8 @@ default_set = set([
     'pytorch-linux-xenial-py3-clang5-asan',
     # PyTorch DEBUG
     'pytorch-linux-xenial-py3.6-gcc5.4',
+    # LibTorch
+    'pytorch-libtorch-linux-xenial-cuda9-cudnn7-py3',
 
     # Caffe2 CPU
     'caffe2-py2-mkl-ubuntu16.04',
@@ -30,14 +32,17 @@ default_set = set([
     'caffe2-py2-clang7-ubuntu16.04',
     # Caffe2 CMake
     'caffe2-cmake-cuda9.0-cudnn7-ubuntu16.04',
+    # Caffe2 CentOS
+    'caffe2-py3.6-devtoolset7-cuda9.0-cudnn7-centos7',
 
     # Binaries
     'manywheel 2.7mu cpu devtoolset7',
     'libtorch 2.7m cpu devtoolset7',
     'libtorch 2.7m cpu gcc5.4_cxx11-abi',
-    'libtorch-ios-10.2.1-nightly-x86_64-build',
-    'libtorch-ios-10.2.1-nightly-arm64-build',
-    'libtorch-ios-10.2.1-nightly-binary-build-upload',
+    'libtorch 2.7 cpu',
+    'libtorch-ios-11.2.1-nightly-x86_64-build',
+    'libtorch-ios-11.2.1-nightly-arm64-build',
+    'libtorch-ios-11.2.1-nightly-binary-build-upload',
 
     # Caffe2 Android
     'caffe2-py2-android-ubuntu16.04',
@@ -48,11 +53,15 @@ default_set = set([
     'pytorch-macos-10.13-cuda9.2-cudnn7-py3',
     # PyTorch Android
     'pytorch-linux-xenial-py3-clang5-android-ndk-r19c-x86_32-build',
+    'pytorch-linux-xenial-py3-clang5-android-ndk-r19',
     # PyTorch Android gradle
     'pytorch-linux-xenial-py3-clang5-android-ndk-r19c-gradle-build-only-x86_32',
+
     # Pytorch iOS builds
-    'pytorch-ios-10.2.1-x86_64_build',
-    'pytorch-ios-10.2.1-arm64_build',
+    'pytorch-ios-11.2.1-x86_64_build',
+    'pytorch-ios-11.2.1-arm64_build',
+    # PyTorch Mobile builds
+    'pytorch-linux-xenial-py3-clang5-mobile-build',
 
     # Pytorch backward compatibility check
     'pytorch-linux-backward-compatibility-check-test',
@@ -60,10 +69,9 @@ default_set = set([
     # XLA
     'pytorch-xla-linux-xenial-py3.6-clang7',
 
-    # Named tensor
-    "pytorch-namedtensor-linux-xenial-py3.6-gcc5.4",
-    "pytorch-namedtensor-linux-xenial-py3-clang5-asan",
-    "pytorch-namedtensor-linux-xenial-cuda9-cudnn7-py2",
+    # GraphExecutor config jobs
+    'pytorch-linux-xenial-py3.6-gcc5.4-ge_config_simple-test',
+    'pytorch-linux-xenial-py3.6-gcc5.4-ge_config_legacy-test',
 
     # Other checks
     'pytorch-short-perf-test-gpu',

.circleci/verbatim-sources/binary-job-specs.yml

@@ -223,7 +223,7 @@
   binary_ios_build:
     <<: *pytorch_ios_params
     macos:
-      xcode: "10.2.1"
+      xcode: "11.2.1"
     steps:
     - attach_workspace:
         at: ~/workspace
@@ -232,12 +232,18 @@
     - run_brew_for_ios_build
     - run:
         name: Build
-        contxt: org-member
         no_output_timeout: "1h"
         command: |
           script="/Users/distiller/project/.circleci/scripts/binary_ios_build.sh"
           cat "$script"
           source "$script"
+    - run:
+        name: Test
+        no_output_timeout: "30m"
+        command: |
+          script="/Users/distiller/project/.circleci/scripts/binary_ios_test.sh"
+          cat "$script"
+          source "$script"
     - persist_to_workspace:
         root: /Users/distiller/workspace/
         paths: ios
@@ -245,7 +251,7 @@
   binary_ios_upload: 
     <<: *pytorch_ios_params
     macos:
-      xcode: "10.2.1"
+      xcode: "11.2.1"
     steps:
     - attach_workspace:
         at: ~/workspace

.circleci/verbatim-sources/caffe2-job-specs.yml

@@ -41,7 +41,7 @@
 
           echo "DOCKER_IMAGE: "${DOCKER_IMAGE}
           time docker pull ${DOCKER_IMAGE} >/dev/null
-          export id=$(docker run -t -d -w /var/lib/jenkins ${DOCKER_IMAGE})
+          export id=$(docker run --cap-add=SYS_PTRACE --security-opt seccomp=unconfined -t -d -w /var/lib/jenkins ${DOCKER_IMAGE})
           docker cp /home/circleci/project/. $id:/var/lib/jenkins/workspace
 
           export COMMAND='((echo "source ./workspace/env" && echo "sudo chown -R jenkins workspace && cd workspace && ./ci_build_script.sh") | docker exec -u jenkins -i "$id" bash) 2>&1'
@@ -112,9 +112,9 @@
           echo "DOCKER_IMAGE: "${COMMIT_DOCKER_IMAGE}
           time docker pull ${COMMIT_DOCKER_IMAGE} >/dev/null
           if [ -n "${USE_CUDA_DOCKER_RUNTIME}" ]; then
-            export id=$(docker run --runtime=nvidia -t -d -w /var/lib/jenkins ${COMMIT_DOCKER_IMAGE})
+            export id=$(docker run --cap-add=SYS_PTRACE --security-opt seccomp=unconfined --runtime=nvidia -t -d -w /var/lib/jenkins ${COMMIT_DOCKER_IMAGE})
           else
-            export id=$(docker run -t -d -w /var/lib/jenkins ${COMMIT_DOCKER_IMAGE})
+            export id=$(docker run --cap-add=SYS_PTRACE --security-opt seccomp=unconfined -t -d -w /var/lib/jenkins ${COMMIT_DOCKER_IMAGE})
           fi
           docker cp /home/circleci/project/. "$id:/var/lib/jenkins/workspace"
 
@@ -146,12 +146,7 @@
             # Reinitialize path (see man page for path_helper(8))
             eval `/usr/libexec/path_helper -s`
 
-            # Use Homebrew Python if configured to do so
-            if [ "${PYTHON_INSTALLATION}" == "homebrew" ]; then
-              export PATH=/usr/local/opt/python/libexec/bin:/usr/local/bin:$PATH
-            fi
-
-            pip -q install numpy
+            export PATH=/usr/local/opt/python/libexec/bin:/usr/local/bin:$PATH
 
             # Install Anaconda if we need to
             if [ -n "${CAFFE2_USE_ANACONDA}" ]; then
@@ -164,6 +159,8 @@
               source ${TMPDIR}/anaconda/bin/activate
             fi
 
+            pip -q install numpy
+
             # Install sccache
             sudo curl https://s3.amazonaws.com/ossci-macos/sccache --output /usr/local/bin/sccache
             sudo chmod +x /usr/local/bin/sccache
@@ -201,4 +198,3 @@
             if which sccache > /dev/null; then
               sccache --show-stats
             fi
-

.circleci/verbatim-sources/docker_build_job.yml

@@ -0,0 +1,21 @@
+  docker_build_job:
+      parameters:
+        image_name:
+          type: string
+          default: ""
+      machine:
+        image: ubuntu-1604:201903-01
+      resource_class: large
+      environment:
+        IMAGE_NAME: << parameters.image_name >>
+      steps:
+        - checkout
+        - run:
+            name: build_docker_image_<< parameters.image_name >>
+            no_output_timeout: "1h"
+            command: |
+              set +x
+              export AWS_ACCESS_KEY_ID=${CIRCLECI_AWS_ACCESS_KEY_FOR_DOCKER_BUILDER_V1}
+              export AWS_SECRET_ACCESS_KEY=${CIRCLECI_AWS_SECRET_KEY_FOR_DOCKER_BUILDER_V1}
+              set -x
+              cd .circleci/docker && ./build_docker.sh

.circleci/verbatim-sources/job-specs-custom.yml

@@ -1,43 +1,8 @@
-  pytorch_short_perf_test_gpu:
-    environment:
-      BUILD_ENVIRONMENT: pytorch-short-perf-test-gpu
-      DOCKER_IMAGE: "308535385114.dkr.ecr.us-east-1.amazonaws.com/pytorch/pytorch-linux-xenial-cuda9-cudnn7-py3:347"
-      PYTHON_VERSION: "3.6"
-      USE_CUDA_DOCKER_RUNTIME: "1"
-    resource_class: gpu.medium
-    machine:
-      image: ubuntu-1604:201903-01
-    steps:
-    # See Note [Workspace for CircleCI scripts] in job-specs-setup.yml
-    - should_run_job
-    - setup_linux_system_environment
-    - setup_ci_environment
-    - run:
-        name: Perf Test
-        no_output_timeout: "1h"
-        command: |
-          set -e
-          export COMMIT_DOCKER_IMAGE=${DOCKER_IMAGE}-${CIRCLE_SHA1}
-          echo "DOCKER_IMAGE: "${COMMIT_DOCKER_IMAGE}
-          time docker pull ${COMMIT_DOCKER_IMAGE} >/dev/null
-          export id=$(docker run --runtime=nvidia -t -d -w /var/lib/jenkins ${COMMIT_DOCKER_IMAGE})
-
-          docker cp $id:/var/lib/jenkins/workspace/env /home/circleci/project/env
-          # This IAM user allows write access to S3 bucket for perf test numbers
-          set +x
-          echo "declare -x AWS_ACCESS_KEY_ID=${CIRCLECI_AWS_ACCESS_KEY_FOR_PERF_TEST_S3_BUCKET_V4}" >> /home/circleci/project/env
-          echo "declare -x AWS_SECRET_ACCESS_KEY=${CIRCLECI_AWS_SECRET_KEY_FOR_PERF_TEST_S3_BUCKET_V4}" >> /home/circleci/project/env
-          set -x
-          docker cp /home/circleci/project/env $id:/var/lib/jenkins/workspace/env
-
-          export COMMAND='((echo "export BUILD_ENVIRONMENT=${BUILD_ENVIRONMENT}" && echo "source ./workspace/env" && echo "sudo chown -R jenkins workspace && cd workspace && .jenkins/pytorch/short-perf-test-gpu.sh") | docker exec -u jenkins -i "$id" bash) 2>&1'
-          echo ${COMMAND} > ./command.sh && unbuffer bash ./command.sh | ts
-
   pytorch_python_doc_push:
     environment:
       BUILD_ENVIRONMENT: pytorch-python-doc-push
       # TODO: stop hardcoding this
-      DOCKER_IMAGE: "308535385114.dkr.ecr.us-east-1.amazonaws.com/pytorch/pytorch-linux-xenial-cuda9-cudnn7-py3:347"
+      DOCKER_IMAGE: "308535385114.dkr.ecr.us-east-1.amazonaws.com/pytorch/pytorch-linux-xenial-cuda9-cudnn7-py3:405"
     resource_class: large
     machine:
       image: ubuntu-1604:201903-01
@@ -54,7 +19,7 @@
           export COMMIT_DOCKER_IMAGE=${DOCKER_IMAGE}-${CIRCLE_SHA1}
           echo "DOCKER_IMAGE: "${COMMIT_DOCKER_IMAGE}
           time docker pull ${COMMIT_DOCKER_IMAGE} >/dev/null
-          export id=$(docker run -t -d -w /var/lib/jenkins ${COMMIT_DOCKER_IMAGE})
+          export id=$(docker run --cap-add=SYS_PTRACE --security-opt seccomp=unconfined -t -d -w /var/lib/jenkins ${COMMIT_DOCKER_IMAGE})
 
           # master branch docs push
           if [[ "${CIRCLE_BRANCH}" == "master" ]]; then
@@ -82,7 +47,7 @@
   pytorch_cpp_doc_push:
     environment:
       BUILD_ENVIRONMENT: pytorch-cpp-doc-push
-      DOCKER_IMAGE: "308535385114.dkr.ecr.us-east-1.amazonaws.com/pytorch/pytorch-linux-xenial-cuda9-cudnn7-py3:347"
+      DOCKER_IMAGE: "308535385114.dkr.ecr.us-east-1.amazonaws.com/pytorch/pytorch-linux-xenial-cuda9-cudnn7-py3:405"
     resource_class: large
     machine:
       image: ubuntu-1604:201903-01
@@ -99,7 +64,7 @@
           export COMMIT_DOCKER_IMAGE=${DOCKER_IMAGE}-${CIRCLE_SHA1}
           echo "DOCKER_IMAGE: "${COMMIT_DOCKER_IMAGE}
           time docker pull ${COMMIT_DOCKER_IMAGE} >/dev/null
-          export id=$(docker run -t -d -w /var/lib/jenkins ${COMMIT_DOCKER_IMAGE})
+          export id=$(docker run --cap-add=SYS_PTRACE --security-opt seccomp=unconfined -t -d -w /var/lib/jenkins ${COMMIT_DOCKER_IMAGE})
 
           # master branch docs push
           if [[ "${CIRCLE_BRANCH}" == "master" ]]; then
@@ -186,6 +151,8 @@
 
             chmod a+x .jenkins/pytorch/macos-test.sh
             unbuffer .jenkins/pytorch/macos-test.sh 2>&1 | ts
+      - store_test_results:
+          path: test/test-reports
 
   pytorch_macos_10_13_cuda9_2_cudnn7_py3_build:
     environment:
@@ -238,7 +205,7 @@
   pytorch_android_gradle_build:
     environment:
       BUILD_ENVIRONMENT: pytorch-linux-xenial-py3-clang5-android-ndk-r19c-gradle-build
-      DOCKER_IMAGE: "308535385114.dkr.ecr.us-east-1.amazonaws.com/pytorch/pytorch-linux-xenial-py3-clang5-android-ndk-r19c:347"
+      DOCKER_IMAGE: "308535385114.dkr.ecr.us-east-1.amazonaws.com/pytorch/pytorch-linux-xenial-py3-clang5-android-ndk-r19c:405"
       PYTHON_VERSION: "3.6"
     resource_class: large
     machine:
@@ -268,14 +235,14 @@
 
           # x86_32
           time docker pull ${docker_image_libtorch_android_x86_32} >/dev/null
-          export id_x86_32=$(docker run -t -d -w /var/lib/jenkins ${docker_image_libtorch_android_x86_32})
+          export id_x86_32=$(docker run --cap-add=SYS_PTRACE --security-opt seccomp=unconfined -t -d -w /var/lib/jenkins ${docker_image_libtorch_android_x86_32})
 
           export COMMAND='((echo "source ./workspace/env" && echo "sudo chown -R jenkins workspace") | docker exec -u jenkins -i "$id_x86_32" bash) 2>&1'
           echo ${COMMAND} > ./command.sh && unbuffer bash ./command.sh | ts
 
           # arm-v7a
           time docker pull ${docker_image_libtorch_android_arm_v7a} >/dev/null
-          export id_arm_v7a=$(docker run -t -d -w /var/lib/jenkins ${docker_image_libtorch_android_arm_v7a})
+          export id_arm_v7a=$(docker run --cap-add=SYS_PTRACE --security-opt seccomp=unconfined -t -d -w /var/lib/jenkins ${docker_image_libtorch_android_arm_v7a})
 
           export COMMAND='((echo "source ./workspace/env" && echo "sudo chown -R jenkins workspace") | docker exec -u jenkins -i "$id_arm_v7a" bash) 2>&1'
           echo ${COMMAND} > ./command.sh && unbuffer bash ./command.sh | ts
@@ -285,7 +252,7 @@
 
           # x86_64
           time docker pull ${docker_image_libtorch_android_x86_64} >/dev/null
-          export id_x86_64=$(docker run -t -d -w /var/lib/jenkins ${docker_image_libtorch_android_x86_64})
+          export id_x86_64=$(docker run --cap-add=SYS_PTRACE --security-opt seccomp=unconfined -t -d -w /var/lib/jenkins ${docker_image_libtorch_android_x86_64})
 
           export COMMAND='((echo "source ./workspace/env" && echo "sudo chown -R jenkins workspace") | docker exec -u jenkins -i "$id_x86_64" bash) 2>&1'
           echo ${COMMAND} > ./command.sh && unbuffer bash ./command.sh | ts
@@ -295,7 +262,7 @@
 
           # arm-v8a
           time docker pull ${docker_image_libtorch_android_arm_v8a} >/dev/null
-          export id_arm_v8a=$(docker run -t -d -w /var/lib/jenkins ${docker_image_libtorch_android_arm_v8a})
+          export id_arm_v8a=$(docker run --cap-add=SYS_PTRACE --security-opt seccomp=unconfined -t -d -w /var/lib/jenkins ${docker_image_libtorch_android_arm_v8a})
 
           export COMMAND='((echo "source ./workspace/env" && echo "sudo chown -R jenkins workspace") | docker exec -u jenkins -i "$id_arm_v8a" bash) 2>&1'
           echo ${COMMAND} > ./command.sh && unbuffer bash ./command.sh | ts
@@ -308,7 +275,7 @@
           docker cp ~/workspace/build_android_install_arm_v8a $id_x86_32:/var/lib/jenkins/workspace/build_android_install_arm_v8a
 
           # run gradle buildRelease
-          export COMMAND='((echo "source ./workspace/env" && echo "export BUILD_ENVIRONMENT=${BUILD_ENVIRONMENT}" && echo "sudo chown -R jenkins workspace && cd workspace && ./.circleci/scripts/build_android_gradle.sh") | docker exec -u jenkins -i "$id_x86_32" bash) 2>&1'
+          export COMMAND='((echo "source ./workspace/env" && echo "export BUILD_ENVIRONMENT=${BUILD_ENVIRONMENT}" && echo "export GRADLE_OFFLINE=1" && echo "sudo chown -R jenkins workspace && cd workspace && ./.circleci/scripts/build_android_gradle.sh") | docker exec -u jenkins -i "$id_x86_32" bash) 2>&1'
           echo ${COMMAND} > ./command.sh && unbuffer bash ./command.sh | ts
 
           mkdir -p ~/workspace/build_android_artifacts
@@ -324,7 +291,7 @@
   pytorch_android_publish_snapshot:
     environment:
       BUILD_ENVIRONMENT: pytorch-linux-xenial-py3-clang5-android-ndk-r19c-gradle-publish-snapshot
-      DOCKER_IMAGE: "308535385114.dkr.ecr.us-east-1.amazonaws.com/pytorch/pytorch-linux-xenial-py3-clang5-android-ndk-r19c:347"
+      DOCKER_IMAGE: "308535385114.dkr.ecr.us-east-1.amazonaws.com/pytorch/pytorch-linux-xenial-py3-clang5-android-ndk-r19c:405"
       PYTHON_VERSION: "3.6"
     resource_class: large
     machine:
@@ -348,7 +315,7 @@
 
           # x86_32
           time docker pull ${docker_image_libtorch_android_x86_32_gradle} >/dev/null
-          export id_x86_32=$(docker run -t -d -w /var/lib/jenkins ${docker_image_libtorch_android_x86_32_gradle})
+          export id_x86_32=$(docker run --cap-add=SYS_PTRACE --security-opt seccomp=unconfined -t -d -w /var/lib/jenkins ${docker_image_libtorch_android_x86_32_gradle})
 
           export COMMAND='((echo "source ./workspace/env" && echo "sudo chown -R jenkins workspace" && echo "export BUILD_ENVIRONMENT=${BUILD_ENVIRONMENT}" && echo "export SONATYPE_NEXUS_USERNAME=${SONATYPE_NEXUS_USERNAME}" && echo "export SONATYPE_NEXUS_PASSWORD=${SONATYPE_NEXUS_PASSWORD}" && echo "export ANDROID_SIGN_KEY=${ANDROID_SIGN_KEY}" && echo "export ANDROID_SIGN_PASS=${ANDROID_SIGN_PASS}" && echo "sudo chown -R jenkins workspace && cd workspace && ./.circleci/scripts/publish_android_snapshot.sh") | docker exec -u jenkins -i "$id_x86_32" bash) 2>&1'
           echo ${COMMAND} > ./command.sh && unbuffer bash ./command.sh | ts
@@ -360,7 +327,7 @@
   pytorch_android_gradle_build-x86_32:
     environment:
       BUILD_ENVIRONMENT: pytorch-linux-xenial-py3-clang5-android-ndk-r19c-gradle-build-only-x86_32
-      DOCKER_IMAGE: "308535385114.dkr.ecr.us-east-1.amazonaws.com/pytorch/pytorch-linux-xenial-py3-clang5-android-ndk-r19c:347"
+      DOCKER_IMAGE: "308535385114.dkr.ecr.us-east-1.amazonaws.com/pytorch/pytorch-linux-xenial-py3-clang5-android-ndk-r19c:405"
       PYTHON_VERSION: "3.6"
     resource_class: large
     machine:
@@ -388,9 +355,9 @@
 
           # x86
           time docker pull ${docker_image_libtorch_android_x86_32} >/dev/null
-          export id=$(docker run -t -d -w /var/lib/jenkins ${docker_image_libtorch_android_x86_32})
+          export id=$(docker run --cap-add=SYS_PTRACE --security-opt seccomp=unconfined -t -d -w /var/lib/jenkins ${docker_image_libtorch_android_x86_32})
 
-          export COMMAND='((echo "source ./workspace/env" && echo "export BUILD_ENVIRONMENT=${BUILD_ENVIRONMENT}" && echo "sudo chown -R jenkins workspace && cd workspace && ./.circleci/scripts/build_android_gradle.sh") | docker exec -u jenkins -i "$id" bash) 2>&1'
+          export COMMAND='((echo "source ./workspace/env" && echo "export BUILD_ENVIRONMENT=${BUILD_ENVIRONMENT}" && echo "export GRADLE_OFFLINE=1" && echo "sudo chown -R jenkins workspace && cd workspace && ./.circleci/scripts/build_android_gradle.sh") | docker exec -u jenkins -i "$id" bash) 2>&1'
           echo ${COMMAND} > ./command.sh && unbuffer bash ./command.sh | ts
 
           mkdir -p ~/workspace/build_android_x86_32_artifacts
@@ -406,12 +373,34 @@
   pytorch_ios_build:
     <<: *pytorch_ios_params
     macos:
-      xcode: "10.2.1"
+      xcode: "11.2.1"
     steps:
       # See Note [Workspace for CircleCI scripts] in job-specs-setup.yml
       - should_run_job
       - checkout
-      - run_brew_for_ios_build
+      - run_brew_for_ios_build    
+      - run:
+          name: Run Fastlane
+          no_output_timeout: "1h"
+          command: |
+            set -e
+            PROJ_ROOT=/Users/distiller/project
+            cd ${PROJ_ROOT}/ios/TestApp
+            # install fastlane
+            sudo gem install bundler && bundle install
+            # install certificates
+            echo ${IOS_CERT_KEY} >> cert.txt
+            base64 --decode cert.txt -o Certificates.p12
+            rm cert.txt
+            bundle exec fastlane install_cert
+            # install the provisioning profile
+            PROFILE=TestApp_CI.mobileprovision
+            PROVISIONING_PROFILES=~/Library/MobileDevice/Provisioning\ Profiles
+            mkdir -pv "${PROVISIONING_PROFILES}"
+            cd "${PROVISIONING_PROFILES}"
+            echo ${IOS_SIGN_KEY} >> cert.txt
+            base64 --decode cert.txt -o ${PROFILE}
+            rm cert.txt
       - run:
           name: Build
           no_output_timeout: "1h"
@@ -421,7 +410,6 @@
             WORKSPACE=/Users/distiller/workspace
             PROJ_ROOT=/Users/distiller/project
             export TCLLIBPATH="/usr/local/lib"
-
             # Install conda
             curl -o ~/Downloads/conda.sh https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-x86_64.sh
             chmod +x ~/Downloads/conda.sh
@@ -444,3 +432,43 @@
             export IOS_ARCH=${IOS_ARCH}
             export IOS_PLATFORM=${IOS_PLATFORM}
             unbuffer ${PROJ_ROOT}/scripts/build_ios.sh 2>&1 | ts
+      - run:
+          name: Run Build Tests
+          no_output_timeout: "30m"
+          command: |
+            set -e
+            PROJ_ROOT=/Users/distiller/project
+            PROFILE=TestApp_CI
+            # run the ruby build script
+            if ! [ -x "$(command -v xcodebuild)" ]; then
+              echo 'Error: xcodebuild is not installed.'
+              exit 1
+            fi
+            echo ${IOS_DEV_TEAM_ID}
+            ruby ${PROJ_ROOT}/scripts/xcode_build.rb -i ${PROJ_ROOT}/build_ios/install -x ${PROJ_ROOT}/ios/TestApp/TestApp.xcodeproj -p ${IOS_PLATFORM} -c ${PROFILE} -t ${IOS_DEV_TEAM_ID}
+            if ! [ "$?" -eq "0" ]; then
+              echo 'xcodebuild failed!'
+              exit 1
+            fi
+      - run:
+          name: Run Simulator Tests
+          no_output_timeout: "2h"
+          command: |
+            set -e
+            if [ ${IOS_PLATFORM} != "SIMULATOR" ]; then 
+              echo "not SIMULATOR build, skip it."
+              exit 0
+            fi
+            WORKSPACE=/Users/distiller/workspace
+            PROJ_ROOT=/Users/distiller/project
+            source ~/anaconda/bin/activate
+            #install the latest version of PyTorch and TorchVision
+            pip install torch torchvision
+            #run unit test
+            cd ${PROJ_ROOT}/ios/TestApp/benchmark
+            python trace_model.py
+            ruby setup.rb
+            cd ${PROJ_ROOT}/ios/TestApp
+            instruments -s -devices
+            fastlane scan
+            

.circleci/verbatim-sources/job-specs-setup.yml

@@ -4,10 +4,6 @@
       - image: circleci/python:3.7.3
     steps:
       - checkout
-      - run:
-          name: Ensure config is up to date
-          command: ./ensure-consistency.py
-          working_directory: .circleci
       - run:
           name: Save commit message
           command: git log --format='%B' -n 1 HEAD > .circleci/scripts/COMMIT_MSG

.circleci/verbatim-sources/pytorch-job-specs.yml

@@ -17,52 +17,57 @@ jobs:
           # Pull Docker image and run build
           echo "DOCKER_IMAGE: "${DOCKER_IMAGE}
           time docker pull ${DOCKER_IMAGE} >/dev/null
-          export id=$(docker run -t -d -w /var/lib/jenkins ${DOCKER_IMAGE})
+          export id=$(docker run --cap-add=SYS_PTRACE --security-opt seccomp=unconfined --cap-add=SYS_PTRACE --security-opt seccomp=unconfined -t -d -w /var/lib/jenkins ${DOCKER_IMAGE})
 
-          # TODO We may want to move the rebase logic to a separate step after checkout
-          # Rebase to master only if in xenial_py3_6_gcc5_4 case
-          if [[ "${CIRCLE_BRANCH}" != "master" && "${BUILD_ENVIRONMENT}" == *"gcc5"* ]]; then
-            echo "Merge master branch into $CIRCLE_BRANCH before build in environment $BUILD_ENVIRONMENT"
-            set -x
-            git config --global user.email "circleci.ossci@gmail.com"
-            git config --global user.name "CircleCI"
-            git config remote.origin.url https://github.com/pytorch/pytorch.git
-            git config --add remote.origin.fetch +refs/heads/master:refs/remotes/origin/master
-            git fetch --tags --progress https://github.com/pytorch/pytorch.git +refs/heads/master:refs/remotes/origin/master --depth=50 --quiet
-            export GIT_MERGE_TARGET=`git log -n 1 --pretty=format:"%H" origin/master`
-            echo "GIT_MERGE_TARGET: " ${GIT_MERGE_TARGET}
-            export GIT_COMMIT=${CIRCLE_SHA1}
-            echo "GIT_COMMIT: " ${GIT_COMMIT}
-            git checkout -f ${GIT_COMMIT}
-            git reset --hard ${GIT_COMMIT}
-            git merge --no-edit --no-ff ${GIT_MERGE_TARGET}
-            set +x
-          else
-            echo "Do NOT merge master branch into $CIRCLE_BRANCH in environment $BUILD_ENVIRONMENT"
-          fi
+          # NB: Temporarily disable the rebase logic in v1.4.0, don't merge this change into master
+          # # TODO We may want to move the rebase logic to a separate step after checkout
+          # # Rebase to master only if in xenial_py3_6_gcc5_4 case
+          # if [[ "${CIRCLE_BRANCH}" != "master" && "${BUILD_ENVIRONMENT}" == *"gcc5"* ]]; then
+          #   echo "Merge master branch into $CIRCLE_BRANCH before build in environment $BUILD_ENVIRONMENT"
+          #   set -x
+          #   git config --global user.email "circleci.ossci@gmail.com"
+          #   git config --global user.name "CircleCI"
+          #   git config remote.origin.url https://github.com/pytorch/pytorch.git
+          #   git config --add remote.origin.fetch +refs/heads/master:refs/remotes/origin/master
+          #   git fetch --tags --progress https://github.com/pytorch/pytorch.git +refs/heads/master:refs/remotes/origin/master --depth=100 --quiet
+          #   export GIT_MERGE_TARGET=`git log -n 1 --pretty=format:"%H" origin/master`
+          #   echo "GIT_MERGE_TARGET: " ${GIT_MERGE_TARGET}
+          #   export GIT_COMMIT=${CIRCLE_SHA1}
+          #   echo "GIT_COMMIT: " ${GIT_COMMIT}
+          #   git checkout -f ${GIT_COMMIT}
+          #   git reset --hard ${GIT_COMMIT}
+          #   git merge --allow-unrelated-histories --no-edit --no-ff ${GIT_MERGE_TARGET}
+          #   set +x
+          # else
+          #   echo "Do NOT merge master branch into $CIRCLE_BRANCH in environment $BUILD_ENVIRONMENT"
+          # fi
 
           git submodule sync && git submodule update -q --init --recursive
 
           docker cp /home/circleci/project/. $id:/var/lib/jenkins/workspace
 
-          if [[ ${BUILD_ENVIRONMENT} == *"namedtensor"* ]]; then
-            NAMED_FLAG="export BUILD_NAMEDTENSOR=1"
+          if [[ ${BUILD_ENVIRONMENT} == *"paralleltbb"* ]]; then
+            export PARALLEL_FLAGS="export ATEN_THREADING=TBB USE_TBB=1 "
+          elif [[ ${BUILD_ENVIRONMENT} == *"parallelnative"* ]]; then
+            export PARALLEL_FLAGS="export ATEN_THREADING=NATIVE "
           fi
+          echo "Parallel backend flags: "${PARALLEL_FLAGS}
+
+          export COMMAND='((echo "export BUILD_ENVIRONMENT=${BUILD_ENVIRONMENT}" && echo '"$PARALLEL_FLAGS"' && echo "source ./workspace/env" && echo "sudo chown -R jenkins workspace && cd workspace && .jenkins/pytorch/build.sh") | docker exec -u jenkins -i "$id" bash) 2>&1'
 
-          export COMMAND='((echo "export BUILD_ENVIRONMENT=${BUILD_ENVIRONMENT}" && echo '"$NAMED_FLAG"' && echo "source ./workspace/env" && echo "sudo chown -R jenkins workspace && cd workspace && .jenkins/pytorch/build.sh") | docker exec -u jenkins -i "$id" bash) 2>&1'
           echo ${COMMAND} > ./command.sh && unbuffer bash ./command.sh | ts
 
           # Push intermediate Docker image for next phase to use
           if [ -z "${BUILD_ONLY}" ]; then
             # Note [Special build images]
-            # The namedtensor and xla builds use the same docker image as
+            # The xla build uses the same docker image as
             # pytorch-linux-trusty-py3.6-gcc5.4-build. In the push step, we have to
             # distinguish between them so the test can pick up the correct image.
             output_image=${DOCKER_IMAGE}-${CIRCLE_SHA1}
-            if [[ ${BUILD_ENVIRONMENT} == *"namedtensor"* ]]; then
-              export COMMIT_DOCKER_IMAGE=$output_image-namedtensor
-            elif [[ ${BUILD_ENVIRONMENT} == *"xla"* ]]; then
+            if [[ ${BUILD_ENVIRONMENT} == *"xla"* ]]; then
               export COMMIT_DOCKER_IMAGE=$output_image-xla
+            elif [[ ${BUILD_ENVIRONMENT} == *"libtorch"* ]]; then
+              export COMMIT_DOCKER_IMAGE=$output_image-libtorch
             elif [[ ${BUILD_ENVIRONMENT} == *"android-ndk-r19c-x86_64"* ]]; then
               export COMMIT_DOCKER_IMAGE=$output_image-android-x86_64
             elif [[ ${BUILD_ENVIRONMENT} == *"android-ndk-r19c-arm-v7a"* ]]; then
@@ -94,24 +99,43 @@ jobs:
           set -e
           # See Note [Special build images]
           output_image=${DOCKER_IMAGE}-${CIRCLE_SHA1}
-          if [[ ${BUILD_ENVIRONMENT} == *"namedtensor"* ]]; then
-            export COMMIT_DOCKER_IMAGE=$output_image-namedtensor
-            export NAMED_FLAG="export BUILD_NAMEDTENSOR=1 && export TEST_NAMEDTENSOR=1"
-          elif [[ ${BUILD_ENVIRONMENT} == *"xla"* ]]; then
+          if [[ ${BUILD_ENVIRONMENT} == *"xla"* ]]; then
             export COMMIT_DOCKER_IMAGE=$output_image-xla
+          elif [[ ${BUILD_ENVIRONMENT} == *"libtorch"* ]]; then
+            export COMMIT_DOCKER_IMAGE=$output_image-libtorch
           else
             export COMMIT_DOCKER_IMAGE=$output_image
           fi
           echo "DOCKER_IMAGE: "${COMMIT_DOCKER_IMAGE}
-          time docker pull ${COMMIT_DOCKER_IMAGE} >/dev/null
-          if [ -n "${USE_CUDA_DOCKER_RUNTIME}" ]; then
-            export id=$(docker run --runtime=nvidia -t -d -w /var/lib/jenkins ${COMMIT_DOCKER_IMAGE})
-          else
-            export id=$(docker run -t -d -w /var/lib/jenkins ${COMMIT_DOCKER_IMAGE})
+
+          if [[ ${BUILD_ENVIRONMENT} == *"paralleltbb"* ]]; then
+            export PARALLEL_FLAGS="export ATEN_THREADING=TBB USE_TBB=1 "
+          elif [[ ${BUILD_ENVIRONMENT} == *"parallelnative"* ]]; then
+            export PARALLEL_FLAGS="export ATEN_THREADING=NATIVE "
           fi
-          if [[ ${BUILD_ENVIRONMENT} == *"multigpu"* ]]; then
-            export COMMAND='((echo "export BUILD_ENVIRONMENT=${BUILD_ENVIRONMENT}" && echo "${NAMED_FLAG}" && echo "source ./workspace/env" && echo "sudo chown -R jenkins workspace && cd workspace && .jenkins/pytorch/multigpu-test.sh") | docker exec -u jenkins -i "$id" bash) 2>&1'
+          echo "Parallel backend flags: "${PARALLEL_FLAGS}
+
+          time docker pull ${COMMIT_DOCKER_IMAGE} >/dev/null
+
+          if [ -n "${USE_CUDA_DOCKER_RUNTIME}" ]; then
+            export id=$(docker run --cap-add=SYS_PTRACE --security-opt seccomp=unconfined --runtime=nvidia -t -d -w /var/lib/jenkins ${COMMIT_DOCKER_IMAGE})
           else
-            export COMMAND='((echo "export BUILD_ENVIRONMENT=${BUILD_ENVIRONMENT}" && echo "${NAMED_FLAG}" && echo "source ./workspace/env" && echo "sudo chown -R jenkins workspace && cd workspace && .jenkins/pytorch/test.sh") | docker exec -u jenkins -i "$id" bash) 2>&1'
+            export id=$(docker run --cap-add=SYS_PTRACE --security-opt seccomp=unconfined -t -d -w /var/lib/jenkins ${COMMIT_DOCKER_IMAGE})
+          fi
+
+          retrieve_test_reports() {
+            echo "retrieving test reports"
+            docker cp $id:/var/lib/jenkins/workspace/test/test-reports ./ || echo 'No test reports found!'
+          }
+          trap "retrieve_test_reports" ERR
+
+          if [[ ${BUILD_ENVIRONMENT} == *"multigpu"* ]]; then
+            export COMMAND='((echo "export BUILD_ENVIRONMENT=${BUILD_ENVIRONMENT}" && echo "${PARALLEL_FLAGS}" && echo "source ./workspace/env" && echo "sudo chown -R jenkins workspace && cd workspace && .jenkins/pytorch/multigpu-test.sh") | docker exec -u jenkins -i "$id" bash) 2>&1'
+          else
+            export COMMAND='((echo "export BUILD_ENVIRONMENT=${BUILD_ENVIRONMENT}" && echo "${PARALLEL_FLAGS}" && echo "source ./workspace/env" && echo "sudo chown -R jenkins workspace && cd workspace && .jenkins/pytorch/test.sh") | docker exec -u jenkins -i "$id" bash) 2>&1'
           fi
           echo ${COMMAND} > ./command.sh && unbuffer bash ./command.sh | ts
+
+          retrieve_test_reports
+    - store_test_results:
+        path: test-reports

.circleci/verbatim-sources/workflows-binary-builds-smoke-subset.yml

@@ -10,19 +10,19 @@
           build_environment: "manywheel 2.7mu cpu devtoolset7"
           requires:
             - setup
-          docker_image: "soumith/manylinux-cuda100"
+          docker_image: "pytorch/manylinux-cuda100"
       - binary_linux_build:
           name: binary_linux_manywheel_3_7m_cu100_devtoolset7_build
           build_environment: "manywheel 3.7m cu100 devtoolset7"
           requires:
             - setup
-          docker_image: "soumith/manylinux-cuda100"
+          docker_image: "pytorch/manylinux-cuda100"
       - binary_linux_build:
           name: binary_linux_conda_2_7_cpu_devtoolset7_build
           build_environment: "conda 2.7 cpu devtoolset7"
           requires:
             - setup
-          docker_image: "soumith/conda-cuda"
+          docker_image: "pytorch/conda-cuda"
       # This binary build is currently broken, see https://github_com/pytorch/pytorch/issues/16710
       # - binary_linux_conda_3_6_cu90_devtoolset7_build
       - binary_linux_build:
@@ -31,14 +31,14 @@
           requires:
             - setup
           libtorch_variant: "shared-with-deps"
-          docker_image: "soumith/manylinux-cuda100"
+          docker_image: "pytorch/manylinux-cuda100"
       - binary_linux_build:
           name: binary_linux_libtorch_2_7m_cpu_gcc5_4_cxx11-abi_shared-with-deps_build
           build_environment: "libtorch 2.7m cpu gcc5.4_cxx11-abi"
           requires:
             - setup
           libtorch_variant: "shared-with-deps"
-          docker_image: "yf225/pytorch-binary-docker-image-ubuntu16.04:latest"
+          docker_image: "pytorch/pytorch-binary-docker-image-ubuntu16.04:latest"
       # TODO we should test a libtorch cuda build, but they take too long
       # - binary_linux_libtorch_2_7m_cu90_devtoolset7_static-without-deps_build
       - binary_mac_build:
@@ -63,14 +63,14 @@
           requires:
             - setup
             - binary_linux_manywheel_2_7mu_cpu_devtoolset7_build
-          docker_image: "soumith/manylinux-cuda100"
+          docker_image: "pytorch/manylinux-cuda100"
       - binary_linux_test:
           name: binary_linux_manywheel_3_7m_cu100_devtoolset7_test
           build_environment: "manywheel 3.7m cu100 devtoolset7"
           requires:
             - setup
             - binary_linux_manywheel_3_7m_cu100_devtoolset7_build
-          docker_image: "soumith/manylinux-cuda100"
+          docker_image: "pytorch/manylinux-cuda100"
           use_cuda_docker_runtime: "1"
           resource_class: gpu.medium
       - binary_linux_test:
@@ -79,7 +79,7 @@
           requires:
             - setup
             - binary_linux_conda_2_7_cpu_devtoolset7_build
-          docker_image: "soumith/conda-cuda"
+          docker_image: "pytorch/conda-cuda"
       # This binary build is currently broken, see https://github_com/pytorch/pytorch/issues/16710
       # - binary_linux_conda_3_6_cu90_devtoolset7_test:
       - binary_linux_test:
@@ -89,7 +89,7 @@
             - setup
             - binary_linux_libtorch_2_7m_cpu_devtoolset7_shared-with-deps_build
           libtorch_variant: "shared-with-deps"
-          docker_image: "soumith/manylinux-cuda100"
+          docker_image: "pytorch/manylinux-cuda100"
       - binary_linux_test:
           name: binary_linux_libtorch_2_7m_cpu_gcc5_4_cxx11-abi_shared-with-deps_test
           build_environment: "libtorch 2.7m cpu gcc5.4_cxx11-abi"
@@ -97,5 +97,5 @@
             - setup
             - binary_linux_libtorch_2_7m_cpu_gcc5_4_cxx11-abi_shared-with-deps_build
           libtorch_variant: "shared-with-deps"
-          docker_image: "yf225/pytorch-binary-docker-image-ubuntu16.04:latest"
+          docker_image: "pytorch/pytorch-binary-docker-image-ubuntu16.04:latest"
 

.circleci/verbatim-sources/workflows-docker-builder.yml

@@ -0,0 +1,66 @@
+  docker_build:
+    triggers:
+      - schedule:
+          cron: "0 15 * * 0"
+          filters:
+            branches:
+              only:
+                - master
+    jobs:
+      - docker_build_job:
+          name: "pytorch-linux-bionic-clang9-thrift-llvmdev"
+          image_name: "pytorch-linux-bionic-clang9-thrift-llvmdev"
+      - docker_build_job:
+          name: "pytorch-linux-xenial-cuda10-cudnn7-py3-gcc7"
+          image_name: "pytorch-linux-xenial-cuda10-cudnn7-py3-gcc7"
+      - docker_build_job:
+          name: "pytorch-linux-xenial-cuda10.1-cudnn7-py3-gcc7"
+          image_name: "pytorch-linux-xenial-cuda10.1-cudnn7-py3-gcc7"
+      - docker_build_job:
+          name: "pytorch-linux-xenial-cuda8-cudnn7-py2"
+          image_name: "pytorch-linux-xenial-cuda8-cudnn7-py2"
+      - docker_build_job:
+          name: "pytorch-linux-xenial-cuda8-cudnn7-py3"
+          image_name: "pytorch-linux-xenial-cuda8-cudnn7-py3"
+      - docker_build_job:
+          name: "pytorch-linux-xenial-cuda9-cudnn7-py2"
+          image_name: "pytorch-linux-xenial-cuda9-cudnn7-py2"
+      - docker_build_job:
+          name: "pytorch-linux-xenial-cuda9-cudnn7-py3"
+          image_name: "pytorch-linux-xenial-cuda9-cudnn7-py3"
+      - docker_build_job:
+          name: "pytorch-linux-xenial-cuda9.2-cudnn7-py3-gcc7"
+          image_name: "pytorch-linux-xenial-cuda9.2-cudnn7-py3-gcc7"
+      - docker_build_job:
+          name: "pytorch-linux-xenial-py2.7.9"
+          image_name: "pytorch-linux-xenial-py2.7.9"
+      - docker_build_job:
+          name: "pytorch-linux-xenial-py2.7"
+          image_name: "pytorch-linux-xenial-py2.7"
+      - docker_build_job:
+          name: "pytorch-linux-xenial-py3-clang5-android-ndk-r19c"
+          image_name: "pytorch-linux-xenial-py3-clang5-android-ndk-r19c"
+      - docker_build_job:
+          name: "pytorch-linux-xenial-py3-clang5-asan"
+          image_name: "pytorch-linux-xenial-py3-clang5-asan"
+      - docker_build_job:
+          name: "pytorch-linux-xenial-py3.5"
+          image_name: "pytorch-linux-xenial-py3.5"
+      - docker_build_job:
+          name: "pytorch-linux-xenial-py3.6-clang7"
+          image_name: "pytorch-linux-xenial-py3.6-clang7"
+      - docker_build_job:
+          name: "pytorch-linux-xenial-py3.6-gcc4.8"
+          image_name: "pytorch-linux-xenial-py3.6-gcc4.8"
+      - docker_build_job:
+          name: "pytorch-linux-xenial-py3.6-gcc5.4"
+          image_name: "pytorch-linux-xenial-py3.6-gcc5.4"
+      - docker_build_job:
+          name: "pytorch-linux-xenial-py3.6-gcc7.2"
+          image_name: "pytorch-linux-xenial-py3.6-gcc7.2"
+      - docker_build_job:
+          name: "pytorch-linux-xenial-py3.6-gcc7"
+          image_name: "pytorch-linux-xenial-py3.6-gcc7"
+      - docker_build_job:
+          name: "pytorch-linux-xenial-pynightly"
+          image_name: "pytorch-linux-xenial-pynightly"

.circleci/verbatim-sources/workflows-nightly-android-binary-builds.yml

@@ -3,7 +3,7 @@
           build_environment: "pytorch-linux-xenial-py3-clang5-android-ndk-r19c-x86_32"
           requires:
             - setup
-          docker_image: "308535385114.dkr.ecr.us-east-1.amazonaws.com/pytorch/pytorch-linux-xenial-py3-clang5-android-ndk-r19c:347"
+          docker_image: "308535385114.dkr.ecr.us-east-1.amazonaws.com/pytorch/pytorch-linux-xenial-py3-clang5-android-ndk-r19c:405"
           filters:
             branches:
               only: nightly
@@ -12,7 +12,7 @@
           build_environment: "pytorch-linux-xenial-py3-clang5-android-ndk-r19c-x86_64"
           requires:
             - setup
-          docker_image: "308535385114.dkr.ecr.us-east-1.amazonaws.com/pytorch/pytorch-linux-xenial-py3-clang5-android-ndk-r19c:347"
+          docker_image: "308535385114.dkr.ecr.us-east-1.amazonaws.com/pytorch/pytorch-linux-xenial-py3-clang5-android-ndk-r19c:405"
           filters:
             branches:
               only: nightly
@@ -21,7 +21,7 @@
           build_environment: "pytorch-linux-xenial-py3-clang5-android-ndk-r19c-arm-v7a"
           requires:
             - setup
-          docker_image: "308535385114.dkr.ecr.us-east-1.amazonaws.com/pytorch/pytorch-linux-xenial-py3-clang5-android-ndk-r19c:347"
+          docker_image: "308535385114.dkr.ecr.us-east-1.amazonaws.com/pytorch/pytorch-linux-xenial-py3-clang5-android-ndk-r19c:405"
           filters:
             branches:
               only: nightly
@@ -30,7 +30,7 @@
           build_environment: "pytorch-linux-xenial-py3-clang5-android-ndk-r19c-arm-v8a"
           requires:
             - setup
-          docker_image: "308535385114.dkr.ecr.us-east-1.amazonaws.com/pytorch/pytorch-linux-xenial-py3-clang5-android-ndk-r19c:347"
+          docker_image: "308535385114.dkr.ecr.us-east-1.amazonaws.com/pytorch/pytorch-linux-xenial-py3-clang5-android-ndk-r19c:405"
           filters:
             branches:
               only: nightly

.circleci/verbatim-sources/workflows-nightly-ios-binary-builds.yml

@@ -1,7 +1,8 @@
       # Pytorch iOS binary builds
       - binary_ios_build:
-          name: pytorch_ios_10_2_1_nightly_x86_64_build
-          build_environment: "libtorch-ios-10.2.1-nightly-x86_64-build"
+          name: pytorch_ios_11_2_1_nightly_x86_64_build
+          build_environment: "libtorch-ios-11.2.1-nightly-x86_64-build"
+          context: org-member
           ios_platform: "SIMULATOR"
           ios_arch: "x86_64"
           requires: 
@@ -10,8 +11,9 @@
             branches:
               only: nightly
       - binary_ios_build:
-          name: pytorch_ios_10_2_1_nightly_arm64_build
-          build_environment: "libtorch-ios-10.2.1-nightly-arm64-build"
+          name: pytorch_ios_11_2_1_nightly_arm64_build
+          build_environment: "libtorch-ios-11.2.1-nightly-arm64-build"
+          context: org-member
           ios_arch: "arm64"
           ios_platform: "OS"
           requires: 
@@ -20,12 +22,12 @@
             branches:
               only: nightly
       - binary_ios_upload:
-          build_environment: "libtorch-ios-10.2.1-nightly-binary-build-upload"
+          build_environment: "libtorch-ios-11.2.1-nightly-binary-build-upload"
           context: org-member
           requires:
             - setup
-            - pytorch_ios_10_2_1_nightly_x86_64_build
-            - pytorch_ios_10_2_1_nightly_arm64_build
+            - pytorch_ios_11_2_1_nightly_x86_64_build
+            - pytorch_ios_11_2_1_nightly_arm64_build
           filters:
             branches:
               only: nightly

.circleci/verbatim-sources/workflows-pytorch-ge-config-tests.yml

@@ -0,0 +1,16 @@
+      - pytorch_linux_test:
+          name: pytorch_linux_xenial_py3_6_gcc5_4_ge_config_legacy_test
+          requires:
+            - setup
+            - pytorch_linux_xenial_py3_6_gcc5_4_build
+          build_environment: "pytorch-linux-xenial-py3.6-gcc5.4-ge_config_legacy-test"
+          docker_image: "308535385114.dkr.ecr.us-east-1.amazonaws.com/pytorch/pytorch-linux-xenial-py3.6-gcc5.4:405"
+          resource_class: large
+      - pytorch_linux_test:
+          name: pytorch_linux_xenial_py3_6_gcc5_4_ge_config_simple_test
+          requires:
+            - setup
+            - pytorch_linux_xenial_py3_6_gcc5_4_build
+          build_environment: "pytorch-linux-xenial-py3.6-gcc5.4-ge_config_simple-test"
+          docker_image: "308535385114.dkr.ecr.us-east-1.amazonaws.com/pytorch/pytorch-linux-xenial-py3.6-gcc5.4:405"
+          resource_class: large

.circleci/verbatim-sources/workflows-pytorch-ios-builds.yml

@@ -1,13 +1,17 @@
       # Pytorch iOS PR builds
       - pytorch_ios_build:
-          name: pytorch_ios_10_2_1_x86_64_build
-          build_environment: "pytorch-ios-10.2.1-x86_64_build"
+          name: pytorch_ios_11_2_1_x86_64_build
+          context: org-member
+          build_environment: "pytorch-ios-11.2.1-x86_64_build"
+          ios_arch: "x86_64"
           ios_platform: "SIMULATOR"
           requires:
             - setup
       - pytorch_ios_build:
-          name: pytorch_ios_10_2_1_arm64_build
-          build_environment: "pytorch-ios-10.2.1-arm64_build"
+          name: pytorch_ios_11_2_1_arm64_build
+          context: org-member
+          build_environment: "pytorch-ios-11.2.1-arm64_build"
           ios_arch: "arm64"
+          ios_platform: "OS"
           requires:
             - setup

.circleci/verbatim-sources/workflows-pytorch-mobile-builds.yml

@@ -0,0 +1,7 @@
+      # PyTorch Mobile PR builds (use linux host toolchain + mobile build options)
+      - pytorch_linux_build:
+          name: pytorch_linux_xenial_py3_clang5_mobile_build
+          requires:
+            - setup
+          build_environment: "pytorch-linux-xenial-py3-clang5-mobile-build"
+          docker_image: "308535385114.dkr.ecr.us-east-1.amazonaws.com/pytorch/pytorch-linux-xenial-py3-clang5-asan:405"

.circleci/verbatim-sources/workflows-s3-html.yml

@@ -1,16 +1,3 @@
-
-  # Scheduled to run 4 hours after the binary jobs start
-  # These jobs need to run after all the binary jobs run, regardless of if the
-  # jobs failed or not. There's no way to do this in CircleCI right now, so we
-  # just schedule this to run after all the binary jobs should've finished.
-  # These jobs are all idempotent and very lightweight; they just upload html
-  # files that track what binaries are available and what their sizes are.
-  update_s3_htmls:
-    jobs:
-      - setup:
-          filters:
-            branches:
-              only: postnightly
       - update_s3_htmls_for_nightlies:
           context: org-member
           requires:

.clang-tidy

@@ -1,34 +1,32 @@
 ---
-# NOTE there must be no spaces before the '-', so put the comma first.
-Checks: '
-  -*
-  ,bugprone-*
-  ,-bugprone-forward-declaration-namespace
-  ,-bugprone-macro-parentheses
-  ,-bugprone-lambda-function-name
-  ,cppcoreguidelines-*
-  ,-cppcoreguidelines-interfaces-global-init
-  ,-cppcoreguidelines-owning-memory
-  ,-cppcoreguidelines-pro-bounds-array-to-pointer-decay
-  ,-cppcoreguidelines-pro-bounds-constant-array-index
-  ,-cppcoreguidelines-pro-bounds-pointer-arithmetic
-  ,-cppcoreguidelines-pro-type-cstyle-cast
-  ,-cppcoreguidelines-pro-type-reinterpret-cast
-  ,-cppcoreguidelines-pro-type-static-cast-downcast
-  ,-cppcoreguidelines-pro-type-union-access
-  ,-cppcoreguidelines-pro-type-vararg
-  ,-cppcoreguidelines-special-member-functions
-  ,hicpp-exception-baseclass
-  ,hicpp-avoid-goto
-  ,modernize-*
-  ,-modernize-return-braced-init-list
-  ,-modernize-use-auto
-  ,-modernize-use-default-member-init
-  ,-modernize-use-using
-  ,performance-*
-  ,-performance-noexcept-move-constructor
+# NOTE there must be no spaces before the '-', so put the comma last.
+Checks: '-*,
+bugprone-*,
+-bugprone-forward-declaration-namespace,
+-bugprone-macro-parentheses,
+-bugprone-lambda-function-name,
+cppcoreguidelines-*,
+-cppcoreguidelines-interfaces-global-init,
+-cppcoreguidelines-owning-memory,
+-cppcoreguidelines-pro-bounds-array-to-pointer-decay,
+-cppcoreguidelines-pro-bounds-constant-array-index,
+-cppcoreguidelines-pro-bounds-pointer-arithmetic,
+-cppcoreguidelines-pro-type-cstyle-cast,
+-cppcoreguidelines-pro-type-reinterpret-cast,
+-cppcoreguidelines-pro-type-static-cast-downcast,
+-cppcoreguidelines-pro-type-union-access,
+-cppcoreguidelines-pro-type-vararg,
+-cppcoreguidelines-special-member-functions,
+hicpp-exception-baseclass,
+hicpp-avoid-goto,
+modernize-*,
+-modernize-return-braced-init-list,
+-modernize-use-auto,
+-modernize-use-default-member-init,
+-modernize-use-using,
+performance-*,
+-performance-noexcept-move-constructor,
   '
-WarningsAsErrors: '*'
 HeaderFilterRegex: 'torch/csrc/.*'
 AnalyzeTemporaryDtors: false
 CheckOptions:

.flake8

@@ -5,10 +5,9 @@ max-line-length = 120
 # E501 is not flexible enough, we're using B950 instead
 ignore =
     E203,E305,E402,E501,E721,E741,F403,F405,F821,F841,F999,W503,W504,C408,E302,W291,E303,
-    # EXE001 is skipped for now because some files use shebang to determine Python version.
-    EXE001,
     # these ignores are from flake8-bugbear; please fix!
     B007,B008,
     # these ignores are from flake8-comprehensions; please fix!
     C400,C401,C402,C403,C404,C405,C407,C411,
-exclude = docs/src,venv,third_party,caffe2,scripts,docs/caffe2,tools/amd_build/pyHIPIFY,torch/lib/include,torch/lib/tmp_install,build,torch/include,*.pyi
+per-file-ignores = __init__.py: F401
+exclude = docs/src,venv,third_party,caffe2,scripts,docs/caffe2,torch/lib/include,torch/lib/tmp_install,build,torch/include,*.pyi,.git

.github/workflows/lint.yml

@@ -7,29 +7,60 @@ on:
   pull_request:
 
 jobs:
+  quick-checks:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Setup Python
+        uses: actions/setup-python@v1
+        with:
+          python-version: 3.x
+          architecture: x64
+      - name: Checkout PyTorch
+        uses: actions/checkout@v1
+      - name: Ensure consistent CircleCI YAML config
+        run: |
+          pip install -r requirements.txt
+          cd .circleci && ./ensure-consistency.py
+      - name: Ensure Docker version is correctly deployed
+        run: .circleci/validate-docker-version.py
+      - name: Shellcheck Jenkins scripts
+        run: |
+          sudo apt-get install -y shellcheck
+          .jenkins/run-shellcheck.sh
+      - name: Ensure no tabs
+        run: |
+          (! git grep -I -l $'\t' -- . ':(exclude)*.svg' ':(exclude)**Makefile' ':(exclude)**/contrib/**' ':(exclude)third_party' ':(exclude).gitattributes' ':(exclude).gitmodules' || (echo "The above files have tabs; please convert them to spaces"; false))
+      - name: Ensure C++ source files are not executable
+        run: |
+          (! find . \( -path ./third_party -o -path ./.git -o -path ./torch/bin -o -path ./build \) -prune -o -type f -executable -regextype posix-egrep -not -regex '.+(\.(bash|sh|py|so)|git-pre-commit)$' -print | grep . || (echo 'The above files have executable permission; please remove their executable permission by using `chmod -x`'; false))
+      - name: MyPy typecheck
+        run: |
+          pip install mypy mypy-extensions
+          mypy @mypy-files.txt
+      - name: C++ docs check
+        run: |
+          sudo apt-get install -y doxygen && pip install -r requirements.txt
+          cd docs/cpp/source && ./check-doxygen.sh
+
   flake8-py3:
     runs-on: ubuntu-latest
     steps:
       - name: Setup Python
         uses: actions/setup-python@v1
         with:
-          python-version: 3.7.4
+          python-version: 3.x
           architecture: x64
       - name: Fetch PyTorch
-        uses: actions/checkout@master
+        uses: actions/checkout@v1
       - name: Checkout PR tip
         run: |
           set -eux
-          if [ -z "${GITHUB_HEAD_REF}" ]; then
-            # We are on master, just set the SHA from our current location
-            echo ::set-output name=commit_sha::${GITHUB_SHA}
-          else
-            # We are on a PR, so actions/checkout leaves us on merge commit.
+          if [[ "${{ github.event_name }}" == "pull_request" ]]; then
+            # We are on a PR, so actions/checkout leaves us on a merge commit.
             # Check out the actual tip of the branch.
-            PR_TIP=$(git rev-parse HEAD^2)
-            git checkout ${PR_TIP}
-            echo ::set-output name=commit_sha::${PR_TIP}
+            git checkout ${{ github.event.pull_request.head.sha }}
           fi
+          echo ::set-output name=commit_sha::$(git rev-parse HEAD)
         id: get_pr_tip
       - name: Run flake8
         run: |
@@ -46,3 +77,134 @@ jobs:
           regex: '^(?<filename>.*?):(?<lineNumber>\d+):(?<columnNumber>\d+): (?<errorCode>\w\d+) (?<errorDesc>.*)'
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+  flake8-py2:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Setup Python
+        uses: actions/setup-python@v1
+        with:
+          python-version: 2.x
+          architecture: x64
+      - name: Fetch PyTorch
+        uses: actions/checkout@v1
+      - name: Checkout PR tip
+        run: |
+          set -eux
+          if [[ "${{ github.event_name }}" == "pull_request" ]]; then
+            # We are on a PR, so actions/checkout leaves us on a merge commit.
+            # Check out the actual tip of the branch.
+            git checkout ${{ github.event.pull_request.head.sha }}
+          fi
+          echo ::set-output name=commit_sha::$(git rev-parse HEAD)
+        id: get_pr_tip
+      - name: Run flake8
+        run: |
+          set -eux
+          pip install flake8
+          rm -rf .circleci
+          flake8 --exit-zero > ${GITHUB_WORKSPACE}/flake8-output.txt
+          cat ${GITHUB_WORKSPACE}/flake8-output.txt
+      - name: Add annotations
+        uses: pytorch/add-annotations-github-action@master
+        with:
+          check_name: 'flake8-py2'
+          linter_output_path: 'flake8-output.txt'
+          commit_sha: ${{ steps.get_pr_tip.outputs.commit_sha }}
+          regex: '^(?<filename>.*?):(?<lineNumber>\d+):(?<columnNumber>\d+): (?<errorCode>\w\d+) (?<errorDesc>.*)'
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+
+  clang-tidy:
+    if: github.event_name == 'pull_request'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Setup Python
+        uses: actions/setup-python@v1
+        with:
+          python-version: 3.x
+          architecture: x64
+      - name: Checkout PyTorch
+        uses: actions/checkout@v1
+      - name: Checkout PR tip
+        run: |
+          set -eux
+          if [[ "${{ github.event_name }}" == "pull_request" ]]; then
+            # We are on a PR, so actions/checkout leaves us on a merge commit.
+            # Check out the actual tip of the branch.
+            git checkout ${{ github.event.pull_request.head.sha }}
+          fi
+          echo ::set-output name=commit_sha::$(git rev-parse HEAD)
+        id: get_pr_tip
+      - name: Install dependencies
+        run: |
+          set -eux
+          # Install CUDA
+          wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64/cuda-ubuntu1804.pin
+          sudo mv cuda-ubuntu1804.pin /etc/apt/preferences.d/cuda-repository-pin-600
+          sudo apt-key adv --fetch-keys https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64/7fa2af80.pub
+          sudo add-apt-repository "deb http://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64/ /"
+          sudo apt-get update
+          sudo apt-get --no-install-recommends -y install cuda
+          # Install dependencies
+          pip install pyyaml
+          wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
+          sudo apt-add-repository "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-8 main"
+          sudo apt-get update
+          sudo apt-get install -y clang-tidy-8
+          sudo update-alternatives --install /usr/bin/clang-tidy clang-tidy /usr/bin/clang-tidy-8 1000
+      - name: Run clang-tidy
+        run: |
+          set -eux
+          git remote add upstream https://github.com/pytorch/pytorch
+          git fetch upstream "$GITHUB_BASE_REF"
+          BASE_SHA=${{ github.event.pull_request.base.sha }}
+          HEAD_SHA=${{ github.event.pull_request.head.sha }}
+          MERGE_BASE=$(git merge-base $BASE_SHA $HEAD_SHA)
+
+          if [[ ! -d build ]]; then
+            git submodule update --init --recursive
+
+            export USE_NCCL=0
+            # We really only need compile_commands.json, so no need to build!
+            time python setup.py --cmake-only build
+
+            # Generate ATen files.
+            time python aten/src/ATen/gen.py \
+              -s aten/src/ATen \
+              -d build/aten/src/ATen \
+              aten/src/ATen/Declarations.cwrap \
+              aten/src/THNN/generic/THNN.h \
+              aten/src/THCUNN/generic/THCUNN.h \
+              aten/src/ATen/nn.yaml \
+              aten/src/ATen/native/native_functions.yaml
+
+            # Generate PyTorch files.
+            time python tools/setup_helpers/generate_code.py            \
+              --declarations-path build/aten/src/ATen/Declarations.yaml \
+              --nn-path aten/src
+          fi
+
+          # Run Clang-Tidy
+          # The negative filters below are to exclude files that include onnx_pb.h or
+          # caffe2_pb.h, otherwise we'd have to build protos as part of this CI job.
+          python tools/clang_tidy.py                  \
+            --verbose                                 \
+            --paths torch/csrc/                       \
+            --diff "$MERGE_BASE"                      \
+            -g"-torch/csrc/jit/export.cpp"            \
+            -g"-torch/csrc/jit/import.cpp"            \
+            -g"-torch/csrc/jit/netdef_converter.cpp"  \
+            "$@" > ${GITHUB_WORKSPACE}/clang-tidy-output.txt
+
+          cat ${GITHUB_WORKSPACE}/clang-tidy-output.txt
+      - name: Add annotations
+        uses: suo/add-annotations-github-action@master
+        with:
+          check_name: 'clang-tidy'
+          linter_output_path: 'clang-tidy-output.txt'
+          commit_sha: ${{ steps.get_pr_tip.outputs.commit_sha }}
+          regex: '^(?<filename>.*?):(?<lineNumber>\d+):(?<columnNumber>\d+): (?<errorDesc>.*?) \[(?<errorCode>.*)\]'
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -42,6 +42,7 @@ dropout_model.pt
 test/generated_type_hints_smoketest.py
 test/htmlcov
 test/cpp_extensions/install/
+test/test-reports/
 third_party/build/
 tools/shared/_utils_internal.py
 torch.egg-info/

.gitmodules

@@ -117,4 +117,4 @@
 [submodule "android/libs/fbjni"]
     ignore = dirty
     path = android/libs/fbjni
-    url = https://github.com/IvanKobzarev/fbjni.git
+    url = https://github.com/facebookincubator/fbjni.git

.jenkins/caffe2/build.sh

@@ -4,14 +4,6 @@ set -ex
 
 source "$(dirname "${BASH_SOURCE[0]}")/common.sh"
 
-# TODO: Migrate all centos jobs to use proper devtoolset
-if [[ "$BUILD_ENVIRONMENT" == *py2-cuda9.0-cudnn7-centos7* ]]; then
-  # There is a bug in pango packge on Centos7 that causes undefined
-  # symbols, upgrading glib2 to >=2.56.1 solves the issue. See
-  # https://bugs.centos.org/view.php?id=15495
-  sudo yum install -y -q glib2-2.56.1
-fi
-
 # CMAKE_ARGS are only passed to 'cmake' and the -Dfoo=bar does not work with
 # setup.py, so we build a list of foo=bars and then either convert it to
 # -Dfoo=bars or export them before running setup.py
@@ -169,7 +161,6 @@ if [[ $BUILD_ENVIRONMENT == *cuda* ]]; then
   export PATH="/usr/local/cuda/bin:$PATH"
 fi
 if [[ $BUILD_ENVIRONMENT == *rocm* ]]; then
-  build_args+=("USE_ROCM=ON")
   # This is needed to enable ImageInput operator in resnet50_trainer
   build_args+=("USE_OPENCV=ON")
   # This is needed to read datasets from https://download.caffe2.ai/databases/resnet_trainer.zip

.jenkins/caffe2/test.sh

@@ -64,7 +64,7 @@ if [[ "$BUILD_ENVIRONMENT" == *cmake* ]]; then
   exit 0
 fi
 
-if [[ "$BUILD_ENVIRONMENT" == *ubuntu14.04* ]]; then
+# if [[ "$BUILD_ENVIRONMENT" == *ubuntu14.04* ]]; then
   # Hotfix, use hypothesis 3.44.6 on Ubuntu 14.04
   # See comments on
   # https://github.com/HypothesisWorks/hypothesis-python/commit/eadd62e467d6cee6216e71b391951ec25b4f5830
@@ -74,9 +74,9 @@ if [[ "$BUILD_ENVIRONMENT" == *ubuntu14.04* ]]; then
   sudo pip -q install attrs==18.1.0 -f https://s3.amazonaws.com/ossci-linux/wheels/attrs-18.1.0-py2.py3-none-any.whl
   sudo pip -q install coverage==4.5.1 -f https://s3.amazonaws.com/ossci-linux/wheels/coverage-4.5.1-cp36-cp36m-macosx_10_12_x86_64.whl
   sudo pip -q install hypothesis==3.44.6 -f https://s3.amazonaws.com/ossci-linux/wheels/hypothesis-3.44.6-py3-none-any.whl
-else
-  pip install --user --no-cache-dir hypothesis==3.59.0
-fi
+# else
+#   pip install --user --no-cache-dir hypothesis==3.59.0
+# fi
 
 # Collect additional tests to run (outside caffe2/python)
 EXTRA_TESTS=()
@@ -93,6 +93,10 @@ if [[ $BUILD_ENVIRONMENT == *-rocm* ]]; then
   # On ROCm, RCCL (distributed) development isn't complete.
   # https://github.com/ROCmSoftwarePlatform/rccl
   rocm_ignore_test+=("--ignore $caffe2_pypath/python/data_parallel_model_test.py")
+
+  # This test has been flaky in ROCm CI (but note the tests are
+  # cpu-only so should be unrelated to ROCm)
+  rocm_ignore_test+=("--ignore $caffe2_pypath/python/operator_test/blobs_queue_db_test.py")
 fi
 
 # NB: Warnings are disabled because they make it harder to see what
@@ -100,8 +104,13 @@ fi
 echo "Running Python tests.."
 if [[ "$BUILD_ENVIRONMENT" == *py3* ]]; then
   # locale setting is required by click package with py3
-  export LC_ALL=C.UTF-8
-  export LANG=C.UTF-8
+  for loc in "en_US.utf8" "C.UTF-8"; do
+    if locale -a | grep "$loc" >/dev/null 2>&1; then
+      export LC_ALL="$loc"
+      export LANG="$loc"
+      break;
+    fi
+  done
 fi
 
 pip install --user pytest-sugar
@@ -115,6 +124,7 @@ pip install --user pytest-sugar
   --ignore "$caffe2_pypath/python/operator_test/matmul_op_test.py" \
   --ignore "$caffe2_pypath/python/operator_test/pack_ops_test.py" \
   --ignore "$caffe2_pypath/python/mkl/mkl_sbn_speed_test.py" \
+  --ignore "$caffe2_pypath/python/trt/test_pt_onnx_trt.py" \
   ${rocm_ignore_test[@]} \
   "$caffe2_pypath/python" \
   "${EXTRA_TESTS[@]}"
@@ -123,7 +133,7 @@ pip install --user pytest-sugar
 # torchvision tests #
 #####################
 if [[ "$BUILD_ENVIRONMENT" == *onnx* ]]; then
-  pip install -q --user git+https://github.com/pytorch/vision.git
+  pip install -q --user git+https://github.com/pytorch/vision.git@v0.5.0
   pip install -q --user ninja
   # JIT C++ extensions require ninja, so put it into PATH.
   export PATH="/var/lib/jenkins/.local/bin:$PATH"
@@ -131,8 +141,7 @@ if [[ "$BUILD_ENVIRONMENT" == *onnx* ]]; then
     # default pip version is too old(9.0.2), unable to support tag `manylinux2010`.
     # Fix the pip error: Couldn't find a version that satisfies the requirement
     sudo pip install --upgrade pip
-    pip install -q --user -i https://test.pypi.org/simple/ ort-nightly==0.5.0.dev905
+    pip install -q --user -i https://test.pypi.org/simple/ ort-nightly==1.1.0.dev1228
   fi
   "$ROOT_DIR/scripts/onnx/test.sh"
 fi
-

.jenkins/pytorch/build.sh

@@ -36,6 +36,12 @@ if [[ "$BUILD_ENVIRONMENT" == *-linux-xenial-py3-clang5-asan* ]]; then
   exec "$(dirname "${BASH_SOURCE[0]}")/build-asan.sh" "$@"
 fi
 
+if [[ "$BUILD_ENVIRONMENT" == *-linux-xenial-py3-clang5-mobile* ]]; then
+  # Use linux host toolchain + mobile build options in order to build & test
+  # mobile libtorch without having to setup Android/iOS toolchain/simulator.
+  exec ./scripts/build_mobile.sh -DBUILD_BINARY=ON "$@"
+fi
+
 echo "Python version:"
 python --version
 
@@ -61,6 +67,24 @@ if ! which conda; then
   fi
 fi
 
+if [[ "$BUILD_ENVIRONMENT" == *libtorch* ]]; then
+  POSSIBLE_JAVA_HOMES=()
+  POSSIBLE_JAVA_HOMES+=(/usr/local)
+  POSSIBLE_JAVA_HOMES+=(/usr/lib/jvm/java-8-openjdk-amd64)
+  POSSIBLE_JAVA_HOMES+=(/Library/Java/JavaVirtualMachines/*.jdk/Contents/Home)
+  for JH in "${POSSIBLE_JAVA_HOMES[@]}" ; do
+    if [[ -e "$JH/include/jni.h" ]] ; then
+      echo "Found jni.h under $JH"
+      export JAVA_HOME="$JH"
+      export BUILD_JNI=ON
+      break
+    fi
+  done
+  if [ -z "$JAVA_HOME" ]; then
+    echo "Did not find jni.h"
+  fi
+fi
+
 # Use special scripts for Android builds
 if [[ "${BUILD_ENVIRONMENT}" == *-android* ]]; then
   export ANDROID_NDK=/opt/ndk
@@ -112,9 +136,7 @@ if [[ "$BUILD_ENVIRONMENT" == *rocm* ]]; then
   fi
 
   python tools/amd_build/build_amd.py
-  # OPENCV is needed to enable ImageInput operator in caffe2 resnet5_trainer
-  # LMDB is needed to read datasets from https://download.caffe2.ai/databases/resnet_trainer.zip
-  USE_ROCM=1 USE_LMDB=1 USE_OPENCV=1 python setup.py install --user
+  python setup.py install --user
 
   # runtime compilation of MIOpen kernels manages to crash sccache - hence undo the wrapping
   bash tools/amd_build/unwrap_clang.sh
@@ -137,10 +159,6 @@ if [[ "$BUILD_ENVIRONMENT" == *ppc64le* ]]; then
   export TORCH_CUDA_ARCH_LIST="6.0"
 fi
 
-if [[ "$BUILD_ENVIRONMENT" == *xenial-py3.6-gcc5.4* ]]; then
-  export DEBUG=1
-fi
-
 # Patch required to build xla
 if [[ "${BUILD_ENVIRONMENT}" == *xla* ]]; then
   git clone --recursive https://github.com/pytorch/xla.git
@@ -159,47 +177,60 @@ echo "The next three invocations are expected to fail with invalid command error
 ( ! get_exit_code python setup.py clean] )
 ( ! get_exit_code python setup.py clean bad_argument )
 
-# ppc64le build fails when WERROR=1
-# set only when building other architectures
-# only use for "python setup.py install" line
-if [[ "$BUILD_ENVIRONMENT" != *ppc64le*  && "$BUILD_ENVIRONMENT" != *clang* ]]; then
-  WERROR=1 python setup.py install
+if [[ "$BUILD_ENVIRONMENT" != *libtorch* ]]; then
+
+  # ppc64le build fails when WERROR=1
+  # set only when building other architectures
+  # only use for "python setup.py install" line
+  if [[ "$BUILD_ENVIRONMENT" != *ppc64le*  && "$BUILD_ENVIRONMENT" != *clang* ]]; then
+    WERROR=1 python setup.py install
+  else
+    python setup.py install
+  fi
+
+  # TODO: I'm not sure why, but somehow we lose verbose commands
+  set -x
+
+  if which sccache > /dev/null; then
+    echo 'PyTorch Build Statistics'
+    sccache --show-stats
+  fi
+
+  assert_git_not_dirty
+
+  # Test documentation build
+  if [[ "$BUILD_ENVIRONMENT" == *xenial-cuda9-cudnn7-py3* ]]; then
+    pushd docs
+    # TODO: Don't run this here
+    pip_install -r requirements.txt || true
+    LC_ALL=C make html
+    popd
+    assert_git_not_dirty
+  fi
+
+  # Build custom operator tests.
+  CUSTOM_OP_BUILD="$PWD/../custom-op-build"
+  CUSTOM_OP_TEST="$PWD/test/custom_operator"
+  python --version
+  SITE_PACKAGES="$(python -c 'from distutils.sysconfig import get_python_lib; print(get_python_lib())')"
+  mkdir "$CUSTOM_OP_BUILD"
+  pushd "$CUSTOM_OP_BUILD"
+  cmake "$CUSTOM_OP_TEST" -DCMAKE_PREFIX_PATH="$SITE_PACKAGES/torch" -DPYTHON_EXECUTABLE="$(which python)"
+  make VERBOSE=1
+  popd
+  assert_git_not_dirty
 else
-  python setup.py install
-fi
+  # Test standalone c10 build
+  if [[ "$BUILD_ENVIRONMENT" == *xenial-cuda9-cudnn7-py3* ]]; then
+    mkdir -p c10/build
+    pushd c10/build
+    cmake ..
+    make -j
+    popd
+    assert_git_not_dirty
+  fi
 
-# TODO: I'm not sure why, but somehow we lose verbose commands
-set -x
-
-if which sccache > /dev/null; then
-  echo 'PyTorch Build Statistics'
-  sccache --show-stats
-fi
-
-assert_git_not_dirty
-
-# Test documentation build
-if [[ "$BUILD_ENVIRONMENT" == *xenial-cuda9-cudnn7-py3* ]]; then
-  pushd docs
-  # TODO: Don't run this here
-  pip_install -r requirements.txt || true
-  LC_ALL=C make html
-  popd
-  assert_git_not_dirty
-fi
-
-# Test standalone c10 build
-if [[ "$BUILD_ENVIRONMENT" == *xenial-cuda9-cudnn7-py3* ]]; then
-  mkdir -p c10/build
-  pushd c10/build
-  cmake ..
-  make -j
-  popd
-  assert_git_not_dirty
-fi
-
-# Test no-Python build
-if [[ "$BUILD_TEST_LIBTORCH" == "1" ]]; then
+  # Test no-Python build
   echo "Building libtorch"
   # NB: Install outside of source directory (at the same level as the root
   # pytorch folder) so that it doesn't get cleaned away prior to docker push.
@@ -210,18 +241,6 @@ if [[ "$BUILD_TEST_LIBTORCH" == "1" ]]; then
   popd
 fi
 
-# Build custom operator tests.
-CUSTOM_OP_BUILD="$PWD/../custom-op-build"
-CUSTOM_OP_TEST="$PWD/test/custom_operator"
-python --version
-SITE_PACKAGES="$(python -c 'from distutils.sysconfig import get_python_lib; print(get_python_lib())')"
-mkdir "$CUSTOM_OP_BUILD"
-pushd "$CUSTOM_OP_BUILD"
-cmake "$CUSTOM_OP_TEST" -DCMAKE_PREFIX_PATH="$SITE_PACKAGES/torch" -DPYTHON_EXECUTABLE="$(which python)"
-make VERBOSE=1
-popd
-assert_git_not_dirty
-
 # Test XLA build
 if [[ "${BUILD_ENVIRONMENT}" == *xla* ]]; then
   # TODO: Move this to Dockerfile.

.jenkins/pytorch/common.sh

@@ -158,7 +158,9 @@ fi
 
 function pip_install() {
   # retry 3 times
-  pip install --progress-bar off "$@" || pip install --progress-bar off "$@" || pip install --progress-bar off "$@"
+  # old versions of pip don't have the "--progress-bar" flag
+  pip install --progress-bar off "$@" || pip install --progress-bar off "$@" || pip install --progress-bar off "$@" ||\
+  pip install "$@" || pip install "$@" || pip install "$@"
 }
 
 function pip_uninstall() {
@@ -166,6 +168,10 @@ function pip_uninstall() {
   pip uninstall -y "$@" || pip uninstall -y "$@"
 }
 
+retry () {
+  $*  || (sleep 1 && $*) || (sleep 2 && $*)
+}
+
 function get_exit_code() {
   set +e
   "$@"

.jenkins/pytorch/macos-common.sh

@@ -13,12 +13,12 @@ mkdir -p ${WORKSPACE_DIR}
 # If a local installation of conda doesn't exist, we download and install conda
 if [ ! -d "${WORKSPACE_DIR}/miniconda3" ]; then
   mkdir -p ${WORKSPACE_DIR}
-  curl https://repo.continuum.io/miniconda/Miniconda3-latest-MacOSX-x86_64.sh -o ${WORKSPACE_DIR}/miniconda3.sh
-  bash ${WORKSPACE_DIR}/miniconda3.sh -b -p ${WORKSPACE_DIR}/miniconda3
+  retry curl https://repo.continuum.io/miniconda/Miniconda3-latest-MacOSX-x86_64.sh -o ${WORKSPACE_DIR}/miniconda3.sh
+  retry bash ${WORKSPACE_DIR}/miniconda3.sh -b -p ${WORKSPACE_DIR}/miniconda3
 fi
 export PATH="${WORKSPACE_DIR}/miniconda3/bin:$PATH"
 source ${WORKSPACE_DIR}/miniconda3/bin/activate
-conda install -y mkl mkl-include numpy pyyaml setuptools cmake cffi ninja
+retry conda install -y mkl mkl-include numpy pyyaml setuptools cmake cffi ninja
 
 # The torch.hub tests make requests to GitHub.
 #
@@ -29,13 +29,13 @@ conda install -y mkl mkl-include numpy pyyaml setuptools cmake cffi ninja
 # > certificate verify failed: unable to get local issuer certificate
 # > (_ssl.c:1056)
 #
-conda install -y -c conda-forge certifi
+retry conda install -y -c conda-forge certifi
 
 # Needed by torchvision, which is imported from TestHub in test_utils.py.
-conda install -y pillow
+retry conda install -y pillow
 
 # Building with USE_DISTRIBUTED=1 requires libuv (for Gloo).
-conda install -y libuv pkg-config
+retry conda install -y libuv pkg-config
 
 # Image commit tag is used to persist the build from the build job
 # and to retrieve the build from the test job.

.jenkins/pytorch/macos-test.sh

@@ -6,6 +6,9 @@ source "$(dirname "${BASH_SOURCE[0]}")/macos-common.sh"
 conda install -y six
 pip install -q hypothesis "librosa>=0.6.2" psutil
 
+# TODO move this to docker
+pip install unittest-xml-reporting
+
 # faulthandler become built-in since 3.3
 if [[ ! $(python -c "import sys; print(int(sys.version_info >= (3, 3)))") == "1" ]]; then
   pip install -q faulthandler

.jenkins/pytorch/multigpu-test.sh

@@ -10,8 +10,10 @@ COMPACT_JOB_NAME="${BUILD_ENVIRONMENT}"
 source "$(dirname "${BASH_SOURCE[0]}")/common.sh"
 
 echo "Testing pytorch (distributed only)"
-
 if [ -n "${IN_CIRCLECI}" ]; then
+  # TODO move this to docker
+  pip_install unittest-xml-reporting
+
   if [[ "$BUILD_ENVIRONMENT" == *-xenial-cuda9-* ]]; then
     # TODO: move this to Docker
     sudo apt-get update
@@ -28,7 +30,7 @@ if [ -n "${IN_CIRCLECI}" ]; then
 fi
 
 python tools/download_mnist.py --quiet -d test/cpp/api/mnist
-OMP_NUM_THREADS=2 TORCH_CPP_TEST_MNIST_PATH="test/cpp/api/mnist" "$PWD/../cpp-build"/caffe2/build/bin/test_api
+OMP_NUM_THREADS=2 TORCH_CPP_TEST_MNIST_PATH="test/cpp/api/mnist" build/bin/test_api
 time python test/run_test.py --verbose -i distributed
 time python test/run_test.py --verbose -i c10d
 time python test/run_test.py --verbose -i c10d_spawn

.jenkins/pytorch/test.sh

@@ -12,6 +12,9 @@ source "$(dirname "${BASH_SOURCE[0]}")/common.sh"
 echo "Testing pytorch"
 
 if [ -n "${IN_CIRCLECI}" ]; then
+  # TODO move this to docker
+  pip_install unittest-xml-reporting
+
   if [[ "$BUILD_ENVIRONMENT" == *-xenial-cuda9-* ]]; then
     # TODO: move this to Docker
     sudo apt-get -qq update
@@ -32,6 +35,12 @@ if [ -n "${IN_CIRCLECI}" ]; then
   fi
 fi
 
+if [[ "$BUILD_ENVIRONMENT" == *rocm* ]]; then
+  # TODO: Move this to Docker
+  sudo apt-get -qq update
+  sudo apt-get -qq install --no-install-recommends libsndfile1
+fi
+
 # --user breaks ppc64le builds and these packages are already in ppc64le docker
 if [[ "$BUILD_ENVIRONMENT" != *ppc64le* ]]; then
   # JIT C++ extensions require ninja.
@@ -40,7 +49,7 @@ if [[ "$BUILD_ENVIRONMENT" != *ppc64le* ]]; then
   export PATH="/var/lib/jenkins/.local/bin:$PATH"
 
   # TODO: move this to Docker
-  pip_install --user hypothesis
+  pip_install --user "hypothesis==4.53.2"
 
   # TODO: move this to Docker
   PYTHON_VERSION=$(python -c 'import platform; print(platform.python_version())'|cut -c1)
@@ -103,8 +112,18 @@ test_python_nn() {
   assert_git_not_dirty
 }
 
+test_python_ge_config_simple() {
+  time python test/run_test.py --include jit_simple --verbose
+  assert_git_not_dirty
+}
+
+test_python_ge_config_legacy() {
+  time python test/run_test.py --include jit_legacy jit_fuser_legacy --verbose
+  assert_git_not_dirty
+}
+
 test_python_all_except_nn() {
-  time python test/run_test.py --exclude nn --verbose --bring-to-front quantization quantized quantized_tensor quantized_nn_mods quantizer
+  time python test/run_test.py --exclude nn jit_simple jit_legacy jit_fuser_legacy --verbose --bring-to-front quantization quantized quantized_tensor quantized_nn_mods
   assert_git_not_dirty
 }
 
@@ -134,7 +153,7 @@ test_aten() {
 }
 
 test_torchvision() {
-  pip_install --user git+https://github.com/pytorch/vision.git@2b73a4846773a670632b29fb2fc2ac57df7bce5d
+  pip_install --user git+https://github.com/pytorch/vision.git@44a5bae933655ed7ff798669a43452b833f9ce01
 }
 
 test_libtorch() {
@@ -195,15 +214,17 @@ test_backward_compatibility() {
   pushd test/backward_compatibility
   python dump_all_function_schemas.py --filename new_schemas.txt
   pip_uninstall torch
-  pip_install --pre torch -f https://download.pytorch.org/whl/nightly/cpu/torch_nightly.html
+  pip_install torch==1.3.1+cpu -f https://download.pytorch.org/whl/torch_stable.html
   python check_backward_compatibility.py --new-schemas new_schemas.txt
   popd
   set +x
   assert_git_not_dirty
 }
 
-(cd test && python -c "import torch; print(torch.__config__.show())")
-(cd test && python -c "import torch; print(torch.__config__.parallel_info())")
+if ! [[ "${BUILD_ENVIRONMENT}" == *libtorch* ]]; then
+  (cd test && python -c "import torch; print(torch.__config__.show())")
+  (cd test && python -c "import torch; print(torch.__config__.parallel_info())")
+fi
 
 if [[ "${BUILD_ENVIRONMENT}" == *backward* ]]; then
   test_backward_compatibility
@@ -211,6 +232,13 @@ if [[ "${BUILD_ENVIRONMENT}" == *backward* ]]; then
 elif [[ "${BUILD_ENVIRONMENT}" == *xla* || "${JOB_BASE_NAME}" == *xla* ]]; then
   test_torchvision
   test_xla
+elif [[ "${BUILD_ENVIRONMENT}" == *ge_config_legacy* || "${JOB_BASE_NAME}" == *ge_config_legacy* ]]; then
+  test_python_ge_config_legacy
+elif [[ "${BUILD_ENVIRONMENT}" == *ge_config_simple* || "${JOB_BASE_NAME}" == *ge_config_simple* ]]; then
+  test_python_ge_config_simple
+elif [[ "${BUILD_ENVIRONMENT}" == *libtorch* ]]; then
+  # TODO: run some C++ tests
+  echo "no-op at the moment"
 elif [[ "${BUILD_ENVIRONMENT}" == *-test1 || "${JOB_BASE_NAME}" == *-test1 ]]; then
   test_torchvision
   test_python_nn

.jenkins/pytorch/win-test-helpers/setup_pytorch_env.bat

@@ -22,7 +22,7 @@ if NOT "%BUILD_ENVIRONMENT%"=="" (
     :: Numba is pinned to 0.44.0 to avoid https://github.com/numba/numba/issues/4352
     call conda install -y -q python=3.6.7 numpy mkl cffi pyyaml boto3 protobuf numba==0.44.0
 )
-pip install -q ninja future hypothesis "librosa>=0.6.2" psutil pillow
+pip install -q ninja future "hypothesis==4.53.2" "librosa>=0.6.2" psutil pillow
 :: No need to install faulthandler since we only test Python >= 3.6 on Windows
 :: faulthandler is builtin since Python 3.3
 

.jenkins/pytorch/win-test-helpers/test_python_all_except_nn.bat

@@ -1,3 +1,3 @@
 call %SCRIPT_HELPERS_DIR%\setup_pytorch_env.bat
-cd test && python run_test.py --exclude nn --verbose && cd ..
+cd test && python run_test.py --exclude nn jit_simple jit_legacy jit_fuser_legacy --verbose && cd ..
 if ERRORLEVEL 1 exit /b 1

CMakeLists.txt

@@ -15,6 +15,10 @@ if(NOT CMAKE_VERSION VERSION_LESS 3.15.0)
   cmake_policy(SET CMP0092 NEW)
 endif()
 
+if(NOT CMAKE_VERSION VERSION_LESS 3.10)
+  set(FIND_CUDA_MODULE_DEPRECATED ON)
+endif()
+
 # ---[ Project and semantic versioning.
 project(Caffe2 CXX C)
 
@@ -103,7 +107,8 @@ option(BUILD_BINARY "Build C++ binaries" OFF)
 option(BUILD_DOCS "Build Caffe2 documentation" OFF)
 option(BUILD_CUSTOM_PROTOBUF "Build and use Caffe2's own protobuf under third_party" ON)
 option(BUILD_PYTHON "Build Python binaries" ON)
-option(BUILD_CAFFE2_OPS "Build Caffe2 operators" ON)
+cmake_dependent_option(BUILD_CAFFE2_OPS "Build Caffe2 operators" ON
+  "NOT MSVC" OFF)
 option(BUILD_SHARED_LIBS "Build libcaffe2.so" ON)
 option(BUILD_CAFFE2_MOBILE "Build libcaffe2 for mobile (deprecating)" ON)
 option(BUILD_NAMEDTENSOR "Experimental: compile with namedtensor support" OFF)
@@ -115,6 +120,7 @@ cmake_dependent_option(
     CAFFE2_USE_MSVC_STATIC_RUNTIME "Using MSVC static runtime libraries" ON
     "NOT BUILD_SHARED_LIBS" OFF)
 option(BUILD_TEST "Build C++ test binaries (need gtest and gbenchmark)" OFF)
+option(BUILD_JNI "Build JNI bindings" OFF)
 cmake_dependent_option(
     INSTALL_TEST "Install test binaries if BUILD_TEST is on" ON
     "BUILD_TEST" OFF)
@@ -140,7 +146,7 @@ option(USE_METAL "Use Metal for iOS build" ON)
 option(USE_NATIVE_ARCH "Use -march=native" OFF)
 cmake_dependent_option(
     USE_NCCL "Use NCCL" ON
-    "USE_CUDA;UNIX;NOT APPLE" OFF)
+    "USE_CUDA OR USE_ROCM;UNIX;NOT APPLE" OFF)
 cmake_dependent_option(
     USE_STATIC_NCCL "Use static NCCL" OFF
     "USE_NCCL" OFF)
@@ -199,6 +205,8 @@ cmake_dependent_option(
   "MSVC" OFF)
 
 set(ONNX_NAMESPACE "onnx_torch" CACHE STRING "A namespace for ONNX; needed to build with other frameworks that share ONNX.")
+set(SELECTED_OP_LIST "" CACHE STRING
+    "Path to the yaml file that contains the list of operators to include for custom build. Include all operators by default.")
 
 # This is a fix for a rare build issue on Ubuntu:
 # symbol lookup error: miniconda3/envs/pytorch-py3.7/lib/libmkl_intel_lp64.so: undefined symbol: mkl_blas_dsyrk
@@ -312,7 +320,6 @@ if (INTERN_BUILD_MOBILE AND NOT BUILD_CAFFE2_MOBILE)
   set(USE_FBGEMM OFF)
   set(USE_PYTORCH_QNNPACK ON)
   set(USE_QNNPACK OFF)
-  set(USE_STATIC_DISPATCH ON)
   set(INTERN_DISABLE_ONNX ON)
   set(INTERN_DISABLE_AUTOGRAD ON)
   set(INTERN_USE_EIGEN_BLAS ON)
@@ -490,7 +497,7 @@ if(CMAKE_COMPILER_IS_GNUCXX AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 7.0.0
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-stringop-overflow")
 endif()
 
-if(ANDROID)
+if(ANDROID AND (NOT ANDROID_DEBUG_SYMBOLS))
   if(CMAKE_COMPILER_IS_GNUCXX)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -s")
   else()
@@ -642,5 +649,12 @@ if (BUILD_BINARY)
   add_subdirectory(binaries)
 endif()
 
+# ---[ JNI
+if (BUILD_JNI)
+  set(BUILD_LIBTORCH_WITH_JNI 1)
+  set(FBJNI_SKIP_TESTS 1)
+  add_subdirectory(android/pytorch_android)
+endif()
+
 include(cmake/Summary.cmake)
 caffe2_print_configuration_summary()

CODEOWNERS

@@ -4,10 +4,10 @@
 /docs/cpp @goldsborough @ebetica @yf225
 /torch/csrc/api/ @ebetica @goldsborough @yf225
 /test/cpp/api/ @ebetica @goldsborough @yf225
-/torch/lib/c10d/ @pietern @mrshenli
-/torch/csrc/distributed/ @pietern @mrshenli
-/torch/distributed/ @apaszke @pietern @mrshenli
-/test/test_c10d.py @pietern @mrshenli
+/torch/lib/c10d/ @pietern @mrshenli @zhaojuanmao
+/torch/csrc/distributed/ @pietern @mrshenli @zhaojuanmao
+/torch/distributed/ @apaszke @pietern @mrshenli @zhaojuanmao
+/test/test_c10d.py @pietern @mrshenli @zhaojuanmao
 /torch/utils/cpp_extension.py @goldsborough @fmassa @soumith @ezyang
 
 # Not there to stricly require the approval, but to be tagged as a reviewer
@@ -19,3 +19,9 @@
 /torch/autograd/ @apaszke
 /torch/jit/ @apaszke
 /torch/utils/data/ @apaszke
+
+# Distributed RPC Framework.
+/torch/csrc/distributed/rpc @mrshenli @pritamdamania87 @zhaojuanmao
+/torch/csrc/distributed/autograd @mrshenli @pritamdamania87 @zhaojuanmao
+/torch/distributed/rpc @mrshenli @pritamdamania87 @zhaojuanmao
+/torch/distributed/autograd @mrshenli @pritamdamania87 @zhaojuanmao

CONTRIBUTING.md

@@ -216,8 +216,10 @@ To build the documentation:
 cd docs
 pip install -r requirements.txt
 # `katex` must also be available in your PATH.
-# If you are using Ubuntu or Debian, you can install it with:
-# sudo apt install katex
+# You can either install katex globally if you have properly configured npm:
+# npm install -g katex
+# Or if you prefer an uncontaminated global executable environment or do not want to go through the node configuration:
+# npm install katex && export PATH="$PATH:$(pwd)/node_modules/.bin"
 ```
 
 3. Generate the documentation HTML files. The generated files will be in `docs/build/html`.
@@ -284,6 +286,57 @@ cd docs
 make doctest
 ```
 
+## Profiling with `py-spy`
+
+Evaluating the performance impact of code changes in PyTorch can be complicated,
+particularly if code changes happen in compiled code. One simple way to profile
+both Python and C++ code in PyTorch is to use
+[`py-spy`](https://github.com/benfred/py-spy), a sampling profiler for Python
+that has the ability to profile native code and Python code in the same session.
+
+`py-spy` can be installed via `pip`:
+
+```bash
+$ pip install py-spy
+```
+
+To use `py-spy`, first write a Python test script that exercises the
+functionality you would like to profile. For example, this script profiles
+`torch.add`:
+
+```python
+import torch
+
+t1 = torch.tensor([[1, 1], [1, 1.]])
+t2 = torch.tensor([[0, 0], [0, 0.]])
+
+for _ in range(1000000):
+    torch.add(t1, t2)
+```
+
+Since the `torch.add` operation happens in microseconds, we repeat it a large
+number of times to get good statistics. The most straightforward way to use
+`py-spy` with such a script is to generate a [flame
+graph](http://www.brendangregg.com/flamegraphs.html):
+
+```bash
+$ py-spy record -o profile.svg --native -- python test_tensor_tensor_add.py
+```
+
+This will output a file named `profile.svg` containing a flame graph you can
+view in a web browser or SVG viewer. Individual stack frame entries in the graph
+can be selected interactively with your mouse to zoom in on a particular part of
+the program execution timeline. The `--native` command-line option tells
+`py-spy` to record stack frame entries for PyTorch C++ code. To get line numbers
+for C++ code it may be necessary to compile PyTorch in debug mode by prepending
+your `setup.py develop` call to compile PyTorch with `DEBUG=1`. Depending on
+your operating system it may also be necessary to run `py-spy` with root
+privileges.
+
+`py-spy` can also work in an `htop`-like "live profiling" mode and can be
+tweaked to adjust the stack sampling rate, see the `py-spy` readme for more
+details.
+
 ## Managing Multiple Build Trees
 
 One downside to using `python setup.py develop` is that your development
@@ -438,6 +491,38 @@ ccache -F 0
 # deploy (and add to ~/.bashrc for later)
 export PATH="/usr/lib/ccache:$PATH"
 ```
+
+It is also possible to install `ccache` via `conda` by installing it from the
+community-maintained `conda-forge` channel. Here is how to set up `ccache` this
+way:
+
+```bash
+# install ccache
+conda install -c conda-forge ccache
+
+# set up ccache compiler symlinks
+mkdir ~/ccache
+mkdir ~/ccache/lib
+mkdir ~/ccache/cuda
+ln -s $CONDA_PREFIX/bin/ccache ~/ccache/lib/cc
+ln -s $CONDA_PREFIX/bin/ccache ~/ccache/lib/c++
+ln -s $CONDA_PREFIX/bin/ccache ~/ccache/lib/gcc
+ln -s $CONDA_PREFIX/bin/ccache ~/ccache/lib/g++
+ln -s $CONDA_PREFIX/bin/ccache ~/ccache/cuda/nvcc
+
+# update PATH to reflect symlink locations, consider
+# adding this to your .bashrc
+export PATH=~/ccache/lib:$PATH
+export CUDA_NVCC_EXECUTABLE=~/ccache/cuda/nvcc
+
+# increase ccache cache size to 25 GiB
+ccache -M 25Gi
+```
+
+To check this is working, do two clean builds of pytorch in a row. The second
+build should be substantially and noticeably faster than the first build.
+
+
 #### Use a faster linker
 If you are editing a single file and rebuilding in a tight loop, the time spent
 linking will dominate. The system linker available in most Linux distributions

README.md

@@ -44,7 +44,7 @@ At a granular level, PyTorch is a library that consists of the following compone
 | [**torch.multiprocessing**](https://pytorch.org/docs/stable/multiprocessing.html) | Python multiprocessing, but with magical memory sharing of torch Tensors across processes. Useful for data loading and Hogwild training |
 | [**torch.utils**](https://pytorch.org/docs/stable/data.html) | DataLoader and other utility functions for convenience |
 
-Usually one uses PyTorch either as:
+Usually PyTorch is used either as:
 
 - a replacement for NumPy to use the power of GPUs.
 - a deep learning research platform that provides maximum flexibility and speed.
@@ -88,7 +88,7 @@ You get the best of speed and flexibility for your crazy research.
 
 PyTorch is not a Python binding into a monolithic C++ framework.
 It is built to be deeply integrated into Python.
-You can use it naturally like you would use [NumPy](http://www.numpy.org/) / [SciPy](https://www.scipy.org/) / [scikit-learn](http://scikit-learn.org) etc.
+You can use it naturally like you would use [NumPy](https://www.numpy.org/) / [SciPy](https://www.scipy.org/) / [scikit-learn](https://scikit-learn.org) etc.
 You can write your new neural network layers in Python itself, using your favorite libraries
 and use packages such as Cython and Numba.
 Our goal is to not reinvent the wheel where appropriate.
@@ -124,7 +124,7 @@ You can write new neural network layers in Python using the torch API
 [or your favorite NumPy-based libraries such as SciPy](https://pytorch.org/tutorials/advanced/numpy_extensions_tutorial.html).
 
 If you want to write your layers in C/C++, we provide a convenient extension API that is efficient and with minimal boilerplate.
-There is no wrapper code that needs to be written. You can see [a tutorial here](https://pytorch.org/tutorials/advanced/cpp_extension.html) and [an example here](https://github.com/pytorch/extension-cpp).
+No wrapper code needs to be written. You can see [a tutorial here](https://pytorch.org/tutorials/advanced/cpp_extension.html) and [an example here](https://github.com/pytorch/extension-cpp).
 
 
 ## Installation
@@ -145,12 +145,12 @@ Python wheels for NVIDIA's Jetson Nano, Jetson TX2, and Jetson AGX Xavier are av
   - Python 2.7: https://nvidia.box.com/v/torch-weekly-cp27-jetson-jp42
   - Python 3.6: https://nvidia.box.com/v/torch-weekly-cp36-jetson-jp42
 
-They requires JetPack 4.2 and above and are maintained by @dusty-nv
+They require JetPack 4.2 and above, and @dusty-nv maintains them
 
 
 ### From Source
 
-If you are installing from source, we highly recommend installing an [Anaconda](https://www.anaconda.com/distribution/#download-section) environment.
+If you are installing from source, you will need a C++14 compiler. Also, we highly recommend installing an [Anaconda](https://www.anaconda.com/distribution/#download-section) environment.
 You will get a high-quality BLAS library (MKL) and you get controlled dependency versions regardless of your Linux distro.
 
 Once you have [Anaconda](https://www.anaconda.com/distribution/#download-section) installed, here are the instructions.
@@ -167,7 +167,7 @@ If you are building for NVIDIA's Jetson platforms (Jetson Nano, TX1, TX2, AGX Xa
 
 #### Install Dependencies
 
-Common
+Common (only install `typing` for Python <3.5)
 ```
 conda install numpy ninja pyyaml mkl mkl-include setuptools cmake cffi typing
 ```
@@ -175,7 +175,7 @@ conda install numpy ninja pyyaml mkl mkl-include setuptools cmake cffi typing
 On Linux
 ```bash
 # Add LAPACK support for the GPU if needed
-conda install -c pytorch magma-cuda90 # or [magma-cuda92 | magma-cuda100 ] depending on your cuda version
+conda install -c pytorch magma-cuda90 # or [magma-cuda92 | magma-cuda100 | magma-cuda101 ] depending on your cuda version
 ```
 
 #### Get the PyTorch Source
@@ -209,13 +209,13 @@ If the version of Visual Studio 2017 is higher than 15.4.5, installing of "VC++
 <br/> There is no guarantee of the correct building with VC++ 2017 toolsets, others than version 15.4 v14.11.
 <br/> "VC++ 2017 version 15.4 v14.11 toolset" might be installed onto already installed Visual Studio 2017 by running its installation once again and checking the corresponding checkbox under "Individual components"/"Compilers, build tools, and runtimes".
 
-NVTX is a part of CUDA distributive, where it is called "Nsight Compute". For installing it onto already installed CUDA run CUDA installation once again and check the corresponding checkbox.
+NVTX is a part of CUDA distributive, where it is called "Nsight Compute". To install it onto already installed CUDA run CUDA installation once again and check the corresponding checkbox.
 Be sure that CUDA with Nsight Compute is installed after Visual Studio 2017.
 
 Currently VS 2017, VS 2019 and Ninja are supported as the generator of CMake. If `ninja.exe` is detected in `PATH`, then Ninja will be used as the default generator, otherwise it will use VS 2017.
 <br/> If Ninja is selected as the generator, the latest MSVC which is newer than VS 2015 (14.0) will get selected as the underlying toolchain if you have Python > 3.5, otherwise VS 2015 will be selected so you'll have to activate the environment. If you use CMake <= 3.14.2 and has VS 2019 installed, then even if you specify VS 2017 as the generator, VS 2019 will get selected as the generator.
 
-CUDA and MSVC has strong version dependencies, so even if you use VS 2017 / 2019, you will get build errors like `nvcc fatal : Host compiler targets unsupported OS`. For this kind of problem, please install the corresponding VS toolchain in the table below and then you can either specify the toolset during activation (recommended) or set `CUDAHOSTCXX` to override the cuda host compiler (not recommended if there are big version differences).
+CUDA and MSVC have strong version dependencies, so even if you use VS 2017 / 2019, you will get build errors like `nvcc fatal : Host compiler targets unsupported OS`. For this kind of problem, please install the corresponding VS toolchain in the table below and then you can either specify the toolset during activation (recommended) or set `CUDAHOSTCXX` to override the cuda host compiler (not recommended if there are big version differences).
 
 | CUDA version | Newest supported VS version                             |
 | ------------ | ------------------------------------------------------- |
@@ -234,7 +234,7 @@ set FORCE_PY27_BUILD=1
 :: Note: This value is useless if Ninja is detected. However, you can force that by using `set USE_NINJA=OFF`.
 set CMAKE_GENERATOR=Visual Studio 15 2017
 
-:: Read the content in the previous section carefully before you preceed.
+:: Read the content in the previous section carefully before you proceed.
 :: [Optional] If you want to override the underlying toolset used by Ninja and Visual Studio with CUDA, please run the following script block.
 :: "Visual Studio 2017 Developer Command Prompt" will be run automatically.
 :: Make sure you have CMake >= 3.12 before you do this when you use the Visual Studio generator.
@@ -331,7 +331,7 @@ Sending a PR without discussion might end up resulting in a rejected PR, because
 PyTorch is a community driven project with several skillful engineers and researchers contributing to it.
 
 PyTorch is currently maintained by [Adam Paszke](https://apaszke.github.io/), [Sam Gross](https://github.com/colesbury), [Soumith Chintala](http://soumith.ch) and [Gregory Chanan](https://github.com/gchanan) with major contributions coming from hundreds of talented individuals in various forms and means.
-A non-exhaustive but growing list needs to mention: Trevor Killeen, Sasank Chilamkurthy, Sergey Zagoruyko, Adam Lerer, Francisco Massa, Alykhan Tejani, Luca Antiga, Alban Desmaison, Andreas Kopf, James Bradbury, Zeming Lin, Yuandong Tian, Guillaume Lample, Marat Dukhan, Natalia Gimelshein, Christian Sarofeen, Martin Raison, Edward Yang, Zachary Devito.
+A non-exhaustive but growing list needs to mention: Trevor Killeen, Sasank Chilamkurthy, Sergey Zagoruyko, Adam Lerer, Francisco Massa, Alykhan Tejani, Luca Antiga, Alban Desmaison, Andreas Koepf, James Bradbury, Zeming Lin, Yuandong Tian, Guillaume Lample, Marat Dukhan, Natalia Gimelshein, Christian Sarofeen, Martin Raison, Edward Yang, Zachary Devito.
 
 Note: this project is unrelated to [hughperkins/pytorch](https://github.com/hughperkins/pytorch) with the same name. Hugh is a valuable contributor in the Torch community and has helped with many things Torch and PyTorch.
 

android/.gitignore

@@ -6,11 +6,5 @@ gradle/wrapper
 .idea/*
 .externalNativeBuild
 build
-pytorch_android/src/main/cpp/libtorch_include/x86/**
-pytorch_android/src/main/cpp/libtorch_include/x86_64/**
-pytorch_android/src/main/cpp/libtorch_include/armeabi-v7a/**
-pytorch_android/src/main/cpp/libtorch_include/arm64-v8a/**
-pytorch_android/src/main/jniLibs/x86/**
-pytorch_android/src/main/jniLibs/x86_64/**
-pytorch_android/src/main/jniLibs/armeabi-v7a/**
-pytorch_android/src/main/jniLibs/arm64-v8a/**
+pytorch_android/src/main/cpp/libtorch_include/**
+pytorch_android/src/main/jniLibs/**

android/README.md

@@ -0,0 +1,118 @@
+# Android
+
+## Demo applications and tutorials
+
+Demo applications with code walk-through can be find in [this github repo](https://github.com/pytorch/android-demo-app).
+
+## Publishing
+
+##### Release
+Release artifacts are published to jcenter:
+
+```
+repositories {
+    jcenter()
+}
+
+dependencies {
+    implementation 'org.pytorch:pytorch_android:1.3.0'
+    implementation 'org.pytorch:pytorch_android_torchvision:1.3.0'
+}
+```
+
+##### Nightly
+
+Nightly(snapshots) builds are published every night from `master` branch to [nexus sonatype snapshots repository](https://oss.sonatype.org/#nexus-search;quick~pytorch_android)
+
+To use them repository must be specified explicitly:
+```
+repositories {
+    maven {
+        url "https://oss.sonatype.org/content/repositories/snapshots"
+    }
+}
+
+dependencies {
+    ...
+    implementation 'org.pytorch:pytorch_android:1.4.0-SNAPSHOT'
+    implementation 'org.pytorch:pytorch_android_torchvision:1.4.0-SNAPSHOT'
+    ...
+}
+```
+The current nightly(snapshots) version is the value of `VERSION_NAME` in `gradle.properties` in current folder, at this moment it is `1.4.0-SNAPSHOT`.
+
+## Building PyTorch Android from Source
+
+In some cases you might want to use a local build of pytorch android, for example you may build custom libtorch binary with another set of operators or to make local changes.
+
+For this you can use `./scripts/build_pytorch_android.sh` script.
+```
+git clone https://github.com/pytorch/pytorch.git
+cd pytorch
+sh ./scripts/build_pytorch_android.sh
+```
+
+The workflow contains several steps:
+
+1\. Build libtorch for android for all 4 android abis (armeabi-v7a, arm64-v8a, x86, x86_64)
+
+2\. Create symbolic links to the results of those builds:
+`android/pytorch_android/src/main/jniLibs/${abi}` to the directory with output libraries
+`android/pytorch_android/src/main/cpp/libtorch_include/${abi}` to the directory with headers. These directories are used to build `libpytorch.so` library that will be loaded on android device.
+ 
+3\. And finally run `gradle` in `android/pytorch_android` directory with task `assembleRelease`
+
+Script requires that Android SDK, Android NDK and gradle are installed.
+They are specified as environment variables:
+
+`ANDROID_HOME` - path to [Android SDK](https://developer.android.com/studio/command-line/sdkmanager.html)
+
+`ANDROID_NDK` - path to [Android NDK](https://developer.android.com/studio/projects/install-ndk)
+
+`GRADLE_HOME` - path to [gradle](https://gradle.org/releases/)
+
+
+After successful build you should see the result as aar file:
+
+```
+$ find pytorch_android/build/ -type f -name *aar
+pytorch_android/build/outputs/aar/pytorch_android.aar
+pytorch_android_torchvision/build/outputs/aar/pytorch_android.aar
+libs/fbjni_local/build/outputs/aar/pytorch_android_fbjni.aar
+```
+
+It can be used directly in android projects, as a gradle dependency:
+```
+allprojects {
+    repositories {
+        flatDir {
+            dirs 'libs'
+        }
+    }
+}
+
+android {
+    ...
+    packagingOptions {
+        pickFirst "**/libfbjni.so"
+    }
+    ...
+}
+
+dependencies {
+    implementation(name:'pytorch_android', ext:'aar')
+    implementation(name:'pytorch_android_torchvision', ext:'aar')
+    implementation(name:'pytorch_android_fbjni', ext:'aar')
+}
+```
+
+At the moment for the case of using aar files directly we need additional configuration due to packaging specific (`libfbjni.so` is packaged in both `pytorch_android_fbjni.aar` and `pytorch_android.aar`).
+```
+packagingOptions {
+    pickFirst "**/libfbjni.so"
+}
+```
+
+## More Details
+
+You can find more details about the PyTorch Android API in the [Javadoc](https://pytorch.org/docs/stable/packages.html).

android/build.gradle

@@ -1,33 +1,33 @@
-buildscript {
-    ext {
-        minSdkVersion = 21
-        targetSdkVersion = 28
-        compileSdkVersion = 28
-        buildToolsVersion = '28.0.3'
-
-        coreVersion = "1.2.0"
-        extJUnitVersion = "1.1.1"
-        runnerVersion = "1.2.0"
-        rulesVersion = "1.2.0"
-        junitVersion = "4.12"
-    }
-
-    repositories {
-        google()
-        mavenLocal()
-        mavenCentral()
-        jcenter()
-    }
-
-    dependencies {
-        classpath 'com.android.tools.build:gradle:3.3.2'
-        classpath "com.jfrog.bintray.gradle:gradle-bintray-plugin:${GRADLE_BINTRAY_PLUGIN_VERSION}"
-        classpath "com.github.dcendents:android-maven-gradle-plugin:${ANDROID_MAVEN_GRADLE_PLUGIN_VERSION}"
-        classpath "org.jfrog.buildinfo:build-info-extractor-gradle:4.9.8"
-    }
-}
-
 allprojects {
+    buildscript {
+        ext {
+            minSdkVersion = 21
+            targetSdkVersion = 28
+            compileSdkVersion = 28
+            buildToolsVersion = '28.0.3'
+
+            coreVersion = "1.2.0"
+            extJUnitVersion = "1.1.1"
+            runnerVersion = "1.2.0"
+            rulesVersion = "1.2.0"
+            junitVersion = "4.12"
+        }
+
+        repositories {
+            google()
+            mavenLocal()
+            mavenCentral()
+            jcenter()
+        }
+
+        dependencies {
+            classpath 'com.android.tools.build:gradle:3.3.2'
+            classpath "com.jfrog.bintray.gradle:gradle-bintray-plugin:${GRADLE_BINTRAY_PLUGIN_VERSION}"
+            classpath "com.github.dcendents:android-maven-gradle-plugin:${ANDROID_MAVEN_GRADLE_PLUGIN_VERSION}"
+            classpath "org.jfrog.buildinfo:build-info-extractor-gradle:4.9.8"
+        }
+    }
+
     repositories {
         google()
         jcenter()

android/build_test_app.sh

@@ -0,0 +1,100 @@
+#!/bin/bash
+set -eux
+
+PYTORCH_DIR="$(cd $(dirname $0)/..; pwd -P)"
+
+PYTORCH_ANDROID_DIR=$PYTORCH_DIR/android
+WORK_DIR=$PYTORCH_DIR
+
+echo "PYTORCH_DIR:$PYTORCH_DIR"
+echo "WORK_DIR:$WORK_DIR"
+
+echo "ANDROID_HOME:$ANDROID_HOME"
+if [ ! -z "$ANDROID_HOME" ]; then
+  echo "ANDROID_HOME not set; please set it to Android sdk directory"
+fi
+
+if [ ! -d $ANDROID_HOME ]; then
+  echo "ANDROID_HOME not a directory; did you install it under $ANDROID_HOME?"
+  exit 1
+fi
+
+GRADLE_PATH=gradle
+GRADLE_NOT_FOUND_MSG="Unable to find gradle, please add it to PATH or set GRADLE_HOME"
+
+if [ ! -x "$(command -v gradle)" ]; then
+  if [ -z "$GRADLE_HOME" ]; then
+    echo GRADLE_NOT_FOUND_MSG
+    exit 1
+  fi
+  GRADLE_PATH=$GRADLE_HOME/bin/gradle
+  if [ ! -f "$GRADLE_PATH" ]; then
+    echo GRADLE_NOT_FOUND_MSG
+    exit 1
+  fi
+fi
+echo "GRADLE_PATH:$GRADLE_PATH"
+
+ABIS_LIST="armeabi-v7a,arm64-v8a,x86,x86_64"
+CUSTOM_ABIS_LIST=false
+if [ $# -gt 0 ]; then
+  ABIS_LIST=$1
+  CUSTOM_ABIS_LIST=true
+fi
+
+echo "ABIS_LIST:$ABIS_LIST"
+
+LIB_DIR=$PYTORCH_ANDROID_DIR/pytorch_android/src/main/jniLibs
+INCLUDE_DIR=$PYTORCH_ANDROID_DIR/pytorch_android/src/main/cpp/libtorch_include
+mkdir -p $LIB_DIR
+rm -f $LIB_DIR/*
+mkdir -p $INCLUDE_DIR
+
+for abi in $(echo $ABIS_LIST | tr ',' '\n')
+do
+echo "abi:$abi"
+
+OUT_DIR=$WORK_DIR/build_android_$abi
+
+rm -rf $OUT_DIR
+mkdir -p $OUT_DIR
+
+pushd $PYTORCH_DIR
+python $PYTORCH_DIR/setup.py clean
+
+ANDROID_ABI=$abi BUILD_PYTORCH_MOBILE=1 VERBOSE=1 ANDROID_DEBUG_SYMBOLS=1 $PYTORCH_DIR/scripts/build_android.sh -DANDROID_CCACHE=$(which ccache)
+
+cp -R $PYTORCH_DIR/build_android/install/lib $OUT_DIR/
+cp -R $PYTORCH_DIR/build_android/install/include $OUT_DIR/
+
+echo "$abi build output lib,include copied to $OUT_DIR"
+
+LIB_LINK_PATH=$LIB_DIR/$abi
+INCLUDE_LINK_PATH=$INCLUDE_DIR/$abi
+
+rm -f $LIB_LINK_PATH
+rm -f $INCLUDE_LINK_PATH
+
+ln -s $OUT_DIR/lib $LIB_LINK_PATH
+ln -s $OUT_DIR/include $INCLUDE_LINK_PATH
+
+done
+
+# To set proxy for gradle add following lines to ./gradle/gradle.properties:
+# systemProp.http.proxyHost=...
+# systemProp.http.proxyPort=8080
+# systemProp.https.proxyHost=...
+# systemProp.https.proxyPort=8080
+
+if [ "$CUSTOM_ABIS_LIST" = true ]; then
+  NDK_DEBUG=1 $GRADLE_PATH -PnativeLibsDoNotStrip=true -PABI_FILTERS=$ABIS_LIST -p $PYTORCH_ANDROID_DIR clean test_app:assembleDebug
+else
+  NDK_DEBUG=1 $GRADLE_PATH -PnativeLibsDoNotStrip=true -p $PYTORCH_ANDROID_DIR clean test_app:assembleDebug
+fi
+
+find $PYTORCH_ANDROID_DIR -type f -name *apk
+
+find $PYTORCH_ANDROID_DIR -type f -name *apk | xargs echo "To install apk run: $ANDROID_HOME/platform-tools/adb install -r "
+
+popd
+

android/gradle.properties

@@ -1,6 +1,6 @@
 ABI_FILTERS=armeabi-v7a,arm64-v8a,x86,x86_64
 
-VERSION_NAME=0.0.7-SNAPSHOT
+VERSION_NAME=1.4.0-SNAPSHOT
 GROUP=org.pytorch
 MAVEN_GROUP=org.pytorch
 POM_URL=https://github.com/pytorch/pytorch/tree/master/android
@@ -22,3 +22,8 @@ ANDROID_MAVEN_GRADLE_PLUGIN_VERSION=2.1
 # Gradle internals
 org.gradle.internal.repository.max.retries=1
 org.gradle.jvmargs=-XX:MaxMetaspaceSize=1024m
+
+android.useAndroidX=true
+android.enableJetifier=true
+
+nativeLibsDoNotStrip=false

android/gradle/gradle_maven_push.gradle

@@ -25,6 +25,18 @@ def getRepositoryPassword() {
   return hasProperty('SONATYPE_NEXUS_PASSWORD') ? SONATYPE_NEXUS_PASSWORD : ""
 }
 
+def getHttpProxyHost() {
+  return project.properties['systemProp.http.proxyHost']
+}
+
+def getHttpProxyPort() {
+  return project.properties['systemProp.http.proxyPort']
+}
+
+def needProxy() {
+  return (getHttpProxyHost() != null) && (getHttpProxyPort() != null)
+}
+
 afterEvaluate { project ->
   uploadArchives {
     repositories {
@@ -37,9 +49,15 @@ afterEvaluate { project ->
 
         repository(url: getReleaseRepositoryUrl()) {
           authentication(userName: getRepositoryUsername(), password: getRepositoryPassword())
+          if (needProxy()) {
+            proxy(host: getHttpProxyHost(), port: getHttpProxyPort() as Integer, type: 'http')
+          }
         }
         snapshotRepository(url: getSnapshotRepositoryUrl()) {
           authentication(userName: getRepositoryUsername(), password: getRepositoryPassword())
+          if (needProxy()) {
+            proxy(host: getHttpProxyHost(), port: getHttpProxyPort() as Integer, type: 'http')
+          }
         }
 
         pom.project {

android/libs/fbjni_local/build.gradle

@@ -11,12 +11,15 @@ android {
 
         sourceSets {
             main {
-                manifest.srcFile '../fbjni/ApplicationManifest.xml'
+                manifest.srcFile '../fbjni/java/com/facebook/jni/AndroidManifest.xml'
                 java {
                     srcDir '../fbjni/java'
                 }
             }
         }
+        ndk {
+            abiFilters ABI_FILTERS.split(",")
+        }
     }
     buildTypes {
         debug {
@@ -35,6 +38,7 @@ android {
 
 dependencies {
     compileOnly 'com.google.code.findbugs:jsr305:3.0.1'
+    implementation 'com.facebook.soloader:nativeloader:0.8.0'
 }
 
 apply from: rootProject.file('gradle/release.gradle')

android/pytorch_android/CMakeLists.txt

@@ -1,63 +1,110 @@
 cmake_minimum_required(VERSION 3.4.1)
-project(pytorch CXX)
+project(pytorch_jni CXX)
 set(CMAKE_CXX_STANDARD 11)
 set(CMAKE_VERBOSE_MAKEFILE ON)
 
+set(TRACE_ENABLED OFF)
+if(DEFINED ENV{TRACE_ENABLED})
+  if($ENV{TRACE_ENABLED} STREQUAL "1")
+    message(STATUS "TRACE_ENABLED ON")
+    set(TRACE_ENABLED ON)
+  endif()
+endif()
+if(NOT TRACE_ENABLED)
+  message(STATUS "TRACE_ENABLED OFF")
+endif()
+
 set(pytorch_android_DIR ${CMAKE_CURRENT_LIST_DIR}/src/main/cpp)
-set(libtorch_include_DIR ${pytorch_android_DIR}/libtorch_include/${ANDROID_ABI})
+
+if (ANDROID_ABI)
+  set(libtorch_include_DIR ${pytorch_android_DIR}/libtorch_include/${ANDROID_ABI})
+  set(BUILD_SUBDIR ${ANDROID_ABI})
+elseif(BUILD_LIBTORCH_WITH_JNI)
+  # Don't need LIBTORCH_HOME if we're building from within PyTorch.
+else()
+  # Building against a pre-built libtorch.
+  if (NOT LIBTORCH_HOME)
+    message(FATAL_ERROR
+      "pytorch_android requires LIBTORCH_HOME to be defined for non-Android builds.")
+  endif()
+  set(libtorch_include_DIR ${LIBTORCH_HOME}/include)
+  link_directories(${LIBTORCH_HOME}/lib)
+  set(BUILD_SUBDIR host)
+endif()
 
 message(STATUS "libtorch dir:${libtorch_DIR}")
 
+configure_file(
+    ${pytorch_android_DIR}/cmake_macros.h.in
+    ${pytorch_android_DIR}/cmake_macros.h)
+
 file(GLOB pytorch_android_SOURCES
-  ${pytorch_android_DIR}/*.cpp
+  ${pytorch_android_DIR}/pytorch_jni_jit.cpp
+  ${pytorch_android_DIR}/pytorch_jni_common.cpp
+  ${pytorch_android_DIR}/pytorch_jni_common.h
 )
 
-add_library(pytorch SHARED
+add_library(pytorch_jni SHARED
     ${pytorch_android_SOURCES}
 )
 
-target_compile_options(pytorch PRIVATE
+target_compile_options(pytorch_jni PRIVATE
   -fexceptions
 )
 
-target_include_directories(pytorch PUBLIC
+target_include_directories(pytorch_jni PUBLIC
     ${libtorch_include_DIR}
 )
 
-set(BUILD_DIR ${CMAKE_SOURCE_DIR}/build)
-file(MAKE_DIRECTORY ${BUILD_DIR})
-
 set(fbjni_DIR ${CMAKE_CURRENT_LIST_DIR}/../libs/fbjni/)
-set(fbjni_BUILD_DIR ${BUILD_DIR}/fbjni/${ANDROID_ABI})
+set(fbjni_BUILD_DIR ${CMAKE_BINARY_DIR}/fbjni/${BUILD_SUBDIR})
 
 add_subdirectory(${fbjni_DIR} ${fbjni_BUILD_DIR})
 
-function(import_static_lib name)
-  add_library(${name} STATIC IMPORTED)
-  set_property(
-      TARGET ${name}
-      PROPERTY IMPORTED_LOCATION
-      ${CMAKE_CURRENT_LIST_DIR}/src/main/jniLibs/${ANDROID_ABI}/${name}.a)
-endfunction(import_static_lib)
+if (ANDROID_ABI)
 
-import_static_lib(libtorch)
-import_static_lib(libc10)
-import_static_lib(libnnpack)
-import_static_lib(libpytorch_qnnpack)
-import_static_lib(libeigen_blas)
-import_static_lib(libcpuinfo)
-import_static_lib(libclog)
+  function(import_static_lib name)
+    add_library(${name} STATIC IMPORTED)
+    set_property(
+        TARGET ${name}
+        PROPERTY IMPORTED_LOCATION
+        ${CMAKE_CURRENT_LIST_DIR}/src/main/jniLibs/${ANDROID_ABI}/${name}.a)
+  endfunction(import_static_lib)
 
-target_link_libraries(pytorch
-    fbjni
-    -Wl,--gc-sections
-    -Wl,--whole-archive
-    libtorch
-    -Wl,--no-whole-archive
-    libc10
-    libnnpack
-    libpytorch_qnnpack
-    libeigen_blas
-    libcpuinfo
-    libclog
-)
+  import_static_lib(libtorch)
+  import_static_lib(libc10)
+  import_static_lib(libnnpack)
+  import_static_lib(libpytorch_qnnpack)
+  import_static_lib(libeigen_blas)
+  import_static_lib(libcpuinfo)
+  import_static_lib(libclog)
+
+    # Link most things statically on Android.
+  target_link_libraries(pytorch_jni
+      fbjni
+      -Wl,--gc-sections
+      -Wl,--whole-archive
+      libtorch
+      -Wl,--no-whole-archive
+      libc10
+      libnnpack
+      libpytorch_qnnpack
+      libeigen_blas
+      libcpuinfo
+      libclog
+  )
+
+else()
+
+  # Prefer dynamic linking on the host
+  target_link_libraries(pytorch_jni
+      fbjni
+      torch
+      c10
+      nnpack
+      pytorch_qnnpack
+      cpuinfo
+      clog
+  )
+
+endif()

android/pytorch_android/build.gradle

@@ -27,6 +27,10 @@ android {
     }
     sourceSets {
         main {
+            java {
+                exclude 'org/pytorch/LiteModuleLoader.java'
+                exclude 'org/pytorch/LiteNativePeer.java'
+            }
             jniLibs.srcDirs = ['src/main/jniLibs']
         }
     }
@@ -42,6 +46,10 @@ android {
         } else {
             pickFirst '**/libfbjni.so'
         }
+        if (nativeLibsDoNotStrip.toBoolean()) {
+            doNotStrip "**/*.so"
+            logger.warn('WARNING: nativeLibsDoNotStrip==true; debug symbols included')
+        }
     }
 
     useLibrary 'android.test.runner'
@@ -53,6 +61,7 @@ dependencies {
     api project(':fbjni')
 
     implementation 'com.android.support:appcompat-v7:28.0.0'
+    implementation 'com.facebook.soloader:nativeloader:0.8.0'
 
     testImplementation 'junit:junit:' + rootProject.junitVersion
     testImplementation 'androidx.test:core:' + rootProject.coreVersion
@@ -72,4 +81,3 @@ task sourcesJar(type: Jar) {
 }
 
 artifacts.add('archives', sourcesJar)
-

android/pytorch_android/host/build.gradle

@@ -0,0 +1,36 @@
+// Copyright (c) Facebook, Inc. and its affiliates.
+//
+// This source code is licensed under the Apache-2 license found in the
+// LICENSE file in the root directory of this source tree.
+
+plugins {
+    id 'java-library'
+}
+
+repositories {
+    mavenLocal()
+    jcenter()
+}
+
+sourceSets {
+    main {
+        java.srcDir '../src/main/java'
+    }
+    test {
+        java {
+            srcDir '../src/androidTest/java'
+            exclude '**/PytorchInstrumented*'
+        }
+        resources.srcDirs = ["../src/androidTest/assets"]
+    }
+}
+
+dependencies {
+    compileOnly 'com.google.code.findbugs:jsr305:3.0.1'
+    implementation 'com.facebook.soloader:nativeloader:0.8.0'
+    implementation 'com.facebook.fbjni:fbjni-java-only:0.0.3'
+    testImplementation 'junit:junit:4.12'
+}
+
+apply from: rootProject.file('gradle/release.gradle')
+

android/pytorch_android/host/gradle.properties

@@ -0,0 +1,4 @@
+POM_NAME=pytorch_java_only pytorch java api
+POM_DESCRIPTION=pytorch_java_only pytorch java api
+POM_ARTIFACT_ID=pytorch_java_only
+POM_PACKAGING=jar

android/pytorch_android/src/androidTest/java/org/pytorch/PytorchHostTests.java

@@ -0,0 +1,22 @@
+package org.pytorch;
+
+import org.junit.BeforeClass;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.util.Objects;
+
+public class PytorchHostTests extends PytorchTestBase {
+
+  @Override
+  protected String assetFilePath(String assetName) throws IOException {
+    Path tempFile = Files.createTempFile("test", ".pt");
+    try (InputStream resource = Objects.requireNonNull(getClass().getClassLoader().getResourceAsStream("test.pt"))) {
+      Files.copy(resource, tempFile, StandardCopyOption.REPLACE_EXISTING);
+    }
+    return tempFile.toAbsolutePath().toString();
+  }
+}

android/pytorch_android/src/androidTest/java/org/pytorch/PytorchInstrumentedTests.java

@@ -2,8 +2,6 @@ package org.pytorch;
 
 import android.content.Context;
 
-import org.junit.Before;
-import org.junit.Test;
 import org.junit.runner.RunWith;
 
 import java.io.File;
@@ -11,294 +9,15 @@ import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
-import java.util.HashMap;
-import java.util.Map;
 
 import androidx.test.ext.junit.runners.AndroidJUnit4;
 import androidx.test.platform.app.InstrumentationRegistry;
 
-import static org.junit.Assert.assertArrayEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-
 @RunWith(AndroidJUnit4.class)
-public class PytorchInstrumentedTests {
+public class PytorchInstrumentedTests extends PytorchTestBase {
 
-  private static final String TEST_MODULE_ASSET_NAME = "test.pt";
-
-  @Before
-  public void setUp() {
-    System.loadLibrary("pytorch");
-  }
-
-  @Test
-  public void testForwardNull() throws IOException {
-    final Module module = Module.load(assetFilePath(TEST_MODULE_ASSET_NAME));
-    final IValue input =
-        IValue.tensor(Tensor.newInt8Tensor(new long[] {1}, Tensor.allocateByteBuffer(1)));
-    assertTrue(input.isTensor());
-    final IValue output = module.forward(input);
-    assertTrue(output.isNull());
-  }
-
-  @Test
-  public void testEqBool() throws IOException {
-    final Module module = Module.load(assetFilePath(TEST_MODULE_ASSET_NAME));
-    for (boolean value : new boolean[] {false, true}) {
-      final IValue input = IValue.bool(value);
-      assertTrue(input.isBool());
-      assertTrue(value == input.getBool());
-      final IValue output = module.runMethod("eqBool", input);
-      assertTrue(output.isBool());
-      assertTrue(value == output.getBool());
-    }
-  }
-
-  @Test
-  public void testEqInt() throws IOException {
-    final Module module = Module.load(assetFilePath(TEST_MODULE_ASSET_NAME));
-    for (long value : new long[] {Long.MIN_VALUE, -1024, -1, 0, 1, 1024, Long.MAX_VALUE}) {
-      final IValue input = IValue.long64(value);
-      assertTrue(input.isLong());
-      assertTrue(value == input.getLong());
-      final IValue output = module.runMethod("eqInt", input);
-      assertTrue(output.isLong());
-      assertTrue(value == output.getLong());
-    }
-  }
-
-  @Test
-  public void testEqFloat() throws IOException {
-    final Module module = Module.load(assetFilePath(TEST_MODULE_ASSET_NAME));
-    double[] values =
-        new double[] {
-          -Double.MAX_VALUE,
-          Double.MAX_VALUE,
-          -Double.MIN_VALUE,
-          Double.MIN_VALUE,
-          -Math.exp(1.d),
-          -Math.sqrt(2.d),
-          -3.1415f,
-          3.1415f,
-          -1,
-          0,
-          1,
-        };
-    for (double value : values) {
-      final IValue input = IValue.double64(value);
-      assertTrue(input.isDouble());
-      assertTrue(value == input.getDouble());
-      final IValue output = module.runMethod("eqFloat", input);
-      assertTrue(output.isDouble());
-      assertTrue(value == output.getDouble());
-    }
-  }
-
-  @Test
-  public void testEqTensor() throws IOException {
-    final long[] inputTensorShape = new long[] {1, 3, 224, 224};
-    final long numElements = Tensor.numel(inputTensorShape);
-    final float[] inputTensorData = new float[(int) numElements];
-    for (int i = 0; i < numElements; ++i) {
-      inputTensorData[i] = i;
-    }
-    final Tensor inputTensor = Tensor.newFloat32Tensor(inputTensorShape, inputTensorData);
-
-    final Module module = Module.load(assetFilePath(TEST_MODULE_ASSET_NAME));
-    final IValue input = IValue.tensor(inputTensor);
-    assertTrue(input.isTensor());
-    assertTrue(inputTensor == input.getTensor());
-    final IValue output = module.runMethod("eqTensor", input);
-    assertTrue(output.isTensor());
-    final Tensor outputTensor = output.getTensor();
-    assertNotNull(outputTensor);
-    assertArrayEquals(inputTensorShape, outputTensor.shape);
-    float[] outputData = outputTensor.getDataAsFloatArray();
-    for (int i = 0; i < numElements; i++) {
-      assertTrue(inputTensorData[i] == outputData[i]);
-    }
-  }
-
-  @Test
-  public void testEqDictIntKeyIntValue() throws IOException {
-    final Module module = Module.load(assetFilePath(TEST_MODULE_ASSET_NAME));
-    final Map<Long, IValue> inputMap = new HashMap<>();
-
-    inputMap.put(Long.MIN_VALUE, IValue.long64(-Long.MIN_VALUE));
-    inputMap.put(Long.MAX_VALUE, IValue.long64(-Long.MAX_VALUE));
-    inputMap.put(0l, IValue.long64(0l));
-    inputMap.put(1l, IValue.long64(-1l));
-    inputMap.put(-1l, IValue.long64(1l));
-
-    final IValue input = IValue.dictLongKey(inputMap);
-    assertTrue(input.isDictLongKey());
-
-    final IValue output = module.runMethod("eqDictIntKeyIntValue", input);
-    assertTrue(output.isDictLongKey());
-
-    final Map<Long, IValue> outputMap = output.getDictLongKey();
-    assertTrue(inputMap.size() == outputMap.size());
-    for (Map.Entry<Long, IValue> entry : inputMap.entrySet()) {
-      assertTrue(outputMap.get(entry.getKey()).getLong() == entry.getValue().getLong());
-    }
-  }
-
-  @Test
-  public void testEqDictStrKeyIntValue() throws IOException {
-    final Module module = Module.load(assetFilePath(TEST_MODULE_ASSET_NAME));
-    final Map<String, IValue> inputMap = new HashMap<>();
-
-    inputMap.put("long_min_value", IValue.long64(Long.MIN_VALUE));
-    inputMap.put("long_max_value", IValue.long64(Long.MAX_VALUE));
-    inputMap.put("long_0", IValue.long64(0l));
-    inputMap.put("long_1", IValue.long64(1l));
-    inputMap.put("long_-1", IValue.long64(-1l));
-
-    final IValue input = IValue.dictStringKey(inputMap);
-    assertTrue(input.isDictStringKey());
-
-    final IValue output = module.runMethod("eqDictStrKeyIntValue", input);
-    assertTrue(output.isDictStringKey());
-
-    final Map<String, IValue> outputMap = output.getDictStringKey();
-    assertTrue(inputMap.size() == outputMap.size());
-    for (Map.Entry<String, IValue> entry : inputMap.entrySet()) {
-      assertTrue(outputMap.get(entry.getKey()).getLong() == entry.getValue().getLong());
-    }
-  }
-
-  @Test
-  public void testListIntSumReturnTuple() throws IOException {
-    final Module module = Module.load(assetFilePath(TEST_MODULE_ASSET_NAME));
-
-    for (int n : new int[] {0, 1, 128}) {
-      long[] a = new long[n];
-      long sum = 0;
-      for (int i = 0; i < n; i++) {
-        a[i] = i;
-        sum += a[i];
-      }
-      final IValue input = IValue.longList(a);
-      assertTrue(input.isLongList());
-
-      final IValue output = module.runMethod("listIntSumReturnTuple", input);
-
-      assertTrue(output.isTuple());
-      assertTrue(2 == output.getTuple().length);
-
-      IValue output0 = output.getTuple()[0];
-      IValue output1 = output.getTuple()[1];
-
-      assertArrayEquals(a, output0.getLongList());
-      assertTrue(sum == output1.getLong());
-    }
-  }
-
-  @Test
-  public void testOptionalIntIsNone() throws IOException {
-    final Module module = Module.load(assetFilePath(TEST_MODULE_ASSET_NAME));
-
-    assertFalse(module.runMethod("optionalIntIsNone", IValue.long64(1l)).getBool());
-    assertTrue(module.runMethod("optionalIntIsNone", IValue.optionalNull()).getBool());
-  }
-
-  @Test
-  public void testIntEq0None() throws IOException {
-    final Module module = Module.load(assetFilePath(TEST_MODULE_ASSET_NAME));
-
-    assertTrue(module.runMethod("intEq0None", IValue.long64(0l)).isNull());
-    assertTrue(module.runMethod("intEq0None", IValue.long64(1l)).getLong() == 1l);
-  }
-
-  @Test(expected = IllegalArgumentException.class)
-  public void testRunUndefinedMethod() throws IOException {
-    final Module module = Module.load(assetFilePath(TEST_MODULE_ASSET_NAME));
-    module.runMethod("test_undefined_method_throws_exception");
-  }
-
-  @Test
-  public void testTensorMethods() {
-    long[] shape = new long[] {1, 3, 224, 224};
-    final int numel = (int) Tensor.numel(shape);
-    int[] ints = new int[numel];
-    float[] floats = new float[numel];
-
-    byte[] bytes = new byte[numel];
-    for (int i = 0; i < numel; i++) {
-      bytes[i] = (byte) ((i % 255) - 128);
-      ints[i] = i;
-      floats[i] = i / 1000.f;
-    }
-
-    Tensor tensorBytes = Tensor.newInt8Tensor(shape, bytes);
-    assertTrue(tensorBytes.dtype() == Tensor.DTYPE_INT8);
-    assertArrayEquals(bytes, tensorBytes.getDataAsByteArray());
-
-    Tensor tensorInts = Tensor.newInt32Tensor(shape, ints);
-    assertTrue(tensorInts.dtype() == Tensor.DTYPE_INT32);
-    assertArrayEquals(ints, tensorInts.getDataAsIntArray());
-
-    Tensor tensorFloats = Tensor.newFloat32Tensor(shape, floats);
-    assertTrue(tensorFloats.dtype() == Tensor.DTYPE_FLOAT32);
-    float[] floatsOut = tensorFloats.getDataAsFloatArray();
-    assertTrue(floatsOut.length == numel);
-    for (int i = 0; i < numel; i++) {
-      assertTrue(floats[i] == floatsOut[i]);
-    }
-  }
-
-  @Test(expected = IllegalStateException.class)
-  public void testTensorIllegalStateOnWrongType() {
-    long[] shape = new long[] {1, 3, 224, 224};
-    final int numel = (int) Tensor.numel(shape);
-    float[] floats = new float[numel];
-    Tensor tensorFloats = Tensor.newFloat32Tensor(shape, floats);
-    assertTrue(tensorFloats.dtype() == Tensor.DTYPE_FLOAT32);
-    tensorFloats.getDataAsByteArray();
-  }
-
-
-  @Test
-  public void testEqString() throws IOException {
-    final Module module = Module.load(assetFilePath(TEST_MODULE_ASSET_NAME));
-    String[] values =
-        new String[] {
-            "smoketest",
-            "проверка не латинских символов", // not latin symbols check
-            "#@$!@#)($*!@#$)(!@*#$"
-        };
-    for (String value : values) {
-      final IValue input = IValue.string(value);
-      assertTrue(input.isString());
-      assertTrue(value.equals(input.getString()));
-      final IValue output = module.runMethod("eqStr", input);
-      assertTrue(output.isString());
-      assertTrue(value.equals(output.getString()));
-    }
-  }
-
-  @Test
-  public void testStr3Concat() throws IOException {
-    final Module module = Module.load(assetFilePath(TEST_MODULE_ASSET_NAME));
-    String[] values =
-        new String[] {
-            "smoketest",
-            "проверка не латинских символов", // not latin symbols check
-            "#@$!@#)($*!@#$)(!@*#$"
-        };
-    for (String value : values) {
-      final IValue input = IValue.string(value);
-      assertTrue(input.isString());
-      assertTrue(value.equals(input.getString()));
-      final IValue output = module.runMethod("str3Concat", input);
-      assertTrue(output.isString());
-      String expectedOutput = new StringBuilder().append(value).append(value).append(value).toString();
-      assertTrue(expectedOutput.equals(output.getString()));
-    }
-  }
-
-  private static String assetFilePath(String assetName) throws IOException {
+  @Override
+  protected String assetFilePath(String assetName) throws IOException {
     final Context appContext = InstrumentationRegistry.getInstrumentation().getTargetContext();
     File file = new File(appContext.getFilesDir(), assetName);
     if (file.exists() && file.length() > 0) {

android/pytorch_android/src/androidTest/java/org/pytorch/PytorchTestBase.java

@@ -0,0 +1,285 @@
+package org.pytorch;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+public abstract class PytorchTestBase {
+  private static final String TEST_MODULE_ASSET_NAME = "test.pt";
+
+  @Test
+  public void testForwardNull() throws IOException {
+    final Module module = Module.load(assetFilePath(TEST_MODULE_ASSET_NAME));
+    final IValue input =
+        IValue.from(Tensor.fromBlob(Tensor.allocateByteBuffer(1), new long[] {1}));
+    assertTrue(input.isTensor());
+    final IValue output = module.forward(input);
+    assertTrue(output.isNull());
+  }
+
+  @Test
+  public void testEqBool() throws IOException {
+    final Module module = Module.load(assetFilePath(TEST_MODULE_ASSET_NAME));
+    for (boolean value : new boolean[] {false, true}) {
+      final IValue input = IValue.from(value);
+      assertTrue(input.isBool());
+      assertTrue(value == input.toBool());
+      final IValue output = module.runMethod("eqBool", input);
+      assertTrue(output.isBool());
+      assertTrue(value == output.toBool());
+    }
+  }
+
+  @Test
+  public void testEqInt() throws IOException {
+    final Module module = Module.load(assetFilePath(TEST_MODULE_ASSET_NAME));
+    for (long value : new long[] {Long.MIN_VALUE, -1024, -1, 0, 1, 1024, Long.MAX_VALUE}) {
+      final IValue input = IValue.from(value);
+      assertTrue(input.isLong());
+      assertTrue(value == input.toLong());
+      final IValue output = module.runMethod("eqInt", input);
+      assertTrue(output.isLong());
+      assertTrue(value == output.toLong());
+    }
+  }
+
+  @Test
+  public void testEqFloat() throws IOException {
+    final Module module = Module.load(assetFilePath(TEST_MODULE_ASSET_NAME));
+    double[] values =
+        new double[] {
+            -Double.MAX_VALUE,
+            Double.MAX_VALUE,
+            -Double.MIN_VALUE,
+            Double.MIN_VALUE,
+            -Math.exp(1.d),
+            -Math.sqrt(2.d),
+            -3.1415f,
+            3.1415f,
+            -1,
+            0,
+            1,
+        };
+    for (double value : values) {
+      final IValue input = IValue.from(value);
+      assertTrue(input.isDouble());
+      assertTrue(value == input.toDouble());
+      final IValue output = module.runMethod("eqFloat", input);
+      assertTrue(output.isDouble());
+      assertTrue(value == output.toDouble());
+    }
+  }
+
+  @Test
+  public void testEqTensor() throws IOException {
+    final long[] inputTensorShape = new long[] {1, 3, 224, 224};
+    final long numElements = Tensor.numel(inputTensorShape);
+    final float[] inputTensorData = new float[(int) numElements];
+    for (int i = 0; i < numElements; ++i) {
+      inputTensorData[i] = i;
+    }
+    final Tensor inputTensor = Tensor.fromBlob(inputTensorData, inputTensorShape);
+
+    final Module module = Module.load(assetFilePath(TEST_MODULE_ASSET_NAME));
+    final IValue input = IValue.from(inputTensor);
+    assertTrue(input.isTensor());
+    assertTrue(inputTensor == input.toTensor());
+    final IValue output = module.runMethod("eqTensor", input);
+    assertTrue(output.isTensor());
+    final Tensor outputTensor = output.toTensor();
+    assertNotNull(outputTensor);
+    assertArrayEquals(inputTensorShape, outputTensor.shape());
+    float[] outputData = outputTensor.getDataAsFloatArray();
+    for (int i = 0; i < numElements; i++) {
+      assertTrue(inputTensorData[i] == outputData[i]);
+    }
+  }
+
+  @Test
+  public void testEqDictIntKeyIntValue() throws IOException {
+    final Module module = Module.load(assetFilePath(TEST_MODULE_ASSET_NAME));
+    final Map<Long, IValue> inputMap = new HashMap<>();
+
+    inputMap.put(Long.MIN_VALUE, IValue.from(-Long.MIN_VALUE));
+    inputMap.put(Long.MAX_VALUE, IValue.from(-Long.MAX_VALUE));
+    inputMap.put(0l, IValue.from(0l));
+    inputMap.put(1l, IValue.from(-1l));
+    inputMap.put(-1l, IValue.from(1l));
+
+    final IValue input = IValue.dictLongKeyFrom(inputMap);
+    assertTrue(input.isDictLongKey());
+
+    final IValue output = module.runMethod("eqDictIntKeyIntValue", input);
+    assertTrue(output.isDictLongKey());
+
+    final Map<Long, IValue> outputMap = output.toDictLongKey();
+    assertTrue(inputMap.size() == outputMap.size());
+    for (Map.Entry<Long, IValue> entry : inputMap.entrySet()) {
+      assertTrue(outputMap.get(entry.getKey()).toLong() == entry.getValue().toLong());
+    }
+  }
+
+  @Test
+  public void testEqDictStrKeyIntValue() throws IOException {
+    final Module module = Module.load(assetFilePath(TEST_MODULE_ASSET_NAME));
+    final Map<String, IValue> inputMap = new HashMap<>();
+
+    inputMap.put("long_min_value", IValue.from(Long.MIN_VALUE));
+    inputMap.put("long_max_value", IValue.from(Long.MAX_VALUE));
+    inputMap.put("long_0", IValue.from(0l));
+    inputMap.put("long_1", IValue.from(1l));
+    inputMap.put("long_-1", IValue.from(-1l));
+
+    final IValue input = IValue.dictStringKeyFrom(inputMap);
+    assertTrue(input.isDictStringKey());
+
+    final IValue output = module.runMethod("eqDictStrKeyIntValue", input);
+    assertTrue(output.isDictStringKey());
+
+    final Map<String, IValue> outputMap = output.toDictStringKey();
+    assertTrue(inputMap.size() == outputMap.size());
+    for (Map.Entry<String, IValue> entry : inputMap.entrySet()) {
+      assertTrue(outputMap.get(entry.getKey()).toLong() == entry.getValue().toLong());
+    }
+  }
+
+  @Test
+  public void testListIntSumReturnTuple() throws IOException {
+    final Module module = Module.load(assetFilePath(TEST_MODULE_ASSET_NAME));
+
+    for (int n : new int[] {0, 1, 128}) {
+      long[] a = new long[n];
+      long sum = 0;
+      for (int i = 0; i < n; i++) {
+        a[i] = i;
+        sum += a[i];
+      }
+      final IValue input = IValue.listFrom(a);
+      assertTrue(input.isLongList());
+
+      final IValue output = module.runMethod("listIntSumReturnTuple", input);
+
+      assertTrue(output.isTuple());
+      assertTrue(2 == output.toTuple().length);
+
+      IValue output0 = output.toTuple()[0];
+      IValue output1 = output.toTuple()[1];
+
+      assertArrayEquals(a, output0.toLongList());
+      assertTrue(sum == output1.toLong());
+    }
+  }
+
+  @Test
+  public void testOptionalIntIsNone() throws IOException {
+    final Module module = Module.load(assetFilePath(TEST_MODULE_ASSET_NAME));
+
+    assertFalse(module.runMethod("optionalIntIsNone", IValue.from(1l)).toBool());
+    assertTrue(module.runMethod("optionalIntIsNone", IValue.optionalNull()).toBool());
+  }
+
+  @Test
+  public void testIntEq0None() throws IOException {
+    final Module module = Module.load(assetFilePath(TEST_MODULE_ASSET_NAME));
+
+    assertTrue(module.runMethod("intEq0None", IValue.from(0l)).isNull());
+    assertTrue(module.runMethod("intEq0None", IValue.from(1l)).toLong() == 1l);
+  }
+
+  @Test(expected = IllegalArgumentException.class)
+  public void testRunUndefinedMethod() throws IOException {
+    final Module module = Module.load(assetFilePath(TEST_MODULE_ASSET_NAME));
+    module.runMethod("test_undefined_method_throws_exception");
+  }
+
+  @Test
+  public void testTensorMethods() {
+    long[] shape = new long[] {1, 3, 224, 224};
+    final int numel = (int) Tensor.numel(shape);
+    int[] ints = new int[numel];
+    float[] floats = new float[numel];
+
+    byte[] bytes = new byte[numel];
+    for (int i = 0; i < numel; i++) {
+      bytes[i] = (byte) ((i % 255) - 128);
+      ints[i] = i;
+      floats[i] = i / 1000.f;
+    }
+
+    Tensor tensorBytes = Tensor.fromBlob(bytes, shape);
+    assertTrue(tensorBytes.dtype() == DType.INT8);
+    assertArrayEquals(bytes, tensorBytes.getDataAsByteArray());
+
+    Tensor tensorInts = Tensor.fromBlob(ints, shape);
+    assertTrue(tensorInts.dtype() == DType.INT32);
+    assertArrayEquals(ints, tensorInts.getDataAsIntArray());
+
+    Tensor tensorFloats = Tensor.fromBlob(floats, shape);
+    assertTrue(tensorFloats.dtype() == DType.FLOAT32);
+    float[] floatsOut = tensorFloats.getDataAsFloatArray();
+    assertTrue(floatsOut.length == numel);
+    for (int i = 0; i < numel; i++) {
+      assertTrue(floats[i] == floatsOut[i]);
+    }
+  }
+
+  @Test(expected = IllegalStateException.class)
+  public void testTensorIllegalStateOnWrongType() {
+    long[] shape = new long[] {1, 3, 224, 224};
+    final int numel = (int) Tensor.numel(shape);
+    float[] floats = new float[numel];
+    Tensor tensorFloats = Tensor.fromBlob(floats, shape);
+    assertTrue(tensorFloats.dtype() == DType.FLOAT32);
+    tensorFloats.getDataAsByteArray();
+  }
+
+
+  @Test
+  public void testEqString() throws IOException {
+    final Module module = Module.load(assetFilePath(TEST_MODULE_ASSET_NAME));
+    String[] values =
+        new String[] {
+            "smoketest",
+            "проверка не латинских символов", // not latin symbols check
+            "#@$!@#)($*!@#$)(!@*#$"
+        };
+    for (String value : values) {
+      final IValue input = IValue.from(value);
+      assertTrue(input.isString());
+      assertTrue(value.equals(input.toStr()));
+      final IValue output = module.runMethod("eqStr", input);
+      assertTrue(output.isString());
+      assertTrue(value.equals(output.toStr()));
+    }
+  }
+
+  @Test
+  public void testStr3Concat() throws IOException {
+    final Module module = Module.load(assetFilePath(TEST_MODULE_ASSET_NAME));
+    String[] values =
+        new String[] {
+            "smoketest",
+            "проверка не латинских символов", // not latin symbols check
+            "#@$!@#)($*!@#$)(!@*#$"
+        };
+    for (String value : values) {
+      final IValue input = IValue.from(value);
+      assertTrue(input.isString());
+      assertTrue(value.equals(input.toStr()));
+      final IValue output = module.runMethod("str3Concat", input);
+      assertTrue(output.isString());
+      String expectedOutput = new StringBuilder().append(value).append(value).append(value).toString();
+      assertTrue(expectedOutput.equals(output.toStr()));
+    }
+  }
+
+  protected abstract String assetFilePath(String assetName) throws IOException;
+}

android/pytorch_android/src/main/cpp/cmake_macros.h

@@ -0,0 +1,3 @@
+#pragma once
+
+/* #undef TRACE_ENABLED */

android/pytorch_android/src/main/cpp/cmake_macros.h.in

@@ -0,0 +1,3 @@
+#pragma once
+
+#cmakedefine TRACE_ENABLED

android/pytorch_android/src/main/cpp/pytorch_jni.cpp

@@ -1,657 +0,0 @@
-#include <cassert>
-#include <iostream>
-#include <memory>
-#include <string>
-
-#include <fbjni/ByteBuffer.h>
-#include <fbjni/fbjni.h>
-
-#include <torch/script.h>
-
-namespace pytorch_jni {
-
-constexpr static int kTensorDTypeUInt8 = 1;
-constexpr static int kTensorDTypeInt8 = 2;
-constexpr static int kTensorDTypeInt32 = 3;
-constexpr static int kTensorDTypeFloat32 = 4;
-constexpr static int kTensorDTypeInt64 = 5;
-constexpr static int kTensorDTypeFloat64 = 6;
-
-template <typename K = jobject, typename V = jobject>
-struct JHashMap
-    : facebook::jni::JavaClass<JHashMap<K, V>, facebook::jni::JMap<K, V>> {
-  constexpr static auto kJavaDescriptor = "Ljava/util/HashMap;";
-
-  using Super =
-      facebook::jni::JavaClass<JHashMap<K, V>, facebook::jni::JMap<K, V>>;
-
-  static facebook::jni::local_ref<JHashMap<K, V>> create() {
-    return Super::newInstance();
-  }
-
-  void put(
-      facebook::jni::alias_ref<facebook::jni::JObject::javaobject> key,
-      facebook::jni::alias_ref<facebook::jni::JObject::javaobject> value) {
-    static auto putMethod =
-        Super::javaClassStatic()
-            ->template getMethod<facebook::jni::alias_ref<
-                facebook::jni::JObject::javaobject>(
-                facebook::jni::alias_ref<facebook::jni::JObject::javaobject>,
-                facebook::jni::alias_ref<facebook::jni::JObject::javaobject>)>(
-                "put");
-    putMethod(Super::self(), key, value);
-  }
-};
-
-static at::Tensor newAtTensor(
-    facebook::jni::alias_ref<facebook::jni::JBuffer> jbuffer,
-    facebook::jni::alias_ref<jlongArray> jshape,
-    jint jdtype) {
-  const auto rank = jshape->size();
-  const auto shapeArr = jshape->getRegion(0, rank);
-  std::vector<int64_t> shapeVec{};
-  shapeVec.reserve(rank);
-  auto numel = 1;
-  for (auto i = 0; i < rank; ++i) {
-    shapeVec.push_back(shapeArr[i]);
-    numel *= shapeArr[i];
-  }
-  JNIEnv* jni = facebook::jni::Environment::current();
-  caffe2::TypeMeta typeMeta{};
-  int dataElementSizeBytes = 0;
-  if (kTensorDTypeFloat32 == jdtype) {
-    dataElementSizeBytes = 4;
-    typeMeta = caffe2::TypeMeta::Make<float>();
-  } else if (kTensorDTypeInt32 == jdtype) {
-    dataElementSizeBytes = 4;
-    typeMeta = caffe2::TypeMeta::Make<int32_t>();
-  } else if (kTensorDTypeInt8 == jdtype) {
-    dataElementSizeBytes = 1;
-    typeMeta = caffe2::TypeMeta::Make<int8_t>();
-  } else if (kTensorDTypeUInt8 == jdtype) {
-    dataElementSizeBytes = 1;
-    typeMeta = caffe2::TypeMeta::Make<uint8_t>();
-  } else if (kTensorDTypeFloat64 == jdtype) {
-    dataElementSizeBytes = 8;
-    typeMeta = caffe2::TypeMeta::Make<double>();
-  } else if (kTensorDTypeInt64 == jdtype) {
-    dataElementSizeBytes = 8;
-    typeMeta = caffe2::TypeMeta::Make<int64_t>();
-  } else {
-    facebook::jni::throwNewJavaException(
-        facebook::jni::gJavaLangIllegalArgumentException,
-        "Unknown Tensor jdtype %d",
-        jdtype);
-  }
-  const auto dataCapacity = jni->GetDirectBufferCapacity(jbuffer.get());
-  if (dataCapacity != numel) {
-    facebook::jni::throwNewJavaException(
-        facebook::jni::gJavaLangIllegalArgumentException,
-        "Tensor dimensions(elements number:%d, element byte size:%d, total "
-        "bytes:%d) inconsistent with buffer capacity(%d)",
-        numel,
-        dataElementSizeBytes,
-        numel * dataElementSizeBytes,
-        dataCapacity);
-  }
-  return torch::from_blob(
-      jni->GetDirectBufferAddress(jbuffer.get()),
-      torch::IntArrayRef(shapeVec),
-      at::TensorOptions(typeMeta));
-}
-
-class JTensor : public facebook::jni::JavaClass<JTensor> {
- public:
-  constexpr static const char* kJavaDescriptor = "Lorg/pytorch/Tensor;";
-
-  static facebook::jni::local_ref<JTensor> newJTensor(
-      facebook::jni::alias_ref<facebook::jni::JByteBuffer> jBuffer,
-      facebook::jni::alias_ref<jlongArray> jShape,
-      jint jdtype) {
-    static auto jMethodNewTensor =
-        JTensor::javaClassStatic()
-            ->getStaticMethod<facebook::jni::local_ref<JTensor>(
-                facebook::jni::alias_ref<facebook::jni::JByteBuffer>,
-                facebook::jni::alias_ref<jlongArray>,
-                jint)>("nativeNewTensor");
-    return jMethodNewTensor(
-        JTensor::javaClassStatic(), jBuffer, jShape, jdtype);
-  }
-
-  static facebook::jni::local_ref<JTensor> newJTensorFromAtTensor(
-      const at::Tensor& tensor) {
-    const auto scalarType = tensor.scalar_type();
-    int jdtype = 0;
-    if (at::kFloat == scalarType) {
-      jdtype = kTensorDTypeFloat32;
-    } else if (at::kInt == scalarType) {
-      jdtype = kTensorDTypeInt32;
-    } else if (at::kByte == scalarType) {
-      jdtype = kTensorDTypeUInt8;
-    } else if (at::kChar == scalarType) {
-      jdtype = kTensorDTypeInt8;
-    } else if (at::kLong == scalarType) {
-      jdtype = kTensorDTypeInt64;
-    } else if (at::kDouble == scalarType) {
-      jdtype = kTensorDTypeFloat64;
-    } else {
-      facebook::jni::throwNewJavaException(
-          facebook::jni::gJavaLangIllegalArgumentException,
-          "at::Tensor scalar type is not supported on java side");
-    }
-
-    const auto& tensorShape = tensor.sizes();
-    std::vector<int64_t> tensorShapeVec;
-    for (const auto& s : tensorShape) {
-      tensorShapeVec.push_back(s);
-    }
-
-    facebook::jni::local_ref<jlongArray> jTensorShape =
-        facebook::jni::make_long_array(tensorShapeVec.size());
-
-    jTensorShape->setRegion(0, tensorShapeVec.size(), tensorShapeVec.data());
-
-    facebook::jni::local_ref<facebook::jni::JByteBuffer> jTensorBuffer =
-        facebook::jni::JByteBuffer::allocateDirect(tensor.nbytes());
-    jTensorBuffer->order(facebook::jni::JByteOrder::nativeOrder());
-    std::memcpy(
-        jTensorBuffer->getDirectBytes(),
-        tensor.storage().data(),
-        tensor.nbytes());
-    return JTensor::newJTensor(jTensorBuffer, jTensorShape, jdtype);
-  }
-
-  static at::Tensor newAtTensorFromJTensor(
-      facebook::jni::alias_ref<JTensor> jtensor) {
-    static const auto dtypeMethod =
-        JTensor::javaClassStatic()->getMethod<jint()>("dtype");
-    jint jdtype = dtypeMethod(jtensor);
-
-    static const auto shapeField =
-        JTensor::javaClassStatic()->getField<jlongArray>("shape");
-    auto jshape = jtensor->getFieldValue(shapeField);
-
-    static auto dataBufferMethod =
-        JTensor::javaClassStatic()
-            ->getMethod<
-                facebook::jni::local_ref<facebook::jni::JBuffer::javaobject>()>(
-                "getRawDataBuffer");
-    facebook::jni::local_ref<facebook::jni::JBuffer> jbuffer =
-        dataBufferMethod(jtensor);
-    return newAtTensor(jbuffer, jshape, jdtype);
-  }
-};
-
-class JIValue : public facebook::jni::JavaClass<JIValue> {
- public:
-  constexpr static const char* kJavaDescriptor = "Lorg/pytorch/IValue;";
-
-  constexpr static int kTypeCodeNull = 1;
-
-  constexpr static int kTypeCodeTensor = 2;
-  constexpr static int kTypeCodeBool = 3;
-  constexpr static int kTypeCodeLong = 4;
-  constexpr static int kTypeCodeDouble = 5;
-  constexpr static int kTypeCodeString = 6;
-
-  constexpr static int kTypeCodeTuple = 7;
-  constexpr static int kTypeCodeBoolList = 8;
-  constexpr static int kTypeCodeLongList = 9;
-  constexpr static int kTypeCodeDoubleList = 10;
-  constexpr static int kTypeCodeTensorList = 11;
-  constexpr static int kTypeCodeList = 12;
-
-  constexpr static int kTypeCodeDictStringKey = 13;
-  constexpr static int kTypeCodeDictLongKey = 14;
-
-  static facebook::jni::local_ref<JIValue> newJIValueFromAtIValue(
-      const at::IValue& ivalue) {
-    if (ivalue.isNone()) {
-      static auto jMethodOptionalNull =
-          JIValue::javaClassStatic()
-              ->getStaticMethod<facebook::jni::local_ref<JIValue>()>(
-                  "optionalNull");
-      return jMethodOptionalNull(JIValue::javaClassStatic());
-    } else if (ivalue.isTensor()) {
-      static auto jMethodTensor =
-          JIValue::javaClassStatic()
-              ->getStaticMethod<facebook::jni::local_ref<JIValue>(
-                  facebook::jni::local_ref<JTensor>)>("tensor");
-      return jMethodTensor(
-          JIValue::javaClassStatic(),
-          JTensor::newJTensorFromAtTensor(ivalue.toTensor()));
-    } else if (ivalue.isBool()) {
-      static auto jMethodBool =
-          JIValue::javaClassStatic()
-              ->getStaticMethod<facebook::jni::local_ref<JIValue>(jboolean)>(
-                  "bool");
-      return jMethodBool(JIValue::javaClassStatic(), ivalue.toBool());
-    } else if (ivalue.isInt()) {
-      static auto jMethodInt =
-          JIValue::javaClassStatic()
-              ->getStaticMethod<facebook::jni::local_ref<JIValue>(jlong)>(
-                  "long64");
-      return jMethodInt(JIValue::javaClassStatic(), ivalue.toInt());
-    } else if (ivalue.isDouble()) {
-      static auto jMethodDouble =
-          JIValue::javaClassStatic()
-              ->getStaticMethod<facebook::jni::local_ref<JIValue>(jdouble)>(
-                  "double64");
-      return jMethodDouble(JIValue::javaClassStatic(), ivalue.toDouble());
-    } else if (ivalue.isString()) {
-      static auto jMethodString =
-          JIValue::javaClassStatic()
-              ->getStaticMethod<facebook::jni::local_ref<JIValue>(
-                  facebook::jni::alias_ref<
-                      facebook::jni::JString::javaobject>)>("string");
-      return jMethodString(
-          JIValue::javaClassStatic(),
-          facebook::jni::make_jstring(ivalue.toStringRef()));
-    } else if (ivalue.isTuple()) {
-      auto elementsVec = ivalue.toTuple()->elements();
-      static auto jMethodTupleArr =
-          JIValue::javaClassStatic()
-              ->getStaticMethod<facebook::jni::local_ref<JIValue>(
-                  facebook::jni::alias_ref<facebook::jni::JArrayClass<
-                      JIValue::javaobject>::javaobject>)>("tuple");
-      auto jElementsArray =
-          facebook::jni::JArrayClass<JIValue::javaobject>::newArray(
-              elementsVec.size());
-      auto index = 0;
-      for (const auto& e : elementsVec) {
-        (*jElementsArray)[index++] = JIValue::newJIValueFromAtIValue(e);
-      }
-      return jMethodTupleArr(JIValue::javaClassStatic(), jElementsArray);
-    } else if (ivalue.isBoolList()) {
-      auto list = ivalue.toBoolList();
-      static auto jMethodBoolListArr =
-          JIValue::javaClassStatic()
-              ->getStaticMethod<facebook::jni::local_ref<JIValue>(
-                  facebook::jni::alias_ref<jbooleanArray>)>("boolList");
-      size_t n = list.size();
-      auto jArray = facebook::jni::make_boolean_array(n);
-      auto jArrayPinned = jArray->pin();
-      auto index = 0;
-      for (const auto& e : list) {
-        jArrayPinned[index++] = e;
-      }
-      return jMethodBoolListArr(JIValue::javaClassStatic(), jArray);
-    } else if (ivalue.isIntList()) {
-      auto list = ivalue.toIntList();
-      static auto jMethodLongListArr =
-          JIValue::javaClassStatic()
-              ->getStaticMethod<facebook::jni::local_ref<JIValue>(
-                  facebook::jni::alias_ref<jlongArray>)>("longList");
-      size_t n = list.size();
-      auto jArray = facebook::jni::make_long_array(n);
-      auto jArrayPinned = jArray->pin();
-      auto index = 0;
-      for (const auto& e : list) {
-        jArrayPinned[index++] = e;
-      }
-      return jMethodLongListArr(JIValue::javaClassStatic(), jArray);
-    } else if (ivalue.isDoubleList()) {
-      auto list = ivalue.toDoubleList();
-      static auto jMethoDoubleListArr =
-          JIValue::javaClassStatic()
-              ->getStaticMethod<facebook::jni::local_ref<JIValue>(
-                  facebook::jni::alias_ref<jdoubleArray>)>("doubleList");
-      size_t n = list.size();
-      auto jArray = facebook::jni::make_double_array(n);
-      auto jArrayPinned = jArray->pin();
-      auto index = 0;
-      for (const auto& e : list) {
-        jArrayPinned[index++] = e;
-      }
-      return jMethoDoubleListArr(JIValue::javaClassStatic(), jArray);
-    } else if (ivalue.isTensorList()) {
-      auto list = ivalue.toTensorList();
-      static auto jMethodTensorListArr =
-          JIValue::javaClassStatic()
-              ->getStaticMethod<facebook::jni::local_ref<JIValue>(
-                  facebook::jni::alias_ref<facebook::jni::JArrayClass<
-                      JTensor::javaobject>::javaobject>)>("tensorList");
-      auto jArray = facebook::jni::JArrayClass<JTensor::javaobject>::newArray(
-          list.size());
-      auto index = 0;
-      for (const auto& e : list) {
-        (*jArray)[index++] = JTensor::newJTensorFromAtTensor(e);
-      }
-      return jMethodTensorListArr(JIValue::javaClassStatic(), jArray);
-    } else if (ivalue.isGenericList()) {
-      auto list = ivalue.toGenericList();
-      static auto jMethodListArr =
-          JIValue::javaClassStatic()
-              ->getStaticMethod<facebook::jni::local_ref<JIValue>(
-                  facebook::jni::alias_ref<facebook::jni::JArrayClass<
-                      JIValue::javaobject>::javaobject>)>("list");
-      auto jArray = facebook::jni::JArrayClass<JIValue::javaobject>::newArray(
-          list.size());
-      auto index = 0;
-      for (const auto& e : list) {
-        (*jArray)[index++] = JIValue::newJIValueFromAtIValue(e);
-      }
-      return jMethodListArr(JIValue::javaClassStatic(), jArray);
-    } else if (ivalue.isGenericDict()) {
-      auto dict = ivalue.toGenericDict();
-      const auto keyType = dict.keyType();
-
-      if (!keyType) {
-        facebook::jni::throwNewJavaException(
-            facebook::jni::gJavaLangIllegalArgumentException,
-            "Unknown IValue-Dict key type");
-      }
-
-      const auto keyTypeKind = keyType->kind();
-      if (c10::TypeKind::StringType == keyTypeKind) {
-        static auto jMethodDictStringKey =
-            JIValue::javaClassStatic()
-                ->getStaticMethod<facebook::jni::local_ref<JIValue>(
-                    facebook::jni::alias_ref<facebook::jni::JMap<
-                        facebook::jni::alias_ref<
-                            facebook::jni::JString::javaobject>,
-                        facebook::jni::alias_ref<JIValue::javaobject>>>)>(
-                    "dictStringKey");
-
-        auto jmap = JHashMap<
-            facebook::jni::alias_ref<facebook::jni::JString::javaobject>,
-            facebook::jni::alias_ref<JIValue::javaobject>>::create();
-        for (auto& pair : dict) {
-          jmap->put(
-              facebook::jni::make_jstring(pair.key().toString()->string()),
-              JIValue::newJIValueFromAtIValue(pair.value()));
-        }
-        return jMethodDictStringKey(JIValue::javaClassStatic(), jmap);
-      } else if (c10::TypeKind::IntType == keyTypeKind) {
-        static auto jMethodDictLongKey =
-            JIValue::javaClassStatic()
-                ->getStaticMethod<facebook::jni::local_ref<JIValue>(
-                    facebook::jni::alias_ref<facebook::jni::JMap<
-                        facebook::jni::alias_ref<
-                            facebook::jni::JLong::javaobject>,
-                        facebook::jni::alias_ref<JIValue::javaobject>>>)>(
-                    "dictLongKey");
-        auto jmap = JHashMap<
-            facebook::jni::alias_ref<facebook::jni::JLong::javaobject>,
-            facebook::jni::alias_ref<JIValue::javaobject>>::create();
-        for (auto& pair : dict) {
-          jmap->put(
-              facebook::jni::JLong::valueOf(pair.key().toInt()),
-              JIValue::newJIValueFromAtIValue(pair.value()));
-        }
-        return jMethodDictLongKey(JIValue::javaClassStatic(), jmap);
-      }
-
-      facebook::jni::throwNewJavaException(
-          facebook::jni::gJavaLangIllegalArgumentException,
-          "Unsupported IValue-Dict key type");
-    }
-
-    facebook::jni::throwNewJavaException(
-        facebook::jni::gJavaLangIllegalArgumentException,
-        "Unsupported IValue type %s",
-        ivalue.tagKind().c_str());
-  }
-
-  static at::IValue JIValueToAtIValue(
-      facebook::jni::alias_ref<JIValue> jivalue) {
-    static const auto typeCodeField =
-        JIValue::javaClassStatic()->getField<jint>("mTypeCode");
-    const auto typeCode = jivalue->getFieldValue(typeCodeField);
-    if (JIValue::kTypeCodeNull == typeCode) {
-      return at::IValue{};
-    } else if (JIValue::kTypeCodeTensor == typeCode) {
-      static const auto jMethodGetTensor =
-          JIValue::javaClassStatic()
-              ->getMethod<facebook::jni::alias_ref<JTensor::javaobject>()>(
-                  "getTensor");
-      return JTensor::newAtTensorFromJTensor(jMethodGetTensor(jivalue));
-    } else if (JIValue::kTypeCodeBool == typeCode) {
-      static const auto jMethodGetBool =
-          JIValue::javaClassStatic()->getMethod<jboolean()>("getBool");
-      // explicit cast to bool as jboolean is defined as uint8_t, IValue ctor
-      // for int will be called for jboolean
-      bool b = jMethodGetBool(jivalue);
-      return at::IValue{b};
-    } else if (JIValue::kTypeCodeLong == typeCode) {
-      static const auto jMethodGetLong =
-          JIValue::javaClassStatic()->getMethod<jlong()>("getLong");
-      return at::IValue{jMethodGetLong(jivalue)};
-    } else if (JIValue::kTypeCodeDouble == typeCode) {
-      static const auto jMethodGetDouble =
-          JIValue::javaClassStatic()->getMethod<jdouble()>("getDouble");
-      return at::IValue{jMethodGetDouble(jivalue)};
-    } else if (JIValue::kTypeCodeString == typeCode) {
-      static const auto jMethodGetString =
-          JIValue::javaClassStatic()->getMethod<jstring()>("getString");
-      return at::IValue{jMethodGetString(jivalue)->toStdString()};
-    } else if (JIValue::kTypeCodeTuple == typeCode) {
-      static const auto jMethodGetTuple =
-          JIValue::javaClassStatic()
-              ->getMethod<facebook::jni::JArrayClass<
-                  JIValue::javaobject>::javaobject()>("getTuple");
-      auto jarray = jMethodGetTuple(jivalue);
-      size_t n = jarray->size();
-
-      std::vector<at::IValue> elements;
-      elements.reserve(n);
-      for (auto i = 0; i < n; ++i) {
-        auto jivalue_element = jarray->getElement(i);
-        auto element = JIValue::JIValueToAtIValue(jivalue_element);
-        elements.push_back(std::move(element));
-      }
-      return c10::ivalue::Tuple::create(std::move(elements));
-    } else if (JIValue::kTypeCodeBoolList == typeCode) {
-      static const auto jMethodGetBoolList =
-          JIValue::javaClassStatic()->getMethod<jbooleanArray()>("getBoolList");
-      auto jArray = jMethodGetBoolList(jivalue);
-      auto jArrayPinned = jArray->pin();
-      size_t n = jArrayPinned.size();
-      c10::List<bool> list{};
-      list.reserve(n);
-      for (size_t i = 0; i < n; ++i) {
-        list.push_back(jArrayPinned[i]);
-      }
-      return at::IValue{std::move(list)};
-    } else if (JIValue::kTypeCodeLongList == typeCode) {
-      static const auto jMethodGetLongList =
-          JIValue::javaClassStatic()->getMethod<jlongArray()>("getLongList");
-      auto jArray = jMethodGetLongList(jivalue);
-      auto jArrayPinned = jArray->pin();
-      size_t n = jArrayPinned.size();
-      c10::List<int64_t> list{};
-      list.reserve(n);
-      for (size_t i = 0; i < n; ++i) {
-        list.push_back(jArrayPinned[i]);
-      }
-      return at::IValue{std::move(list)};
-    } else if (JIValue::kTypeCodeDoubleList == typeCode) {
-      static const auto jMethodGetDoubleList =
-          JIValue::javaClassStatic()->getMethod<jdoubleArray()>(
-              "getDoubleList");
-      auto jArray = jMethodGetDoubleList(jivalue);
-      auto jArrayPinned = jArray->pin();
-      size_t n = jArrayPinned.size();
-      c10::List<double> list{};
-      list.reserve(n);
-      for (size_t i = 0; i < n; ++i) {
-        list.push_back(jArrayPinned[i]);
-      }
-      return at::IValue{std::move(list)};
-    } else if (JIValue::kTypeCodeTensorList == typeCode) {
-      static const auto jMethodGetTensorList =
-          JIValue::javaClassStatic()
-              ->getMethod<facebook::jni::JArrayClass<
-                  JTensor::javaobject>::javaobject()>("getTensorList");
-      auto jArray = jMethodGetTensorList(jivalue);
-      size_t n = jArray->size();
-      c10::List<at::Tensor> list{};
-      list.reserve(n);
-      for (size_t i = 0; i < n; ++i) {
-        list.push_back(JTensor::newAtTensorFromJTensor(jArray->getElement(i)));
-      }
-      return at::IValue{std::move(list)};
-    } else if (JIValue::kTypeCodeList == typeCode) {
-      static const auto jMethodGetList =
-          JIValue::javaClassStatic()
-              ->getMethod<facebook::jni::JArrayClass<
-                  JIValue::javaobject>::javaobject()>("getList");
-      auto jarray = jMethodGetList(jivalue);
-      size_t n = jarray->size();
-      if (n == 0) {
-        return at::IValue{c10::impl::GenericList(c10::TensorType::get())};
-      }
-
-      auto jivalue_first_element = jarray->getElement(0);
-      auto first_element = JIValue::JIValueToAtIValue(jivalue_first_element);
-      c10::TypePtr typePtr = c10::attemptToRecoverType(first_element);
-      c10::impl::GenericList list{typePtr};
-      list.reserve(n);
-      list.push_back(first_element);
-      for (auto i = 1; i < n; ++i) {
-        auto jivalue_element = jarray->getElement(i);
-        auto element = JIValue::JIValueToAtIValue(jivalue_element);
-        list.push_back(element);
-      }
-      return at::IValue{list};
-    } else if (JIValue::kTypeCodeDictStringKey == typeCode) {
-      static const auto jMethodGetDictStringKey =
-          JIValue::javaClassStatic()
-              ->getMethod<facebook::jni::JMap<jstring, JIValue::javaobject>::
-                              javaobject()>("getDictStringKey");
-      auto jmap = jMethodGetDictStringKey(jivalue);
-      auto it = jmap->begin();
-      if (it == jmap->end()) {
-        return at::IValue{c10::impl::GenericDict(
-            c10::StringType::get(), c10::TensorType::get())};
-      }
-
-      auto firstEntryValue = JIValue::JIValueToAtIValue(it->second);
-      c10::TypePtr typePtr = c10::attemptToRecoverType(firstEntryValue);
-      c10::impl::GenericDict dict{c10::StringType::get(), typePtr};
-      dict.insert(it->first->toStdString(), firstEntryValue);
-      it++;
-      for (; it != jmap->end(); it++) {
-        dict.insert(
-            it->first->toStdString(), JIValue::JIValueToAtIValue(it->second));
-      }
-      return at::IValue{dict};
-    } else if (JIValue::kTypeCodeDictLongKey == typeCode) {
-      static const auto jMethodGetDictLongKey =
-          JIValue::javaClassStatic()
-              ->getMethod<facebook::jni::JMap<
-                  facebook::jni::JLong::javaobject,
-                  JIValue::javaobject>::javaobject()>("getDictLongKey");
-      auto jmap = jMethodGetDictLongKey(jivalue);
-      auto it = jmap->begin();
-      if (it == jmap->end()) {
-        return at::IValue{c10::impl::GenericDict(
-            c10::IntType::get(), c10::TensorType::get())};
-      }
-
-      auto firstEntryValue = JIValue::JIValueToAtIValue(it->second);
-      c10::TypePtr typePtr = c10::attemptToRecoverType(firstEntryValue);
-      c10::impl::GenericDict dict{c10::IntType::get(), typePtr};
-      dict.insert(it->first->longValue(), firstEntryValue);
-      it++;
-      for (; it != jmap->end(); it++) {
-        dict.insert(
-            it->first->longValue(), JIValue::JIValueToAtIValue(it->second));
-      }
-      return at::IValue{dict};
-    }
-
-    facebook::jni::throwNewJavaException(
-        facebook::jni::gJavaLangIllegalArgumentException,
-        "Unknown IValue typeCode %d",
-        typeCode);
-  }
-};
-
-class PytorchJni : public facebook::jni::HybridClass<PytorchJni> {
- private:
-  friend HybridBase;
-  torch::jit::script::Module module_;
-
- public:
-  constexpr static auto kJavaDescriptor = "Lorg/pytorch/Module$NativePeer;";
-
-  static facebook::jni::local_ref<jhybriddata> initHybrid(
-      facebook::jni::alias_ref<jclass>,
-      facebook::jni::alias_ref<jstring> modelPath) {
-    return makeCxxInstance(modelPath);
-  }
-
-  PytorchJni(facebook::jni::alias_ref<jstring> modelPath) {
-    auto qengines = at::globalContext().supportedQEngines();
-    if (std::find(qengines.begin(), qengines.end(), at::QEngine::QNNPACK) !=
-        qengines.end()) {
-      at::globalContext().setQEngine(at::QEngine::QNNPACK);
-    }
-    module_ = torch::jit::load(std::move(modelPath->toStdString()));
-    module_.eval();
-  }
-
-  static void registerNatives() {
-    registerHybrid({
-        makeNativeMethod("initHybrid", PytorchJni::initHybrid),
-        makeNativeMethod("forward", PytorchJni::forward),
-        makeNativeMethod("runMethod", PytorchJni::runMethod),
-    });
-  }
-
-  facebook::jni::local_ref<JIValue> forward(
-      facebook::jni::alias_ref<
-          facebook::jni::JArrayClass<JIValue::javaobject>::javaobject>
-          jinputs) {
-    std::vector<at::IValue> inputs{};
-    size_t n = jinputs->size();
-    inputs.reserve(n);
-    for (size_t i = 0; i < n; i++) {
-      at::IValue atIValue = JIValue::JIValueToAtIValue(jinputs->getElement(i));
-      inputs.push_back(std::move(atIValue));
-    }
-    auto output = [&]() {
-      torch::autograd::AutoGradMode guard(false);
-      at::AutoNonVariableTypeMode non_var_type_mode(true);
-      return module_.forward(std::move(inputs));
-    }();
-    return JIValue::newJIValueFromAtIValue(output);
-  }
-
-  facebook::jni::local_ref<JIValue> runMethod(
-      facebook::jni::alias_ref<facebook::jni::JString::javaobject> jmethodName,
-      facebook::jni::alias_ref<
-          facebook::jni::JArrayClass<JIValue::javaobject>::javaobject>
-          jinputs) {
-    std::string methodName = jmethodName->toStdString();
-
-    std::vector<at::IValue> inputs{};
-    size_t n = jinputs->size();
-    inputs.reserve(n);
-    for (size_t i = 0; i < n; i++) {
-      at::IValue atIValue = JIValue::JIValueToAtIValue(jinputs->getElement(i));
-      inputs.push_back(std::move(atIValue));
-    }
-    if (auto method = module_.find_method(methodName)) {
-      auto output = [&]() {
-        torch::autograd::AutoGradMode guard(false);
-        at::AutoNonVariableTypeMode non_var_type_mode(true);
-        return (*method)(std::move(inputs));
-      }();
-      return JIValue::newJIValueFromAtIValue(output);
-    }
-
-    facebook::jni::throwNewJavaException(
-        facebook::jni::gJavaLangIllegalArgumentException,
-        "Undefined method %s",
-        methodName.c_str());
-  }
-};
-
-} // namespace pytorch_jni
-
-JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
-  return facebook::jni::initialize(
-      vm, [] { pytorch_jni::PytorchJni::registerNatives(); });
-}