Skip to content

GitLab

Commit 83aa9ac3 authored by Paul's avatar Paul
Browse files

Enforce correct naming

parent 81778d3d
Show whitespace changes
Inline Side-by-side
Showing with 173 additions and 163 deletions
.clang-tidy
View file @ 83aa9ac3
......@@ -11,91 +11,93 @@ CheckOptions:
value: '10'
- key: readability-function-size.StatementThreshold
value: '150'
- key: readability-identifier-naming.Namespace
- key: readability-identifier-naming.NamespaceCase
value: lower_case
- key: readability-identifier-naming.InlineNamespace
- key: readability-identifier-naming.InlineNamespaceCase
value: lower_case
- key: readability-identifier-naming.EnumConstant
- key: readability-identifier-naming.EnumConstantCase
value: lower_case
- key: readability-identifier-naming.ConstexprVariable
- key: readability-identifier-naming.ConstexprVariableCase
value: lower_case
- key: readability-identifier-naming.ConstantMember
- key: readability-identifier-naming.ConstantMemberCase
value: lower_case
- key: readability-identifier-naming.PrivateMember
- key: readability-identifier-naming.PrivateMemberCase
value: lower_case
- key: readability-identifier-naming.ProtectedMember
- key: readability-identifier-naming.ProtectedMemberCase
value: lower_case
- key: readability-identifier-naming.PublicMember
- key: readability-identifier-naming.PublicMemberCase
value: lower_case
- key: readability-identifier-naming.Member
- key: readability-identifier-naming.MemberCase
value: lower_case
- key: readability-identifier-naming.ClassConstant
- key: readability-identifier-naming.ClassConstantCase
value: lower_case
- key: readability-identifier-naming.ClassMember
- key: readability-identifier-naming.ClassMemberCase
value: lower_case
- key: readability-identifier-naming.GlobalConstant
- key: readability-identifier-naming.GlobalConstantCase
value: lower_case
- key: readability-identifier-naming.GlobalVariable
- key: readability-identifier-naming.GlobalVariableCase
value: lower_case
- key: readability-identifier-naming.LocalConstant
- key: readability-identifier-naming.LocalConstantCase
value: lower_case
- key: readability-identifier-naming.LocalVariable
- key: readability-identifier-naming.LocalVariableCase
value: lower_case
- key: readability-identifier-naming.StaticConstant
- key: readability-identifier-naming.StaticConstantCase
value: lower_case
- key: readability-identifier-naming.StaticVariable
- key: readability-identifier-naming.StaticVariableCase
value: lower_case
- key: readability-identifier-naming.Constant
- key: readability-identifier-naming.ConstantCase
value: lower_case
- key: readability-identifier-naming.Variable
- key: readability-identifier-naming.VariableCase
value: lower_case
- key: readability-identifier-naming.ConstantParameter
- key: readability-identifier-naming.ConstantParameterCase
value: lower_case
- key: readability-identifier-naming.ParameterPack
- key: readability-identifier-naming.ParameterPackCase
value: lower_case
- key: readability-identifier-naming.Parameter
- key: readability-identifier-naming.ParameterCase
value: lower_case
- key: readability-identifier-naming.AbstractClass
- key: readability-identifier-naming.AbstractClassCase
value: lower_case
- key: readability-identifier-naming.Struct
- key: readability-identifier-naming.StructCase
value: lower_case
- key: readability-identifier-naming.Class
- key: readability-identifier-naming.ClassCase
value: lower_case
- key: readability-identifier-naming.Union
- key: readability-identifier-naming.UnionCase
value: lower_case
- key: readability-identifier-naming.Enum
- key: readability-identifier-naming.EnumCase
value: lower_case
- key: readability-identifier-naming.GlobalFunction
- key: readability-identifier-naming.GlobalFunctionCase
value: lower_case
- key: readability-identifier-naming.ConstexprFunction
- key: readability-identifier-naming.ConstexprFunctionCase
value: lower_case
- key: readability-identifier-naming.Function
- key: readability-identifier-naming.FunctionCase
value: lower_case
- key: readability-identifier-naming.ConstexprMethod
- key: readability-identifier-naming.ConstexprMethodCase
value: lower_case
- key: readability-identifier-naming.VirtualMethod
- key: readability-identifier-naming.VirtualMethodCase
value: lower_case
- key: readability-identifier-naming.ClassMethod
- key: readability-identifier-naming.ClassMethodCase
value: lower_case
- key: readability-identifier-naming.PrivateMethod
- key: readability-identifier-naming.PrivateMethodCase
value: lower_case
- key: readability-identifier-naming.ProtectedMethod
- key: readability-identifier-naming.ProtectedMethodCase
value: lower_case
- key: readability-identifier-naming.PublicMethod
- key: readability-identifier-naming.PublicMethodCase
value: lower_case
- key: readability-identifier-naming.Method
- key: readability-identifier-naming.MethodCase
value: lower_case
- key: readability-identifier-naming.Typedef
- key: readability-identifier-naming.TypedefCase
value: lower_case
- key: readability-identifier-naming.TypeTemplateParameter
value: lower_case
- key: readability-identifier-naming.ValueTemplateParameter
value: lower_case
- key: readability-identifier-naming.TemplateTemplateParameter
value: lower_case
- key: readability-identifier-naming.TemplateParameter
value: lower_case
- key: readability-identifier-naming.TypeAlias
value: lower_case
- key: readability-identifier-naming.MacroDefinition
- key: readability-identifier-naming.TypeTemplateParameterCase
value: CamelCase
- key: readability-identifier-naming.ValueTemplateParameterCase
value: CamelCase
- key: readability-identifier-naming.TemplateTemplateParameterCase
value: CamelCase
- key: readability-identifier-naming.TemplateParameterCase
value: CamelCase
- key: readability-identifier-naming.TypeAliasCase
value: lower_case
# - key: readability-identifier-naming.MacroDefinitionCase
# value: UPPER_CASE
# - key: readability-identifier-naming.MacroDefinitionPrefix
# value: RTG_
include/rtg/argument.hpp
View file @ 83aa9ac3
......@@ -11,16 +11,16 @@ struct argument : raw_data<argument>
{
argument() {}
argument(shape s, std::function<char*()> d) : data(d), shape_(s) {}
argument(shape s, std::function<char*()> d) : data(d), m_shape(s) {}
std::function<char*()> data;
bool empty() const { return not data; }
const shape& get_shape() const { return this->shape_; }
const shape& get_shape() const { return this->m_shape; }
private:
shape shape_;
shape m_shape;
};
} // namespace rtg
......
include/rtg/literal.hpp
View file @ 83aa9ac3
......@@ -13,14 +13,14 @@ struct literal : raw_data<literal>
literal() {}
template <class T>
literal(T x) : buffer(sizeof(T), 0), shape_(shape::get_type<T>{})
literal(T x) : buffer(sizeof(T), 0), m_shape(shape::get_type<T>{})
{
static_assert(std::is_trivial<T>{}, "Literals can only be trivial types");
*(reinterpret_cast<T*>(buffer.data())) = x;
}
template <class T>
literal(shape s, const std::vector<T>& x) : buffer(s.bytes(), 0), shape_(s)
literal(shape s, const std::vector<T>& x) : buffer(s.bytes(), 0), m_shape(s)
{
assert(s.packed());
static_assert(std::is_trivial<T>{}, "Literals can only be trivial types");
......@@ -28,7 +28,7 @@ struct literal : raw_data<literal>
}
template <class T>
literal(shape s, const std::initializer_list<T>& x) : buffer(s.bytes(), 0), shape_(s)
literal(shape s, const std::initializer_list<T>& x) : buffer(s.bytes(), 0), m_shape(s)
{
assert(s.packed());
static_assert(std::is_trivial<T>{}, "Literals can only be trivial types");
......@@ -36,29 +36,29 @@ struct literal : raw_data<literal>
}
template <class Iterator>
literal(shape s, Iterator start, Iterator end) : buffer(s.bytes(), 0), shape_(s)
literal(shape s, Iterator start, Iterator end) : buffer(s.bytes(), 0), m_shape(s)
{
assert(s.packed());
s.visit_type([&](auto as) { std::copy(start, end, as.from(buffer.data())); });
}
literal(shape s, const char* x) : buffer(x, x + s.bytes()), shape_(s) {}
literal(shape s, const char* x) : buffer(x, x + s.bytes()), m_shape(s) {}
bool empty() const { return this->buffer.empty(); }
const char* data() const { return this->buffer.data(); }
const shape& get_shape() const { return this->shape_; }
const shape& get_shape() const { return this->m_shape; }
argument get_argument() const
{
auto b = buffer;
return {shape_, [b]() mutable { return b.data(); }};
return {m_shape, [b]() mutable { return b.data(); }};
}
private:
std::vector<char> buffer;
shape shape_;
shape m_shape;
};
} // namespace rtg
......
include/rtg/operand.hpp
View file @ 83aa9ac3
......@@ -28,112 +28,120 @@ struct operand
// Constructors
operand() = default;
template <typename TypeErased_T_>
operand(TypeErased_T_ value)
: handle_mem_var_(
std::make_shared<handle_type_<typename std::remove_reference<TypeErased_T_>::type>>(
std::forward<TypeErased_T_>(value)))
template <typename PrivateDetailTypeErasedT>
operand(PrivateDetailTypeErasedT value)
: private_detail_te_handle_mem_var(
std::make_shared<private_detail_te_handle_type<
typename std::remove_reference<PrivateDetailTypeErasedT>::type>>(
std::forward<PrivateDetailTypeErasedT>(value)))
{
}
// Assignment
template <typename TypeErased_T_>
operand& operator=(TypeErased_T_ value)
template <typename PrivateDetailTypeErasedT>
operand& operator=(PrivateDetailTypeErasedT value)
{
if(handle_mem_var_.unique())
*handle_mem_var_ = std::forward<TypeErased_T_>(value);
else if(!handle_mem_var_)
handle_mem_var_ = std::make_shared<TypeErased_T_>(std::forward<TypeErased_T_>(value));
if(private_detail_te_handle_mem_var.unique())
*private_detail_te_handle_mem_var = std::forward<PrivateDetailTypeErasedT>(value);
else if(!private_detail_te_handle_mem_var)
private_detail_te_handle_mem_var = std::make_shared<PrivateDetailTypeErasedT>(
std::forward<PrivateDetailTypeErasedT>(value));
return *this;
}
std::string name() const
{
assert(handle_mem_var_);
return get_handle_().name();
assert(private_detail_te_handle_mem_var);
return private_detail_te_get_handle().name();
}
shape compute_shape(std::vector<shape> input) const
{
assert(handle_mem_var_);
return get_handle_().compute_shape(std::move(input));
assert(private_detail_te_handle_mem_var);
return private_detail_te_get_handle().compute_shape(std::move(input));
}
argument compute(std::vector<argument> input) const
{
assert(handle_mem_var_);
return get_handle_().compute(std::move(input));
assert(private_detail_te_handle_mem_var);
return private_detail_te_get_handle().compute(std::move(input));
}
private:
struct handle_base_type_
struct private_detail_te_handle_base_type
{
virtual ~handle_base_type_() {}
virtual std::shared_ptr<handle_base_type_> clone() const = 0;
virtual ~private_detail_te_handle_base_type() {}
virtual std::shared_ptr<private_detail_te_handle_base_type> clone() const = 0;
virtual std::string name() const = 0;
virtual shape compute_shape(std::vector<shape> input) const = 0;
virtual argument compute(std::vector<argument> input) const = 0;
};
template <typename TypeErased_T_>
struct handle_type_ : handle_base_type_
template <typename PrivateDetailTypeErasedT>
struct private_detail_te_handle_type : private_detail_te_handle_base_type
{
template <typename TypeErased_U_ = TypeErased_T_>
handle_type_(
TypeErased_T_ value,
typename std::enable_if<std::is_reference<TypeErased_U_>::value>::type* = nullptr)
: value_(value)
template <typename PrivateDetailTypeErasedU = PrivateDetailTypeErasedT>
private_detail_te_handle_type(
PrivateDetailTypeErasedT value,
typename std::enable_if<std::is_reference<PrivateDetailTypeErasedU>::value>::type* =
nullptr)
: private_detail_te_value(value)
{
}
template <typename TypeErased_U_ = TypeErased_T_>
handle_type_(TypeErased_T_ value,
typename std::enable_if<!std::is_reference<TypeErased_U_>::value, int>::type* =
nullptr) noexcept
: value_(std::move(value))
template <typename PrivateDetailTypeErasedU = PrivateDetailTypeErasedT>
private_detail_te_handle_type(
PrivateDetailTypeErasedT value,
typename std::enable_if<!std::is_reference<PrivateDetailTypeErasedU>::value,
int>::type* = nullptr) noexcept
: private_detail_te_value(std::move(value))
{
}
std::shared_ptr<handle_base_type_> clone() const override
std::shared_ptr<private_detail_te_handle_base_type> clone() const override
{
return std::make_shared<handle_type_>(value_);
return std::make_shared<private_detail_te_handle_type>(private_detail_te_value);
}
std::string name() const override { return value_.name(); }
std::string name() const override { return private_detail_te_value.name(); }
shape compute_shape(std::vector<shape> input) const override
{
return value_.compute_shape(std::move(input));
return private_detail_te_value.compute_shape(std::move(input));
}
argument compute(std::vector<argument> input) const override
{
return value_.compute(std::move(input));
return private_detail_te_value.compute(std::move(input));
}
TypeErased_T_ value_;
PrivateDetailTypeErasedT private_detail_te_value;
};
template <typename TypeErased_T_>
struct handle_type_<std::reference_wrapper<TypeErased_T_>> : handle_type_<TypeErased_T_&>
template <typename PrivateDetailTypeErasedT>
struct private_detail_te_handle_type<std::reference_wrapper<PrivateDetailTypeErasedT>>
: private_detail_te_handle_type<PrivateDetailTypeErasedT&>
{
handle_type_(std::reference_wrapper<TypeErased_T_> ref)
: handle_type_<TypeErased_T_&>(ref.get())
private_detail_te_handle_type(std::reference_wrapper<PrivateDetailTypeErasedT> ref)
: private_detail_te_handle_type<PrivateDetailTypeErasedT&>(ref.get())
{
}
};
const handle_base_type_& get_handle_() const { return *handle_mem_var_; }
const private_detail_te_handle_base_type& private_detail_te_get_handle() const
{
return *private_detail_te_handle_mem_var;
}
handle_base_type_& get_handle_()
private_detail_te_handle_base_type& private_detail_te_get_handle()
{
if(!handle_mem_var_.unique())
handle_mem_var_ = handle_mem_var_->clone();
return *handle_mem_var_;
if(!private_detail_te_handle_mem_var.unique())
private_detail_te_handle_mem_var = private_detail_te_handle_mem_var->clone();
return *private_detail_te_handle_mem_var;
}
std::shared_ptr<handle_base_type_> handle_mem_var_;
std::shared_ptr<private_detail_te_handle_base_type> private_detail_te_handle_mem_var;
};
} // namespace rtg
......
include/rtg/shape.hpp
View file @ 83aa9ac3
......@@ -110,7 +110,7 @@ struct shape
template <class Visitor>
void visit_type(Visitor v) const
{
switch(this->type_)
switch(this->m_type)
{
#define RTG_SHAPE_VISITOR_CASE(x, t) \
case x: v(as<t>()); return;
......@@ -121,10 +121,10 @@ struct shape
}
private:
type_t type_;
std::vector<std::size_t> lens_;
std::vector<std::size_t> strides_;
bool packed_;
type_t m_type;
std::vector<std::size_t> m_lens;
std::vector<std::size_t> m_strides;
bool m_packed;
void calculate_strides();
std::size_t element_space() const;
......
include/rtg/tensor_view.hpp
View file @ 83aa9ac3
......@@ -11,103 +11,103 @@ namespace rtg {
template <class T>
struct tensor_view
{
tensor_view() : data_(nullptr) {}
tensor_view(shape s, T* d) : data_(d), shape_(s) {}
tensor_view() : m_data(nullptr) {}
tensor_view(shape s, T* d) : m_data(d), m_shape(s) {}
const shape& get_shape() const { return this->shape_; }
const shape& get_shape() const { return this->m_shape; }
bool empty() const { return data_ == nullptr || shape_.lens().empty(); }
bool empty() const { return m_data == nullptr || m_shape.lens().empty(); }
std::size_t size() const { return shape_.elements(); }
std::size_t size() const { return m_shape.elements(); }
T* data() { return this->data_; }
T* data() { return this->m_data; }
const T* data() const { return this->data_; }
const T* data() const { return this->m_data; }
template <class... Ts>
const T& operator()(Ts... xs) const
{
return data_[shape_.index({xs...})];
return m_data[m_shape.index({xs...})];
}
template <class... Ts>
T& operator()(Ts... xs)
{
return data_[shape_.index({xs...})];
return m_data[m_shape.index({xs...})];
}
T& operator[](std::size_t i)
{
assert(!this->empty() && i < this->size());
return data_[shape_.index(i)];
return m_data[m_shape.index(i)];
}
const T& operator[](std::size_t i) const
{
assert(!this->empty() && i < this->size());
return data_[shape_.index(i)];
return m_data[m_shape.index(i)];
}
T& front()
{
assert(!this->empty());
return data_[0];
return m_data[0];
}
const T& front() const
{
assert(!this->empty());
return data_[0];
return m_data[0];
}
T& back()
{
assert(!this->empty());
return data_[shape_.index(this->size() - 1)];
return m_data[m_shape.index(this->size() - 1)];
}
const T& back() const
{
assert(!this->empty());
return data_[shape_.index(this->size() - 1)];
return m_data[m_shape.index(this->size() - 1)];
}
// TODO: Add iterators so it can handle nonpacked tensors
T* begin()
{
assert(this->shape_.packed());
return data_;
assert(this->m_shape.packed());
return m_data;
}
T* end()
{
assert(this->shape_.packed());
assert(this->m_shape.packed());
if(this->empty())
return data_;
return m_data;
else
return data_ + this->size();
return m_data + this->size();
}
const T* begin() const
{
assert(this->shape_.packed());
return data_;
assert(this->m_shape.packed());
return m_data;
}
const T* end() const
{
assert(this->shape_.packed());
assert(this->m_shape.packed());
if(this->empty())
return data_;
return m_data;
else
return data_ + this->size();
return m_data + this->size();
}
friend bool operator==(const tensor_view<T>& x, const tensor_view<T>& y)
{
if(x.shape_ == y.shape_)
if(x.m_shape == y.m_shape)
{
for(std::size_t i = 0; i < x.shape_.elements(); i++)
for(std::size_t i = 0; i < x.m_shape.elements(); i++)
{
if(!float_equal(x[i], y[i]))
return false;
......@@ -124,17 +124,17 @@ struct tensor_view
if(!x.empty())
{
os << x.front();
for(std::size_t i = 1; i < x.shape_.elements(); i++)
for(std::size_t i = 1; i < x.m_shape.elements(); i++)
{
os << ", " << x.data_[x.shape_.index(i)];
os << ", " << x.m_data[x.m_shape.index(i)];
}
}
return os;
}
private:
T* data_;
shape shape_;
T* m_data;
shape m_shape;
};
template <class T>
......
src/shape.cpp
View file @ 83aa9ac3
......@@ -7,35 +7,35 @@
namespace rtg {
shape::shape() : type_(float_type), packed_(false) {}
shape::shape() : m_type(float_type), m_packed(false) {}
shape::shape(type_t t) : type_(t), lens_({1}), strides_({1}), packed_(true) {}
shape::shape(type_t t, std::vector<std::size_t> l) : type_(t), lens_(std::move(l)), packed_(true)
shape::shape(type_t t) : m_type(t), m_lens({1}), m_strides({1}), m_packed(true) {}
shape::shape(type_t t, std::vector<std::size_t> l) : m_type(t), m_lens(std::move(l)), m_packed(true)
{
this->calculate_strides();
assert(lens_.size() == strides_.size());
assert(m_lens.size() == m_strides.size());
}
shape::shape(type_t t, std::vector<std::size_t> l, std::vector<std::size_t> s)
: type_(t), lens_(std::move(l)), strides_(std::move(s))
: m_type(t), m_lens(std::move(l)), m_strides(std::move(s))
{
assert(lens_.size() == strides_.size());
packed_ = this->elements() == this->element_space();
assert(m_lens.size() == m_strides.size());
m_packed = this->elements() == this->element_space();
}
void shape::calculate_strides()
{
strides_.clear();
strides_.resize(lens_.size(), 0);
if(strides_.empty())
m_strides.clear();
m_strides.resize(m_lens.size(), 0);
if(m_strides.empty())
return;
strides_.back() = 1;
m_strides.back() = 1;
std::partial_sum(
lens_.rbegin(), lens_.rend() - 1, strides_.rbegin() + 1, std::multiplies<std::size_t>());
m_lens.rbegin(), m_lens.rend() - 1, m_strides.rbegin() + 1, std::multiplies<std::size_t>());
}
shape::type_t shape::type() const { return this->type_; }
const std::vector<std::size_t>& shape::lens() const { return this->lens_; }
const std::vector<std::size_t>& shape::strides() const { return this->strides_; }
shape::type_t shape::type() const { return this->m_type; }
const std::vector<std::size_t>& shape::lens() const { return this->m_lens; }
const std::vector<std::size_t>& shape::strides() const { return this->m_strides; }
std::size_t shape::elements() const
{
assert(this->lens().size() == this->strides().size());
......@@ -71,7 +71,7 @@ std::size_t shape::index(std::size_t i) const
std::plus<std::size_t>{},
[&](std::size_t len, std::size_t stride) { return ((i / stride) % len) * stride; });
}
bool shape::packed() const { return this->packed_; }
bool shape::packed() const { return this->m_packed; }
std::size_t shape::element_space() const
{
// TODO: Get rid of intermediate vector
......@@ -89,7 +89,7 @@ std::size_t shape::element_space() const
std::string shape::type_string() const
{
switch(this->type_)
switch(this->m_type)
{
#define RTG_SHAPE_TYPE_STRING_CASE(x, t) \
case x: return #x;
......
test/test.hpp
View file @ 83aa9ac3
......@@ -4,8 +4,8 @@
#include <cstdlib>
#include <iostream>
#ifndef GUARD_TEST_TEST_HPP_
#define GUARD_TEST_TEST_HPP_
#ifndef GUARD_TEST_TEST_HPP
#define GUARD_TEST_TEST_HPP
inline void failed(const char* msg, const char* file, int line)
{
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment