[性能优化&工具类] 批量Mesh网格压缩

于 2024-05-07 17:03:10 发布
阅读量288 收藏 8
点赞数 4
分类专栏： 工作清单 文章标签： unity
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mr_PEaSutBUtteR/article/details/138538099
版权

问题描述：

对于3D游戏工程来说，美术资源的存储几乎占据了绝大多数的空间，而对于一个3d 模型文件，MeshFilter（网格过滤器）负责存储物体的网格 以及贴图。依靠MeshRender(网格渲染器)跟据MeshFilter的信息去绘制此物体。Mesh 属性存储众多物理信息，比如顶点的位置、法线、切线。能否在不破坏原有模型外观的情况下尽量减少模型所占体积呢。

解决思路：

这里可以根据模型精度制定压缩规则，使用 Dictionary<VertexAttribute, VertexAttributeFormat> 字典存储（K值对应，顶点依赖属性。V表示它的精度）
比如低模的文件，远景或者边缘物体，小尺寸物体可以不需要添加UV。
根据不同的规则对文件夹下的模型进行分类，依照压缩类型，使用上述字典DescriptorReplaceMap来存储需要替换的顶点属性格式，然后将例如位置、法线和切线的属性格式从Float32或Float16进行替换。这样可以在保持Mesh数据结构不变的情况下，减少存储这些属性所需的内存空间。

压缩过程

根据压缩规则OptimizeType进行分类

OptimizeType 压缩方式

 [SerializeField]
public enum OptimizeType
{
    None,
    CompressByUnityDefault,                     //使用unity默认压缩方式
    CompressAllToFloat16,                       //不建议使用，可以使用Unity自带配置
    CompressPosNormalAndTangentTo8Channel,  //基本等同于CompressAllToFloat16，建议高模
    [Obsolete("法线精度较低，不适用高模、低模")]
    CompressPosNormalAndTangentTo6Channel,  //会较大缺少精度
    CompressPosNormalTo6Channel,  //会删除切线并保留较高精度的法线，建议低模+地形
    CompressNormal,                 //不压缩position, 删除切线并保留较高精度的法线（建议精度较大的不分块地形（与剔除UV联用））
    CompressPosToFloat32,                    //只保留position
    [Obsolete("此类型暂时无法使用")]
    CompressPosNormalTo4Channel,    //将法线压缩到pos的w分量，目前unity的pos.w只能存放符号位
}

填充字典 DescriptorReplaceMap

/// <summary>
/// get optimize mesh
/// worldVertexs : 为空时正常压缩，不为空时将会存储相对坐标
/// </summary>
        public static Mesh GetOptimizeMesh(Mesh originMesh, OptimizeType optimizeType, bool withoutUVs = false, Vector3[] worldVertexs = null)
        {
            if (originMesh == null || originMesh?.tangents.Length == 0)
            {
                Debug.LogWarning("mesh is null or has been optimize");
                return null;
            }
            DescriptorReplaceMap.Clear();
            switch (optimizeType)
            {
                case OptimizeType.None:
                    break;
                case OptimizeType.CompressByUnityDefault:
                    DescriptorReplaceMap.Add(VertexAttribute.Position, VertexAttributeFormat.Float32);
                    DescriptorReplaceMap.Add(VertexAttribute.Normal, VertexAttributeFormat.Float16);
                    DescriptorReplaceMap.Add(VertexAttribute.Tangent, VertexAttributeFormat.Float16);
                    break;
                case OptimizeType.CompressAllToFloat16:
                    DescriptorReplaceMap.Add(VertexAttribute.Position, VertexAttributeFormat.Float16);
                    DescriptorReplaceMap.Add(VertexAttribute.Normal, VertexAttributeFormat.Float16);
                    DescriptorReplaceMap.Add(VertexAttribute.Tangent, VertexAttributeFormat.Float16);
                    break;
                case OptimizeType.CompressPosNormalAndTangentTo8Channel:
                    DescriptorReplaceMap.Add(VertexAttribute.Position, VertexAttributeFormat.Float16);
                    //DescriptorReplaceMap.Add(VertexAttribute.Position, VertexAttributeFormat.Float32);
                    DescriptorReplaceMap.Add(VertexAttribute.Normal, VertexAttributeFormat.Float16);
                    break;
                case OptimizeType.CompressPosNormalAndTangentTo6Channel:
                    DescriptorReplaceMap.Add(VertexAttribute.Position, VertexAttributeFormat.Float16);
                    DescriptorReplaceMap.Add(VertexAttribute.Normal, VertexAttributeFormat.UInt16);
                    break;
                case OptimizeType.CompressPosNormalTo6Channel:
                    DescriptorReplaceMap.Add(VertexAttribute.Position, VertexAttributeFormat.Float16);
                    DescriptorReplaceMap.Add(VertexAttribute.Normal, VertexAttributeFormat.Float16);
                    break;
                case OptimizeType.CompressNormal:
                    DescriptorReplaceMap.Add(VertexAttribute.Position, VertexAttributeFormat.Float32);
                    DescriptorReplaceMap.Add(VertexAttribute.Normal, VertexAttributeFormat.Float16);
                    break;
                case OptimizeType.CompressPosToFloat32:
                    DescriptorReplaceMap.Add(VertexAttribute.Position, VertexAttributeFormat.Float32);
                    break;
                case OptimizeType.CompressPosNormalTo4Channel:
                    DescriptorReplaceMap.Add(VertexAttribute.Position, VertexAttributeFormat.Float16);
                    break;
                default:
                    return null;
            }

            if (!withoutUVs)
            {
                DescriptorReplaceMap.Add(VertexAttribute.TexCoord0, VertexAttributeFormat.Float16);
                DescriptorReplaceMap.Add(VertexAttribute.TexCoord1, VertexAttributeFormat.Float16);
                DescriptorReplaceMap.Add(VertexAttribute.TexCoord2, VertexAttributeFormat.Float16);
                DescriptorReplaceMap.Add(VertexAttribute.TexCoord3, VertexAttributeFormat.Float16);
            }
			DescriptorReplaceMap.Add(VertexAttribute.BlendWeight, VertexAttributeFormat.Float16);
            DescriptorReplaceMap.Add(VertexAttribute.BlendIndices, VertexAttributeFormat.UInt16);

            //-------------压缩开始-------------------
            var newMesh = MeshOptimize(originMesh, optimizeType, worldVertexs);
#if UNITY_2020_2_OR_NEWER
            for (int i = 0; i < 2; i++)
            {
                newMesh.RecalculateUVDistributionMetrics(i);
            }
#else
            float metrics0 = originMesh.GetUVDistributionMetric(0);
            float metrics1 = originMesh.GetUVDistributionMetric(1);
            SerializedObject new_serializedObject = new SerializedObject(newMesh);
            var new_metrics0 = new_serializedObject.FindProperty("m_MeshMetrics[0]");
            var new_metrics1 = new_serializedObject.FindProperty("m_MeshMetrics[1]");
            if (new_metrics0 != null) new_metrics0.floatValue = metrics0;
            if (new_metrics1 != null) new_metrics1.floatValue = metrics1;
            new_serializedObject.ApplyModifiedPropertiesWithoutUndo();
#endif
            newMesh.name = originMesh.name;
            newMesh.UploadMeshData(true);
            return newMesh;
        }

根据分类，降低精度

处理顶点属性描述符（VertexAttributeDescriptor）
根据map中对应的优化类型（optimizeType）和属性类型（attributeDesc[i].attribute），对temp的格式（format）和维度（dimension）进行调整。最后，将调整后的temp添加到优化后的描述符列表（optimizeDesc）中。

Mesh MeshOptimize(Mesh originMesh, OptimizeType optimizeType, Vector3[] worldVertexs = null)
{

    //-----
    
                VertexAttributeFormat optimizeFormat = attributeDesc[i].format;
                if (DescriptorReplaceMap.TryGetValue(attributeDesc[i].attribute, out optimizeFormat))
                {
                    VertexAttributeDescriptor temp = new VertexAttributeDescriptor();
                    temp = attributeDesc[i];

                    temp.format = optimizeFormat;
                    if (isFormat_16(temp.format))
                        temp.dimension += temp.dimension % 2;

                    if (optimizeType == OptimizeType.CompressPosNormalAndTangentTo8Channel && attributeDesc[i].attribute == VertexAttribute.Position)
                    {
                        temp.dimension = 4;
                    }

                    if ((optimizeType == OptimizeType.CompressPosNormalAndTangentTo6Channel || optimizeType == OptimizeType.CompressPosNormalTo6Channel || optimizeType == OptimizeType.CompressNormal) && temp.attribute == VertexAttribute.Normal)
                    {
                        temp.dimension = 2;
                    }

                    optimizeDesc.Add(temp);
                }
            }

    //------

    //收集顶点数据加入缓存区

    //构造新Mesh，返回Mesh
}

收集替换后的Mesh顶点数据

public static void CollectionData(VertexAttributeDescriptor[] optimizeDesc, Mesh originMesh, OptimizeType optimizeType, Vector3[] worldVertexs = null)
{
  VertexAttributeDescriptor[] attributeDesc = originMesh.GetVertexAttributes();
        int maxStream = 0;
        for (int i = 0; i < optimizeDesc.Length; i++)
        {
            if (maxStream < optimizeDesc[i].stream)
            {
                maxStream = optimizeDesc[i].stream;
            }
        }
    for (int streamIndex = 0; streamIndex <= maxStream; streamIndex++)
            {
                for (int vertexIndex = 0; vertexIndex < originMesh.vertexCount; vertexIndex++)
                {
                    for (int i = 0; i < optimizeDesc.Length; i++)
                    {
                        //规则1
                        if (optimizeDesc[i].attribute == VertexAttribute.Position && optimizeDesc[i].stream == streamIndex)
                        {
                            if (optimizeType != OptimizeType.CompressPosNormalTo4Channel)
                            {
                                if (optimizeType == OptimizeType.CompressPosNormalAndTangentTo6Channel ||
                                    optimizeType == OptimizeType.CompressPosNormalAndTangentTo8Channel)
                                {
                                    if (worldVertexs != null)
                                    {
                                        DataOptimize(new Vector4(pos[vertexIndex].x- worldVertexs[vertexIndex].x, pos[vertexIndex].y- worldVertexs[vertexIndex].y, pos[vertexIndex].z- worldVertexs[vertexIndex].z, tangent[vertexIndex].w), GetFormat(attributeDesc, optimizeDesc[i].attribute), optimizeDesc[i].format, optimizeDesc[i].dimension);
                                    }
                                    else
                                    {
                                        DataOptimize(new Vector4(pos[vertexIndex].x, pos[vertexIndex].y, pos[vertexIndex].z, tangent[vertexIndex].w), GetFormat(attributeDesc, optimizeDesc[i].attribute), optimizeDesc[i].format, optimizeDesc[i].dimension);
                                    }
                                }
                                else
                                    DataOptimize(pos[vertexIndex], GetFormat(attributeDesc, optimizeDesc[i].attribute), optimizeDesc[i].format, optimizeDesc[i].dimension);
                            }
                            else
                                DataOptimizeNormalToPosW(pos[vertexIndex], CompressNormalize(normal[vertexIndex]), GetFormat(attributeDesc, optimizeDesc[i].attribute), optimizeDesc[i].format, optimizeDesc[i].dimension);
                        }
                        //其他规则等..

                    }
                }
                        streamOffset.Add(vertexBuffer.Count);//更新顶点缓存区数量

}

//数据格式化
 private static void DataOptimize(int4 data, VertexAttributeFormat formatsrc, VertexAttributeFormat formatdst, int dimension)
        {
            if (formatdst == VertexAttributeFormat.UInt16)
                vertexBuffer.AddRange(Int16_4ToBytes(data));
            else if (formatdst == VertexAttributeFormat.SInt16)
                vertexBuffer.AddRange(Int16_4ToBytes(data));
            else if (formatdst == VertexAttributeFormat.UInt32)
                vertexBuffer.AddRange(Int32_4ToBytes(data));
            else if (formatdst == VertexAttributeFormat.SInt32)
                vertexBuffer.AddRange(Int32_4ToBytes(data));
        }

构造新Mesh

   Mesh newMesh = new Mesh();
    //newMesh.indexFormat = IndexFormat.UInt32;
    int vertexCount = originMesh.vertexCount;

    newMesh.SetVertexBufferParams(vertexCount, optimizeDesc.ToArray());

    newMesh.SetVertexBufferData(vertexBuffer.ToArray(), 0, 0, streamOffset[0], 0);
    for (int streamIndex = 0; streamIndex < streamOffset.Count - 1; streamIndex++)
    {
        newMesh.SetVertexBufferData(vertexBuffer.ToArray(), streamOffset[streamIndex], 0, streamOffset[streamIndex + 1] - streamOffset[streamIndex], streamIndex + 1);
    }

    int subMeshCount = originMesh.subMeshCount;
    newMesh.subMeshCount = subMeshCount;
    for (int subMeshIndex = 0; subMeshIndex < subMeshCount; subMeshIndex++)
    {
        newMesh.SetIndices(originMesh.GetIndices(subMeshIndex), originMesh.GetTopology(subMeshIndex), subMeshIndex);
    }

    newMesh.colors = originMesh.colors;
    newMesh.bindposes = originMesh.bindposes;
    newMesh.OptimizeReorderVertexBuffer();
    //Bound
    newMesh.bounds = originMesh.bounds;
    for (int i = 0; i < originMesh.subMeshCount; i++)
    {
        var subMesh = newMesh.GetSubMesh(i);
        subMesh.bounds = originMesh.GetSubMesh(i).bounds;
        subMesh.topology = originMesh.GetSubMesh(i).topology;
        newMesh.SetSubMesh(i, subMesh, MeshUpdateFlags.DontRecalculateBounds);
    }
    return newMesh;

在外部更换为新的Mesh网格

           var newMesh = MeshOptimize(originMesh, optimizeType, worldVertexs);
#if UNITY_2020_2_OR_NEWER
            for (int i = 0; i < 2; i++)
            {
                //将网格的UV分布指标从顶点和uv坐标重新计算。
                newMesh.RecalculateUVDistributionMetrics(i);
            }
#else
            float metrics0 = originMesh.GetUVDistributionMetric(0);
            float metrics1 = originMesh.GetUVDistributionMetric(1);
            SerializedObject new_serializedObject = new SerializedObject(newMesh);
            var new_metrics0 = new_serializedObject.FindProperty("m_MeshMetrics[0]");
            var new_metrics1 = new_serializedObject.FindProperty("m_MeshMetrics[1]");
            if (new_metrics0 != null) new_metrics0.floatValue = metrics0;
            if (new_metrics1 != null) new_metrics1.floatValue = metrics1;
            new_serializedObject.ApplyModifiedPropertiesWithoutUndo();
#endif
            newMesh.name = originMesh.name;
            newMesh.UploadMeshData(true);
            return newMesh;

处理特殊问题

对应部分fbx文件，压缩后会出现光照贴图异常变暗的情况。
对于这类物体，经过调查发现是其prefab的子级中也包含meshFilter。比起整体包含一个meshfilter的情况，相互之间的渲染收到了影响。
把出问题的bundle文件的mesh回滚，即用原来精度的mesh.
4.gif

递归回退

    void RevertItemSelfAndChildren(GameObject obj)
    {
      try
      {
        if (obj != null)
        {
            // 如果当前物体有MeshFilter组件，则更换其sharedMesh
            string curObjName = obj.name;
            if (curObjName.EndsWith("(Clone)"))
            {
                curObjName = curObjName.Substring(0, curObjName.Length - 7);
            }
            
            if (fbxMeshMap.ContainsKey(curObjName))
            {
                MeshContent originMeshContent = fbxMeshMap[curObjName];
                MeshFilter meshFilter = obj.GetComponent<MeshFilter>();
                MeshRenderer meshRenderer = obj.GetComponent<MeshRenderer>();
                if (meshFilter != null && originMeshContent.curMesh != null)
                {
                    Debug.Log(obj.name + "的sharedMesh:" + meshFilter.sharedMesh.name + "替换为" + originMeshContent.curMesh);
                    //在字典中找到对应fbx，提取Mesh。给prefab重新更换
                    meshFilter.sharedMesh = originMeshContent.curMesh;
                    meshFilter.sharedMesh.RecalculateBounds();
                }

                if (originMeshContent.name != null && meshRenderer != null)
                {
                    if ( originMeshContent.curMaterials!= null && meshRenderer.sharedMaterial!= null)
                    {
                        Debug.Log(obj.name + "的sharedMaterials:" + meshRenderer.sharedMaterial.name + "替换为" + originMeshContent.curMaterials);
                        meshRenderer.sharedMaterial= originMeshContent.curMaterials;
                    }
                }
                EditorUtility.SetDirty(obj);
                string sourcePath = AssetDatabase.GetAssetPath(obj);
                PrefabUtility.SaveAsPrefabAsset(obj, sourcePath);
            }
            
            if ( obj != null && obj.transform.childCount > 0)
            {
                // 遍历所有子节点并更换它们的MeshFilter
                foreach (Transform child in obj.transform)
                {
                    RevertItemSelfAndChildren(child.gameObject);
                }    
            }
        }
      }
      catch (Exception e)
      {
          Console.WriteLine(e);
          throw;
      }
       
    }

编辑器扩展

Editor目录下封装为工具统一使用，继承EditorWindow 制作为编辑器窗口
image.png
image.png
image.png
image.png

欧尼sama
关注
  • 4
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Unity 面试篇|（四）Unity性能优化篇 【全面总结 | 持续更新】
游戏开发小Y的博客
01-12 3万+
Unity中，CPU准备好需要绘制的元素，对底层图形程序接口进行调用的过程，每次引擎准备数据并通知GPU的过程称为一次Draw Call。DrawCall越高对显卡的消耗就越大。降低DrawCall的方法：动态合批静态合批降低shader的等级特性场景优化策略——遮挡技术。rectMask2D替代Mask。
Unity 面试篇⚠️ | Unity性能优化好，山寨机都能跑~
m0_58523831的博客
06-10 172
Unity 面试篇⚠️ | Unity性能优化好，山寨机都能跑~
Unity3d Mesh、Texture、UI 压缩降低内存
yuyingwin的专栏
12-20 5961
一、Mesh压缩：将Mesh Compression 根据情况设置为 heigh、low等不同层次，取消掉Read/write Enabled、Import BlendShapes;根据情况取消 法线的导入 不需要导入动画的Mesh，取消Animations的导入；Rig 下 AnimationType 设置为 None Texture 贴图：主要压缩 Size
Unity游戏开发客户端面经——性能优化（初级）
Sea3752的博客
11-03 9898
Unity游戏开发客户端面经 之 性能优化 篇
unity移动端性能优化技术整理（持续更新）
jianfei_zhou的博客
03-12 1911
unity移动端性能优化技术整理，持续更新中。主要是个目录性质的收集。
Unity之移动端性能优化
itsxwz
10-22 473
整理~ 1.渲染 利用reflect probe代替反射、折射，尽量不用RTT、GrabPass、RenderWithShader、CommandBuffer.Blit (BuiltinRenderTextureType.CurrentActive…) 建立统一后处理框架(bloom、hdr、DOF等)代替多后处理，可以共用模糊函数，减少多次blit；另外要注意RTT的尺寸。 空气折射、热浪扭曲等使用GrabPass不是所有硬件都支持，改为RTT或者后处理来优化。 建立统一shader材质代替单一sh.
Unity - 性能优化 - 包体，内存 - 偏静态资源的优化
Jave.Lin 的学习笔记
01-22 3172
如果 产品 制作出来不经过优化，那不叫 产品，准确的说是：DEMO 今天做了一些项目分析，发现这个项目惨不忍睹 初步判断可以做的优化点： (下面是简述版本，详细的就不说了，免得影响可读性)
unity性能优化 模型、贴图、shader优化方法大全
炼丹炉里有煤灰
04-22 5481
优化，老生常谈。游戏的优化和网站、软件优化没有任何不同，除了编码质量和使用技巧以外，都是那些空间<>时间、效果<>性能的老套路。 Debug工具介绍 Statistics Profile 内存优化 【适当的GC(Garbage Collection垃圾回收)】 GC有两种触发方式，1内存不足自动触发，2手动触发。 首先内存不足时自动GC，经反复测试，并不是很好的办法。因为当...
unity性能优化方案整理 & 一些思路 & 一些技巧(持续更新 2019-09-12)
丶党玲儿的博客
08-12 6089
原文链接1:https://www.cnblogs.com/zhenlong/p/4862869.html
unity 网格合并工具 Mesh Baker 3.35.0
08-30
Mesh Baker 3.35.0
批量文件压缩下载生成压缩包 java 工具类
12-22
批量下载文件包括图片, mp3等, 生成压缩包 java 工具
图片批量压缩+转webp小工具
03-08
适用于常见图片格式的压缩，转webp的批量处理工具。Windows版
图片批量压缩工具.exe
06-10
好用的图片批量压缩工具
图像文件批量压缩工具
10-22
Pngyu是一款使用pngquant作为压缩引擎，是一款简单的PNG图像文件批量压缩工具
简历模板简洁风简洁干练简历模板简历模板简洁风(简洁干练简历模板).zip
06-17
在求职的征途上，一份出色的简历是你通往梦想职位的敲门砖。我们精心准备了一系列面试求职简历模板，旨在帮助你以最佳形象站在潜在雇主面前。这些简历模板不仅设计精美，而且注重内容的清晰呈现，使招聘经理一目了然地看到你的能力和经验。 我们的模板集合了多种风格与布局，无论你是应届毕业生、职场跳槽者还是行业专家，都能在这里找到适合你职业形象的简历设计。每一个模板都经过精心设计，确保你的简历在众多求职者中脱颖而出，同时保持足够的专业度和可读性。 不仅如此，我们的简历模板易于编辑，你可以根据具体职位需求快速调整内容，展现你的个人优势和职业成就。使用这些模板，将大大提高你的面试机会，并帮助你更好地表达自己的价值和潜力。 别让传统且缺乏创意的简历阻碍你迈向成功的道路。立即下载这些精美的简历模板，让你的求职之路更加顺畅，向心仪的工作迈进吧！记住，一个良好的开始是成功的一半，而一份精致的简历，正是你成功的起点。
Python毕业设计-基于深度学习的水果识别系统的源代码+文档说明+数据集+模型（高分项目）
最新发布
06-17
Python毕业设计-基于深度学习的水果识别系统的源代码+文档说明+数据集+模型（高分项目）本资源中的源码都是经过本地编译过可运行的，评审分达到95分以上。资源项目的难度比较适中，内容都是经过助教老师审定过的能够满足学习、使用需求，如果有需要的话可以放心下载使用。 Python毕业设计-基于深度学习的水果识别系统的源代码+文档说明+数据集+模型（高分项目） Python毕业设计-基于深度学习的水果识别系统的源代码+文档说明+数据集+模型。 Python毕业设计-基于深度学习的水果识别系统的源代码+文档说明+数据集+模型（高分项目）Python毕业设计-基于深度学习的水果识别系统的源代码+文档说明+数据集+模型（高分项目）Python毕业设计-基于深度学习的水果识别系统的源代码+文档说明+数据集+模型（高分项目）Python毕业设计-基于深度学习的水果识别系统的源代码+文档说明+数据集+模型（高分项目）Python毕业设计-基于深度学习的水果识别系统的源代码+文档说明+数据集+模型（高分项目）Python毕业设计-基于深度学习的水果识别系统的源代码+文档说明+数据集+模型（高分项目）
navicat基础操作教程
06-17
Navicat 是一款广泛使用且功能强大的数据库管理工具，它能够连接和管理多种数据库系统，例如 MySQL、MariaDB、Oracle、PostgreSQL、SQLite 等[^1^][^3^][^4^][^5^][^7^][^9^][^10^]。自2001年以来，Navicat 已成为全球超过500万名数据库用户的优选[^1^]。它提供了多达7种语言供客户选择，并且被公认为全球最受欢迎的数据库前端用户界面工具[^1^]。 Navicat 的特点包括强大的数据库连接能力、直观的用户界面、多种功能模块以及数据同步和转换能力[^3^]。它还提供了数据库设计和建模功能，帮助用户规划和设计数据库结构[^3^]。Navicat 适用于多种平台，包括 Microsoft Windows、MacOS、Linux 和 iOS[^1^]，并且可以让用户连接到任何本机或远程服务器[^1^]。Navicat Premium 版本允许用户在不同数据库系统间传输数据，并支持批处理作业的计划和执行[^1^]。 Navicat 的功能包括但不限于数据迁移、操作工具、查询编辑、数据库设计器、数据可视化工具、数据
C++性能优化检测工具
02-21
C++性能优化检测工具可以帮助开发人员分析和优化他们的代码，以提高程序的性能。以下是一些常用的C++性能优化检测工具： 1. Profilers（性能分析器）：性能分析器可以帮助开发人员找到程序中的性能瓶颈。它们可以测量函数调用的时间、内存使用情况和其他指标，并生成性能报告。一些常用的性能分析器包括GNU gprof、Valgrind和Intel VTune。 2. 编译器优化选项：大多数C++编译器都提供了一些优化选项，可以在编译时对代码进行优化。例如，GCC编译器提供了一系列的优化选项，如-O1、-O2和-O3，可以根据需求选择不同级别的优化。 3. 静态代码分析工具：静态代码分析工具可以检测代码中的潜在问题和性能瓶颈。它们可以帮助开发人员找到未使用的变量、内存泄漏和其他常见的错误。一些常用的静态代码分析工具包括Cppcheck和Clang Static Analyzer。 4. 动态内存分析工具：动态内存分析工具可以帮助开发人员检测内存泄漏和内存访问错误。它们可以跟踪程序运行时的内存分配和释放，并生成报告。一些常用的动态内存分析工具包括Valgrind和Dr. Memory。 5. 可视化性能分析工具：可视化性能分析工具可以以图形化的方式展示程序的性能数据，帮助开发人员更直观地理解和优化代码。一些常用的可视化性能分析工具包括Intel VTune和Google Performance Tools。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值