Yao Chen | caf339d | 2017-10-06 16:01:10 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2017 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
Joe Onorato | 9fc9edf | 2017-10-15 20:08:52 -0700 | [diff] [blame] | 16 | |
Yao Chen | 3c0b95c | 2017-12-16 14:34:20 -0800 | [diff] [blame] | 17 | #define DEBUG false // STOPSHIP if true |
Joe Onorato | 9fc9edf | 2017-10-15 20:08:52 -0700 | [diff] [blame] | 18 | #include "Log.h" |
Yao Chen | caf339d | 2017-10-06 16:01:10 -0700 | [diff] [blame] | 19 | #include "CombinationConditionTracker.h" |
Joe Onorato | 9fc9edf | 2017-10-15 20:08:52 -0700 | [diff] [blame] | 20 | |
Yao Chen | caf339d | 2017-10-06 16:01:10 -0700 | [diff] [blame] | 21 | #include <log/logprint.h> |
Yao Chen | caf339d | 2017-10-06 16:01:10 -0700 | [diff] [blame] | 22 | |
| 23 | namespace android { |
| 24 | namespace os { |
| 25 | namespace statsd { |
| 26 | |
Yao Chen | 729093d | 2017-10-16 10:33:26 -0700 | [diff] [blame] | 27 | using std::map; |
Joe Onorato | 9fc9edf | 2017-10-15 20:08:52 -0700 | [diff] [blame] | 28 | using std::string; |
| 29 | using std::unique_ptr; |
| 30 | using std::unordered_map; |
| 31 | using std::vector; |
| 32 | |
Yangster-mac | 94e197c | 2018-01-02 16:03:03 -0800 | [diff] [blame] | 33 | CombinationConditionTracker::CombinationConditionTracker(const int64_t& id, const int index) |
| 34 | : ConditionTracker(id, index) { |
| 35 | VLOG("creating CombinationConditionTracker %lld", (long long)mConditionId); |
Yao Chen | caf339d | 2017-10-06 16:01:10 -0700 | [diff] [blame] | 36 | } |
| 37 | |
| 38 | CombinationConditionTracker::~CombinationConditionTracker() { |
Yangster-mac | 94e197c | 2018-01-02 16:03:03 -0800 | [diff] [blame] | 39 | VLOG("~CombinationConditionTracker() %lld", (long long)mConditionId); |
Yao Chen | caf339d | 2017-10-06 16:01:10 -0700 | [diff] [blame] | 40 | } |
| 41 | |
Stefan Lafon | 12d01fa | 2017-12-04 20:56:09 -0800 | [diff] [blame] | 42 | bool CombinationConditionTracker::init(const vector<Predicate>& allConditionConfig, |
Yao Chen | caf339d | 2017-10-06 16:01:10 -0700 | [diff] [blame] | 43 | const vector<sp<ConditionTracker>>& allConditionTrackers, |
Yangster-mac | 94e197c | 2018-01-02 16:03:03 -0800 | [diff] [blame] | 44 | const unordered_map<int64_t, int>& conditionIdIndexMap, |
Yao Chen | caf339d | 2017-10-06 16:01:10 -0700 | [diff] [blame] | 45 | vector<bool>& stack) { |
Yangster-mac | 94e197c | 2018-01-02 16:03:03 -0800 | [diff] [blame] | 46 | VLOG("Combination predicate init() %lld", (long long)mConditionId); |
Yao Chen | caf339d | 2017-10-06 16:01:10 -0700 | [diff] [blame] | 47 | if (mInitialized) { |
| 48 | return true; |
| 49 | } |
| 50 | |
| 51 | // mark this node as visited in the recursion stack. |
| 52 | stack[mIndex] = true; |
| 53 | |
Stefan Lafon | 12d01fa | 2017-12-04 20:56:09 -0800 | [diff] [blame] | 54 | Predicate_Combination combinationCondition = allConditionConfig[mIndex].combination(); |
Yao Chen | caf339d | 2017-10-06 16:01:10 -0700 | [diff] [blame] | 55 | |
| 56 | if (!combinationCondition.has_operation()) { |
| 57 | return false; |
| 58 | } |
| 59 | mLogicalOperation = combinationCondition.operation(); |
| 60 | |
Stefan Lafon | 12d01fa | 2017-12-04 20:56:09 -0800 | [diff] [blame] | 61 | if (mLogicalOperation == LogicalOperation::NOT && combinationCondition.predicate_size() != 1) { |
Yao Chen | caf339d | 2017-10-06 16:01:10 -0700 | [diff] [blame] | 62 | return false; |
| 63 | } |
| 64 | |
Yangster-mac | 94e197c | 2018-01-02 16:03:03 -0800 | [diff] [blame] | 65 | for (auto child : combinationCondition.predicate()) { |
| 66 | auto it = conditionIdIndexMap.find(child); |
Yao Chen | caf339d | 2017-10-06 16:01:10 -0700 | [diff] [blame] | 67 | |
Yangster-mac | 94e197c | 2018-01-02 16:03:03 -0800 | [diff] [blame] | 68 | if (it == conditionIdIndexMap.end()) { |
| 69 | ALOGW("Predicate %lld not found in the config", (long long)child); |
Yao Chen | caf339d | 2017-10-06 16:01:10 -0700 | [diff] [blame] | 70 | return false; |
| 71 | } |
| 72 | |
| 73 | int childIndex = it->second; |
| 74 | const auto& childTracker = allConditionTrackers[childIndex]; |
| 75 | // if the child is a visited node in the recursion -> circle detected. |
| 76 | if (stack[childIndex]) { |
| 77 | ALOGW("Circle detected!!!"); |
| 78 | return false; |
| 79 | } |
| 80 | |
| 81 | bool initChildSucceeded = childTracker->init(allConditionConfig, allConditionTrackers, |
Yangster-mac | 94e197c | 2018-01-02 16:03:03 -0800 | [diff] [blame] | 82 | conditionIdIndexMap, stack); |
Yao Chen | caf339d | 2017-10-06 16:01:10 -0700 | [diff] [blame] | 83 | |
| 84 | if (!initChildSucceeded) { |
Yangster-mac | 94e197c | 2018-01-02 16:03:03 -0800 | [diff] [blame] | 85 | ALOGW("Child initialization failed %lld ", (long long)child); |
Yao Chen | caf339d | 2017-10-06 16:01:10 -0700 | [diff] [blame] | 86 | return false; |
| 87 | } else { |
Yangster-mac | 94e197c | 2018-01-02 16:03:03 -0800 | [diff] [blame] | 88 | ALOGW("Child initialization success %lld ", (long long)child); |
Yao Chen | caf339d | 2017-10-06 16:01:10 -0700 | [diff] [blame] | 89 | } |
| 90 | |
| 91 | mChildren.push_back(childIndex); |
| 92 | |
| 93 | mTrackerIndex.insert(childTracker->getLogTrackerIndex().begin(), |
| 94 | childTracker->getLogTrackerIndex().end()); |
| 95 | } |
| 96 | |
| 97 | // unmark this node in the recursion stack. |
| 98 | stack[mIndex] = false; |
| 99 | |
| 100 | mInitialized = true; |
| 101 | |
| 102 | return true; |
| 103 | } |
| 104 | |
Yao Chen | 729093d | 2017-10-16 10:33:26 -0700 | [diff] [blame] | 105 | void CombinationConditionTracker::isConditionMet( |
Yangster-mac | 2087716 | 2017-12-22 17:19:39 -0800 | [diff] [blame] | 106 | const ConditionKey& conditionParameters, |
Yangster | 7c334a1 | 2017-11-22 14:24:24 -0800 | [diff] [blame] | 107 | const vector<sp<ConditionTracker>>& allConditions, |
| 108 | vector<ConditionState>& conditionCache) const { |
Yao Chen | 729093d | 2017-10-16 10:33:26 -0700 | [diff] [blame] | 109 | for (const int childIndex : mChildren) { |
| 110 | if (conditionCache[childIndex] == ConditionState::kNotEvaluated) { |
| 111 | allConditions[childIndex]->isConditionMet(conditionParameters, allConditions, |
| 112 | conditionCache); |
| 113 | } |
| 114 | } |
| 115 | conditionCache[mIndex] = |
| 116 | evaluateCombinationCondition(mChildren, mLogicalOperation, conditionCache); |
| 117 | } |
| 118 | |
Yao Chen | 967b205 | 2017-11-07 16:36:43 -0800 | [diff] [blame] | 119 | void CombinationConditionTracker::evaluateCondition( |
Joe Onorato | c4dfae5 | 2017-10-17 23:38:21 -0700 | [diff] [blame] | 120 | const LogEvent& event, const std::vector<MatchingState>& eventMatcherValues, |
Yao Chen | caf339d | 2017-10-06 16:01:10 -0700 | [diff] [blame] | 121 | const std::vector<sp<ConditionTracker>>& mAllConditions, |
Yao Chen | 729093d | 2017-10-16 10:33:26 -0700 | [diff] [blame] | 122 | std::vector<ConditionState>& nonSlicedConditionCache, |
Yao Chen | 967b205 | 2017-11-07 16:36:43 -0800 | [diff] [blame] | 123 | std::vector<bool>& conditionChangedCache) { |
Yao Chen | caf339d | 2017-10-06 16:01:10 -0700 | [diff] [blame] | 124 | // value is up to date. |
Yao Chen | 729093d | 2017-10-16 10:33:26 -0700 | [diff] [blame] | 125 | if (nonSlicedConditionCache[mIndex] != ConditionState::kNotEvaluated) { |
Yao Chen | 967b205 | 2017-11-07 16:36:43 -0800 | [diff] [blame] | 126 | return; |
Yao Chen | caf339d | 2017-10-06 16:01:10 -0700 | [diff] [blame] | 127 | } |
| 128 | |
| 129 | for (const int childIndex : mChildren) { |
Yao Chen | 729093d | 2017-10-16 10:33:26 -0700 | [diff] [blame] | 130 | if (nonSlicedConditionCache[childIndex] == ConditionState::kNotEvaluated) { |
Yao Chen | caf339d | 2017-10-06 16:01:10 -0700 | [diff] [blame] | 131 | const sp<ConditionTracker>& child = mAllConditions[childIndex]; |
Yao Chen | 729093d | 2017-10-16 10:33:26 -0700 | [diff] [blame] | 132 | child->evaluateCondition(event, eventMatcherValues, mAllConditions, |
Yao Chen | 967b205 | 2017-11-07 16:36:43 -0800 | [diff] [blame] | 133 | nonSlicedConditionCache, conditionChangedCache); |
Yao Chen | caf339d | 2017-10-06 16:01:10 -0700 | [diff] [blame] | 134 | } |
| 135 | } |
| 136 | |
Yao Chen | 967b205 | 2017-11-07 16:36:43 -0800 | [diff] [blame] | 137 | if (!mSliced) { |
| 138 | ConditionState newCondition = |
| 139 | evaluateCombinationCondition(mChildren, mLogicalOperation, nonSlicedConditionCache); |
Yao Chen | caf339d | 2017-10-06 16:01:10 -0700 | [diff] [blame] | 140 | |
Yao Chen | 967b205 | 2017-11-07 16:36:43 -0800 | [diff] [blame] | 141 | bool nonSlicedChanged = (mNonSlicedConditionState != newCondition); |
| 142 | mNonSlicedConditionState = newCondition; |
Yao Chen | caf339d | 2017-10-06 16:01:10 -0700 | [diff] [blame] | 143 | |
Yao Chen | 967b205 | 2017-11-07 16:36:43 -0800 | [diff] [blame] | 144 | nonSlicedConditionCache[mIndex] = mNonSlicedConditionState; |
Yao Chen | caf339d | 2017-10-06 16:01:10 -0700 | [diff] [blame] | 145 | |
Yao Chen | 967b205 | 2017-11-07 16:36:43 -0800 | [diff] [blame] | 146 | conditionChangedCache[mIndex] = nonSlicedChanged; |
| 147 | } else { |
Yao Chen | 729093d | 2017-10-16 10:33:26 -0700 | [diff] [blame] | 148 | for (const int childIndex : mChildren) { |
| 149 | // If any of the sliced condition in children condition changes, the combination |
| 150 | // condition may be changed too. |
Yao Chen | 967b205 | 2017-11-07 16:36:43 -0800 | [diff] [blame] | 151 | if (conditionChangedCache[childIndex]) { |
| 152 | conditionChangedCache[mIndex] = true; |
Yao Chen | 729093d | 2017-10-16 10:33:26 -0700 | [diff] [blame] | 153 | break; |
| 154 | } |
| 155 | } |
Yao Chen | 967b205 | 2017-11-07 16:36:43 -0800 | [diff] [blame] | 156 | nonSlicedConditionCache[mIndex] = ConditionState::kUnknown; |
Yangster-mac | 94e197c | 2018-01-02 16:03:03 -0800 | [diff] [blame] | 157 | ALOGD("CombinationPredicate %lld sliced may changed? %d", (long long)mConditionId, |
| 158 | conditionChangedCache[mIndex] == true); |
Yao Chen | 729093d | 2017-10-16 10:33:26 -0700 | [diff] [blame] | 159 | } |
Yao Chen | caf339d | 2017-10-06 16:01:10 -0700 | [diff] [blame] | 160 | } |
| 161 | |
| 162 | } // namespace statsd |
| 163 | } // namespace os |
| 164 | } // namespace android |