| // Licensed to the Apache Software Foundation (ASF) under one |
| // or more contributor license agreements. See the NOTICE file |
| // distributed with this work for additional information |
| // regarding copyright ownership. The ASF licenses this file |
| // to you under the Apache License, Version 2.0 (the |
| // "License"); you may not use this file except in compliance |
| // with the License. You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, |
| // software distributed under the License is distributed on an |
| // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| // KIND, either express or implied. See the License for the |
| // specific language governing permissions and limitations |
| // under the License. |
| |
| #include <stdio.h> |
| #include <iostream> |
| |
| #include <jni.h> |
| #include <thrift/Thrift.h> |
| #include <thrift/protocol/TDebugProtocol.h> |
| |
| #include "runtime/exec-env.h" |
| #include "runtime/runtime-state.h" |
| |
| #include "exprs/scalar-expr.h" |
| #include "exprs/scalar-expr-evaluator.h" |
| #include "util/backend-gflag-util.h" |
| #include "util/benchmark.h" |
| #include "util/cpu-info.h" |
| #include "util/debug-util.h" |
| #include "util/jni-util.h" |
| #include "rpc/jni-thrift-util.h" |
| |
| #include "gen-cpp/Types_types.h" |
| #include "gen-cpp/ImpalaService.h" |
| #include "gen-cpp/DataSinks_types.h" |
| #include "gen-cpp/Types_types.h" |
| #include "gen-cpp/ImpalaService.h" |
| #include "gen-cpp/ImpalaService_types.h" |
| #include "gen-cpp/ImpalaInternalService.h" |
| #include "gen-cpp/Frontend_types.h" |
| #include "gen-cpp/ImpalaService.h" |
| #include "gen-cpp/ImpalaInternalService.h" |
| #include "gen-cpp/Frontend_types.h" |
| #include "rpc/thrift-server.h" |
| #include "codegen/llvm-codegen.h" |
| #include "common/init.h" |
| #include "common/object-pool.h" |
| #include "common/status.h" |
| #include "runtime/mem-pool.h" |
| #include "runtime/mem-tracker.h" |
| #include "service/fe-support.h" |
| #include "service/frontend.h" |
| #include "service/impala-server.h" |
| |
| #include "common/names.h" |
| |
| using namespace apache::thrift; |
| using namespace impala; |
| |
| // Utility class to take (ascii) sql and return the plan. This does minimal |
| // error handling. |
| class Planner { |
| public: |
| Planner() { |
| frontend_.SetCatalogIsReady(); |
| ABORT_IF_ERROR(exec_env_.InitForFeTests()); |
| } |
| |
| Status GeneratePlan(const string& stmt, TExecRequest* result) { |
| TQueryCtx query_ctx; |
| query_ctx.client_request.stmt = stmt; |
| query_ctx.client_request.query_options = query_options_; |
| query_ctx.__set_session(session_state_); |
| TNetworkAddress dummy; |
| ImpalaServer::PrepareQueryContext(dummy, dummy, &query_ctx); |
| runtime_state_.reset(new RuntimeState(query_ctx, &exec_env_)); |
| |
| return frontend_.GetExecRequest(query_ctx, result); |
| } |
| |
| RuntimeState* GetRuntimeState() { |
| return runtime_state_.get(); |
| } |
| |
| private: |
| Frontend frontend_; |
| ExecEnv exec_env_; |
| scoped_ptr<RuntimeState> runtime_state_; |
| |
| TQueryOptions query_options_; |
| TSessionState session_state_; |
| }; |
| |
| struct TestData { |
| ScalarExprEvaluator* eval; |
| int64_t dummy_result; |
| }; |
| |
| Planner* planner; |
| ObjectPool pool; |
| MemTracker tracker; |
| MemPool mem_pool(&tracker); |
| |
| // Utility function to get prepare select list for exprs. Assumes this is a |
| // constant query. |
| static Status PrepareSelectList( |
| const TExecRequest& request, ScalarExprEvaluator** eval) { |
| const TQueryExecRequest& query_request = request.query_exec_request; |
| vector<TExpr> texprs = query_request.plan_exec_info[0].fragments[0].output_sink.output_exprs; |
| DCHECK_EQ(texprs.size(), 1); |
| RuntimeState* state = planner->GetRuntimeState(); |
| ScalarExpr* expr; |
| RETURN_IF_ERROR(ScalarExpr::Create(texprs[0], RowDescriptor(), state, &expr)); |
| RETURN_IF_ERROR( |
| ScalarExprEvaluator::Create(*expr, state, &pool, &mem_pool, &mem_pool, eval)); |
| return Status::OK(); |
| } |
| |
| // TODO: handle codegen. Codegen needs a new driver that is also codegen'd. |
| static TestData* GenerateBenchmarkExprs(const string& query, bool codegen) { |
| stringstream ss; |
| ss << "select " << query; |
| TestData* test_data = new TestData; |
| TExecRequest request; |
| ABORT_IF_ERROR(planner->GeneratePlan(ss.str(), &request)); |
| ABORT_IF_ERROR(PrepareSelectList(request, &test_data->eval)); |
| return test_data; |
| } |
| |
| const int ITERATIONS = 256; |
| |
| // Benchmark driver to run expr multiple times. |
| void BenchmarkQueryFn(int batch_size, void* d) { |
| TestData* data = reinterpret_cast<TestData*>(d); |
| for (int i = 0; i < batch_size; ++i) { |
| for (int n = 0; n < ITERATIONS; ++n) { |
| void* value = data->eval->GetValue(NULL); |
| // Dummy result to prevent this from being optimized away |
| data->dummy_result += reinterpret_cast<int64_t>(value); |
| } |
| } |
| } |
| |
| #define BENCHMARK(name, stmt)\ |
| suite->AddBenchmark(name, BenchmarkQueryFn, GenerateBenchmarkExprs(stmt, false)) |
| // Machine Info: Intel(R) Core(TM) i7-2600 CPU @ 3.40GHz |
| // Literals: Function Rate Comparison |
| // ---------------------------------------------------------------------- |
| // int 2154 1X |
| // float 2155 1.001X |
| // double 2179 1.011X |
| // string 2179 1.011X |
| Benchmark* BenchmarkLiterals() { |
| Benchmark* suite = new Benchmark("Literals"); |
| BENCHMARK("int", "1"); |
| BENCHMARK("float", "1.1f"); |
| BENCHMARK("double", "1.1"); |
| BENCHMARK("string", "'1.1'"); |
| return suite; |
| } |
| |
| // Arithmetic: Function Rate Comparison |
| // ---------------------------------------------------------------------- |
| // int-add 527.5 1X |
| // double-add 528 1.001X |
| Benchmark* BenchmarkArithmetic() { |
| Benchmark* suite = new Benchmark("Arithmetic"); |
| BENCHMARK("int-add", "1 + 2"); |
| BENCHMARK("double-add", "1.1 + 2.2"); |
| return suite; |
| } |
| |
| // Machine Info: Intel(R) Core(TM) i7-2600 CPU @ 3.40GHz |
| // Like: Function Rate Comparison |
| // ---------------------------------------------------------------------- |
| // equals 203.9 1X |
| // not equals 426.4 2.091X |
| // strstr 142.8 0.7001X |
| // strncmp1 269.7 1.323X |
| // strncmp2 294.1 1.442X |
| // strncmp3 775.7 3.804X |
| // regex 19.7 0.0966X |
| Benchmark* BenchmarkLike() { |
| Benchmark* suite = new Benchmark("Like"); |
| BENCHMARK("equals", "'abcdefghijklmnopqrstuvwxyz' = 'abcdefghijklmnopqrstuvwxyz'"); |
| BENCHMARK("not equals", "'abcdefghijklmnopqrstuvwxyz' = 'lmnopqrstuvwxyz'"); |
| BENCHMARK("strstr", "'abcdefghijklmnopqrstuvwxyz' LIKE '%lmnopq%'"); |
| BENCHMARK("strncmp1", "'abcdefghijklmnopqrstuvwxyz' LIKE '%xyz'"); |
| BENCHMARK("strncmp2", "'abcdefghijklmnopqrstuvwxyz' LIKE 'abc%'"); |
| BENCHMARK("strncmp3", "'abcdefghijklmnopqrstuvwxyz' LIKE 'abc'"); |
| BENCHMARK("regex", "'abcdefghijklmnopqrstuvwxyz' LIKE 'abc%z'"); |
| return suite; |
| } |
| |
| // Cast: Function Rate Comparison |
| // ---------------------------------------------------------------------- |
| // int_to_int 824 1X |
| // int_to_bool 878 1.066X |
| // int_to_double 775.4 0.941X |
| // int_to_string 32.47 0.03941X |
| // double_to_boolean 823.5 0.9994X |
| // double_to_bigint 775.4 0.941X |
| // double_to_string 4.682 0.005682X |
| // string_to_int 402.6 0.4886X |
| // string_to_float 145.8 0.1769X |
| // string_to_timestamp 83.76 0.1017X |
| Benchmark* BenchmarkCast() { |
| Benchmark* suite = new Benchmark("Cast"); |
| BENCHMARK("int_to_int", "cast(1 as INT)"); |
| BENCHMARK("int_to_bool", "cast(1 as BOOLEAN)"); |
| BENCHMARK("int_to_double", "cast(1 as DOUBLE)"); |
| BENCHMARK("int_to_string", "cast(1 as STRING)"); |
| BENCHMARK("double_to_boolean", "cast(3.14 as BOOLEAN)"); |
| BENCHMARK("double_to_bigint", "cast(3.14 as BIGINT)"); |
| BENCHMARK("double_to_string", "cast(3.14 as STRING)"); |
| BENCHMARK("string_to_int", "cast('1234' as INT)"); |
| BENCHMARK("string_to_float", "cast('1234.5678' as FLOAT)"); |
| BENCHMARK("string_to_timestamp", "cast('2011-10-22 09:10:11' as TIMESTAMP)"); |
| return suite; |
| } |
| |
| Benchmark* BenchmarkDecimalCast() { |
| Benchmark* suite = new Benchmark("Decimal Casts"); |
| BENCHMARK("int_to_decimal4", "cast 12345678 as DECIMAL(9,2)"); |
| BENCHMARK("decimal4_to_decimal4", "cast 12345678.5 as DECIMAL(9,2)"); |
| BENCHMARK("decimal8_to_decimal4", "cast 12345678.345 as DECIMAL(9,2)"); |
| BENCHMARK("decimal16_to_decimal4", "cast 12345678.123456783456789 as DECIMAL(9,2)"); |
| BENCHMARK("double_to_decimal4", "cast e() as DECIMAL(9,7)"); |
| BENCHMARK("string_to_decimal4", "cast '12345678.123456783456789' as DECIMAL(9,2)"); |
| BENCHMARK("int_to_decimal8", "cast 12345678 as DECIMAL(18,2)"); |
| BENCHMARK("decimal4_to_decimal8", "cast 12345678.5 as DECIMAL(18,2)"); |
| BENCHMARK("decimal8_to_decimal8", "cast 12345678.345 as DECIMAL(18,2)"); |
| BENCHMARK("decimal16_to_decimal8", "cast 12345678.123456783456789 as DECIMAL(18,2)"); |
| BENCHMARK("double_to_decimal8", "cast e() as DECIMAL(18,7)"); |
| BENCHMARK("string_to_decimal8", "cast '12345678.123456783456789' as DECIMAL(18,7)"); |
| BENCHMARK("int_to_decimal16", "cast 12345678 as DECIMAL(28,2)"); |
| BENCHMARK("decimal4_to_decimal16", "cast 12345678.5 as DECIMAL(28,2)"); |
| BENCHMARK("decimal8_to_decimal16", "cast 12345678.345 as DECIMAL(28,2)"); |
| BENCHMARK("decimal16_to_decimal16", "cast 12345678.123456783456789 as DECIMAL(28,2)"); |
| BENCHMARK("double_to_decimal16", "cast e() as DECIMAL(28,7)"); |
| BENCHMARK("string_to_decimal16", "cast '12345678.123456783456789' as DECIMAL(28,7)"); |
| BENCHMARK("decimal4_to_tinyint", "cast 78.5 as TINYINT"); |
| BENCHMARK("decimal8_to_tinyint", "cast 0.12345678345 as TINYINT"); |
| BENCHMARK("decimal16_to_tinyint", "cast 78.12345678123456783456789 as TINYINT"); |
| BENCHMARK("decimal4_to_smallint", "cast 78.5 as SMALLINT"); |
| BENCHMARK("decimal8_to_smallint", "cast 0.12345678345 as SMALLINT"); |
| BENCHMARK("decimal16_to_smallint", "cast 78.12345678123456783456789 as SMALLINT"); |
| BENCHMARK("decimal4_to_int", "cast 12345678.5 as INT"); |
| BENCHMARK("decimal8_to_int", "cast 12345678.345 as INT"); |
| BENCHMARK("decimal16_to_int", "cast 12345678.123456783456789 as INT"); |
| BENCHMARK("decimal4_to_bigint", "cast 12345678.5 as BIGINT"); |
| BENCHMARK("decimal8_to_bigint", "cast 12345678.345 as BIGINT"); |
| BENCHMARK("decimal16_to_bigint", "cast 12345678.123456783456789 as BIGINT"); |
| BENCHMARK("decimal4_to_float", "cast 12345678.5 as FLOAT"); |
| BENCHMARK("decimal8_to_float", "cast 12345678.345 as FLOAT"); |
| BENCHMARK("decimal16_to_float", "cast 12345678.123456783456789 as FLOAT"); |
| BENCHMARK("decimal4_to_double", "cast 12345678.5 as DOUBLE"); |
| BENCHMARK("decimal8_to_double", "cast 12345678.345 as DOUBLE"); |
| BENCHMARK("decimal16_to_double", "cast 12345678.123456783456789 as DOUBLE"); |
| BENCHMARK("decimal4_to_string", "cast 12345678.5 as STRING"); |
| BENCHMARK("decimal8_to_string", "cast 12345678.345 as STRING"); |
| BENCHMARK("decimal16_to_string", "cast 12345678.123456783456789 as STRING"); |
| return suite; |
| } |
| |
| // ConditionalFunctions: Function Rate Comparison |
| // ---------------------------------------------------------------------- |
| // not_null 877.8 1X |
| // is null 938.3 1.069X |
| // compound 240.2 0.2736X |
| // int_between 191 0.2176X |
| // timestamp_between 18.5 0.02108X |
| // string_between 93.94 0.107X |
| // bool_in 356.6 0.4063X |
| // int_in 209.7 0.2389X |
| // float_in 216.4 0.2465X |
| // string_in 120.1 0.1368X |
| // timestamp_in 19.79 0.02255X |
| // if_int 506.8 0.5773X |
| // if_string 470.6 0.5361X |
| // if_timestamp 70.19 0.07996X |
| // coalesce_bool 194.2 0.2213X |
| // case_int 259 0.2951X |
| Benchmark* BenchmarkConditionalFunctions() { |
| // TODO: expand these cases when the parser issues are fixed (see corresponding tests |
| // in expr-test). |
| Benchmark* suite = new Benchmark("ConditionalFunctions"); |
| BENCHMARK("not_null", "!NULL"); |
| BENCHMARK("is null", "5 IS NOT NULL"); |
| BENCHMARK("compound", "(TRUE && TRUE) || FALSE"); |
| BENCHMARK("int_between", "5 between 5 and 6"); |
| BENCHMARK("timestamp_between", "cast('2011-10-22 09:10:11' as timestamp) between " |
| "cast('2011-09-22 09:10:11' as timestamp) and " |
| "cast('2011-12-22 09:10:11' as timestamp)"); |
| BENCHMARK("string_between", "'abc' between 'aaa' and 'aab'"); |
| BENCHMARK("bool_in", "true in (true, false, false)"); |
| BENCHMARK("int_in", "1 in (2, 3, 1)"); |
| BENCHMARK("float_in","1.1 not in (2, 3, 4.5)"); |
| BENCHMARK("string_in", "'ab' in ('cd', 'efg', 'ab', 'h')"); |
| BENCHMARK("timestamp_in", "cast('2011-11-23' as timestamp) " |
| "in (cast('2011-11-22 09:10:11' as timestamp), " |
| "cast('2011-11-23 09:11:12' as timestamp), " |
| "cast('2011-11-24 09:12:13' as timestamp))"); |
| BENCHMARK("if_int", "if(TRUE, 10, 20)"); |
| BENCHMARK("if_string", "if(TRUE, 'abc', 'defgh')"); |
| BENCHMARK("if_timestamp", "if(TRUE, cast('2011-01-01 09:01:01' as timestamp), " |
| "cast('1999-06-14 19:07:25' as timestamp))"); |
| BENCHMARK("coalesce_bool", "coalesce(if(true, NULL, NULL), if(true, NULL, NULL))"); |
| BENCHMARK("case_int", "case 21 when 20 then 1 when 19 then 2 when 21 then 3 end"); |
| return suite; |
| } |
| |
| // StringFunctions: Function Rate Comparison |
| // ---------------------------------------------------------------------- |
| // length 920.2 1X |
| // substring1 351.4 0.3819X |
| // substring2 327.9 0.3563X |
| // left 508.6 0.5527X |
| // right 508.2 0.5522X |
| // lower 103.9 0.1129X |
| // upper 103.2 0.1121X |
| // reverse 324.9 0.3531X |
| // trim 421.2 0.4578X |
| // ltrim 526.6 0.5723X |
| // rtrim 566.5 0.6156X |
| // space 94.63 0.1028X |
| // ascii 1048 1.139X |
| // instr 175.6 0.1909X |
| // locate 184.7 0.2007X |
| // locate2 175.8 0.1911X |
| // concat 109.5 0.119X |
| // concat2 75.83 0.08241X |
| // concatws 143.4 0.1559X |
| // concatws2 70.38 0.07649X |
| // repeat 98.54 0.1071X |
| // lpad 154.7 0.1681X |
| // rpad 145.6 0.1582X |
| // find_in_set 83.38 0.09061X |
| // regexp_extract 6.42 0.006977X |
| // regexp_replace 0.7435 0.000808X |
| Benchmark* BenchmarkStringFunctions() { |
| Benchmark* suite = new Benchmark("StringFunctions"); |
| BENCHMARK("length", "length('Hello World!')"); |
| BENCHMARK("substring1", "substring('Hello World!', 5)"); |
| BENCHMARK("substring2", "substring('Hello World!', 5, 5)"); |
| BENCHMARK("left", "strleft('Hello World!', 7)"); |
| BENCHMARK("right", "strleft('Hello World!', 7)"); |
| BENCHMARK("lower", "lower('Hello World!')"); |
| BENCHMARK("upper", "upper('Hello World!')"); |
| BENCHMARK("reverse", "reverse('Hello World!')"); |
| BENCHMARK("trim", "trim(' Hello World! ')"); |
| BENCHMARK("ltrim", "ltrim(' Hello World! ')"); |
| BENCHMARK("rtrim", "rtrim(' Hello World! ')"); |
| BENCHMARK("space", "space(7)"); |
| BENCHMARK("ascii", "ascii('abcd')"); |
| BENCHMARK("instr", "instr('xyzabc', 'abc')"); |
| BENCHMARK("locate", "locate('abc', 'xyzabc')"); |
| BENCHMARK("locate2", "locate('abc', 'abcxyzabc', 3)"); |
| BENCHMARK("concat", "concat('a', 'bcd')"); |
| BENCHMARK("concat2", "concat('a', 'bb', 'ccc', 'dddd')"); |
| BENCHMARK("concatws", "concat_ws('a', 'b')"); |
| BENCHMARK("concatws2", "concat_ws('a', 'b', 'c', 'd')"); |
| BENCHMARK("repeat", "repeat('abc', 7)"); |
| BENCHMARK("lpad", "lpad('abc', 7, 'xyz')"); |
| BENCHMARK("rpad", "rpad('abc', 7, 'xyz')"); |
| BENCHMARK("find_in_set", "find_in_set('ab', 'abc,ad,ab,ade,cde')"); |
| BENCHMARK("regexp_extract", "regexp_extract('abxcy1234a', 'a.x.y.*a', 0)"); |
| BENCHMARK("regexp_replace", "regexp_replace('axcaycazc', '', 'r')"); |
| return suite; |
| } |
| |
| // UrlFunctions: Function Rate Comparison |
| // ---------------------------------------------------------------------- |
| // authority 118.1 1X |
| // file 95.52 0.809X |
| // host 94.52 0.8005X |
| // path 98.63 0.8353X |
| // protocol 36.29 0.3073X |
| // user 121.1 1.026X |
| // user_info 121.4 1.029X |
| // query_name 41.34 0.3501X |
| Benchmark* BenchmarkUrlFunctions() { |
| Benchmark* suite = new Benchmark("UrlFunctions"); |
| BENCHMARK("authority", "parse_url('http://user:pass@example.com:80/docs/books/tutorial/" |
| "index.html?name=networking#DOWNLOADING', 'AUTHORITY')"); |
| BENCHMARK("file", "parse_url('http://example.com/docs/books/tutorial/" |
| "index.html?name=networking ', 'FILE')"); |
| BENCHMARK("host", "parse_url('http://example.com:80/docs/books/tutorial/" |
| "index.html?name=networking#DOWNLOADING', 'HOST')"); |
| BENCHMARK("path", "parse_url('http://user:pass@example.com/docs/books/tutorial/" |
| "index.html?name=networking#DOWNLOADING', 'PATH')"); |
| BENCHMARK("protocol", "parse_url('user:pass@example.com/docs/books/tutorial/" |
| "index.html?name=networking#DOWNLOADING', 'PROTOCOL')"); |
| BENCHMARK("user", "parse_url('http://user@example.com/docs/books/tutorial/" |
| "index.html?name=networking#DOWNLOADING', 'USERINFO')"); |
| BENCHMARK("user_info", "parse_url('http://user:pass@example.com:80/docs/books/tutorial/" |
| "index.html?name=networking#DOWNLOADING', 'USERINFO')"); |
| BENCHMARK("query_name", "parse_url('http://example.com:80/docs/books/tutorial/" |
| "index.htmltest=true&name=networking&op=true', 'QUERY', 'name')"); |
| return suite; |
| } |
| |
| // MathFunctions: Function Rate Comparison |
| // ---------------------------------------------------------------------- |
| // pi 1642 1X |
| // e 1546 0.9416X |
| // abs 877 0.5342X |
| // ln 110.7 0.06744X |
| // log10 88.48 0.0539X |
| // log2 108.3 0.06597X |
| // log 55.61 0.03387X |
| // pow 53.93 0.03285X |
| // sqrt 629.6 0.3835X |
| // sign 732 0.4459X |
| // sin 176.3 0.1074X |
| // asin 169.6 0.1033X |
| // cos 156.3 0.0952X |
| // acos 167.5 0.102X |
| // tan 176.3 0.1074X |
| // atan 153.8 0.09371X |
| // radians 601.5 0.3664X |
| // degrees 601.5 0.3664X |
| // bin 45 0.02741X |
| // pmod_int 147.3 0.08976X |
| // pmod_float 172.9 0.1053X |
| // positive 877 0.5342X |
| // negative 936.9 0.5707X |
| // ceil 466.7 0.2843X |
| // floor 390.9 0.2381X |
| // round 820.5 0.4998X |
| // round2 220.2 0.1341X |
| // hex_int 5.745 0.0035X |
| // hex_string 4.441 0.002705X |
| // unhex 3.394 0.002067X |
| // conv_int 33.15 0.02019X |
| // conv_string 36.6 0.02229X |
| Benchmark* BenchmarkMathFunctions() { |
| Benchmark* suite = new Benchmark("MathFunctions"); |
| BENCHMARK("pi", "pi()"); |
| BENCHMARK("e", "e()"); |
| BENCHMARK("abs", "abs(-1.0)"); |
| BENCHMARK("ln", "ln(3.14)"); |
| BENCHMARK("log10", "log10(3.14)"); |
| BENCHMARK("log2", "log2(3.14)"); |
| BENCHMARK("log", "log(3.14, 5)"); |
| BENCHMARK("pow", "pow(3.14, 5)"); |
| BENCHMARK("sqrt", "sqrt(3.14)"); |
| BENCHMARK("sign", "sign(1.0)"); |
| BENCHMARK("sin", "sin(3.14)"); |
| BENCHMARK("asin", "asin(3.14)"); |
| BENCHMARK("cos", "cos(3.14)"); |
| BENCHMARK("acos", "acos(3.14)"); |
| BENCHMARK("tan", "tan(3.14)"); |
| BENCHMARK("atan", "atan(3.14)"); |
| BENCHMARK("radians", "radians(3.14)"); |
| BENCHMARK("degrees", "degrees(3.14)"); |
| BENCHMARK("bin", "bin(12345)"); |
| BENCHMARK("pmod_int", "pmod(12345, 12)"); |
| BENCHMARK("pmod_float", "pmod(12345.678, 12.34)"); |
| BENCHMARK("positive", "positive(12345)"); |
| BENCHMARK("negative", "negative(12345)"); |
| BENCHMARK("ceil", "ceil(-10.05)"); |
| BENCHMARK("floor", "floor(-10.05)"); |
| BENCHMARK("round", "round(-10.05)"); |
| BENCHMARK("round2", "round(-10.056789, 4)"); |
| BENCHMARK("hex_int", "hex(16)"); |
| BENCHMARK("hex_string", "hex('impala')"); |
| BENCHMARK("unhex", "hex('496D70616C61')"); |
| BENCHMARK("conv_int", "conv(100101, 2, 36)"); |
| BENCHMARK("conv_string", "conv('100101', 2, 36)"); |
| return suite; |
| } |
| |
| // TimestampFunctions: Function Rate Comparison |
| // ---------------------------------------------------------------------- |
| // literal 68.18 1X |
| // to_string 1.131 0.01659X |
| // add_year 34.57 0.507X |
| // sub_month 33.04 0.4846X |
| // add_weeks 56.15 0.8236X |
| // sub_days 57.21 0.8391X |
| // add 55.85 0.8191X |
| // sub_hours 44.44 0.6519X |
| // add_minutes 43.96 0.6448X |
| // sub_seconds 42.78 0.6274X |
| // add_milli 43.43 0.6371X |
| // sub_micro 43.88 0.6436X |
| // add_nano 41.83 0.6135X |
| // unix_timestamp1 32.74 0.4803X |
| // unix_timestamp2 39.39 0.5778X |
| // from_unix1 1.192 0.01748X |
| // from_unix2 1.602 0.0235X |
| // year 73.4 1.077X |
| // month 72.53 1.064X |
| // day of month 71.98 1.056X |
| // day of year 56.67 0.8312X |
| // week of year 50.68 0.7433X |
| // hour 100.1 1.468X |
| // minute 97.18 1.425X |
| // second 96.7 1.418X |
| // to date 3.075 0.04511X |
| // date diff 39.54 0.5799X |
| Benchmark* BenchmarkTimestampFunctions() { |
| Benchmark* suite = new Benchmark("TimestampFunctions"); |
| BENCHMARK("literal", "cast('2012-01-01 09:10:11.123456789' as timestamp)"); |
| BENCHMARK("to_string", |
| "cast(cast('2012-01-01 09:10:11.123456789' as timestamp) as string)"); |
| BENCHMARK("add_year", "date_add(cast('2012-01-01 09:10:11.123456789' " |
| "as timestamp), interval 10 years)"); |
| BENCHMARK("sub_month", "date_sub(cast('2012-02-29 09:10:11.123456789' " |
| "as timestamp), interval 1 month)"); |
| BENCHMARK("add_weeks", "date_add(cast('2012-01-01 09:10:11.123456789' " |
| "as timestamp), interval 53 weeks)"); |
| BENCHMARK("sub_days", "date_sub(cast('2011-12-22 09:10:11.12345678' " |
| "as timestamp), interval 365 days)"); |
| BENCHMARK("add", "date_add(cast('2012-01-01 09:10:11.123456789' " |
| "as timestamp), 10)"); |
| BENCHMARK("sub_hours", "date_sub(cast('2012-01-02 01:00:00.123456789' " |
| "as timestamp), interval 25 hours)"); |
| BENCHMARK("add_minutes", "date_add(cast('2012-01-01 00:00:00.123456789' " |
| "as timestamp), interval 1533 minutes)"); |
| BENCHMARK("sub_seconds", "date_sub(cast('2012-01-02 01:00:33.123456789' " |
| "as timestamp), interval 90033 seconds)"); |
| BENCHMARK("add_milli", "date_add(cast('2012-01-01 00:00:00.000000001' " |
| "as timestamp), interval 90000033 milliseconds)"); |
| BENCHMARK("sub_micro", "date_sub(cast('2012-01-01 00:00:00.001033001' " |
| "as timestamp), interval 1033 microseconds)"); |
| BENCHMARK("add_nano", "date_add(cast('2012-01-01 00:00:00.000000001' " |
| "as timestamp), interval 1033 nanoseconds)"); |
| BENCHMARK("unix_timestamp1", |
| "unix_timestamp('1970-01-01 00:00:00', 'yyyy-MM-dd HH:mm:ss')"); |
| BENCHMARK("unix_timestamp2", |
| "unix_timestamp('1970-10-01', 'yyyy-MM-dd')"); |
| BENCHMARK("from_unix1", "from_unixtime(0, 'yyyy-MM-dd HH:mm:ss')"); |
| BENCHMARK("from_unix2", "from_unixtime(0, 'yyyy-MM-dd')"); |
| BENCHMARK("year", "year(cast('2011-12-22' as timestamp))"); |
| BENCHMARK("month", "month(cast('2011-12-22' as timestamp))"); |
| BENCHMARK("day of month", "dayofmonth(cast('2011-12-22' as timestamp))"); |
| BENCHMARK("day of year", "dayofyear(cast('2011-12-22' as timestamp))"); |
| BENCHMARK("week of year", "weekofyear(cast('2011-12-22' as timestamp))"); |
| BENCHMARK("hour", "hour(cast('09:10:11.000000' as timestamp))"); |
| BENCHMARK("minute", "minute(cast('09:10:11.000000' as timestamp))"); |
| BENCHMARK("second", "second(cast('09:10:11.000000' as timestamp))"); |
| BENCHMARK("to date", |
| "to_date(cast('2011-12-22 09:10:11.12345678' as timestamp))"); |
| BENCHMARK("date diff", "datediff(cast('2011-12-22 09:10:11.12345678' as timestamp), " |
| "cast('2012-12-22' as timestamp))"); |
| #if 0 |
| // TODO: need to create a valid runtime state for these functions |
| BENCHMARK("from utc", |
| "from_utc_timestamp(cast(1.3041352164485E9 as timestamp), 'PST')"); |
| BENCHMARK("to utc", |
| "to_utc_timestamp(cast('2011-01-01 01:01:01' as timestamp), 'PST')"); |
| BENCHMARK("now", "now()"); |
| BENCHMARK("unix_timestamp", "unix_timestamp()"); |
| #endif |
| return suite; |
| } |
| |
| int main(int argc, char** argv) { |
| impala::InitCommonRuntime(argc, argv, true, impala::TestInfo::BE_TEST); |
| impala::InitFeSupport(false); |
| ABORT_IF_ERROR(impala::LlvmCodeGen::InitializeLlvm()); |
| |
| // Dynamically construct at runtime as the planner initialization depends on |
| // static objects being initialized in other compilation modules. |
| planner = new Planner(); |
| |
| // Generate all the tests first (this does the planning) |
| Benchmark* literals = BenchmarkLiterals(); |
| Benchmark* arithmetics = BenchmarkArithmetic(); |
| Benchmark* like = BenchmarkLike(); |
| Benchmark* cast = BenchmarkCast(); |
| Benchmark* decimal_cast = BenchmarkDecimalCast(); |
| Benchmark* conditional_fns = BenchmarkConditionalFunctions(); |
| Benchmark* string_fns = BenchmarkStringFunctions(); |
| Benchmark* url_fns = BenchmarkUrlFunctions(); |
| Benchmark* math_fns = BenchmarkMathFunctions(); |
| Benchmark* timestamp_fns = BenchmarkTimestampFunctions(); |
| |
| cout << Benchmark::GetMachineInfo() << endl; |
| cout << literals->Measure() << endl; |
| cout << arithmetics->Measure() << endl; |
| cout << like->Measure() << endl; |
| cout << cast->Measure() << endl; |
| cout << decimal_cast->Measure() << endl; |
| cout << conditional_fns->Measure() << endl; |
| cout << string_fns->Measure() << endl; |
| cout << url_fns->Measure() << endl; |
| cout << math_fns->Measure() << endl; |
| cout << timestamp_fns->Measure() << endl; |
| |
| return 0; |
| } |
