diff options
author | Henning Baldersheim <balder@yahoo-inc.com> | 2017-04-03 22:46:03 +0200 |
---|---|---|
committer | Henning Baldersheim <balder@yahoo-inc.com> | 2017-04-04 16:36:18 +0200 |
commit | 37cfa9ab6b103ae733a783cde18c8384e0ace507 (patch) | |
tree | 99b4ec1964a7a392b4aec133c4b20a4a40ab0002 /eval | |
parent | 5a48a81c4134bae524aa66e1e49624f678c8b6ce (diff) |
Override
Diffstat (limited to 'eval')
-rw-r--r-- | eval/src/vespa/eval/eval/basic_nodes.h | 80 | ||||
-rw-r--r-- | eval/src/vespa/eval/eval/call_nodes.h | 12 | ||||
-rw-r--r-- | eval/src/vespa/eval/eval/function.cpp | 8 | ||||
-rw-r--r-- | eval/src/vespa/eval/eval/interpreted_function.cpp | 116 | ||||
-rw-r--r-- | eval/src/vespa/eval/eval/key_gen.cpp | 118 | ||||
-rw-r--r-- | eval/src/vespa/eval/eval/llvm/llvm_wrapper.cpp | 116 | ||||
-rw-r--r-- | eval/src/vespa/eval/eval/node_types.cpp | 119 | ||||
-rw-r--r-- | eval/src/vespa/eval/eval/node_visitor.h | 112 | ||||
-rw-r--r-- | eval/src/vespa/eval/eval/operator_nodes.h | 16 | ||||
-rw-r--r-- | eval/src/vespa/eval/eval/test/tensor_conformance.cpp | 2 | ||||
-rw-r--r-- | eval/src/vespa/eval/eval/value.h | 6 |
11 files changed, 350 insertions, 355 deletions
diff --git a/eval/src/vespa/eval/eval/basic_nodes.h b/eval/src/vespa/eval/eval/basic_nodes.h index 2887856a66d..f7bd5af3307 100644 --- a/eval/src/vespa/eval/eval/basic_nodes.h +++ b/eval/src/vespa/eval/eval/basic_nodes.h @@ -109,10 +109,10 @@ public: virtual bool is_const() const override { return true; } virtual double get_const_value() const override { return value(); } double value() const { return _value; } - virtual vespalib::string dump(DumpContext &) const { + vespalib::string dump(DumpContext &) const override { return make_string("%g", _value); } - virtual void accept(NodeVisitor &visitor) const override; + void accept(NodeVisitor &visitor) const override; }; class Symbol : public Leaf { @@ -122,10 +122,10 @@ public: static const int UNDEF = std::numeric_limits<int>::max(); explicit Symbol(int id_in) : _id(id_in) {} int id() const { return _id; } - virtual bool is_param() const override { + bool is_param() const override { return (_id >= 0); } - virtual vespalib::string dump(DumpContext &ctx) const { + vespalib::string dump(DumpContext &ctx) const override { if (_id >= 0) { // param value assert(size_t(_id) < ctx.param_names.size()); return ctx.param_names[_id]; @@ -135,7 +135,7 @@ public: return ctx.let_names[let_offset]; } } - virtual void accept(NodeVisitor &visitor) const override; + void accept(NodeVisitor &visitor) const override; }; class String : public Leaf { @@ -143,12 +143,12 @@ private: vespalib::string _value; public: String(const vespalib::string &value_in) : _value(value_in) {} - virtual bool is_const() const override { return true; } - virtual double get_const_value() const override { return hash(); } + bool is_const() const override { return true; } + double get_const_value() const override { return hash(); } const vespalib::string value() const { return _value; } uint32_t hash() const { return hash_code(_value.data(), _value.size()); } - virtual vespalib::string dump(DumpContext &ctx) const; - virtual void accept(NodeVisitor &visitor) const override; + vespalib::string dump(DumpContext &ctx) const override; + void accept(NodeVisitor &visitor) const override; }; class Array : public Node { @@ -157,12 +157,12 @@ private: bool _is_const; public: Array() : _nodes(), _is_const(false) {} - virtual bool is_const() const override { return _is_const; } + bool is_const() const override { return _is_const; } size_t size() const { return _nodes.size(); } const Node &get(size_t i) const { return *_nodes[i]; } - virtual size_t num_children() const override { return size(); } - virtual const Node &get_child(size_t idx) const override { return get(idx); } - virtual void detach_children(NodeHandler &handler) override { + size_t num_children() const override { return size(); } + const Node &get_child(size_t idx) const override { return get(idx); } + void detach_children(NodeHandler &handler) override { for (size_t i = 0; i < _nodes.size(); ++i) { handler.handle(std::move(_nodes[i])); } @@ -176,7 +176,7 @@ public: } _nodes.push_back(std::move(node)); } - virtual vespalib::string dump(DumpContext &ctx) const { + vespalib::string dump(DumpContext &ctx) const override { vespalib::string str; str += "["; CommaTracker node_list; @@ -187,7 +187,7 @@ public: str += "]"; return str; } - virtual void accept(NodeVisitor &visitor) const override; + void accept(NodeVisitor &visitor) const override; }; class Neg : public Node { @@ -196,25 +196,25 @@ private: bool _is_const; public: Neg(Node_UP child_in) : _child(std::move(child_in)), _is_const(_child->is_const()) {} - virtual bool is_const() const override { return _is_const; } + bool is_const() const override { return _is_const; } const Node &child() const { return *_child; } - virtual size_t num_children() const override { return _child ? 1 : 0; } - virtual const Node &get_child(size_t idx) const override { + size_t num_children() const override { return _child ? 1 : 0; } + const Node &get_child(size_t idx) const override { (void) idx; assert(idx == 0); return child(); } - virtual void detach_children(NodeHandler &handler) override { + void detach_children(NodeHandler &handler) override { handler.handle(std::move(_child)); } - virtual vespalib::string dump(DumpContext &ctx) const { + vespalib::string dump(DumpContext &ctx) const override { vespalib::string str; str += "(-"; str += _child->dump(ctx); str += ")"; return str; } - virtual void accept(NodeVisitor &visitor) const override; + void accept(NodeVisitor &visitor) const override; }; class Not : public Node { @@ -223,25 +223,25 @@ private: bool _is_const; public: Not(Node_UP child_in) : _child(std::move(child_in)), _is_const(_child->is_const()) {} - virtual bool is_const() const override { return _is_const; } + bool is_const() const override { return _is_const; } const Node &child() const { return *_child; } - virtual size_t num_children() const override { return _child ? 1 : 0; } - virtual const Node &get_child(size_t idx) const override { + size_t num_children() const override { return _child ? 1 : 0; } + const Node &get_child(size_t idx) const override { (void) idx; assert(idx == 0); return child(); } - virtual void detach_children(NodeHandler &handler) override { + void detach_children(NodeHandler &handler) override { handler.handle(std::move(_child)); } - virtual vespalib::string dump(DumpContext &ctx) const { + vespalib::string dump(DumpContext &ctx) const override { vespalib::string str; str += "(!"; str += _child->dump(ctx); str += ")"; return str; } - virtual void accept(NodeVisitor &visitor) const override; + void accept(NodeVisitor &visitor) const override; }; class If : public Node { @@ -257,11 +257,11 @@ public: const Node &true_expr() const { return *_true_expr; } const Node &false_expr() const { return *_false_expr; } double p_true() const { return _p_true; } - virtual bool is_tree() const override { return _is_tree; } - virtual size_t num_children() const override { + bool is_tree() const override { return _is_tree; } + size_t num_children() const override { return (_cond && _true_expr && _false_expr) ? 3 : 0; } - virtual const Node &get_child(size_t idx) const override { + const Node &get_child(size_t idx) const override { assert(idx < 3); if (idx == 0) { return cond(); @@ -271,12 +271,12 @@ public: return false_expr(); } } - virtual void detach_children(NodeHandler &handler) override { + void detach_children(NodeHandler &handler) override { handler.handle(std::move(_cond)); handler.handle(std::move(_true_expr)); handler.handle(std::move(_false_expr)); } - virtual vespalib::string dump(DumpContext &ctx) const { + vespalib::string dump(DumpContext &ctx) const override { vespalib::string str; str += "if("; str += _cond->dump(ctx); @@ -290,7 +290,7 @@ public: str += ")"; return str; } - virtual void accept(NodeVisitor &visitor) const override; + void accept(NodeVisitor &visitor) const override; }; class Let : public Node { @@ -304,16 +304,16 @@ public: const vespalib::string &name() const { return _name; } const Node &value() const { return *_value; } const Node &expr() const { return *_expr; } - virtual size_t num_children() const override { return (_value && _expr) ? 2 : 0; } - virtual const Node &get_child(size_t idx) const override { + size_t num_children() const override { return (_value && _expr) ? 2 : 0; } + const Node &get_child(size_t idx) const override { assert(idx < 2); return (idx == 0) ? value() : expr(); } - virtual void detach_children(NodeHandler &handler) override { + void detach_children(NodeHandler &handler) override { handler.handle(std::move(_value)); handler.handle(std::move(_expr)); } - virtual vespalib::string dump(DumpContext &ctx) const { + vespalib::string dump(DumpContext &ctx) const override { vespalib::string str; str += "let("; str += _name; @@ -326,7 +326,7 @@ public: str += ")"; return str; } - virtual void accept(NodeVisitor &visitor) const override; + void accept(NodeVisitor &visitor) const override; }; class Error : public Leaf { @@ -335,8 +335,8 @@ private: public: Error(const vespalib::string &message_in) : _message(message_in) {} const vespalib::string &message() const { return _message; } - virtual vespalib::string dump(DumpContext &) const { return _message; } - virtual void accept(NodeVisitor &visitor) const override; + vespalib::string dump(DumpContext &) const override { return _message; } + void accept(NodeVisitor &visitor) const override; }; } // namespace vespalib::eval::nodes diff --git a/eval/src/vespa/eval/eval/call_nodes.h b/eval/src/vespa/eval/eval/call_nodes.h index 01283a00e42..87a9c6007cb 100644 --- a/eval/src/vespa/eval/eval/call_nodes.h +++ b/eval/src/vespa/eval/eval/call_nodes.h @@ -30,14 +30,14 @@ public: Call(const vespalib::string &name_in, size_t num_params_in) : _name(name_in), _num_params(num_params_in), _is_const(false) {} ~Call(); - virtual bool is_const() const override { return _is_const; } + bool is_const() const override { return _is_const; } const vespalib::string &name() const { return _name; } size_t num_params() const { return _num_params; } size_t num_args() const { return _args.size(); } const Node &arg(size_t i) const { return *_args[i]; } - virtual size_t num_children() const override { return num_args(); } - virtual const Node &get_child(size_t idx) const override { return arg(idx); } - virtual void detach_children(NodeHandler &handler) override { + size_t num_children() const override { return num_args(); } + const Node &get_child(size_t idx) const override { return arg(idx); } + void detach_children(NodeHandler &handler) override { for (size_t i = 0; i < _args.size(); ++i) { handler.handle(std::move(_args[i])); } @@ -51,7 +51,7 @@ public: } _args.push_back(std::move(arg_in)); } - virtual vespalib::string dump(DumpContext &ctx) const { + vespalib::string dump(DumpContext &ctx) const override { vespalib::string str; str += _name; str += "("; @@ -106,7 +106,7 @@ struct CallHelper : Call { typedef CallHelper<T> Helper; CallHelper(const vespalib::string &name_in, size_t num_params_in) : Call(name_in, num_params_in) {} - virtual void accept(NodeVisitor &visitor) const override; + void accept(NodeVisitor &visitor) const override; static Call_UP create() { return Call_UP(new T()); } }; diff --git a/eval/src/vespa/eval/eval/function.cpp b/eval/src/vespa/eval/eval/function.cpp index 5be5147fa3a..dd8d7743041 100644 --- a/eval/src/vespa/eval/eval/function.cpp +++ b/eval/src/vespa/eval/eval/function.cpp @@ -83,15 +83,15 @@ struct ExplicitParams : Params { lookup_add(param); } } - virtual bool implicit() const { return false; } - virtual size_t resolve(vespalib::stringref token) const override { + bool implicit() const override { return false; } + size_t resolve(vespalib::stringref token) const override { return lookup(token); } }; struct ImplicitParams : Params { - virtual bool implicit() const { return true; } - virtual size_t resolve(vespalib::stringref token) const override { + bool implicit() const override { return true; } + size_t resolve(vespalib::stringref token) const override { return const_cast<ImplicitParams*>(this)->lookup_add(token); } }; diff --git a/eval/src/vespa/eval/eval/interpreted_function.cpp b/eval/src/vespa/eval/eval/interpreted_function.cpp index b308de6b3c0..82d34e1017d 100644 --- a/eval/src/vespa/eval/eval/interpreted_function.cpp +++ b/eval/src/vespa/eval/eval/interpreted_function.cpp @@ -239,10 +239,10 @@ struct ProgramBuilder : public NodeVisitor, public NodeTraverser { //------------------------------------------------------------------------- - virtual void visit(const Number &node) { + void visit(const Number&node) override { program.emplace_back(op_load_const, wrap_param<Value>(stash.create<DoubleValue>(node.value()))); } - virtual void visit(const Symbol &node) { + void visit(const Symbol&node) override { if (node.id() >= 0) { // param value program.emplace_back(op_load_param, node.id()); } else { // let binding @@ -250,19 +250,19 @@ struct ProgramBuilder : public NodeVisitor, public NodeTraverser { program.emplace_back(op_load_let, let_offset); } } - virtual void visit(const String &node) { + void visit(const String&node) override { program.emplace_back(op_load_const, wrap_param<Value>(stash.create<DoubleValue>(node.hash()))); } - virtual void visit(const Array &node) { + void visit(const Array&node) override { program.emplace_back(op_load_const, wrap_param<Value>(stash.create<DoubleValue>(node.size()))); } - virtual void visit(const Neg &) { + void visit(const Neg &) override { program.emplace_back(op_unary<operation::Neg>); } - virtual void visit(const Not &) { + void visit(const Not &) override { program.emplace_back(op_unary<operation::Not>); } - virtual void visit(const If &node) { + void visit(const If&node) override { node.cond().traverse(*this); size_t after_cond = program.size(); program.emplace_back(op_skip_if_false); @@ -273,16 +273,16 @@ struct ProgramBuilder : public NodeVisitor, public NodeTraverser { program[after_cond].update_param(after_true - after_cond); program[after_true].update_param(program.size() - after_true - 1); } - virtual void visit(const Let &node) { + void visit(const Let&node) override { node.value().traverse(*this); program.emplace_back(op_store_let); node.expr().traverse(*this); program.emplace_back(op_evict_let); } - virtual void visit(const Error &) { + void visit(const Error &) override { program.emplace_back(op_load_const, wrap_param<Value>(stash.create<ErrorValue>())); } - virtual void visit(const TensorSum &node) { + void visit(const TensorSum&node) override { if (is_typed(node) && is_typed_tensor_product_of_params(node.get_child(0))) { assert(program.size() >= 3); // load,load,mul program.pop_back(); // mul @@ -307,23 +307,23 @@ struct ProgramBuilder : public NodeVisitor, public NodeTraverser { wrap_param<vespalib::string>(stash.create<vespalib::string>(node.dimension()))); } } - virtual void visit(const TensorMap &node) { + void visit(const TensorMap&node) override { const auto &token = stash.create<CompileCache::Token::UP>(CompileCache::compile(node.lambda(), PassParams::SEPARATE)); program.emplace_back(op_tensor_map, wrap_param<CompiledFunction>(token.get()->get())); } - virtual void visit(const TensorJoin &node) { + void visit(const TensorJoin&node) override { const auto &token = stash.create<CompileCache::Token::UP>(CompileCache::compile(node.lambda(), PassParams::SEPARATE)); program.emplace_back(op_tensor_join, wrap_param<CompiledFunction>(token.get()->get())); } - virtual void visit(const TensorReduce &node) { + void visit(const TensorReduce&node) override { ReduceParams ¶ms = stash.create<ReduceParams>(node.aggr(), node.dimensions()); program.emplace_back(op_tensor_reduce, wrap_param<ReduceParams>(params)); } - virtual void visit(const TensorRename &node) { + void visit(const TensorRename&node) override { RenameParams ¶ms = stash.create<RenameParams>(node.from(), node.to()); program.emplace_back(op_tensor_rename, wrap_param<RenameParams>(params)); } - virtual void visit(const TensorLambda &node) { + void visit(const TensorLambda&node) override { const auto &type = node.type(); TensorSpec spec(type.to_spec()); const auto &token = stash.create<CompileCache::Token::UP>(CompileCache::compile(node.lambda(), PassParams::ARRAY)); @@ -340,47 +340,47 @@ struct ProgramBuilder : public NodeVisitor, public NodeTraverser { auto tensor = tensor_engine.create(spec); program.emplace_back(op_load_const, wrap_param<Value>(stash.create<TensorValue>(std::move(tensor)))); } - virtual void visit(const TensorConcat &node) { + void visit(const TensorConcat&node) override { vespalib::string &dimension = stash.create<vespalib::string>(node.dimension()); program.emplace_back(op_tensor_concat, wrap_param<vespalib::string>(dimension)); } - virtual void visit(const Add &) { + void visit(const Add &) override { program.emplace_back(op_binary<operation::Add>); } - virtual void visit(const Sub &) { + void visit(const Sub &) override { program.emplace_back(op_binary<operation::Sub>); } - virtual void visit(const Mul &) { + void visit(const Mul &) override { program.emplace_back(op_binary<operation::Mul>); } - virtual void visit(const Div &) { + void visit(const Div &) override { program.emplace_back(op_binary<operation::Div>); } - virtual void visit(const Pow &) { + void visit(const Pow &) override { program.emplace_back(op_binary<operation::Pow>); } - virtual void visit(const Equal &) { + void visit(const Equal &) override { program.emplace_back(op_binary<operation::Equal>); } - virtual void visit(const NotEqual &) { + void visit(const NotEqual &) override { program.emplace_back(op_binary<operation::NotEqual>); } - virtual void visit(const Approx &) { + void visit(const Approx &) override { program.emplace_back(op_binary<operation::Approx>); } - virtual void visit(const Less &) { + void visit(const Less &) override { program.emplace_back(op_binary<operation::Less>); } - virtual void visit(const LessEqual &) { + void visit(const LessEqual &) override { program.emplace_back(op_binary<operation::LessEqual>); } - virtual void visit(const Greater &) { + void visit(const Greater &) override { program.emplace_back(op_binary<operation::Greater>); } - virtual void visit(const GreaterEqual &) { + void visit(const GreaterEqual &) override { program.emplace_back(op_binary<operation::GreaterEqual>); } - virtual void visit(const In &node) { + void visit(const In&node) override { std::vector<size_t> checks; node.lhs().traverse(*this); auto array = as<Array>(node.rhs()); @@ -400,91 +400,91 @@ struct ProgramBuilder : public NodeVisitor, public NodeTraverser { } program.emplace_back(op_not_member); } - virtual void visit(const And &) { + void visit(const And &) override { program.emplace_back(op_binary<operation::And>); } - virtual void visit(const Or &) { + void visit(const Or &) override { program.emplace_back(op_binary<operation::Or>); } - virtual void visit(const Cos &) { + void visit(const Cos &) override { program.emplace_back(op_unary<operation::Cos>); } - virtual void visit(const Sin &) { + void visit(const Sin &) override { program.emplace_back(op_unary<operation::Sin>); } - virtual void visit(const Tan &) { + void visit(const Tan &) override { program.emplace_back(op_unary<operation::Tan>); } - virtual void visit(const Cosh &) { + void visit(const Cosh &) override { program.emplace_back(op_unary<operation::Cosh>); } - virtual void visit(const Sinh &) { + void visit(const Sinh &) override { program.emplace_back(op_unary<operation::Sinh>); } - virtual void visit(const Tanh &) { + void visit(const Tanh &) override { program.emplace_back(op_unary<operation::Tanh>); } - virtual void visit(const Acos &) { + void visit(const Acos &) override { program.emplace_back(op_unary<operation::Acos>); } - virtual void visit(const Asin &) { + void visit(const Asin &) override { program.emplace_back(op_unary<operation::Asin>); } - virtual void visit(const Atan &) { + void visit(const Atan &) override { program.emplace_back(op_unary<operation::Atan>); } - virtual void visit(const Exp &) { + void visit(const Exp &) override { program.emplace_back(op_unary<operation::Exp>); } - virtual void visit(const Log10 &) { + void visit(const Log10 &) override { program.emplace_back(op_unary<operation::Log10>); } - virtual void visit(const Log &) { + void visit(const Log &) override { program.emplace_back(op_unary<operation::Log>); } - virtual void visit(const Sqrt &) { + void visit(const Sqrt &) override { program.emplace_back(op_unary<operation::Sqrt>); } - virtual void visit(const Ceil &) { + void visit(const Ceil &) override { program.emplace_back(op_unary<operation::Ceil>); } - virtual void visit(const Fabs &) { + void visit(const Fabs &) override { program.emplace_back(op_unary<operation::Fabs>); } - virtual void visit(const Floor &) { + void visit(const Floor &) override { program.emplace_back(op_unary<operation::Floor>); } - virtual void visit(const Atan2 &) { + void visit(const Atan2 &) override { program.emplace_back(op_binary<operation::Atan2>); } - virtual void visit(const Ldexp &) { + void visit(const Ldexp &) override { program.emplace_back(op_binary<operation::Ldexp>); } - virtual void visit(const Pow2 &) { + void visit(const Pow2 &) override { program.emplace_back(op_binary<operation::Pow>); } - virtual void visit(const Fmod &) { + void visit(const Fmod &) override { program.emplace_back(op_binary<operation::Fmod>); } - virtual void visit(const Min &) { + void visit(const Min &) override { program.emplace_back(op_binary<operation::Min>); } - virtual void visit(const Max &) { + void visit(const Max &) override { program.emplace_back(op_binary<operation::Max>); } - virtual void visit(const IsNan &) { + void visit(const IsNan &) override { program.emplace_back(op_unary<operation::IsNan>); } - virtual void visit(const Relu &) { + void visit(const Relu &) override { program.emplace_back(op_unary<operation::Relu>); } - virtual void visit(const Sigmoid &) { + void visit(const Sigmoid &) override { program.emplace_back(op_unary<operation::Sigmoid>); } //------------------------------------------------------------------------- - virtual bool open(const Node &node) { + bool open(const Node&node) override { if (check_type<Array, If, Let, In>(node)) { node.accept(*this); return false; @@ -492,7 +492,7 @@ struct ProgramBuilder : public NodeVisitor, public NodeTraverser { return true; } - virtual void close(const Node &node) { + void close(const Node&node) override { node.accept(*this); } }; diff --git a/eval/src/vespa/eval/eval/key_gen.cpp b/eval/src/vespa/eval/eval/key_gen.cpp index 861bcd9b904..6d78ec50049 100644 --- a/eval/src/vespa/eval/eval/key_gen.cpp +++ b/eval/src/vespa/eval/eval/key_gen.cpp @@ -1,10 +1,8 @@ // Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. -#include <vespa/fastos/fastos.h> #include "key_gen.h" #include "node_visitor.h" #include "node_traverser.h" -#include "function.h" namespace vespalib { namespace eval { @@ -24,66 +22,66 @@ struct KeyGen : public NodeVisitor, public NodeTraverser { void add_byte(uint8_t value) { key.append(&value, sizeof(value)); } // visit - virtual void visit(const Number &node) { add_byte( 1); add_double(node.value()); } - virtual void visit(const Symbol &node) { add_byte( 2); add_int(node.id()); } - virtual void visit(const String &node) { add_byte( 3); add_hash(node.hash()); } - virtual void visit(const Array &node) { add_byte( 4); add_size(node.size()); } - virtual void visit(const Neg &) { add_byte( 5); } - virtual void visit(const Not &) { add_byte( 6); } - virtual void visit(const If &node) { add_byte( 7); add_double(node.p_true()); } - virtual void visit(const Let &) { add_byte( 8); } - virtual void visit(const Error &) { add_byte( 9); } - virtual void visit(const TensorSum &) { add_byte(10); } // dimensions should be part of key - virtual void visit(const TensorMap &) { add_byte(11); } // lambda should be part of key - virtual void visit(const TensorJoin &) { add_byte(12); } // lambda should be part of key - virtual void visit(const TensorReduce &) { add_byte(13); } // aggr/dimensions should be part of key - virtual void visit(const TensorRename &) { add_byte(14); } // dimensions should be part of key - virtual void visit(const TensorLambda &) { add_byte(15); } // type/lambda should be part of key - virtual void visit(const TensorConcat &) { add_byte(16); } // dimension should be part of key - virtual void visit(const Add &) { add_byte(20); } - virtual void visit(const Sub &) { add_byte(21); } - virtual void visit(const Mul &) { add_byte(22); } - virtual void visit(const Div &) { add_byte(23); } - virtual void visit(const Pow &) { add_byte(24); } - virtual void visit(const Equal &) { add_byte(25); } - virtual void visit(const NotEqual &) { add_byte(26); } - virtual void visit(const Approx &) { add_byte(27); } - virtual void visit(const Less &) { add_byte(28); } - virtual void visit(const LessEqual &) { add_byte(29); } - virtual void visit(const Greater &) { add_byte(30); } - virtual void visit(const GreaterEqual &) { add_byte(31); } - virtual void visit(const In &) { add_byte(32); } - virtual void visit(const And &) { add_byte(33); } - virtual void visit(const Or &) { add_byte(34); } - virtual void visit(const Cos &) { add_byte(35); } - virtual void visit(const Sin &) { add_byte(36); } - virtual void visit(const Tan &) { add_byte(37); } - virtual void visit(const Cosh &) { add_byte(38); } - virtual void visit(const Sinh &) { add_byte(39); } - virtual void visit(const Tanh &) { add_byte(40); } - virtual void visit(const Acos &) { add_byte(41); } - virtual void visit(const Asin &) { add_byte(42); } - virtual void visit(const Atan &) { add_byte(43); } - virtual void visit(const Exp &) { add_byte(44); } - virtual void visit(const Log10 &) { add_byte(45); } - virtual void visit(const Log &) { add_byte(46); } - virtual void visit(const Sqrt &) { add_byte(47); } - virtual void visit(const Ceil &) { add_byte(48); } - virtual void visit(const Fabs &) { add_byte(49); } - virtual void visit(const Floor &) { add_byte(50); } - virtual void visit(const Atan2 &) { add_byte(51); } - virtual void visit(const Ldexp &) { add_byte(52); } - virtual void visit(const Pow2 &) { add_byte(53); } - virtual void visit(const Fmod &) { add_byte(54); } - virtual void visit(const Min &) { add_byte(55); } - virtual void visit(const Max &) { add_byte(56); } - virtual void visit(const IsNan &) { add_byte(57); } - virtual void visit(const Relu &) { add_byte(58); } - virtual void visit(const Sigmoid &) { add_byte(59); } + void visit(const Number &node) override { add_byte( 1); add_double(node.value()); } + void visit(const Symbol &node) override { add_byte( 2); add_int(node.id()); } + void visit(const String &node) override { add_byte( 3); add_hash(node.hash()); } + void visit(const Array &node) override { add_byte( 4); add_size(node.size()); } + void visit(const Neg &) override { add_byte( 5); } + void visit(const Not &) override { add_byte( 6); } + void visit(const If &node) override { add_byte( 7); add_double(node.p_true()); } + void visit(const Let &) override { add_byte( 8); } + void visit(const Error &) override { add_byte( 9); } + void visit(const TensorSum &) override { add_byte(10); } // dimensions should be part of key + void visit(const TensorMap &) override { add_byte(11); } // lambda should be part of key + void visit(const TensorJoin &) override { add_byte(12); } // lambda should be part of key + void visit(const TensorReduce &) override { add_byte(13); } // aggr/dimensions should be part of key + void visit(const TensorRename &) override { add_byte(14); } // dimensions should be part of key + void visit(const TensorLambda &) override { add_byte(15); } // type/lambda should be part of key + void visit(const TensorConcat &) override { add_byte(16); } // dimension should be part of key + void visit(const Add &) override { add_byte(20); } + void visit(const Sub &) override { add_byte(21); } + void visit(const Mul &) override { add_byte(22); } + void visit(const Div &) override { add_byte(23); } + void visit(const Pow &) override { add_byte(24); } + void visit(const Equal &) override { add_byte(25); } + void visit(const NotEqual &) override { add_byte(26); } + void visit(const Approx &) override { add_byte(27); } + void visit(const Less &) override { add_byte(28); } + void visit(const LessEqual &) override { add_byte(29); } + void visit(const Greater &) override { add_byte(30); } + void visit(const GreaterEqual &) override { add_byte(31); } + void visit(const In &) override { add_byte(32); } + void visit(const And &) override { add_byte(33); } + void visit(const Or &) override { add_byte(34); } + void visit(const Cos &) override { add_byte(35); } + void visit(const Sin &) override { add_byte(36); } + void visit(const Tan &) override { add_byte(37); } + void visit(const Cosh &) override { add_byte(38); } + void visit(const Sinh &) override { add_byte(39); } + void visit(const Tanh &) override { add_byte(40); } + void visit(const Acos &) override { add_byte(41); } + void visit(const Asin &) override { add_byte(42); } + void visit(const Atan &) override { add_byte(43); } + void visit(const Exp &) override { add_byte(44); } + void visit(const Log10 &) override { add_byte(45); } + void visit(const Log &) override { add_byte(46); } + void visit(const Sqrt &) override { add_byte(47); } + void visit(const Ceil &) override { add_byte(48); } + void visit(const Fabs &) override { add_byte(49); } + void visit(const Floor &) override { add_byte(50); } + void visit(const Atan2 &) override { add_byte(51); } + void visit(const Ldexp &) override { add_byte(52); } + void visit(const Pow2 &) override { add_byte(53); } + void visit(const Fmod &) override { add_byte(54); } + void visit(const Min &) override { add_byte(55); } + void visit(const Max &) override { add_byte(56); } + void visit(const IsNan &) override { add_byte(57); } + void visit(const Relu &) override { add_byte(58); } + void visit(const Sigmoid &) override { add_byte(59); } // traverse - virtual bool open(const Node &node) { node.accept(*this); return true; } - virtual void close(const Node &) {} + bool open(const Node &node) override { node.accept(*this); return true; } + void close(const Node &) override {} }; } // namespace vespalib::eval::<unnamed> diff --git a/eval/src/vespa/eval/eval/llvm/llvm_wrapper.cpp b/eval/src/vespa/eval/eval/llvm/llvm_wrapper.cpp index 5b607280403..ac4c4e597ca 100644 --- a/eval/src/vespa/eval/eval/llvm/llvm_wrapper.cpp +++ b/eval/src/vespa/eval/eval/llvm/llvm_wrapper.cpp @@ -242,7 +242,7 @@ struct FunctionBuilder : public NodeVisitor, public NodeTraverser { //------------------------------------------------------------------------- - bool open(const Node &node) { + bool open(const Node &node) override { if (node.is_const()) { push_double(node.get_const_value()); return false; @@ -261,7 +261,7 @@ struct FunctionBuilder : public NodeVisitor, public NodeTraverser { return true; } - void close(const Node &node) { + void close(const Node &node) override { node.accept(*this); if (inside_forest && (forest_end == &node)) { inside_forest = false; @@ -348,10 +348,10 @@ struct FunctionBuilder : public NodeVisitor, public NodeTraverser { // basic nodes - virtual void visit(const Number &item) { + void visit(const Number &item) override { push_double(item.value()); } - virtual void visit(const Symbol &item) { + void visit(const Symbol &item) override { if (item.id() >= 0) { push(get_param(item.id())); } else { @@ -360,22 +360,22 @@ struct FunctionBuilder : public NodeVisitor, public NodeTraverser { push(let_values[let_offset]); } } - virtual void visit(const String &item) { + void visit(const String &item) override { push_double(item.hash()); } - virtual void visit(const Array &item) { + void visit(const Array &item) override { // NB: visit not open push_double(item.size()); } - virtual void visit(const Neg &) { + void visit(const Neg &) override { llvm::Value *child = pop_double(); push(builder.CreateFNeg(child, "neg_res")); } - virtual void visit(const Not &) { + void visit(const Not &) override { llvm::Value *child = pop_bool(); push(builder.CreateNot(child, "not_res")); } - virtual void visit(const If &item) { + void visit(const If &item) override { // NB: visit not open llvm::BasicBlock *true_block = llvm::BasicBlock::Create(context, "true_block", function); llvm::BasicBlock *false_block = llvm::BasicBlock::Create(context, "false_block", function); @@ -402,100 +402,100 @@ struct FunctionBuilder : public NodeVisitor, public NodeTraverser { phi->addIncoming(false_res, false_end); push(phi); } - virtual void visit(const Let &item) { + void visit(const Let &item) override { // NB: visit not open item.value().traverse(*this); // NB: recursion let_values.push_back(pop_double()); item.expr().traverse(*this); // NB: recursion let_values.pop_back(); } - virtual void visit(const Error &) { + void visit(const Error &) override { make_error(0); } // tensor nodes (not supported in compiled expressions) - virtual void visit(const TensorSum &node) { + void visit(const TensorSum &node) override { make_error(node.num_children()); } - virtual void visit(const TensorMap &node) { + void visit(const TensorMap &node) override { make_error(node.num_children()); } - virtual void visit(const TensorJoin &node) { + void visit(const TensorJoin &node) override { make_error(node.num_children()); } - virtual void visit(const TensorReduce &node) { + void visit(const TensorReduce &node) override { make_error(node.num_children()); } - virtual void visit(const TensorRename &node) { + void visit(const TensorRename &node) override { make_error(node.num_children()); } - virtual void visit(const TensorLambda &node) { + void visit(const TensorLambda &node) override { make_error(node.num_children()); } - virtual void visit(const TensorConcat &node) { + void visit(const TensorConcat &node) override { make_error(node.num_children()); } // operator nodes - virtual void visit(const Add &) { + void visit(const Add &) override { llvm::Value *b = pop_double(); llvm::Value *a = pop_double(); push(builder.CreateFAdd(a, b, "add_res")); } - virtual void visit(const Sub &) { + void visit(const Sub &) override { llvm::Value *b = pop_double(); llvm::Value *a = pop_double(); push(builder.CreateFSub(a, b, "sub_res")); } - virtual void visit(const Mul &) { + void visit(const Mul &) override { llvm::Value *b = pop_double(); llvm::Value *a = pop_double(); push(builder.CreateFMul(a, b, "mul_res")); } - virtual void visit(const Div &) { + void visit(const Div &) override { llvm::Value *b = pop_double(); llvm::Value *a = pop_double(); push(builder.CreateFDiv(a, b, "div_res")); } - virtual void visit(const Pow &) { + void visit(const Pow &) override { make_call_2(llvm::Intrinsic::pow); } - virtual void visit(const Equal &) { + void visit(const Equal &) override { llvm::Value *b = pop_double(); llvm::Value *a = pop_double(); push(builder.CreateFCmpOEQ(a, b, "cmp_eq_res")); } - virtual void visit(const NotEqual &) { + void visit(const NotEqual &) override { llvm::Value *b = pop_double(); llvm::Value *a = pop_double(); push(builder.CreateFCmpUNE(a, b, "cmp_ne_res")); } - virtual void visit(const Approx &) { + void visit(const Approx &) override { make_call_2("vespalib_eval_approx"); } - virtual void visit(const Less &) { + void visit(const Less &) override { llvm::Value *b = pop_double(); llvm::Value *a = pop_double(); push(builder.CreateFCmpOLT(a, b, "cmp_lt_res")); } - virtual void visit(const LessEqual &) { + void visit(const LessEqual &) override { llvm::Value *b = pop_double(); llvm::Value *a = pop_double(); push(builder.CreateFCmpOLE(a, b, "cmp_le_res")); } - virtual void visit(const Greater &) { + void visit(const Greater &) override { llvm::Value *b = pop_double(); llvm::Value *a = pop_double(); push(builder.CreateFCmpOGT(a, b, "cmp_gt_res")); } - virtual void visit(const GreaterEqual &) { + void visit(const GreaterEqual &) override { llvm::Value *b = pop_double(); llvm::Value *a = pop_double(); push(builder.CreateFCmpOGE(a, b, "cmp_ge_res")); } - virtual void visit(const In &item) { + void visit(const In &item) override { // NB: visit not open item.lhs().traverse(*this); // NB: recursion llvm::Value *lhs = pop_double(); @@ -527,12 +527,12 @@ struct FunctionBuilder : public NodeVisitor, public NodeTraverser { push(builder.CreateFCmpOEQ(lhs, rhs, "rhs_eq")); } } - virtual void visit(const And &) { + void visit(const And &) override { llvm::Value *b = pop_bool(); llvm::Value *a = pop_bool(); push(builder.CreateAnd(a, b, "and_res")); } - virtual void visit(const Or &) { + void visit(const Or &) override { llvm::Value *b = pop_bool(); llvm::Value *a = pop_bool(); push(builder.CreateOr(a, b, "or_res")); @@ -540,79 +540,79 @@ struct FunctionBuilder : public NodeVisitor, public NodeTraverser { // call nodes - virtual void visit(const Cos &) { + void visit(const Cos &) override { make_call_1(llvm::Intrinsic::cos); } - virtual void visit(const Sin &) { + void visit(const Sin &) override { make_call_1(llvm::Intrinsic::sin); } - virtual void visit(const Tan &) { + void visit(const Tan &) override { make_call_1("tan"); } - virtual void visit(const Cosh &) { + void visit(const Cosh &) override { make_call_1("cosh"); } - virtual void visit(const Sinh &) { + void visit(const Sinh &) override { make_call_1("sinh"); } - virtual void visit(const Tanh &) { + void visit(const Tanh &) override { make_call_1("tanh"); } - virtual void visit(const Acos &) { + void visit(const Acos &) override { make_call_1("acos"); } - virtual void visit(const Asin &) { + void visit(const Asin &) override { make_call_1("asin"); } - virtual void visit(const Atan &) { + void visit(const Atan &) override { make_call_1("atan"); } - virtual void visit(const Exp &) { + void visit(const Exp &) override { make_call_1(llvm::Intrinsic::exp); } - virtual void visit(const Log10 &) { + void visit(const Log10 &) override { make_call_1(llvm::Intrinsic::log10); } - virtual void visit(const Log &) { + void visit(const Log &) override { make_call_1(llvm::Intrinsic::log); } - virtual void visit(const Sqrt &) { + void visit(const Sqrt &) override { make_call_1(llvm::Intrinsic::sqrt); } - virtual void visit(const Ceil &) { + void visit(const Ceil &) override { make_call_1(llvm::Intrinsic::ceil); } - virtual void visit(const Fabs &) { + void visit(const Fabs &) override { make_call_1(llvm::Intrinsic::fabs); } - virtual void visit(const Floor &) { + void visit(const Floor &) override { make_call_1(llvm::Intrinsic::floor); } - virtual void visit(const Atan2 &) { + void visit(const Atan2 &) override { make_call_2("atan2"); } - virtual void visit(const Ldexp &) { + void visit(const Ldexp &) override { make_call_2("vespalib_eval_ldexp"); } - virtual void visit(const Pow2 &) { + void visit(const Pow2 &) override { make_call_2(llvm::Intrinsic::pow); } - virtual void visit(const Fmod &) { + void visit(const Fmod &) override { make_call_2("fmod"); } - virtual void visit(const Min &) { + void visit(const Min &) override { make_call_2("vespalib_eval_min"); } - virtual void visit(const Max &) { + void visit(const Max &) override { make_call_2("vespalib_eval_max"); } - virtual void visit(const IsNan &) { + void visit(const IsNan &) override { make_call_1("vespalib_eval_isnan"); } - virtual void visit(const Relu &) { + void visit(const Relu &) override { make_call_1("vespalib_eval_relu"); } - virtual void visit(const Sigmoid &) { + void visit(const Sigmoid &) override { make_call_1("vespalib_eval_sigmoid"); } }; diff --git a/eval/src/vespa/eval/eval/node_types.cpp b/eval/src/vespa/eval/eval/node_types.cpp index c02060a1060..645baa2e5a6 100644 --- a/eval/src/vespa/eval/eval/node_types.cpp +++ b/eval/src/vespa/eval/eval/node_types.cpp @@ -1,11 +1,8 @@ // Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. -#include <vespa/fastos/fastos.h> #include "check_type.h" -#include "function.h" #include "node_traverser.h" #include "node_types.h" -#include "node_visitor.h" namespace vespalib { namespace eval { @@ -119,10 +116,10 @@ struct TypeResolver : public NodeVisitor, public NodeTraverser { //------------------------------------------------------------------------- - virtual void visit(const Number &node) { + void visit(const Number &node) override { bind_type(ValueType::double_type(), node); } - virtual void visit(const Symbol &node) { + void visit(const Symbol &node) override { if (node.id() >= 0) { // param value bind_type(state.param_type(node.id()), node); } else { // let binding @@ -130,15 +127,15 @@ struct TypeResolver : public NodeVisitor, public NodeTraverser { bind_type(state.let_type(let_offset), node); } } - virtual void visit(const String &node) { + void visit(const String &node) override { bind_type(ValueType::double_type(), node); } - virtual void visit(const Array &node) { + void visit(const Array &node) override { bind_type(ValueType::double_type(), node); } - virtual void visit(const Neg &node) { resolve_op1(node); } - virtual void visit(const Not &node) { resolve_op1(node); } - virtual void visit(const If &node) { + void visit(const Neg &node) override { resolve_op1(node); } + void visit(const Not &node) override { resolve_op1(node); } + void visit(const If &node) override { ValueType true_type = state.peek(1); ValueType false_type = state.peek(0); if (true_type == false_type) { @@ -149,13 +146,13 @@ struct TypeResolver : public NodeVisitor, public NodeTraverser { bind_type(ValueType::any_type(), node); } } - virtual void visit(const Let &node) { + void visit(const Let &node) override { bind_type(state.peek(0), node); } - virtual void visit(const Error &node) { + void visit(const Error &node) override { bind_type(ValueType::error_type(), node); } - virtual void visit(const TensorSum &node) { + void visit(const TensorSum &node) override { const ValueType &child = state.peek(0); if (node.dimension().empty()) { bind_type(child.reduce({}), node); @@ -163,69 +160,69 @@ struct TypeResolver : public NodeVisitor, public NodeTraverser { bind_type(child.reduce({node.dimension()}), node); } } - virtual void visit(const TensorMap &node) { resolve_op1(node); } - virtual void visit(const TensorJoin &node) { resolve_op2(node); } - virtual void visit(const TensorReduce &node) { + void visit(const TensorMap &node) override { resolve_op1(node); } + void visit(const TensorJoin &node) override { resolve_op2(node); } + void visit(const TensorReduce &node) override { const ValueType &child = state.peek(0); bind_type(child.reduce(node.dimensions()), node); } - virtual void visit(const TensorRename &node) { + void visit(const TensorRename &node) override { const ValueType &child = state.peek(0); bind_type(child.rename(node.from(), node.to()), node); } - virtual void visit(const TensorLambda &node) { + void visit(const TensorLambda &node) override { bind_type(node.type(), node); } - virtual void visit(const TensorConcat &node) { + void visit(const TensorConcat &node) override { bind_type(ValueType::concat(state.peek(1), state.peek(0), node.dimension()), node); } - virtual void visit(const Add &node) { resolve_op2(node); } - virtual void visit(const Sub &node) { resolve_op2(node); } - virtual void visit(const Mul &node) { resolve_op2(node); } - virtual void visit(const Div &node) { resolve_op2(node); } - virtual void visit(const Pow &node) { resolve_op2(node); } - virtual void visit(const Equal &node) { resolve_op2(node); } - virtual void visit(const NotEqual &node) { resolve_op2(node); } - virtual void visit(const Approx &node) { resolve_op2(node); } - virtual void visit(const Less &node) { resolve_op2(node); } - virtual void visit(const LessEqual &node) { resolve_op2(node); } - virtual void visit(const Greater &node) { resolve_op2(node); } - virtual void visit(const GreaterEqual &node) { resolve_op2(node); } - virtual void visit(const In &node) { + void visit(const Add &node) override { resolve_op2(node); } + void visit(const Sub &node) override { resolve_op2(node); } + void visit(const Mul &node) override { resolve_op2(node); } + void visit(const Div &node) override { resolve_op2(node); } + void visit(const Pow &node) override { resolve_op2(node); } + void visit(const Equal &node) override { resolve_op2(node); } + void visit(const NotEqual &node) override { resolve_op2(node); } + void visit(const Approx &node) override { resolve_op2(node); } + void visit(const Less &node) override { resolve_op2(node); } + void visit(const LessEqual &node) override { resolve_op2(node); } + void visit(const Greater &node) override { resolve_op2(node); } + void visit(const GreaterEqual &node) override { resolve_op2(node); } + void visit(const In &node) override { bind_type(ValueType::double_type(), node); } - virtual void visit(const And &node) { resolve_op2(node); } - virtual void visit(const Or &node) { resolve_op2(node); } - virtual void visit(const Cos &node) { resolve_op1(node); } - virtual void visit(const Sin &node) { resolve_op1(node); } - virtual void visit(const Tan &node) { resolve_op1(node); } - virtual void visit(const Cosh &node) { resolve_op1(node); } - virtual void visit(const Sinh &node) { resolve_op1(node); } - virtual void visit(const Tanh &node) { resolve_op1(node); } - virtual void visit(const Acos &node) { resolve_op1(node); } - virtual void visit(const Asin &node) { resolve_op1(node); } - virtual void visit(const Atan &node) { resolve_op1(node); } - virtual void visit(const Exp &node) { resolve_op1(node); } - virtual void visit(const Log10 &node) { resolve_op1(node); } - virtual void visit(const Log &node) { resolve_op1(node); } - virtual void visit(const Sqrt &node) { resolve_op1(node); } - virtual void visit(const Ceil &node) { resolve_op1(node); } - virtual void visit(const Fabs &node) { resolve_op1(node); } - virtual void visit(const Floor &node) { resolve_op1(node); } - virtual void visit(const Atan2 &node) { resolve_op2(node); } - virtual void visit(const Ldexp &node) { resolve_op2(node); } - virtual void visit(const Pow2 &node) { resolve_op2(node); } - virtual void visit(const Fmod &node) { resolve_op2(node); } - virtual void visit(const Min &node) { resolve_op2(node); } - virtual void visit(const Max &node) { resolve_op2(node); } - virtual void visit(const IsNan &node) { resolve_op1(node); } - virtual void visit(const Relu &node) { resolve_op1(node); } - virtual void visit(const Sigmoid &node) { resolve_op1(node); } + void visit(const And &node) override { resolve_op2(node); } + void visit(const Or &node) override { resolve_op2(node); } + void visit(const Cos &node) override { resolve_op1(node); } + void visit(const Sin &node) override { resolve_op1(node); } + void visit(const Tan &node) override { resolve_op1(node); } + void visit(const Cosh &node) override { resolve_op1(node); } + void visit(const Sinh &node) override { resolve_op1(node); } + void visit(const Tanh &node) override { resolve_op1(node); } + void visit(const Acos &node) override { resolve_op1(node); } + void visit(const Asin &node) override { resolve_op1(node); } + void visit(const Atan &node) override { resolve_op1(node); } + void visit(const Exp &node) override { resolve_op1(node); } + void visit(const Log10 &node) override { resolve_op1(node); } + void visit(const Log &node) override { resolve_op1(node); } + void visit(const Sqrt &node) override { resolve_op1(node); } + void visit(const Ceil &node) override { resolve_op1(node); } + void visit(const Fabs &node) override { resolve_op1(node); } + void visit(const Floor &node) override { resolve_op1(node); } + void visit(const Atan2 &node) override { resolve_op2(node); } + void visit(const Ldexp &node) override { resolve_op2(node); } + void visit(const Pow2 &node) override { resolve_op2(node); } + void visit(const Fmod &node) override { resolve_op2(node); } + void visit(const Min &node) override { resolve_op2(node); } + void visit(const Max &node) override { resolve_op2(node); } + void visit(const IsNan &node) override { resolve_op1(node); } + void visit(const Relu &node) override { resolve_op1(node); } + void visit(const Sigmoid &node) override { resolve_op1(node); } //------------------------------------------------------------------------- - virtual bool open(const Node &node) { + bool open(const Node &node) override { auto let = as<Let>(node); if (let) { add_action(let->expr(), action_unbind_let); @@ -234,7 +231,7 @@ struct TypeResolver : public NodeVisitor, public NodeTraverser { return true; } - virtual void close(const Node &node) { + void close(const Node &node) override { if (!check_error(node)) { node.accept(*this); } diff --git a/eval/src/vespa/eval/eval/node_visitor.h b/eval/src/vespa/eval/eval/node_visitor.h index 3196a00820e..128533c0410 100644 --- a/eval/src/vespa/eval/eval/node_visitor.h +++ b/eval/src/vespa/eval/eval/node_visitor.h @@ -90,62 +90,62 @@ struct NodeVisitor { * of all types not specifically handled. **/ struct EmptyNodeVisitor : NodeVisitor { - virtual void visit(const nodes::Number &) {} - virtual void visit(const nodes::Symbol &) {} - virtual void visit(const nodes::String &) {} - virtual void visit(const nodes::Array &) {} - virtual void visit(const nodes::Neg &) {} - virtual void visit(const nodes::Not &) {} - virtual void visit(const nodes::If &) {} - virtual void visit(const nodes::Let &) {} - virtual void visit(const nodes::Error &) {} - virtual void visit(const nodes::TensorSum &) {} - virtual void visit(const nodes::TensorMap &) {} - virtual void visit(const nodes::TensorJoin &) {} - virtual void visit(const nodes::TensorReduce &) {} - virtual void visit(const nodes::TensorRename &) {} - virtual void visit(const nodes::TensorLambda &) {} - virtual void visit(const nodes::TensorConcat &) {} - virtual void visit(const nodes::Add &) {} - virtual void visit(const nodes::Sub &) {} - virtual void visit(const nodes::Mul &) {} - virtual void visit(const nodes::Div &) {} - virtual void visit(const nodes::Pow &) {} - virtual void visit(const nodes::Equal &) {} - virtual void visit(const nodes::NotEqual &) {} - virtual void visit(const nodes::Approx &) {} - virtual void visit(const nodes::Less &) {} - virtual void visit(const nodes::LessEqual &) {} - virtual void visit(const nodes::Greater &) {} - virtual void visit(const nodes::GreaterEqual &) {} - virtual void visit(const nodes::In &) {} - virtual void visit(const nodes::And &) {} - virtual void visit(const nodes::Or &) {} - virtual void visit(const nodes::Cos &) {} - virtual void visit(const nodes::Sin &) {} - virtual void visit(const nodes::Tan &) {} - virtual void visit(const nodes::Cosh &) {} - virtual void visit(const nodes::Sinh &) {} - virtual void visit(const nodes::Tanh &) {} - virtual void visit(const nodes::Acos &) {} - virtual void visit(const nodes::Asin &) {} - virtual void visit(const nodes::Atan &) {} - virtual void visit(const nodes::Exp &) {} - virtual void visit(const nodes::Log10 &) {} - virtual void visit(const nodes::Log &) {} - virtual void visit(const nodes::Sqrt &) {} - virtual void visit(const nodes::Ceil &) {} - virtual void visit(const nodes::Fabs &) {} - virtual void visit(const nodes::Floor &) {} - virtual void visit(const nodes::Atan2 &) {} - virtual void visit(const nodes::Ldexp &) {} - virtual void visit(const nodes::Pow2 &) {} - virtual void visit(const nodes::Fmod &) {} - virtual void visit(const nodes::Min &) {} - virtual void visit(const nodes::Max &) {} - virtual void visit(const nodes::IsNan &) {} - virtual void visit(const nodes::Relu &) {} - virtual void visit(const nodes::Sigmoid &) {} + virtual void visit(const nodes::Number &) override {} + virtual void visit(const nodes::Symbol &) override {} + virtual void visit(const nodes::String &) override {} + virtual void visit(const nodes::Array &) override {} + virtual void visit(const nodes::Neg &) override {} + virtual void visit(const nodes::Not &) override {} + virtual void visit(const nodes::If &) override {} + virtual void visit(const nodes::Let &) override {} + void visit(const nodes::Error &) override {} + void visit(const nodes::TensorSum &) override {} + void visit(const nodes::TensorMap &) override {} + void visit(const nodes::TensorJoin &) override {} + void visit(const nodes::TensorReduce &) override {} + void visit(const nodes::TensorRename &) override {} + void visit(const nodes::TensorLambda &) override {} + void visit(const nodes::TensorConcat &) override {} + void visit(const nodes::Add &) override {} + void visit(const nodes::Sub &) override {} + void visit(const nodes::Mul &) override {} + void visit(const nodes::Div &) override {} + void visit(const nodes::Pow &) override {} + void visit(const nodes::Equal &) override {} + void visit(const nodes::NotEqual &) override {} + void visit(const nodes::Approx &) override {} + void visit(const nodes::Less &) override {} + void visit(const nodes::LessEqual &) override {} + void visit(const nodes::Greater &) override {} + void visit(const nodes::GreaterEqual &) override {} + void visit(const nodes::In &) override {} + void visit(const nodes::And &) override {} + void visit(const nodes::Or &) override {} + void visit(const nodes::Cos &) override {} + void visit(const nodes::Sin &) override {} + void visit(const nodes::Tan &) override {} + void visit(const nodes::Cosh &) override {} + void visit(const nodes::Sinh &) override {} + void visit(const nodes::Tanh &) override {} + void visit(const nodes::Acos &) override {} + void visit(const nodes::Asin &) override {} + void visit(const nodes::Atan &) override {} + void visit(const nodes::Exp &) override {} + void visit(const nodes::Log10 &) override {} + void visit(const nodes::Log &) override {} + void visit(const nodes::Sqrt &) override {} + void visit(const nodes::Ceil &) override {} + void visit(const nodes::Fabs &) override {} + void visit(const nodes::Floor &) override {} + void visit(const nodes::Atan2 &) override {} + void visit(const nodes::Ldexp &) override {} + void visit(const nodes::Pow2 &) override {} + void visit(const nodes::Fmod &) override {} + void visit(const nodes::Min &) override {} + void visit(const nodes::Max &) override {} + void visit(const nodes::IsNan &) override {} + void visit(const nodes::Relu &) override {} + void visit(const nodes::Sigmoid &) override {} }; } // namespace vespalib::eval diff --git a/eval/src/vespa/eval/eval/operator_nodes.h b/eval/src/vespa/eval/eval/operator_nodes.h index a0726137015..93b30d7695b 100644 --- a/eval/src/vespa/eval/eval/operator_nodes.h +++ b/eval/src/vespa/eval/eval/operator_nodes.h @@ -42,13 +42,13 @@ public: Order order() const { return _order; } const Node &lhs() const { return *_lhs; } const Node &rhs() const { return *_rhs; } - virtual bool is_const() const override { return _is_const; } - virtual size_t num_children() const override { return (_lhs && _rhs) ? 2 : 0; } - virtual const Node &get_child(size_t idx) const override { + bool is_const() const override { return _is_const; } + size_t num_children() const override { return (_lhs && _rhs) ? 2 : 0; } + const Node &get_child(size_t idx) const override { assert(idx < 2); return (idx == 0) ? lhs() : rhs(); } - virtual void detach_children(NodeHandler &handler) override { + void detach_children(NodeHandler &handler) override { handler.handle(std::move(_lhs)); handler.handle(std::move(_rhs)); } @@ -70,7 +70,7 @@ public: _is_const = (_lhs->is_const() && _rhs->is_const()); } - virtual vespalib::string dump(DumpContext &ctx) const { + vespalib::string dump(DumpContext &ctx) const override { vespalib::string str; str += "("; str += _lhs->dump(ctx); @@ -129,7 +129,7 @@ struct OperatorHelper : Operator { using Helper = OperatorHelper<T>; OperatorHelper(const vespalib::string &op_str_in, int priority_in, Operator::Order order_in) : Operator(op_str_in, priority_in, order_in) {} - virtual void accept(NodeVisitor &visitor) const override; + void accept(NodeVisitor &visitor) const override; static Operator_UP create() { return Operator_UP(new T()); } }; @@ -140,13 +140,13 @@ private: bool _is_forest; public: Add() : Helper("+", 101, LEFT), _is_forest(false) {} - virtual bool is_forest() const override { return _is_forest; } + bool is_forest() const override { return _is_forest; } bool check_forest() const { bool lhs_ok = (lhs().is_tree() || lhs().is_forest()); bool rhs_ok = (rhs().is_tree() || rhs().is_forest()); return (lhs_ok && rhs_ok); } - virtual void bind(Node_UP lhs_in, Node_UP rhs_in) override { + void bind(Node_UP lhs_in, Node_UP rhs_in) override { OperatorHelper<Add>::bind(std::move(lhs_in), std::move(rhs_in)); _is_forest = check_forest(); } diff --git a/eval/src/vespa/eval/eval/test/tensor_conformance.cpp b/eval/src/vespa/eval/eval/test/tensor_conformance.cpp index 93b0cde7363..40366f39db9 100644 --- a/eval/src/vespa/eval/eval/test/tensor_conformance.cpp +++ b/eval/src/vespa/eval/eval/test/tensor_conformance.cpp @@ -515,7 +515,7 @@ struct Input : TensorFunction::Input { ASSERT_GREATER(tensors.size(), offset); return tensors[offset]; } - const UnaryOperation &get_map_operation(size_t id) const { + const UnaryOperation &get_map_operation(size_t id) const override { ASSERT_TRUE(map_op != nullptr); ASSERT_EQUAL(id, map_operation_id); return *map_op; diff --git a/eval/src/vespa/eval/eval/value.h b/eval/src/vespa/eval/eval/value.h index e8b682e84b5..3b2f7eca62c 100644 --- a/eval/src/vespa/eval/eval/value.h +++ b/eval/src/vespa/eval/eval/value.h @@ -39,9 +39,9 @@ struct Value { }; struct ErrorValue : public Value { - virtual bool is_error() const override { return true; } - virtual double as_double() const { return error_value; } - virtual bool equal(const Value &) const override { return false; } + bool is_error() const override { return true; } + double as_double() const override { return error_value; } + bool equal(const Value &) const override { return false; } ValueType type() const override { return ValueType::error_type(); } }; |