diff --git a/tests/benchmarks/CMakeLists.txt b/tests/benchmarks/CMakeLists.txt index 774746e8..483b0453 100644 --- a/tests/benchmarks/CMakeLists.txt +++ b/tests/benchmarks/CMakeLists.txt @@ -15,8 +15,10 @@ add_executable(casbin_benchmark config_path.h main.cpp + model_b.cpp enforcer_cached_b.cpp management_api_b.cpp + role_manager_b.cpp ) target_include_directories(casbin_benchmark PUBLIC ${CMAKE_SOURCE_DIR}) diff --git a/tests/benchmarks/enforcer_cached_b.cpp b/tests/benchmarks/enforcer_cached_b.cpp index 4b08a947..322b306c 100644 --- a/tests/benchmarks/enforcer_cached_b.cpp +++ b/tests/benchmarks/enforcer_cached_b.cpp @@ -93,9 +93,9 @@ static void BenchmarkCachedRBACModelLarge(benchmark::State& state) { p_policies[i] = {"group", std::to_string(i), "data", std::to_string(i / 10), "read"}; e.AddPolicies(p_policies); - // 100000 users. - std::vector> g_policies(100000); - for (int i = 0; i < 100000; ++i) { + // 100000 users. + std::vector> g_policies(100000); + for (int i = 0; i < 100000; ++i) { g_policies[i] = {"user" + std::to_string(i), "group", std::to_string(i / 10)}; } e.AddGroupingPolicies(g_policies); diff --git a/tests/benchmarks/management_api_b.cpp b/tests/benchmarks/management_api_b.cpp index bee7836d..58605fcf 100644 --- a/tests/benchmarks/management_api_b.cpp +++ b/tests/benchmarks/management_api_b.cpp @@ -39,7 +39,7 @@ static inline int GetRandom1000() static inline int GetRandom10000() { - return dist_10000(generator); + return dist_10000(generator); } static void BenchmarkVectorOperations(benchmark::State& state) { diff --git a/tests/benchmarks/model_b.cpp b/tests/benchmarks/model_b.cpp new file mode 100644 index 00000000..e603e8d9 --- /dev/null +++ b/tests/benchmarks/model_b.cpp @@ -0,0 +1,174 @@ +/* +* Copyright 2021 The casbin Authors. All Rights Reserved. +* +* Licensed 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. +* +* This is a test file for benchmarking the performance of casbin::Model +*/ + +#include +#include +#include "config_path.h" + +static const std::vector> s_policy = { {"alice", "data1", "read"}, {"bob", "data2", "write"} }; + +static bool rawEnforce(const std::string& sub, const std::string& obj, const std::string& act) { + for(const auto& rule : s_policy) { + if(rule[0] == sub && rule[1] == obj && rule[2] == act) + return true; + } + return false; +} + +static void BenchmarkRaw(benchmark::State& state) { + for(auto _ : state) + rawEnforce("alice", "data1", "read"); +} + +BENCHMARK(BenchmarkRaw); + +static void BenchmarkBasicModel(benchmark::State& state) { + casbin::Enforcer e(basic_model_path, basic_policy_path); + casbin::DataList params = {"alice", "data1", "read"}; + + for(auto _ : state) + e.Enforce(params); +} + +BENCHMARK(BenchmarkBasicModel); + +static void BenchmarkRBACModel(benchmark::State& state) { + casbin::Enforcer e(rbac_model_path, rbac_policy_path); + + casbin::DataList params = {"alice", "data2", "read"}; + + for (auto _ : state) + e.Enforce(params); +} + +BENCHMARK(BenchmarkRBACModel); + +static void BenchmarkRBACModelSmall(benchmark::State& state) { + casbin::Enforcer e(rbac_model_path); + + // 100 roles, 10 resources. + for(int i = 0; i < 100; ++i) + e.AddPolicy({ "group" + std::to_string(i), "data" + std::to_string(i/10), "read" }); + + // 1000 users. + for(int i = 0; i < 1000; ++i) + e.AddGroupingPolicy({ "user" + std::to_string(i), "group" + std::to_string(i / 10) }); + + casbin::DataList params = {"user501", "data9", "read"}; + for (auto _ : state) + e.Enforce(params); +} + +BENCHMARK(BenchmarkRBACModelSmall); + +static void BenchmarkRBACModelMedium(benchmark::State& state) { + casbin::Enforcer e(rbac_model_path); + + // 1000 roles, 100 resources. + for (int i = 0; i < 1000; ++i) + e.AddPolicy({"group" + std::to_string(i), "data" + std::to_string(i / 10), "read"}); + + // 10000 users. + for (int i = 0; i < 10000; ++i) + e.AddGroupingPolicy({"user" + std::to_string(i), "group" + std::to_string(i / 10)}); + + casbin::DataList params = {"user5001", "data99", "read"}; + for (auto _ : state) + e.Enforce(params); +} + +BENCHMARK(BenchmarkRBACModelMedium); + +static void BenchmarkRBACModelLarge(benchmark::State& state) { + casbin::Enforcer e(rbac_model_path); + + // 10000 roles, 1000 resources. + for(int i = 0; i < 10000; ++i) + e.AddPolicy({"group" + std::to_string(i), "data" + std::to_string(i / 10), "read"}); + + // 100000 users. + for(int i = 0; i < 100000; i++) + e.AddGroupingPolicy({"user" + std::to_string(i), "group" + std::to_string(i / 10)}); + + casbin::DataList params = {"user50001", "data999", "read"}; + + for(auto _ : state) + e.Enforce(params); +} + +// BENCHMARK(BenchmarkRBACModelLarge); + +static void BenchmarkRBACModelWithResourceRoles(benchmark::State& state) { + casbin::Enforcer e(rbac_with_resource_roles_model_path, rbac_with_resource_roles_policy_path); + casbin::DataList params = {"alice", "data1", "read"}; + for (auto _ : state) + e.Enforce(params); +} + +// BENCHMARK(BenchmarkRBACModelWithResourceRoles); + +static void BenchmarkRBACModelWithDomains(benchmark::State& state) { + casbin::Enforcer e(rbac_with_domains_model_path, rbac_with_domains_policy_path); + casbin::DataList params = {"alice", "domain1", "data1", "read"}; + + for(auto _ : state) + e.Enforce(params); +} + +BENCHMARK(BenchmarkRBACModelWithDomains); + +// ------ TODO ------ +// static void BenchmarkABACModel(benchmark::State& state) { +// casbin::Enforcer e("examples/abac_model.conf") +// data1 := newTestResource("data1", "alice") + + +// for(auto _ : state) { +// _, _ = e.Enforce("alice", data1, "read") +// } +// } + +static void BenchmarkKeyMatchModel(benchmark::State& state) { + casbin::Enforcer e(keymatch_model_path, keymatch_policy_path); + casbin::DataList params = {"alice", "/alice_data/resource1", "GET"}; + + for (auto _ : state) + e.Enforce(params); +} + +BENCHMARK(BenchmarkKeyMatchModel); + +static void BenchmarkRBACModelWithDeny(benchmark::State& state) { + casbin::Enforcer e(rbac_with_deny_model_path, rbac_with_deny_policy_path); + casbin::DataList params = {"alice", "data1", "read"}; + + for(auto _ : state) + e.Enforce(params); +} + +BENCHMARK(BenchmarkRBACModelWithDeny); + +static void BenchmarkPriorityModel(benchmark::State& state) { + casbin::Enforcer e(priority_model_path, priority_policy_path); + casbin::DataList params = {"alice", "data1", "read"}; + + for(auto _ : state) + e.Enforce(params); +} + +BENCHMARK(BenchmarkPriorityModel); diff --git a/tests/benchmarks/role_manager_b.cpp b/tests/benchmarks/role_manager_b.cpp new file mode 100644 index 00000000..519265f9 --- /dev/null +++ b/tests/benchmarks/role_manager_b.cpp @@ -0,0 +1,97 @@ +/* +* Copyright 2021 The casbin Authors. All Rights Reserved. +* +* Licensed 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. +* +* This is a test file for benchmarking the performance of casbin::RoleManager +*/ + +#include +#include +#include "config_path.h" + +static std::vector params(3); +static std::vector g_params(2); + +static void BenchmarkRoleManagerSmall(benchmark::State& state) { + casbin::Enforcer e(rbac_model_path); + // Do not rebuild the role inheritance relations for every AddGroupingPolicy() call. + e.EnableAutoBuildRoleLinks(false); + + // 100 roles, 10 resources. + for (int i = 0; i < 100; ++i) + params = {"group" + std::to_string(i), "data" + std::to_string(i / 10), "read"}, e.AddPolicy(params); + + // 1000 users. + for (int i = 0; i < 1000; ++i) + g_params = {"user" + std::to_string(i), "group" + std::to_string(i / 10)}, e.AddGroupingPolicy(g_params); + + auto rm = e.GetRoleManager(); + + for(auto _ : state) { + for(int j = 0; j < 100; ++j) + rm->HasLink("user501", "group" + std::to_string(j)); + } +} + +BENCHMARK(BenchmarkRoleManagerSmall); + +static void BenchmarkRoleManagerMedium(benchmark::State& state) { + casbin::Enforcer e(rbac_model_path); + // Do not rebuild the role inheritance relations for every AddGroupingPolicy() call. + e.EnableAutoBuildRoleLinks(false); + + // 1000 roles, 100 resources. + + for (int i = 0; i < 1000; ++i) + params = {"group" + std::to_string(i), "data" + std::to_string(i / 10), "read"}, e.AddPolicy(params); + + // 10000 users. + + for (int i = 0; i < 10000; ++i) + g_params = {"user" + std::to_string(i), "group" + std::to_string(i / 10)}, e.AddGroupingPolicy(g_params); + + e.BuildRoleLinks(); + + auto rm = e.GetRoleManager(); + + for(auto _ : state) { + for(int j = 0; j < 1000; ++j) + rm->HasLink("user501", "group" + std::to_string(j)); + } +} + +BENCHMARK(BenchmarkRoleManagerMedium); + +static void BenchmarkRoleManagerLarge(benchmark::State& state) { + casbin::Enforcer e(rbac_model_path); + + // 10000 roles, 1000 resources. + + for (int i = 0; i < 10000; ++i) + params = {"group" + std::to_string(i), "data" + std::to_string(i / 10), "read"}, e.AddPolicy(params); + + // 100000 users. + + for (int i = 0; i < 100000; ++i) + g_params = {"user" + std::to_string(i), "group" + std::to_string(i / 10)}, e.AddGroupingPolicy(g_params); + + auto rm = e.GetRoleManager(); + + for(auto _ : state) { + for(int j = 0; j < 10000; ++j) + rm->HasLink("user501", "group" + std::to_string(j)); + } +} + +// BENCHMARK(BenchmarkRoleManagerLarge);