1 /* 2 * Copyright 2018 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 */ 16 #undef LOG_TAG 17 #define LOG_TAG "LayerStats" 18 #define ATRACE_TAG ATRACE_TAG_GRAPHICS 19 20 #include "LayerStats.h" 21 #include "DisplayHardware/HWComposer.h" 22 #include "ui/DebugUtils.h" 23 24 #include <android-base/stringprintf.h> 25 #include <log/log.h> 26 #include <utils/String8.h> 27 #include <utils/Trace.h> 28 29 namespace android { 30 31 void LayerStats::enable() { 32 ATRACE_CALL(); 33 std::lock_guard<std::mutex> lock(mMutex); 34 if (mEnabled) return; 35 mLayerShapeStatsMap.clear(); 36 mEnabled = true; 37 ALOGD("Logging enabled"); 38 } 39 40 void LayerStats::disable() { 41 ATRACE_CALL(); 42 std::lock_guard<std::mutex> lock(mMutex); 43 if (!mEnabled) return; 44 mEnabled = false; 45 ALOGD("Logging disabled"); 46 } 47 48 void LayerStats::clear() { 49 ATRACE_CALL(); 50 std::lock_guard<std::mutex> lock(mMutex); 51 mLayerShapeStatsMap.clear(); 52 ALOGD("Cleared current layer stats"); 53 } 54 55 bool LayerStats::isEnabled() { 56 return mEnabled; 57 } 58 59 void LayerStats::traverseLayerTreeStatsLocked( 60 const std::vector<std::unique_ptr<LayerProtoParser::Layer>>& layerTree, 61 const LayerProtoParser::LayerGlobal& layerGlobal, 62 std::vector<std::string>* const outLayerShapeVec) { 63 for (const auto& layer : layerTree) { 64 if (!layer) continue; 65 traverseLayerTreeStatsLocked(layer->children, layerGlobal, outLayerShapeVec); 66 std::string key = ""; 67 base::StringAppendF(&key, ",%s", layer->type.c_str()); 68 base::StringAppendF(&key, ",%s", layerCompositionType(layer->hwcCompositionType)); 69 base::StringAppendF(&key, ",%d", layer->isProtected); 70 base::StringAppendF(&key, ",%s", layerTransform(layer->hwcTransform)); 71 base::StringAppendF(&key, ",%s", layerPixelFormat(layer->activeBuffer.format)); 72 base::StringAppendF(&key, ",%s", layer->dataspace.c_str()); 73 base::StringAppendF(&key, ",%s", 74 destinationLocation(layer->hwcFrame.left, layerGlobal.resolution[0], 75 true)); 76 base::StringAppendF(&key, ",%s", 77 destinationLocation(layer->hwcFrame.top, layerGlobal.resolution[1], 78 false)); 79 base::StringAppendF(&key, ",%s", 80 destinationSize(layer->hwcFrame.right - layer->hwcFrame.left, 81 layerGlobal.resolution[0], true)); 82 base::StringAppendF(&key, ",%s", 83 destinationSize(layer->hwcFrame.bottom - layer->hwcFrame.top, 84 layerGlobal.resolution[1], false)); 85 base::StringAppendF(&key, ",%s", scaleRatioWH(layer.get()).c_str()); 86 base::StringAppendF(&key, ",%s", alpha(static_cast<float>(layer->color.a))); 87 88 outLayerShapeVec->push_back(key); 89 ALOGV("%s", key.c_str()); 90 } 91 } 92 93 void LayerStats::logLayerStats(const LayersProto& layersProto) { 94 ATRACE_CALL(); 95 ALOGV("Logging"); 96 auto layerGlobal = LayerProtoParser::generateLayerGlobalInfo(layersProto); 97 auto layerTree = LayerProtoParser::generateLayerTree(layersProto); 98 std::vector<std::string> layerShapeVec; 99 100 std::lock_guard<std::mutex> lock(mMutex); 101 traverseLayerTreeStatsLocked(layerTree, layerGlobal, &layerShapeVec); 102 103 std::string layerShapeKey = 104 base::StringPrintf("%d,%s,%s,%s", static_cast<int32_t>(layerShapeVec.size()), 105 layerGlobal.colorMode.c_str(), layerGlobal.colorTransform.c_str(), 106 layerTransform(layerGlobal.globalTransform)); 107 ALOGV("%s", layerShapeKey.c_str()); 108 109 std::sort(layerShapeVec.begin(), layerShapeVec.end(), std::greater<std::string>()); 110 for (auto const& s : layerShapeVec) { 111 layerShapeKey += s; 112 } 113 114 mLayerShapeStatsMap[layerShapeKey]++; 115 } 116 117 void LayerStats::dump(String8& result) { 118 ATRACE_CALL(); 119 ALOGD("Dumping"); 120 std::lock_guard<std::mutex> lock(mMutex); 121 result.append("Frequency,LayerCount,ColorMode,ColorTransform,Orientation\n"); 122 result.append("LayerType,CompositionType,IsProtected,Transform,PixelFormat,Dataspace,"); 123 result.append("DstX,DstY,DstWidth,DstHeight,WScale,HScale,Alpha\n"); 124 for (auto& u : mLayerShapeStatsMap) { 125 result.appendFormat("%u,%s\n", u.second, u.first.c_str()); 126 } 127 } 128 129 const char* LayerStats::destinationLocation(int32_t location, int32_t range, bool isHorizontal) { 130 static const char* locationArray[8] = {"0", "1/8", "1/4", "3/8", "1/2", "5/8", "3/4", "7/8"}; 131 int32_t ratio = location * 8 / range; 132 if (ratio < 0) return "N/A"; 133 if (isHorizontal) { 134 // X location is divided into 4 buckets {"0", "1/4", "1/2", "3/4"} 135 if (ratio > 6) return "3/4"; 136 // use index 0, 2, 4, 6 137 return locationArray[ratio & ~1]; 138 } 139 if (ratio > 7) return "7/8"; 140 return locationArray[ratio]; 141 } 142 143 const char* LayerStats::destinationSize(int32_t size, int32_t range, bool isWidth) { 144 static const char* sizeArray[8] = {"1/8", "1/4", "3/8", "1/2", "5/8", "3/4", "7/8", "1"}; 145 int32_t ratio = size * 8 / range; 146 if (ratio < 0) return "N/A"; 147 if (isWidth) { 148 // width is divided into 4 buckets {"1/4", "1/2", "3/4", "1"} 149 if (ratio > 6) return "1"; 150 // use index 1, 3, 5, 7 151 return sizeArray[ratio | 1]; 152 } 153 if (ratio > 7) return "1"; 154 return sizeArray[ratio]; 155 } 156 157 const char* LayerStats::layerTransform(int32_t transform) { 158 return getTransformName(static_cast<hwc_transform_t>(transform)); 159 } 160 161 const char* LayerStats::layerCompositionType(int32_t compositionType) { 162 return getCompositionName(static_cast<hwc2_composition_t>(compositionType)); 163 } 164 165 const char* LayerStats::layerPixelFormat(int32_t pixelFormat) { 166 return decodePixelFormat(pixelFormat).c_str(); 167 } 168 169 std::string LayerStats::scaleRatioWH(const LayerProtoParser::Layer* layer) { 170 if (!layer->type.compare("ColorLayer")) return "N/A,N/A"; 171 std::string ret = ""; 172 if (isRotated(layer->hwcTransform)) { 173 ret += scaleRatio(layer->hwcFrame.right - layer->hwcFrame.left, 174 static_cast<int32_t>(layer->hwcCrop.bottom - layer->hwcCrop.top)); 175 ret += ","; 176 ret += scaleRatio(layer->hwcFrame.bottom - layer->hwcFrame.top, 177 static_cast<int32_t>(layer->hwcCrop.right - layer->hwcCrop.left)); 178 } else { 179 ret += scaleRatio(layer->hwcFrame.right - layer->hwcFrame.left, 180 static_cast<int32_t>(layer->hwcCrop.right - layer->hwcCrop.left)); 181 ret += ","; 182 ret += scaleRatio(layer->hwcFrame.bottom - layer->hwcFrame.top, 183 static_cast<int32_t>(layer->hwcCrop.bottom - layer->hwcCrop.top)); 184 } 185 return ret; 186 } 187 188 const char* LayerStats::scaleRatio(int32_t destinationScale, int32_t sourceScale) { 189 // Make scale buckets from <1/64 to >= 16, to avoid floating point 190 // calculation, x64 on destinationScale first 191 int32_t scale = destinationScale * 64 / sourceScale; 192 if (!scale) return "<1/64"; 193 if (scale < 2) return "1/64"; 194 if (scale < 4) return "1/32"; 195 if (scale < 8) return "1/16"; 196 if (scale < 16) return "1/8"; 197 if (scale < 32) return "1/4"; 198 if (scale < 64) return "1/2"; 199 if (scale < 128) return "1"; 200 if (scale < 256) return "2"; 201 if (scale < 512) return "4"; 202 if (scale < 1024) return "8"; 203 return ">=16"; 204 } 205 206 const char* LayerStats::alpha(float a) { 207 if (a == 1.0f) return "1.0"; 208 if (a > 0.9f) return "0.99"; 209 if (a > 0.8f) return "0.9"; 210 if (a > 0.7f) return "0.8"; 211 if (a > 0.6f) return "0.7"; 212 if (a > 0.5f) return "0.6"; 213 if (a > 0.4f) return "0.5"; 214 if (a > 0.3f) return "0.4"; 215 if (a > 0.2f) return "0.3"; 216 if (a > 0.1f) return "0.2"; 217 if (a > 0.0f) return "0.1"; 218 return "0.0"; 219 } 220 221 bool LayerStats::isRotated(int32_t transform) { 222 return transform & HWC_TRANSFORM_ROT_90; 223 } 224 225 bool LayerStats::isVFlipped(int32_t transform) { 226 return transform & HWC_TRANSFORM_FLIP_V; 227 } 228 229 bool LayerStats::isHFlipped(int32_t transform) { 230 return transform & HWC_TRANSFORM_FLIP_H; 231 } 232 233 } // namespace android 234
