swung0x48/MobileGL
1
0
Fork 0
mirror of https://github.com/MobileGL-Dev/MobileGL synced 2026-09-10 21:28:32 +09:00
Code Issues Packages Projects Releases Wiki Activity

[Refactor] (MG_Config, MG_Backend, trace-replay): remove unused stats instrumentation

Browse Source
This commit is contained in:
swung0x48
2026-07-13 20:33:31 -04:00
parent a55a0645e2
commit a26e9aaf25
7 changed files with 0 additions and 261 deletions
Download Patch File Download Diff File Expand all files Collapse all files
MobileGL/MG_Backend/DirectVulkan/Renderer/UniformManager.cpp
-19
View File
@@ -78,10 +78,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
return uniformUnit >= 0 ? uniformUnit : 0;
}
static Bool ShouldDumpDescriptorStats() {
return MG_Config::Features.DescriptorStats;
}
Bool UniformManager::Initialize(VkDevice device, VkBufferManager* bufferManager,
ProgramFactory* programFactory,
VkDeviceSize minUniformBufferOffsetAlignment, Uint32 frameCount,
@@ -314,21 +310,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
.imageView = resource->sampledView != VK_NULL_HANDLE ? resource->sampledView : resource->fullView,
.imageLayout = resource->layout,
};
if (ShouldDumpDescriptorStats()) {
std::fprintf(stderr,
"MOBILEGL_DESCRIPTOR_STATS program=%u binding=%u name=%s location=%d unit=%d "
"texture=%u target=%d sampler=%p imageView=%p layout=%d\n",
program.GetExternalIndex(),
binding,
programObj.samplerNameByBinding[binding].c_str(),
location,
unit,
texture->GetExternalIndex(),
static_cast<Int>(texture->GetTarget()),
reinterpret_cast<void*>(outImageInfo.sampler),
reinterpret_cast<void*>(outImageInfo.imageView),
static_cast<Int>(outImageInfo.imageLayout));
}
return outImageInfo.sampler != VK_NULL_HANDLE;
}
MobileGL/MG_Backend/DirectVulkan/Renderer/VkTextureManager.cpp
-102
View File
@@ -383,102 +383,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
return true;
}
static Bool ShouldDumpTextureUploadStats() {
return MG_Config::Features.TextureUploadStats;
}
static void DumpTextureSyncStats(Int textureId, TextureInternalFormat format, TextureUploadTarget uploadTarget,
Uint32 mipLevelCount, const IntVec3& texelSize, SizeT byteSize,
Bool hasDirtyMipLevel) {
if (!ShouldDumpTextureUploadStats()) {
return;
}
std::fprintf(stderr,
"MOBILEGL_TEXTURE_SYNC_STATS texture=%d format=%s target=%s mips=%u size=%dx%dx%d "
"bytes=%zu dirty=%d\n",
textureId,
MG_Util::ConvertTextureInternalFormatToString(format).c_str(),
MG_Util::ConvertTextureUploadTargetToString(uploadTarget).c_str(),
mipLevelCount,
texelSize.x(),
texelSize.y(),
texelSize.z(),
byteSize,
hasDirtyMipLevel ? 1 : 0);
}
static void DumpTextureUploadStats(Int textureId, TextureUploadTarget target, Uint32 level,
const IntVec3& texelSize, const void* data, SizeT byteSize, Uint32 channels) {
if (channels == 0 && texelSize.x() > 0 && texelSize.y() > 0) {
const SizeT depth = static_cast<SizeT>(std::max(texelSize.z(), 1));
const SizeT pixelCount = static_cast<SizeT>(texelSize.x()) * static_cast<SizeT>(texelSize.y()) * depth;
if (pixelCount > 0 && byteSize % pixelCount == 0) {
channels = static_cast<Uint32>(std::min<SizeT>(byteSize / pixelCount, 4));
}
}
if (!ShouldDumpTextureUploadStats() || data == nullptr || byteSize == 0 || channels == 0) {
return;
}
const auto* bytes = static_cast<const Uint8*>(data);
Uint8 minValue = 255;
Uint8 maxValue = 0;
SizeT nonZero = 0;
Uint64 sum = 0;
Uint64 neighborDiff = 0;
SizeT neighborCount = 0;
for (SizeT i = 0; i < byteSize; ++i) {
minValue = std::min(minValue, bytes[i]);
maxValue = std::max(maxValue, bytes[i]);
nonZero += bytes[i] != 0 ? 1 : 0;
sum += bytes[i];
}
const SizeT width = static_cast<SizeT>(std::max(texelSize.x(), 0));
const SizeT height = static_cast<SizeT>(std::max(texelSize.y(), 0));
const SizeT pixelStride = channels;
if (width > 1 && height > 0 && byteSize >= width * height * pixelStride) {
for (SizeT y = 0; y < height; ++y) {
const SizeT row = y * width * pixelStride;
for (SizeT x = 1; x < width; ++x) {
const SizeT prev = row + (x - 1) * pixelStride;
const SizeT cur = row + x * pixelStride;
for (SizeT c = 0; c < std::min<SizeT>(channels, 3); ++c) {
neighborDiff += static_cast<Uint64>(
std::abs(static_cast<Int>(bytes[cur + c]) - static_cast<Int>(bytes[prev + c])));
++neighborCount;
}
}
}
}
const double avg = byteSize > 0 ? static_cast<double>(sum) / static_cast<double>(byteSize) : 0.0;
const double avgNeighborDiff =
neighborCount > 0 ? static_cast<double>(neighborDiff) / static_cast<double>(neighborCount) : 0.0;
std::fprintf(stderr,
"MOBILEGL_TEXTURE_UPLOAD_STATS texture=%d target=%s level=%u size=%dx%dx%d bytes=%zu "
"channels=%u min=%u max=%u avg=%.2f nonzero=%zu neighborDiff=%.2f first=%u,%u,%u,%u\n",
textureId,
MG_Util::ConvertTextureUploadTargetToString(target).c_str(),
level,
texelSize.x(),
texelSize.y(),
texelSize.z(),
byteSize,
channels,
static_cast<Uint>(minValue),
static_cast<Uint>(maxValue),
avg,
nonZero,
avgNeighborDiff,
byteSize > 0 ? static_cast<Uint>(bytes[0]) : 0u,
byteSize > 1 ? static_cast<Uint>(bytes[1]) : 0u,
byteSize > 2 ? static_cast<Uint>(bytes[2]) : 0u,
byteSize > 3 ? static_cast<Uint>(bytes[3]) : 0u);
}
static VkComponentSwizzle ToVkComponentSwizzle(TextureSwizzleParam swizzle) {
switch (swizzle) {
case TextureSwizzleParam::Red:
@@ -1123,8 +1027,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
break;
}
}
DumpTextureSyncStats(texture.GetExternalIndex(), texture.GetFormat(), uploadTarget, mipLevelCount,
texelSize, byteSize, hasDirtyMipLevel);
if (!hasDirtyMipLevel) {
outResource.syncedContentVersion = syncingContentVersion;
outResource.syncedMipLevelCount = syncingMipLevelCount;
@@ -1514,10 +1416,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
if (!uploadItems.back().expandedData.empty()) {
uploadItems.back().source = uploadItems.back().expandedData.data();
}
DumpTextureUploadStats(mipmapTexture.GetExternalIndex(), uploadItems.back().target,
uploadItems.back().level, uploadItems.back().texelSize,
uploadItems.back().source, uploadItems.back().uploadByteSize,
formatInfo.expandRgbToRgba ? 4u : 0u);
stagingSize += static_cast<VkDeviceSize>(uploadItems.back().uploadByteSize);
}
}
MobileGL/MG_Backend/DirectVulkan/Renderer/VulkanRenderer.cpp
-82
View File
@@ -639,10 +639,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
return attributeMask;
}
static Bool ShouldDumpVertexInputStats() {
return MG_Config::Features.VertexInputStats;
}
static const char* PresentDumpPath() {
const String& path = MG_Config::Features.PresentDumpPath;
return path.empty() ? nullptr : path.c_str();
@@ -661,80 +657,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
return current != nullptr && std::strcmp(target, current) == 0;
}
static void DumpVertexInputStats(Uint32 location, const MG_State::GLState::VertexAttribute& attr,
Uint32 firstVertex, Uint32 vertexCount) {
if (!ShouldDumpVertexInputStats() || attr.Type != DataType::Float32 || attr.Size <= 0 || attr.Size > 4) {
return;
}
const SizeT componentSize = sizeof(float);
const SizeT elementSize = componentSize * static_cast<SizeT>(attr.Size);
const SizeT stride = attr.Stride > 0 ? static_cast<SizeT>(attr.Stride) : elementSize;
const Uint8* base = nullptr;
SizeT available = 0;
if (attr.Buffer) {
if (attr.Offset >= attr.Buffer->GetSize()) {
return;
}
base = attr.Buffer->MappedData() + attr.Offset;
available = attr.Buffer->GetSize() - attr.Offset;
} else {
base = reinterpret_cast<const Uint8*>(attr.Offset);
available = static_cast<SizeT>(firstVertex + vertexCount) * stride;
}
if (base == nullptr || vertexCount == 0 || available < elementSize) {
return;
}
float minValues[4] = {0.0f, 0.0f, 0.0f, 0.0f};
float maxValues[4] = {0.0f, 0.0f, 0.0f, 0.0f};
Bool initialized = false;
SizeT sampled = 0;
const Uint32 maxSamples = std::min<Uint32>(vertexCount, 256);
for (Uint32 sample = 0; sample < maxSamples; ++sample) {
const SizeT offset = static_cast<SizeT>(firstVertex + sample) * stride;
if (offset + elementSize > available) {
break;
}
const auto* values = reinterpret_cast<const float*>(base + offset);
for (Int component = 0; component < attr.Size; ++component) {
if (!initialized) {
minValues[component] = values[component];
maxValues[component] = values[component];
} else {
minValues[component] = std::min(minValues[component], values[component]);
maxValues[component] = std::max(maxValues[component], values[component]);
}
}
initialized = true;
++sampled;
}
if (!initialized) {
return;
}
std::fprintf(stderr,
"MOBILEGL_VERTEX_INPUT_STATS loc=%u buffer=%u size=%d stride=%zu first=%u count=%u sampled=%zu "
"min=(%.3f,%.3f,%.3f,%.3f) max=(%.3f,%.3f,%.3f,%.3f)\n",
location,
attr.Buffer ? attr.Buffer->GetExternalIndex() : 0u,
attr.Size,
stride,
firstVertex,
vertexCount,
sampled,
minValues[0],
minValues[1],
minValues[2],
minValues[3],
maxValues[0],
maxValues[1],
maxValues[2],
maxValues[3]);
}
static Bool TryGetCurrentVertexAttributeFormat(GLenum glType, VkFormat& outFormat) {
switch (glType) {
case GL_FLOAT:
@@ -2189,10 +2111,6 @@ void main() {
const Uint32 bindingLocation = binding < vertexInputState.bindingAttributeLocations.size()
? vertexInputState.bindingAttributeLocations[binding]
: static_cast<Uint32>(MG_State::GLState::VertexArrayObject::MAX_VERTEX_ATTRIBS);
if (bindingLocation < MG_State::GLState::VertexArrayObject::MAX_VERTEX_ATTRIBS) {
DumpVertexInputStats(bindingLocation, vao.GetAttribute(bindingLocation),
drawParams.firstVertex, drawParams.vertexCount);
}
const Bool usesClientMemory = binding < vertexInputState.bindingUsesClientMemory.size() &&
vertexInputState.bindingUsesClientMemory[binding];
if (usesClientMemory) {