[LANG] Include buffer semnatics, introduce pylint

Makefile

@@ -37,7 +37,7 @@ LIBHALIDEIR:
  + cd HalideIR; make lib/libHalideIR.a ; cd $(ROOTDIR)
 
 lint:
- python2 dmlc-core/scripts/lint.py tvm cpp include src
+ python2 dmlc-core/scripts/lint.py tvm all include src python
 
 doc:
  doxygen docs/Doxyfile

include/tvm/buffer.h

@@ -0,0 +1,98 @@
+
+/*!
+ * Copyright (c) 2016 by Contributors
+ * \file buffer.h
+ * \brief Symbolic n-dimensional array, to represent a memory buffer.
+ */
+#ifndef TVM_BUFFER_H_
+#define TVM_BUFFER_H_
+
+#include <tvm/container.h>
+#include <string>
+
+#include "./base.h"
+#include "./expr.h"
+
+namespace tvm {
+
+// Internal node container Buffer
+class BufferNode;
+/*!
+ * \brief Buffer is a symbolic n-darray structure.
+ * It is a composition of primitive symbolic types,
+ * used to specify input/output strcuture of the program.
+ */
+class Buffer : public NodeRef {
+ public:
+ Buffer() {}
+ explicit Buffer(std::shared_ptr<Node> n) : NodeRef(n) {}
+ /*!
+ * \brief construct a new buffer based on shape and strides.
+ */
+ explicit Buffer(Array<Expr> shape,
+ Type dtype = Float(32),
+ std::string name = "buffer");
+ /*!
+ * \brief Generate a load expression loading the index location of buffer.
+ * \param index The index to the buffer.
+ * \return The load expression.
+ */
+ Expr MakeLoad(Array<Expr> index) const;
+ /*!
+ * \brief Generate a store statement.
+ * \param index The index to the buffer.
+ * \param value The value to be stored.
+ * \return The load expression.
+ */
+ Stmt MakeStore(Array<Expr> index, Expr value) const;
+ /*!
+ * \brief access the internal node container
+ * \return the pointer to the internal node container
+ */
+ inline const BufferNode* operator->() const;
+};
+
+/*! \brief Node to represent a buffer */
+class BufferNode : public Node {
+ public:
+ /*! \brief optional name of the buffer */
+ std::string name;
+ /*! \brief The pointer to the head of the data */
+ Var ptr;
+ /*! \brief The shape of the buffer */
+ Array<Expr> shape;
+ /*!
+ * \brief The strides of each dimension
+ * This can be an empty array, indicating array is contiguous
+ */
+ Array<Expr> strides;
+ /*! \brief data type in the content of the tensor */
+ Type dtype;
+ // Maybe need more information(alignment) later
+ /*! \brief constructor */
+ BufferNode() {}
+
+ void VisitAttrs(AttrVisitor* v) final {
+ v->Visit("name", &name);
+ v->Visit("ptr", &ptr);
+ v->Visit("shape", &shape);
+ v->Visit("strides", &strides);
+ v->Visit("dtype", &dtype);
+ }
+
+ static Buffer make(std::string name,
+ Var ptr,
+ Array<Expr> shape,
+ Array<Expr> strides,
+ Type dtype);
+
+ static constexpr const char* _type_key = "Buffer";
+ TVM_DECLARE_NODE_TYPE_INFO(BufferNode);
+};
+
+inline const BufferNode* Buffer::operator->() const {
+ return static_cast<const BufferNode*>(node_.get());
+}
+
+} // namespace tvm
+#endif // TVM_BUFFER_H_

include/tvm/ir_pass.h

@@ -13,6 +13,7 @@
 #include <unordered_map>
 #include <vector>
 #include "./expr.h"
+#include "./buffer.h"
 #include "./schedule.h"
 
 namespace tvm {
@@ -56,10 +57,22 @@ Stmt ConvertSSA(Stmt stmt);
  *
  * \note All the passes in this file uses SSA form and outputs SSA form.
  */
-Stmt Inline(FunctionRef f,
+Stmt Inline(Stmt stmt,
+ FunctionRef f,
  Array<Var> args,
- Expr body,
- Stmt stmt);
+ Expr body);
+
+
+/*!
+ * \brief Flatten the multi-dimensional read/write
+ * to single dimensional Load/Store
+ *
+ * \param stmt The stmt to be trasnformed.
+ * \param extern_buffer Map specifies external
+ * buffer assignment of input and outputs.
+ */
+Stmt StorageFlatten(Stmt stmt,
+ Map<Tensor, Buffer> extern_buffer);
 
 } // namespace ir
 } // namespace tvm

python/tvm/__init__.py

@@ -1,3 +1,4 @@
+# pylint: disable=redefined-builtin, wildcard-import
 """C++ backend related python scripts"""
 from __future__ import absolute_import as _abs
 from ._ctypes._api import register_node

python/tvm/_base.py

@@ -1,10 +1,9 @@
 # coding: utf-8
-# pylint: disable=invalid-name
+# pylint: disable=invalid-name, no-member
 """ ctypes library of nnvm and helper functions """
 from __future__ import absolute_import
 
 import sys
-import os
 import ctypes
 import numpy as np
 from . import libinfo

python/tvm/_ctypes/_api.py

@@ -1,5 +1,6 @@
 # coding: utf-8
 # pylint: disable=invalid-name, protected-access, too-many-arguments, too-many-lines
+# pylint: disable=attribute-defined-outside-init, no-member, missing-docstring
 """Symbolic configuration API."""
 from __future__ import absolute_import as _abs
 
@@ -14,6 +15,7 @@
 from .. import _function_internal
 
 class ArgVariant(ctypes.Union):
+ """ArgVariant in C API"""
  _fields_ = [("v_long", ctypes.c_long),
  ("v_double", ctypes.c_double),
  ("v_str", ctypes.c_char_p),
@@ -30,8 +32,8 @@ class ArgVariant(ctypes.Union):
 
 def _return_node(x):
  handle = x.v_handle
- if not isinstance(handle, ctypes.c_void_p):
- handle = ctypes.c_void_p(handle)
+ if not isinstance(handle, NodeHandle):
+ handle = NodeHandle(handle)
  ret_val = ArgVariant()
  ret_typeid = ctypes.c_int()
  ret_success = ctypes.c_int()
@@ -47,7 +49,7 @@ def _return_node(x):
  kLong: lambda x: x.v_long,
  kDouble: lambda x: x.v_double,
  kStr: lambda x: py_str(x.v_str),
- kNodeHandle: lambda x: _return_node(x)
+ kNodeHandle: _return_node
 }
 
 class SliceBase(object):
@@ -251,6 +253,7 @@ def register_node(type_key=None):
  """
  if isinstance(type_key, str):
  def register(cls):
+ """internal register function"""
  NODE_TYPE[type_key] = cls
  return cls
  return register
@@ -273,9 +276,9 @@ def _init_function_module(root_namespace):
  module_obj = sys.modules["%s.function" % root_namespace]
  module_internal = sys.modules["%s._function_internal" % root_namespace]
  namespace_match = {
- "_make_" : sys.modules["%s.make" % root_namespace],
- "_pass_" : sys.modules["%s.ir_pass" % root_namespace],
- "_schedule_" : sys.modules["%s.schedule" % root_namespace]
+ "_make_": sys.modules["%s.make" % root_namespace],
+ "_pass_": sys.modules["%s.ir_pass" % root_namespace],
+ "_schedule_": sys.modules["%s.schedule" % root_namespace]
  }
 
  for name in op_names:

python/tvm/collections.py

@@ -1,3 +1,4 @@
+# pylint: disable=protected-access, no-member
 """Collection structure in the high level DSL."""
 from __future__ import absolute_import as _abs
 from ._ctypes._api import NodeBase, register_node
@@ -6,6 +7,7 @@
 
 @register_node
 class Array(NodeBase):
+ """Array container of TVM"""
  def __getitem__(self, i):
  if i >= len(self):
  raise IndexError("array index out ot range")
@@ -19,13 +21,15 @@ def __repr__(self):
 
 @register_node
 class Map(NodeBase):
+ """Map container of TVM"""
  def __getitem__(self, k):
  return _function_internal._MapGetItem(self, k)
 
  def __contains__(self, k):
  return _function_internal._MapCount(self, k) != 0
 
  def items(self):
+ """Get the items from the map"""
  akvs = _function_internal._MapItems(self)
  return [(akvs[i], akvs[i+1]) for i in range(0, len(akvs), 2)]
 
@@ -38,9 +42,17 @@ def __repr__(self):
 
 @register_node
 class Range(NodeBase):
+ """Represent range in TVM"""
  pass
 
 
 @register_node
 class IterVar(NodeBase, _expr.ExprOp):
+ """Represent iteration variable."""
+ pass
+
+
+@register_node
+class Buffer(NodeBase):
+ """Represent a Buffer in TVM."""
  pass

python/tvm/expr.py

@@ -1,3 +1,4 @@
+# pylint: disable=protected-access, no-member, missing-docstring
 from __future__ import absolute_import as _abs
 from ._ctypes._api import NodeBase, register_node
 from . import make as _make
@@ -174,7 +175,7 @@ class Call(Expr):
  Halide = 3
  Intrinsic = 4
  PureIntrinsic = 5
- pass
+
 
 @register_node
 class Let(Expr):

python/tvm/function.py

@@ -1,5 +1,8 @@
+# pylint: disable=protected-access, no-member, invalid-name
+# pylint: disable=redefined-builtin, undefined-variable
+"""Functions defined in TVM."""
 from __future__ import absolute_import as _abs
-from numbers import Number as _Number, Integral as _Integral
+from numbers import Integral as _Integral
 from ._ctypes._api import _init_function_module, convert
 from . import _function_internal
 from . import make as _make
@@ -8,6 +11,7 @@
 
 int32 = "int32"
 float32 = "float32"
+handle = "handle"
 
 def const(value, dtype=None):
  """construct a constant"""
@@ -65,7 +69,7 @@ def Var(name="tindex", dtype=int32):
  return _function_internal._Var(name, dtype)
 
 
-def placeholder(shape, dtype = None, name="placeholder"):
+def placeholder(shape, dtype=None, name="placeholder"):
  """Construct an empty tensor object.
 
  Parameters
@@ -84,6 +88,7 @@ def placeholder(shape, dtype = None, name="placeholder"):
  tensor: tensor.Tensor
  The created tensor
  """
+ shape = (shape,) if isinstance(shape, _expr.Expr) else shape
  dtype = float32 if dtype is None else dtype
  return _function_internal._Placeholder(
  shape, dtype, name)
@@ -111,8 +116,7 @@ def compute(shape, fcompute, name="compute"):
  tensor: tensor.Tensor
  The created tensor
  """
- if isinstance(shape, _expr.Expr):
- shape = (shape, )
+ shape = (shape,) if isinstance(shape, _expr.Expr) else shape
 
  ndim = len(shape)
  arg_names = fcompute.__code__.co_varnames
@@ -125,7 +129,44 @@ def compute(shape, fcompute, name="compute"):
  op_node = _function_internal._ComputeOp(
  name, dim_var, body)
  return _function_internal._Tensor(
- shape, name, body.dtype, op_node, 0)
+ shape, body.dtype, op_node, 0)
+
+
+def Buffer(shape, dtype=None,
+ name="buffer", ptr=None,
+ strides=None):
+ """Create a new buffer
+
+ Parameters
+ ----------
+ shape : tuple of Expr
+ The shape of the buffer.
+
+ dtype : str, optional
+ The data type of the buffer.
+
+ name : str, optional
+ The name of the buffer.
+
+ ptr : Var, optional
+ The data pointer in the buffer.
+
+ strides: array of Expr
+ The stride of the buffer.
+
+ Returns
+ -------
+ buffer : Buffer
+ The created buffer
+ """
+ shape = (shape,) if isinstance(shape, _expr.Expr) else shape
+ dtype = float32 if dtype is None else dtype
+ strides = () if strides is None else strides
+ if ptr is None:
+ ptr = Var(name, "handle")
+
+ return _function_internal._Buffer(
+ name, ptr, shape, strides, dtype)
 
 
 def IterVar(dom, name='iter', thread_tag=''):
@@ -170,7 +211,7 @@ def sum(expr, rdom):
  The reduction domainx
  """
  rdom = rdom if isinstance(rdom, list) else [rdom]
- x =  _make.Reduce("Add", expr, rdom)
+ x = _make.Reduce("Add", expr, rdom)
  return x
 
 
@@ -186,7 +227,7 @@ def min(expr, rdom):
  The reduction domainx
  """
  rdom = rdom if isinstance(rdom, list) else [rdom]
- x =  _make.Reduce("Min", expr, rdom)
+ x = _make.Reduce("Min", expr, rdom)
  return x
 
 
@@ -202,7 +243,7 @@ def max(expr, rdom):
  The reduction domainx
  """
  rdom = rdom if isinstance(rdom, list) else [rdom]
- x =  _make.Reduce("Max", expr, rdom)
+ x = _make.Reduce("Max", expr, rdom)
  return x