/* * Copyright 2024 The Android Open Source Project * * 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. */ #pragma once #include #include #include "InputEventTimeline.h" namespace android::inputdispatcher { static constexpr size_t NUM_BINS = 20; static constexpr size_t NUM_INPUT_EVENT_TYPES = 6; enum class LatencyStageIndex : size_t { EVENT_TO_READ = 0, READ_TO_DELIVER = 1, DELIVER_TO_CONSUME = 2, CONSUME_TO_FINISH = 3, CONSUME_TO_GPU_COMPLETE = 4, GPU_COMPLETE_TO_PRESENT = 5, END_TO_END = 6, SIZE = 7, // must be last }; // Let's create a full timeline here: // eventTime // readTime // <---- after this point, the data becomes per-connection // deliveryTime // time at which the event was sent to the receiver // consumeTime // time at which the receiver read the event // finishTime // time at which the dispatcher reads the response from the receiver that the event // was processed // GraphicsTimeline::GPU_COMPLETED_TIME // GraphicsTimeline::PRESENT_TIME /** * Keep histograms with latencies of the provided events */ class LatencyAggregatorWithHistograms final : public InputEventTimelineProcessor { public: /** * Record a complete event timeline */ void processTimeline(const InputEventTimeline& timeline) override; void pushLatencyStatistics() override; std::string dump(const char* prefix) const override; private: // ---------- Slow event handling ---------- void processSlowEvent(const InputEventTimeline& timeline); nsecs_t mLastSlowEventTime = 0; // How many slow events have been skipped due to rate limiting size_t mNumSkippedSlowEvents = 0; // How many events have been received since the last time we reported a slow event size_t mNumEventsSinceLastSlowEventReport = 0; // ---------- Statistics handling ---------- /** * Data structure to gather time samples into NUM_BINS buckets */ class Histogram { public: Histogram(const std::array& binSizes) : mBinSizes(binSizes) { mBinCounts.fill(0); } // Increments binCounts of the appropriate bin when adding a new sample void addSample(int64_t sample) { size_t binIndex = getSampleBinIndex(sample); mBinCounts[binIndex]++; } const std::array& getBinCounts() const { return mBinCounts; } private: // reference to an array that represents the range of values each bin holds. // in bin i+1 live samples such that *mBinSizes[i] <= sample < *mBinSizes[i+1] const std::array& mBinSizes; std::array mBinCounts; // the number of samples that currently live in each bin size_t getSampleBinIndex(int64_t sample) { auto it = std::upper_bound(mBinSizes.begin(), mBinSizes.end(), sample); return std::distance(mBinSizes.begin(), it); } }; void processStatistics(const InputEventTimeline& timeline); // Identifier for the an input event. If two input events have the same identifiers we // want to use the same histograms to count the latency samples using InputEventLatencyIdentifier = std::tuple /*sources*/, InputEventActionType /*inputEventActionType*/>; // Maps an input event identifier to an array of 7 histograms, one for each latency // stage. It is cleared after an atom push std::map> mHistograms; void addSampleToHistogram(const InputEventLatencyIdentifier& identifier, LatencyStageIndex latencyStageIndex, nsecs_t time); // Stores all possible arrays of bin sizes. The order in the vector does not matter, as long // as binSizesMappings points to the right index static constexpr std::array, 6> allBinSizes = { {{10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 100}, {1, 2, 3, 4, 5, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32}, {15, 30, 45, 60, 75, 90, 105, 120, 135, 150, 165, 180, 195, 210, 225, 240, 255, 270, 285}, {40, 80, 120, 160, 200, 240, 280, 320, 360, 400, 440, 480, 520, 560, 600, 640, 680, 720, 760}, {20, 40, 60, 80, 100, 120, 140, 160, 180, 200, 220, 240, 260, 280, 300, 320, 340, 360, 380}, {200, 300, 400, 500, 600, 700, 800, 900, 1000, 1100, 1200, 1300, 1400, 1500, 1600, 1700, 1800, 1900, 2000}}}; // Stores indexes in allBinSizes to use with each {LatencyStage, InputEventType} pair. // Bin sizes for a certain latencyStage and inputEventType are at: // *(allBinSizes[binSizesMappings[latencyStageIndex][inputEventTypeIndex]]) // inputEventTypeIndex is the int value of InputEventActionType enum decreased by 1 since we // don't want to record latencies for unknown events. // e.g. MOTION_ACTION_DOWN is 0, MOTION_ACTION_MOVE is 1... static constexpr std::array, static_cast(LatencyStageIndex::SIZE)> binSizesMappings = {{{0, 0, 0, 0, 0, 0}, {1, 1, 1, 1, 1, 1}, {1, 1, 1, 1, 1, 1}, {2, 2, 2, 2, 2, 2}, {3, 3, 3, 3, 3, 3}, {4, 4, 4, 4, 4, 4}, {5, 5, 5, 5, 5, 5}}}; // Similar to binSizesMappings, but holds the index of the array of bin ranges to use on the // server. The index gets pushed with the atom within the histogram_version field. static constexpr std::array, static_cast(LatencyStageIndex::SIZE)> histogramVersions = {{{0, 0, 0, 0, 0, 0}, {1, 1, 1, 1, 1, 1}, {1, 1, 1, 1, 1, 1}, {2, 2, 2, 2, 2, 2}, {3, 3, 3, 3, 3, 3}, {4, 4, 4, 4, 4, 4}, {5, 5, 5, 5, 5, 5}}}; }; } // namespace android::inputdispatcher