1. 13 Mar, 2020 1 commit
  2. 26 Feb, 2020 1 commit
  3. 19 Feb, 2020 1 commit
  4. 13 Feb, 2020 1 commit
  5. 12 Feb, 2020 1 commit
    • [REFACTOR][PY][API-CHANGE] establish tvm.ir, migrate corresponding files (#4862) · a5661611
      * [REFACTOR][PY][API-CHANGE] establish tvm.ir, migrate corresponding relay files.
      
      This PR establishes tvm.ir and migrates the corresponding relay
      files into the new folder.
      
      API Change:
      - relay.Module -> tvm.IRModule
      
      * Update with ADT
      
      * Migrate transform
      
      * address comments
      
      * Migrate module
      
      * Migrate json_compact
      
      * Migrate attrs
      
      * Move LoweredFunc to stmt temporarily
      
      * temp migrate container
      
      * Finish migrate container
      Tianqi Chen committed
  6. 09 Feb, 2020 1 commit
  7. 07 Feb, 2020 1 commit
    • [REFACTOR][PY][API-Change] Polish tvm.runtime, tvm.runtime.module API update (#4837) · e0122c0e
      * [REFACTOR][PY-API] Polish tvm.runtime, tvm.runtime.module API update
      
      This PR updates the tvm.runtime to use the new FFI style.
      
      - Remove top-level tvm.module to avoid confusion between runtime.Module and IRModule
      - API changes wrt to runtime.Module
        - tvm.module.load -> tvm.runtime.load_module
        - tvm.module.enabled -> tvm.runtime.enabled
        - tvm.module.system_lib -> tvm.runtime.system_lib
      - Remove dep on api_internal from runtime.
      
      * Update module.load in the latest API
      Tianqi Chen committed
  8. 05 Feb, 2020 2 commits
    • [REFACTOR][PY] Establish tvm.runtime (#4818) · fc7dd6d7
      * [REFACTOR][PY] Establish tvm.runtime
      
      This PR establishes the tvm.runtime namespace that contains the core runtime data structures.
      The top-level API are kept inact for now via re-exporting.
      
      We will followup later to cleanup some of the top-level APIs.
      
      * Fix ndarray name
      Tianqi Chen committed
    • [REFACTOR][PY] tvm._ffi (#4813) · f9b46c43
      * [REFACTOR][PY] tvm._ffi
      
      - Remove from __future__ import absolute_import in the related files as they are no longer needed if the code only runs in python3
      - Remove reverse dependency of _ctypes _cython to object_generic.
      - function.py -> packed_func.py
      - Function -> PackedFunc
      - all registry related logics goes to tvm._ffi.registry
      - Use absolute references for FFI related calls.
        - tvm._ffi.register_object
        - tvm._ffi.register_func
        - tvm._ffi.get_global_func
      
      * Move get global func to the ffi side
      Tianqi Chen committed
  9. 30 Jan, 2020 1 commit
  10. 27 Jan, 2020 1 commit
  11. 16 Jan, 2020 2 commits
  12. 15 Jan, 2020 1 commit
  13. 11 Jan, 2020 1 commit
  14. 30 Dec, 2019 1 commit
    • [REFACTOR][RUNTIME] Update NDArray use the Unified Object System (#4581) · 55bd786f
      * [REFACTOR][RUNTIME] Move NDArray to Object System.
      
      Previously NDArray has its own object reference counting mechanism.
      This PR migrates NDArray to the unified object protocol.
      
      The calling convention of NDArray remained intact.
      That means NDArray still has its own type_code and
      its handle is still DLTensor compatible.
      
      In order to do so, this PR added a few minimum runtime type
      detection in TVMArgValue and RetValue only when the corresponding
      type is a base type(ObjectRef) that could also refer to NDArray.
      
      This means that even if we return a base reference object ObjectRef
      which refers to the NDArray. The type_code will still be translated
      correctly as kNDArrayContainer.
      If we assign a non-base type(say Expr) that we know is not compatible
      with NDArray during compile time, no runtime type detection will be performed.
      
      This PR also adopts the object protocol for NDArray sub-classing and
      removed the legacy NDArray subclass protocol.
      Examples in apps/extension are now updated to reflect that.
      
      Making NDArray as an Object brings all the benefits of the object system.
      For example, we can now use the Array container to store NDArrays.
      
      * Address review comments
      Tianqi Chen committed
  15. 25 Dec, 2019 2 commits
    • Some Windows and MSVC fixes (#4569) · 949c4d27
      * fix python exception creation in Windows
      
      * better string conversion for msvc
      
      * fix cpp style issue
      kice committed
    • [RUNTIME] Remove Extension VTable in favor of Unified Object system. (#4578) · e91cc5ab
      Before the unified object protocol, we support pass
      additional extension objects around by declaring a type as an extension type.
      The old extension mechanism requires the types to register their
      constructor and deleter to a VTable and does not enjoy the benefit of the
      self-contained deletion property of the new Object system.
      
      This PR upgrades the extension example to make use of the new object system
      and removed the old Extension VTable.
      
      Note that the register_extension funtion in the python side continues to work
      when the passed argument does not require explicit container copy/deletion,
      which covers the current usecases of the extension mechanism.
      Tianqi Chen committed
  16. 22 Dec, 2019 2 commits
  17. 20 Dec, 2019 1 commit
  18. 04 Dec, 2019 1 commit
  19. 02 Dec, 2019 1 commit
  20. 24 Nov, 2019 1 commit
  21. 06 Nov, 2019 1 commit
  22. 21 Oct, 2019 1 commit
    • [REFACTOR][NODE][RUNTIME] Move Node to the new Object protocol. (#4161) · 7895adb2
      * [REFACTOR][NODE][RUNTIME] Move Node to the new Object protocol.
      
      This PR removes the original node system, and make node as a subclass of Object.
      This is a major refactor towards a better unified runtime object system.
      
      List of changes in the refactor:
      
      - We now hide data_ field, use Downcast explicitly to get a sub-class object.
      - Removed the node system FFI in python.
      - Removed the node C API, instead use PackedFunc for list and get attrs.
      - Change relay::Op::set_attr_type_key(attr_key_name) to relay::Op::set_attr_type<AttrType>().
        - This change was necessary because of the new Object registration mechanism.
        - Subsequent changes to the op registrations
        - The change revealed a few previous problems that is now fixed.
      - Patched up a few missing node type registration.
        - Now we will raise an error if we register object that is not registered.
      - The original node.h and container.h are kept in the same location.
      - Calling convention: kObjectHandle now equals the old kNodeHandle, kNodeHandle is removed.
      - IRFunctor now dispatches on ObjectRef.
      - Update to the new type checking API: is_type, derived_from are replaced by IsInstance.
      - Removed .hash member function, instead use C++ convention hasher functors.
      
      * Address review comments
      Tianqi Chen committed
  23. 16 Oct, 2019 1 commit
    • [RUNTIME] Refactor object python FFI to new protocol. (#4128) · 02c1e117
      * [RUNTIME] Refactor object python FFI to new protocol.
      
      This is a pre-req to bring the Node system under object protocol.
      Most of the code reflects the current code in the Node system.
      
      - Use new instead of init so subclass can define their own constructors
      - Allow register via name, besides type idnex
      - Introduce necessary runtime C API functions
      - Refactored Tensor and Datatype to directly use constructor.
      
      * address review comments
      Tianqi Chen committed
  24. 15 Oct, 2019 1 commit
    • [RFC][RUNTIME] Introduce new object protocol. (#4115) · a0bd3786
      * [RUNTIME] Introduce new object protocol.
      
      This PR introduces a new object protocol to unify the node and object.
      We also updated the existing runtime::vm code to make use of the new system.
      
      Update to the node will be done in a follow up PR.
      
      Other changes:
      
      - Remove object related code in json serializer as that code logic was not complete
        and we have a separate serializer for VM, can revisit later.
      
      * address review  comment
      
      * Fix the child slot logic
      Tianqi Chen committed
  25. 09 Sep, 2019 1 commit
  26. 05 Sep, 2019 1 commit
  27. 25 Jul, 2019 1 commit
    • Implementation of uTVM (#3227) · ef909df1
      * uTVM interfaces (#14)
      
      * some minor interface changes
      
      * implemented HostLowLevelDevice
      
      * added MicroDeviceAPI
      
      * implemented micro_common and added Python interfaces
      
      * current status, semi implemented micro session
      
      * added micro_common implementation and python interfaces (#18)
      
      * added micro_common implementation and python interfaces (#18)
      
      * current status, semi implemented
      
      * host test working
      
      * updated interfaces for MicroSession arguments allocation
      
      * make somewhat lint compatible
      
      * fix based on comments
      
      * added rounding macro
      
      * fix minor bug
      
      * improvements based on comments
      
      * Clean up `binutil.py` and make Python-3-compatible
      
      * Change argument allocation design
      
      * Address feedback and lint errors
      
      * Improve binutil tests
      
      * Simplify allocator (per @tqchen's suggestions)
      
      * Doc/style fixes
      
      * farts
      
      * mcgee
      
      * rodata section werks
      
      (and so does `test_runtime_micro_workspace.py`)
      
      * simple graph runtime werk
      
      * TEMP
      
      * ResNet works, yo
      
      * First round of cleanup
      
      * More cleanup
      
      * runs a dyson over the code
      
      * Another pass
      
      * Fix `make lint` issues
      
      * ready to pr... probably
      
      * final
      
      * Undo change
      
      * Fix rebase resolution
      
      * Minor fixes
      
      * Undo changes to C codegen tests
      
      * Add `obj_path` in `create_micro_lib`
      
      * TEMP
      
      * Address feedback
      
      * Add missing TODO
      
      * Partially address feedback
      
      * Fix headers
      
      * Switch to enum class for `SectionKind`
      
      * Add missing ASF header
      
      * Fix lint
      
      * Fix lint again
      
      * Fix lint
      
      * Kill lint warnings
      
      * Address feedback
      
      * Change Python interface to MicroTVM
      
      All interaction with the device is now through `Session` objects, which
      are used through Python's `with` blocks.
      
      * Reorder LowLevelDevice interface
      
      * Store shared ptr to session in all alloced objects
      
      * Move helper functions out of `tvm.micro`
      
      * Switch static char arr to vector
      
      * Improve general infra and code quality
      
      Does not yet address all of tqchen's feedback
      
      * Forgot a rename
      
      * Fix lint
      
      * Add ASF header
      
      * Fix lint
      
      * Partially address MarisaKirisame's feedback
      
      * Lint
      
      * Expose `MicroSession` as a node to Python
      
      * Revert to using `Session` constructor
      
      * Fix compiler error
      
      * (Maybe) fix CI error
      
      * Debugging
      
      * Remove
      
      * Quell lint
      
      * Switch to stack-based session contexts
      
      * Make uTVM less intrusive to host codegen
      
      And use SSA for operands of generated ternary operators
      
      * Inline UTVMArgs into UTVMTask struct
      
      * Remove `HostLowLevelDevice` header
      
      * Remove `BaseAddr` class
      
      * Address feedback
      
      * Add "utvm" prefix to global vars in runtime
      
      * Fix lint
      
      * Fix CI
      
      * Fix `test_binutil.py`
      
      * Fix submodules
      
      * Remove ResNet tests
      
      * Make `test_binutil.py` work with nose
      
      * Fix CI
      
      * I swear this actually fixes the binutil tests
      
      * lint
      
      * lint
      
      * Add fcompile-compatible cross-compile func
      
      * Add docs for uTVM runtime files
      
      * Move pointer patching into `MicroSession`
      
      * Fix lint
      
      * First attempt at unifying cross-compile APIs
      
      * Fix lint
      
      * Rename `cross_compile` back to `cc`
      
      * Address feedback
      
      * Remove commented code
      
      * Lint
      
      * Figure out failing function
      
      * Remove debugging code
      
      * Change "micro_dev" target to "micro"
      
      * Add checks in tests for whether uTVM is enabled
      
      * Add TODO for 32-bit support
      
      * Rename more "micro_dev" to "micro"
      
      * Undo rename
      
      We already have `tvm.micro` as a namespace.  Can't have it as a method
      as well.
      
      * Fix failing CI
      
      Thanks to @tqchen for finding this bug.  Emitting ternary operators for
      `min` and `max` causes concurrency bugs in CUDA, so we're moving the
      ternary op emissions from `CodeGenC` to `CodeGenCHost`.
      
      * Address feedback
      
      * Fix lint
      Logan Weber committed
  28. 16 Jul, 2019 1 commit
  29. 10 Jul, 2019 1 commit
    • [Relay][RFC] Implement type checking for Any (#3221) · 3fb84e2b
      * Implement type checking for Any
      
      Remove code generation related changes
      
      Remove compile changes
      
      Remove more
      
      Remove unification hack
      
      Add some code back that was needed, and clean up test
      
      Refactor test cases
      
      WIP
      
      Implement TypeHint AST
      
      Add test case which should fail
      
      Remove unification changes, and fix bug with let rec
      
      Restore unification for shapes
      
      Improve error reporting while debugging
      
      All examples type check
      
      All examples type check
      
      WIP
      
      First version that works with hints, needs clean up
      
      Remove dead code
      
      Tweaks
      
      Remove type hint
      
      Remove unecessary type hint stuff
      
      Remove more type hints
      
      Clean up
      
      Expose Any expression node
      
      Address CR
      
      Fix
      
      Fix solver
      
      Kill unecessary code
      
      Fix
      
      PyLint
      
      Fix
      
      Relocate loops
      
      Fix license and test
      
      Lint again
      
      Lint again
      
      Fix loops
      
      Fix docstring
      
      Fix template error
      
      Fix compiler issue
      
      Fix compile err
      
      Remove more runtime changes
      
      Restore buffer
      
      Fix segfault
      
      Fix
      
      Fix arange
      
      * Address feedback
      
      * Fix typo
      
      * Fix arange
      
      * Fix op level3
      
      * Fix issue with Python wrapper
      Jared Roesch committed
  30. 15 May, 2019 1 commit
    • [Datatypes] Custom datatypes (#2900) · 7d845f0d
      * Register and use custom datatypes in TVM
      
      This patch adds the ability to register and use a custom datatype from Python,
      using the `register_datatype` call. The datatype can then be passed as the
      `dtype` parameter using the syntax `dtype="custom[<type_name>]bitsxlanes"`.
      
      * Removes extra file
      
      * Register custom datatypes with TVM; specify Cast and Add lowering
      
      This commit adds functionality for registering custom datatypes with TVM, and
      furthermore adding custom lowering functions to lower those custom datatypes.
      This commit only adds lowering for the Cast and Add ops; more ops will be added
      soon.
      
      Check out some custom datatype samples in my repository of samples:
      https://github.com/gussmith23/tvm-custom-datatype-samples
      
      * Register and lower casts from Python
      
      * Formatting
      
      * Fix include; was including too much
      
      * Add comment
      
      * Add DatatypeRegistered
      
      * Add storage size field to custom datatypes
      
      This field indicates the bitwidth of the opaque block of data into which
      instances of the datatype will be stored, when TVM compiles. For example, if I
      create a datatype with a storage size of 16, then
      - Constants of that datatype will be created as unsigned 16-bit ints
      - Calls to external functions taking that datatype will pass the data as
        unsigned 16-bit ints
      - External functions returning that datatype will be assumed to return unsigned
        16-bit ints.
      
      * Change how lowering funcs (Cast and other ops) are named in registry
      
      tvm.datatypes.lower.<target>.cast.<dst-type>.<src-type>
      becomes
      tvm.datatypes.lower.<target>.Cast.<dst-type>.<src-type>
      
      And fixes some sloppy code around how the other ops were being formatted.
      
      * Update Python register_datatype to accept storage size
      
      * Oops, left out one cast->Cast change
      
      * Look up storage size when parsing `custom[typename]`
      
      When we encounter this type string in Python, it will be parsed into a Halide
      type object in C++. Some of my original code supported this parsing, but we now
      have to attach the storage type to the type (by setting the bits field).
      
      * Change how external calls for casting/other ops are done
      
      Firstly, we now use the storage size of the custom type when determining
      input/output types; e.g. a cast to a custom type with storage size 16 is seen as
      a call to an external function returning an opaque uint of size 16.
      
      Secondly, write a macro to handle the other ops. Originally I thought I could
      handle these at runtime, with a single `_register_op` global. I transitioned
      instead to using individual `_register_Add` etc. calls generated with a macro,
      but I don't remember why.
      
      * When encountering a custom type immediate, generate UIntImm
      
      * Translate custom types to LLVM type
      
      * Generate correct return type in Casts
      
      Originally I was assuming that the result type from casts was always a custom
      datatype, and so I was making the Call return a UInt type.
      
      * Use TVM-idiomatic recursion style in DatatypesLowerer
      
      This was actually a bug, I'm pretty sure; we wouldn't have recursed deep on any
      complex programs. As a result of making this change, I also uncovered another
      potential bug, where the datatypes lowering pass would attempt to lower a Load
      of a custom type. By commenting out the `Mutate_` for Load, I was able to stop
      the error from cropping up, but frankly, I'm not satisfied with the solution;
      how is it that we are able to run codegen when Loads of custom datatypes are
      present in the IR? I have not written any code, to my knowledge, that will
      support this. Perhaps Load does not care about the underlying datatype?
      
      * Use CHECK
      
      * Add comment about which Mutate_s are needed
      
      * Add comments
      
      * Add GetCustomDatatypeRegistered as an extern C function
      
      * Formatting, comments, casting
      
      * Change how datatype string is formatted
      
      * Use bits() instead of GetStorageSize
      
      Use bits() instead of GetStorageSize
      
      * Change comment
      
      * Add datatype.py
      
      * Change registered function name (datatypes->datatype)
      
      * Remove GetStorageSize
      
      * Format custom datatypes like any other datatype
      
      Specifically, we now print the bits and lanes after the `custom[...]` string.
      
      * Correctly implement datatype lowering in Python
      
      * Remove unneeded include
      
      * Make function naming consistent
      
      * Use CHECK instead of internal_assert
      
      * Rename macro
      
      * Formatting
      
      * Rename functions
      
      * Implement Cast lowering
      
      `_datatype_register_op` is now able to lower both binary ops and Casts.
      
      * Formatting
      
      * Formatting
      
      * Clang format, google style
      
      * Fix std::string/extern "C" warnings
      
      * Formatting
      
      * Formatting
      
      * Lower Allocates and Loads during datatype lowering
      
      This should ensure that there are no custom datatypes remaining once datatype
      lowering is done. This will allow us to remove the code in the LLVM codegen
      which deals with custom datatypes.
      
      * Revert additions to codegen_llvm.cc which are now unneeded
      
      * Pass cpplint on lower_datatypes.cc
      
      * Add clarifying comment
      
      * Remove datatype lowering registration funcs from C++
      
      * Add CHECKs
      
      * Remove TODO
      
      * Remove all references to storage size
      
      * Move and rename function
      
      * Rename function
      
      * Remove done TODOs and other handled comments
      
      * Remove irrelevant Load code and comments
      
      * Comment out the IR node types I'm not sure about yet
      
      * Add bfloat16 datatype unittest
      
      * Fix MakeConstScalar
      
      MakeConstScalar for a custom datatype will now call out to a function which can
      be registered on a per-datatype basis. The function will take a double and
      return the equivalent value in the custom datatype format.
      
      Note that these code paths are not actually used or tested at the moment. I have
      not yet written an example which uses const scalars of a custom datatype.
      
      * Formatting
      
      * Change pass name
      
      * Allow users to register whatever lowering function they want
      
      Tianqi pointed out that users should be able to register whatever lowering
      function they want, and should not be constrained to registering lowering
      functions which just call out to external libraries.
      
      I still provide a function for making lowering functions which call out to
      external libraries, for convenience.
      
      * Add clarifying comment
      
      * Remove unneeded comment
      
      * Remove unneeded function
      
      * Rename file
      
      * Undo unnecessary change
      
      * Undo unnecessary change
      
      * Make naming consistent
      
      Rename "datatypes" to "custom datatypes" in most contexts.
      
      * Revert an artifact of old code
      
      * Fix build warnings, add TODO
      
      * Lint
      
      * Remove unnecessary use of extern C by separating decl and impl
      
      * Error checking
      
      * Remove TODO
      
      * Missed a name change
      
      * Lint
      
      * Python lint
      
      * Correctly format datatype
      
      * Move bfloat16 to 3rdparty
      
      * "custom_datatypes" --> "datatype" in most places
      
      I left the pass as "LowerCustomDatatypes" to indicate that we're not lowering
      anything other than custom datatypes. Otherwise, everything else has been
      changed.
      
      * Upgrade datatype unittest
      
      I used a float calculator to generate some real testcases for the unittest.
      
      * Separate public includes and private implementation
      
      Specifically, create cleaner decoupling between datatypes stuff in packed_func
      and the datatype registry implementation.
      
      * Formatting
      
      * Limit custom datatype codes to >128
      
      * Add TODOs
      
      * Fix comment
      
      * Formatting
      
      * Clean up datatype unittest
      
      * Remove un-exported functions in public headers; UIntImm->FloatImm
      
      More places where I accidentally was using implementation-only functions in
      public headers.
      
      Additionally, store custom datatype immediates as FloatImms. A later change will
      add new lowering logic to lower these FloatImms to UIntImms.
      
      Plus formatting change.
      
      * Lint
      
      * Use FloatImm (not UIntImm) to hold immediates of custom datatypes
      
      This change switches from using UIntImm to FloatImm for storing immediates of
      custom datatypes. The value of the number is stored in a double, which should be
      enough precision for now, for most custom types we will explore in the immediate
      future.
      
      In line with this change, we change the datatype lowering so that FloatImms are
      lowered to UInts of the appropriate size. Originally, this was going to be done
      by allowing the user to register a double->uint_<storage size>_t conversion
      which would be called at compile time to convert the value from the FloatImm to
      a UInt and store it in a UIntImm. After discussions with Tianqi, we decided to
      take the simpler route, and lower FloatImms just as we lower all other ops: by
      replacing them with Call nodes. In this case, presumably the user will Call out
      to a conversion function in their datatype library.
      
      The justification for this decision is due to the functionality added in #1486.
      This pull request adds the ability to load LLVM bytecode in at compile time.
      This applies in our case as follows:
       1. The user writes their custom datatype programs and registers their lowering
          functions in the same way we've been doing it so far. All operations over
          custom datatypes are lowered to Calls to the datatype library.
       2. The user compiles their datatype library to LLVM bytecode.
       3. At TVM compile time, the user loads the LLVM bytecode. Depending on how the
          datatype library is written, Clang should be able to perform constant
          folding over the custom datatype immediates, even if their conversions are
          done with calls to the library.
      
      Additionally adds test to test the FloatImm codepath.
      
      * Re-add a change I removed accidentally during rebase
      
      * Cleanup
      
      * Remove unnecessary TVM_DLLs
      
      * Add custom datatype utilities source file to Go runtime pack
      
      * Revert "Remove unnecessary TVM_DLLs"
      
      This reverts commit 4b742b99557fd3bf0ce6617f033c8b444b74eda4.
      
      * Mark bfloat code as TVM_DLL
      
      * Moves custom datatype runtime utilities to c_runtime_api.cc
      
      * Revert "Add custom datatype utilities source file to Go runtime pack"
      
      This reverts commit aecbcde0b2cc09a2693955b77037fe20f93b5bfd.
      
      * Move datatype parsing to its own function
      
      * Change comments
      
      * Remove unneeded function
      
      * Formatting
      
      * Formatting
      
      * Documentation
      
      * Add kCustomBegin, use it for checking for custom types
      
      * Documentation
      
      * Formatting
      
      * Move static definition to implementation
      
      * Remove comment
      
      * Decide toBeLowered before lowering arguments of Expr
      
      In the past, e.g. when lowering custom datatypes for an Add, we would lower a
      and b first, and then decide whether the resulting new Add needed to be lowered
      based on the (new) types of a and b. Now, instead, we need to check the types of
      a and b first (to see if they're custom types), and then lower them (so they'll
      become non-custom types), and then lower the new Add.
      
      * Revert "Move datatype parsing to its own function"
      
      This reverts commit d554a5881afcf69af1c070d882a7651022703a09.
      
      This broke parsing. Will figure this out later. There isn't a really clean way
      to separate this out given how the rest of the function is written.
      
      * Replace comment
      
      * Documentation
      
      * Remove comment and TVM_DLL
      
      * Better error messages
      
      * Remove artifact of rebase
      
      * Separate datatypes parsing to its own function
      
      * Add \returns
      
      * Comment changes; add TODO
      
      * Refactor tests
      Gus Smith committed
  31. 02 May, 2019 1 commit
  32. 08 Apr, 2019 1 commit
    • [HEADER] Add Header to Comply with ASF Release Policy (#2982) · cffb4fba
      * [HEADER] ASF header dir=include
      
      * [HEADER] ASF Header dir=src
      
      * [HEADER] ASF Header -dir=python
      
      * [HEADER] ASF header dir=topi
      
      * [HEADER] ASF Header dir=nnvm
      
      * [HEADER] ASF Header -dir=tutorials
      
      * [HEADER] ASF Header dir=tests
      
      * [HEADER] ASF Header -dir=docker
      
      * fix whitespace
      
      * [HEADER] ASF Header -dir=jvm
      
      * [HEADER] ASF Header -dir=web
      
      * [HEADER] ASF Header --dir=apps
      
      * [HEADER] ASF Header --dir=vta
      
      * [HEADER] ASF Header -dir=go
      
      * temp
      
      * [HEADER] ASF Header --dir=rust
      
      * [HEADER] Add ASF Header --dir=cmake
      
      * [HEADER] ASF Header --dir=docs
      
      * [HEADER] Header for Jenkinsfile
      
      * [HEADER] ASF Header to toml and md
      
      * [HEADER] ASF Header to gradle
      
      * Finalize rat cleanup
      
      * Fix permission
      
      * Fix java test
      
      * temporary remove nnvm onnx test
      Tianqi Chen committed
  33. 19 Mar, 2019 1 commit
  34. 09 Mar, 2019 1 commit
  35. 06 Mar, 2019 1 commit
  36. 21 Feb, 2019 1 commit