tech.compute.tvm — tvm-clj 4.3

->module clj

(->module driver
          sched-data-seq
          &
          {:keys [build-config target-host]
           :or {build-config tvm-api/default-build-config target-host :llvm}
           :as opts})

Given a sequence of schedule-data, return a map of name to clojure callable function. A module is created and added to the resource context transparently. Schedule data: {:name :fn-name :arglist arguments :schedule schedule :bind-map (optional) bind-map } returns: {:module module :fn-map map of name->IFn (clojure callable function.)

as-cpu-tensor clj

(as-cpu-tensor data & {:keys [shape datatype]})

call-function clj

(call-function stream fn & args)

Call a tvm function on this stream with these arguments.

cpu? clj

(cpu? item)

device clj

(device device-type & [device-id])

device-id clj

(device-id item)

Generically get the tvm device id from a thing.

device-id->device clj

(device-id->device driver device-id)

device-type clj

(device-type item)

Generically get the tvm device type from a thing

driver clj

(driver device-type)

enable-cpu-driver! clj

(enable-cpu-driver!)

enable-gpu-drivers! clj

(enable-gpu-drivers!)

enable-tensor-math! clj

(enable-tensor-math!)

enumerate-device-ids clj

(enumerate-device-ids device-type)

gpu-scheduling? clj

(gpu-scheduling? item)

has-byte-offset? clj

(has-byte-offset? buffer)

Used for code generation, because some tvm driver buffer types do not support pointer offsetting, you pass in a pointer + byte offset when doing' code generation.

make-cpu-device-buffer clj

(make-cpu-device-buffer datatype elem-count)

Make a cpu device buffer. These are used as host buffers for all devices and device buffers for the cpu device.

scalar-datatype->device-datatype clj

(scalar-datatype->device-datatype driver scalar-datatype)

schedule->fn clj

(schedule->fn driver
              {:keys [schedule name arglist bind-map] :as schedule-data}
              &
              args)

schedule-injective! clj

(schedule-injective! driver schedule compute-op-or-vec options)

A large class of functions are injective, meaning that they are result-element by result-element parallelizeable. Thus fusing all axis and then running things in parallel works at least passably well.