呼和浩特市网站建设_网站建设公司_模板建站_seo优化

相反的指针追踪（The Opposite of Pointer Chasing）

目标与挑战

我们通常在系统中需要对象彼此引用，并且需要运行时多态性。这种设计方式在大多数情况下并没有什么不对，但它会极大地影响性能。因为对象引用和运行时多态性需要动态的内存管理和指针追踪，这对性能的要求非常高。

如何提升性能？

如果我们愿意投入大量的精力来提升性能，**数据导向（Data Orientation）**技术提供了一种有效的手段。这种方法的核心思想是通过优化数据的存储和访问方式，以提升计算性能。

什么是数据的“可移动性” (Relocatability)?

这里提到的可移动性与传统意义上的位置独立代码（Position Independent Code, PIC）无关。在动态链接库的上下文中，位置独立代码指的是代码在内存中可以被放置在任何位置而不影响其功能。
但在这里，可移动性是指通过数据导向技术，使得我们能够更灵活地移动和重新组织数据，从而达到优化性能的目标。具体来说：

• 我们希望能够重新安排数据的位置，以便最大程度地提升性能。
• 这意味着我们不再局限于对象间的引用关系和传统的内存布局，而是根据性能需求优化数据布局。

为什么要这么做？

优化数据布局是为了将数据保持在内存中最有利于缓存命中率的地方。通过数据导向设计，我们可以通过合适的排列数据、减少不必要的指针间接访问，来提升程序性能。简而言之，我们通过数据的布局优化来尽量避免缓存未命中和内存带宽瓶颈。

数据导向技术：

在 2021 年，我通过 C++ 的视角详细讲解了数据导向技术，并讨论了如何通过应用这些技术来获得性能提升。这些技术的核心思想至今依然有效。

1. 数据优先：数据导向技术的核心在于将数据本身置于首位，以便计算操作能够更有效地对其进行处理。通过关注数据的存储和组织方式，计算的效率能够显著提高。
2. 灵活性：数据导向的优化方式不仅仅是通过合适的内存布局来提升性能，更重要的是它允许我们对数据的位置进行调整和移动，以进一步提升性能。
3. 优点：这种方式能够使计算过程更加简洁、数据访问更加高效，进而在系统架构中大幅提升性能，特别是在面对需要大量数据处理的计算密集型场景时。

数据导向的实施：

在实践中，数据导向的优化可以通过以下几种方式实现：

• 内存对齐和布局优化：通过对数据进行合适的内存对齐和重排，以减少缓存未命中。
• 结构体重新设计：例如，将多层嵌套的结构体展平，将不常用的字段延迟加载或分散存储。
• 减少指针追踪：通过减少对象间的引用和指针间接访问，优化内存访问模式。

总结：

1. 性能提升：通过采用数据导向的设计方法，可以在不牺牲功能的前提下，显著提升程序的运行效率。特别是通过重新安排数据位置和存储布局，优化了内存访问模式，提升了性能。
2. 可移动性：数据的“可移动性”指的是在数据导向设计下，可以自由调整数据的存储和访问方式，从而实现更加高效的计算。
3. 数据优先：数据导向技术不仅优化了数据存储，还考虑了数据的可操作性，使得计算更加高效。

“正常方式” (The “Normal Way”)

在传统的面向对象编程（OOP）中，类和结构体通常包含多个异构类型的成员（heterogeneous types）。这种设计方式在计算资源的映射上往往并不高效，主要体现在以下几个方面：

1. 异构类型的类和结构体：
   • 类和结构体通常包含多个成员变量，这些成员变量的类型可能是不同的（异构类型）。这种设计方式很难映射到计算资源，尤其是当数据量大时，它会导致内存布局不够紧凑，进而影响性能。
   • 例如，类中可能有整数、浮点数、指针等不同类型的成员，这种异构类型的结构会导致内存中对象的布局不连续，从而增加缓存未命中的可能性，影响数据的访问效率。
2. 指针的使用：
   • 通过指针来使得对象能够相互引用，这样的做法存在许多问题。虽然指针可以有效地实现动态绑定和对象的间接引用，但它也带来了许多潜在的性能问题：
     • 额外的间接访问：每次访问指针所指向的对象时，都会产生额外的内存访问开销。这种间接访问增加了缓存未命中的概率，降低了程序的性能。
     • 内存分配：通过指针引用的对象往往需要动态分配内存，这不仅增加了内存的管理开销，还可能导致内存碎片问题。
3. 继承和虚函数的使用：
   • 运行时多态性通常通过继承和虚函数实现。尽管这种设计提供了很强的灵活性和可扩展性，但它也带来了多个问题：
     • 额外的间接访问：虚函数的调用会引入虚拟表（vtable），每次调用虚函数时需要通过虚拟表来查找合适的函数，这是一种额外的间接访问，导致性能降低。
     • 额外的内存分配：使用指针引用的方式来管理对象需要额外的内存分配和管理。这种内存分配通常是动态的，可能导致频繁的堆内存分配，增加内存开销。
     • 认知负担：开发者需要管理复杂的生命周期、共享所有权（如std::shared_ptr）和唯一所有权（如std::unique_ptr）的问题。对于初学者来说，这些概念需要额外的理解和处理，增加了开发的复杂度。

总结：

在传统的面向对象编程中，使用指针、继承和虚函数等机制虽然为程序设计提供了灵活性和扩展性，但它们也会带来多个性能瓶颈：

• 内存访问效率低：指针的使用和异构类型的成员分布使得内存访问不连续，增加了缓存未命中的概率。
• 额外的内存分配：动态内存分配和堆内存的使用导致了性能的下降。
• 认知负担：管理生命周期和内存所有权增加了开发者的认知负担和错误的风险。

“非正常的方式” (The “Abnormal” Way)

列式表示 (Columnar Representation)

列式表示是一种优化数据存储和访问的方式。在传统的面向对象编程中，我们通常会使用包含多个异构类型成员的结构体或类，然而，这种设计方式存在一定的性能问题，特别是在大规模数据处理时。
列式表示（又称“散列”或“结构化数组”）是将包含异构数据成员的结构体转换为包含同质数据类型的数组的结构。在数据库领域，这通常称为从“行表示”（row-representation）转换为“列表示”（columnar representation）。这种方式不仅在数据库中常用，在性能优化的编程中也得到了广泛应用。

行式表示 (Row-wise Representation)

行式表示是我们通常在程序中看到的结构体表示方式。在这种方式下，每个结构体的实例包含多个不同类型的成员，它们通常存储在内存中连续的内存区域中。这种方式的例子如下：

structItem{intid;doubleprice;Specials*specials;// 指向Specials类型的指针Category*category;// 指向Category类型的指针boolis_homemade;};

在这个例子中，Item结构体包含不同类型的成员（int、double、指针等）。它们的存储方式是按顺序排列的，即每个Item实例都会在内存中存储所有这些成员。

• 指针问题：指针成员可能为null，并且需要特殊处理（如Optional类型）。
• 异构类型：由于结构体内包含不同类型的成员（如整数、浮动、指针等），它们的存储方式不够高效，尤其是在需要大量数据处理时，这种存储方式的性能会受到很大影响。
  行式表示有其必要性，但从性能角度来说，它的内存布局效率低，访问效率差。尤其在涉及大规模数据时，指针的解引用、内存访问的局部性差等问题都可能导致性能瓶颈。

列式表示 (Column-wise Representation)

列式表示通过将不同类型的数据按列（而非按行）组织，来改善内存布局和数据访问效率。在列式表示中，同一类型的数据被存储在相邻的内存位置，从而增加了缓存命中率，提高了性能。
以下是一个列式表示的示例：

template<std::size_t N>structState{std::array<int,N>ids;// 所有ID数据存储在一个数组中std::array<double,N>prices;// 所有价格数据存储在一个数组中EfficientMap<std::size_t,Specials>specials;// 特殊数据通过高效映射存储std::array<Category_handle,N>categories;// 类别通过数组存储EfficientSet<std::size_t>homemade;// 使用集合存储是否是自制的标志};

在这种列式表示中，所有相同类型的数据（如id、price）被存储在同一个容器中（如std::array）。每种数据类型都存储在独立的数组中，从而避免了结构体中的混合数据类型。

• 高效的内存布局：所有相同类型的数据按顺序存储，有助于提高数据的访问局部性，从而提升缓存命中率。
• 简化的内存访问：由于同一类型的数据是连续存储的，内存访问变得更加高效，减少了指针间接访问带来的性能开销。

行式表示与列式表示的对比：

• 内存布局：
  • 行式表示：数据类型异构，存储在一个结构体中，访问时可能会涉及不同类型数据的分散访问。
  • 列式表示：数据类型同质，存储在数组或集合中，内存访问更为高效，尤其在大数据量处理时优势明显。
• 性能：
  • 行式表示：对于小规模数据，行式表示可以较为简单直接。但随着数据规模增大，其性能可能会下降。
  • 列式表示：尤其适合于数据处理密集型的场景（如数据分析、大规模并行处理等），通过优化数据存储和访问，提高了程序的效率。

总结：

1. 行式表示适合于对象之间关系复杂且不关注性能的场景，但在大数据量处理时其性能会受到很大限制。
2. 列式表示通过优化内存布局和数据访问，提升了程序的性能，特别适用于需要高效数据处理的场景。通过将异构数据转换为同质数据数组，可以显著减少内存访问的成本。
   通过这种方式，程序的性能可以得到显著优化，特别是在处理大量数据时。

实体-组件系统 (Entity-Component Systems)

实体-组件系统（ECS）是一种数据驱动的设计模式，广泛应用于游戏开发和其他需要高效数据管理的领域。在这种设计中，传统的面向对象的“对象”被“实体”替代，而“成员”则成为了“组件”。每个实体由多个组件组成，系统负责管理和操作这些组件。通过这种方式，可以高效地管理和操作大量的数据。

组件-实体的关系

在传统的面向对象设计中，一个对象通常由多个成员（如属性）组成，这些成员有不同的数据类型和功能。比如，在面向对象的类中，成员可能是整数、浮点数、指针等不同类型的数据。而在ECS中，组件代表了这些不同的功能或数据项，实体则是组件的集合。

• 实体 (Entity)：在ECS中，实体不再是具有不同成员的对象，而只是一个标识符。它本身并不包含数据或行为，而是由多个组件组成。实体是数据的容器，通常通过一个索引来标识。
• 组件 (Component)：每个组件代表一个单一的数据项或功能（例如，位置、速度、健康状态等）。这些组件不包含行为（如方法），它们只存储数据。所有的组件通常具有相同类型的数据，并按照某种方式存储在内存中。
• 系统 (System)：系统负责对组件数据进行处理。系统通过绑定特定的组件到实体来操作数据。系统可以执行例如移动、碰撞检测、渲染等操作。每个系统操作一个或多个组件的数据，并根据需要执行特定的行为。

散列 (Scattering)

在ECS中，为了优化性能，数据会以列式存储（scattering）的方式排列，而不是传统的行式存储（例如对象中的成员）。这样做的好处是，所有同类型的数据（例如所有的id、price等）都会存储在一起，这有助于提高内存访问的局部性和缓存命中率。

句柄 (Handle)

在ECS中，实体和组件之间的绑定是通过句柄来实现的。句柄通常是一个简单的整数，它表示某个实体或组件在全局数据结构中的位置。通过这种方式，可以高效地访问和修改组件数据。

示例代码：

在下面的代码中，State结构体包含了所有的组件数据，而ItemHandle类则是一个句柄，用于通过索引访问这些数据。

autostate=State<N>;classItemHandle{std::size_t index;// 索引，用于访问特定的组件数据public:// 通过索引访问组件数据intid(){returnstate.ids[index];}// 获取iddoubleprice(){returnstate.prices[index];}// 获取价格Specials*specials(){returnstate.specials[id()];}// 获取特殊数据Category_handlecategory(){returnstate.categories[id()];}// 获取类别bool&is_homemade(){returnstate.homemade.contains(id());}// 获取是否自制};

代码说明：

1. State<N>：包含所有组件数据的全局结构体。它包含了多个std::array，每个数组存储一个特定类型的组件数据。N表示数组的大小（即实体的数量）。
2. ItemHandle：是一个句柄类，代表单个实体。每个ItemHandle通过一个index来访问全局State结构中的组件数据。通过这种方式，ItemHandle可以访问特定实体的所有组件（如id、price等）。
3. id()、price()、specials()、category()、is_homemade()：这些方法通过句柄提供对特定组件数据的访问。它们通过index来查找并返回对应的组件数据。

优点：

1. 性能优化：通过将组件按类型存储在数组中（列式存储），可以提高缓存命中率，减少内存访问延迟。
2. 灵活性：每个实体的行为是由系统动态地绑定到组件上的，这使得ECS具有高度的灵活性和可扩展性。
3. 简化管理：实体仅作为标识符，而不是复杂的数据结构，这使得程序中的实体管理更加简洁，避免了传统面向对象中的复杂继承和多态问题。

总结：

实体-组件系统通过将传统的面向对象编程中的对象和类转化为“实体”和“组件”的方式，优化了性能并简化了数据管理。它通过使用句柄来管理实体和组件之间的关系，并通过系统来操作这些组件数据，适合于需要处理大量数据的场景，如游戏引擎和大规模并行计算。

句柄 (Handles)

在实体-组件系统（ECS）中，句柄是一个非常关键的概念。它是用来代表实体或组件的标识符，通常是一个整数，指向特定数据结构中的某个位置。通过这种方式，ECS避免了传统的对象关系，使得内存访问更加高效，数据组织也更符合计算资源的最佳性能。

句柄的基本概念

• 底层实现：在底层，句柄通常是一个整数（通常是数组的索引），它表示一个特定组件或实体的数据位置。
• 句柄的作用：句柄作为一个引用类型，用于访问组件或实体的具体数据。它本身不持有数据，而是提供访问数据的途径。

示例代码：

以下是一个使用句柄访问组件数据的例子：

autostate=State<N>;// State是一个包含所有组件数据的结构体classItemHandle{std::size_t index;// 用一个索引表示句柄，索引指向State中的数据public:// 通过句柄访问不同类型的组件数据intid(){returnstate.ids[index];}// 获取 iddoubleprice(){returnstate.prices[index];}// 获取 priceSpecials*specials(){returnstate.specials[id()];}// 获取 specials 数据Category_handlecategory(){returnstate.categories[id()];}// 获取 category 数据bool&is_homemade(){returnstate.homemade.contains(id());}// 获取 homemade 标志};

代码解释：

1. State<N>：State是一个全局数据结构，它存储所有组件的数据。N是实体的数量，表示State中每个组件的数据大小。每种组件数据（如ids、prices等）存储在不同的数组中。
2. ItemHandle：是一个句柄类，每个句柄通过index引用特定实体的数据。在ItemHandle类中，通过访问state中的数据数组，可以获取实体的各个组件（如id、price等）。
3. id()、price()、specials()等方法：这些方法通过句柄访问state中的组件数据。每个方法通过index查找对应的组件。

运行时多态性 (Runtime Polymorphism)

虚函数表 (Virtual Tables)

运行时多态性通常通过虚函数表（vtable）来实现，这要求对象有动态绑定的能力。在传统的面向对象编程中，虚函数表用于实现继承和动态方法调用。但是，在 ECS 中，虚函数表的实现方式会有所不同。

• 程序员负责生成虚函数表：在传统的面向对象编程中，虚函数表由编译器自动生成；而在 ECS 中，程序员通过使用类型擦除（type-erasure）等技术来实现虚函数表的创建。
• Zoo 类型擦除 (Zoo type-erasure)：通过类型擦除，生成的虚函数表可以允许不同类型的对象共享同一个接口，从而实现运行时的多态性。这使得 ECS 系统能够处理不同类型的实体。

句柄中的虚函数表索引

• 句柄中的虚函数表索引：在 ECS 中，每个子类型的句柄（例如ItemHandle）会有一个虚函数表索引，它指向该类型的虚函数表。这样，每个实体的句柄可以通过一个统一的接口访问不同子类型的虚函数。

子类型和父类型句柄的继承

每个子类型（如ItemHandle）的句柄会继承自超类句柄（如Handle），这样可以通过继承关系对不同子类型的实体进行访问。这种设计使得运行时的多态性得以保留，同时保持了 ECS 的高效性。

资源管理 (Resource Management)

在一些情况下，系统需要管理特殊资源（如文件流、内存管理等）。资源管理通常是系统中的特殊情况，这些资源不能像普通数据那样通过 ECS 进行处理。

• 示例：文件流管理：例如一个类用于管理一个std::ostream文件输出流。这样的资源管理通常需要单独处理，并不是 ECS 能直接支持的。
• 资源管理的稀缺性：资源管理对象通常是非常少的，它们通常不会频繁出现在系统中，因此这部分问题不会影响到 ECS 的核心优势。

为什么采用列式表示 (Columnar Representation)

ECS 中采用列式表示（Scattering）是为了优化性能。通过将不同类型的组件存储为同质数据的数组（而不是传统的面向对象的异构结构），可以显著提高数据访问的局部性，从而提高性能。

• 异构数据问题：在传统的面向对象编程中，多个不同类型的成员（如int、double等）存储在同一个对象中，这种存储方式可能会导致性能问题，特别是在需要频繁访问大量数据时。
• 列式表示的优势：通过将每种类型的数据存储在独立的数组中，能够优化内存布局，减少缓存未命中的问题，从而提高性能。尤其在需要对大量数据进行SIMD操作或并行处理时，列式表示可以充分发挥计算资源的性能。

总结：

1. 句柄：通过索引来管理组件和实体之间的关系，使得数据存储和访问更加高效。
2. 运行时多态性：通过程序员控制的虚函数表和类型擦除，支持不同类型实体的多态性，保持了 ECS 的高效性。
3. 资源管理：资源管理对象需要特殊处理，但在 ECS 中占据的比例较少，不会影响核心性能。
4. 列式表示：通过将数据按类型分列存储，提高了内存访问效率，适合大规模数据处理，尤其在性能要求高的场景（如游戏引擎和并行计算）中具有明显优势。

总结：

稳定索引与内存重定位 (Stable Indices and Relocatability)

在现代计算机系统中，内存管理通常是性能优化的关键部分。尤其是对于高效存储和访问大量动态数据的系统（如游戏引擎、仿真系统等），内存的碎片化和数据的迁移是影响性能的重要因素。
Björn Fahller在他的演讲中介绍了稳定索引 (Stable Indices)的概念，并解释了如何通过引入间接访问来提高性能并实现数据的重定位。通过这种方式，系统可以在需要时移动数据，并且不会影响程序的正确性。

内存碎片与重定位的挑战

1. 内存碎片 (Memory Fragmentation)：随着应用程序的运行，许多对象会被创建和销毁。这样，内存分配器分配的地址将变得不稳定，导致内存碎片化。如果你尝试持久化应用的状态（例如，通过内存转储），由于分配器给出的地址不同，恢复时会遇到问题。
2. 分配器的不关心：现代内存分配器并不会关心数据在内存中的实际位置，分配器关注的是如何高效地管理内存块的分配和回收。然而，在某些高效能的应用场景下，数据的位置对性能至关重要。
3. 必须自由移动数据：为了应对内存碎片和性能问题，系统需要有能力重新排列数据的位置。尤其是在大量动态创建和销毁对象的情况下，通过重定位，可以确保数据始终存储在最有利于性能的地方。

稳定索引（Stable Indices）

稳定索引是一种使用额外的间接访问来为数据分配稳定标识符的技术。这样，即使数据的位置发生变化，程序仍然可以通过稳定的标识符（而不是直接的内存地址）来访问数据。

• 间接访问：通过引入额外的间接引用，可以确保数据的地址不会因为内存重分配而发生变化。每个数据项的访问通过索引进行，而不是直接的内存地址，这样即使数据在内存中的位置发生变化，索引仍然保持有效。
• 前向映射与反向映射：这种间接访问的技术不仅可以提供“前向映射”，即从数据的索引获取数据，还可以提供“反向映射”，即根据数据获取其索引。这提供了更大的灵活性，适应不同的需求。

重定位的优势 (Advantages of Relocatability)

• 数据的可预测性与控制：通过将数据组织为列式存储，系统能够精确控制数据在内存中的位置。数据可以被优化存放在最有利于性能的地方，提升访问效率。
• 外部存储与内存映射：当数据需要持久化（例如存储到文件系统中）时，数据的布局将与内存中的布局保持一致。通过内存映射，程序可以直接对文件进行操作而无需复制数据，这进一步提高了效率。
• 内存“整理”：当数据结构发生变化时（例如，实体被移除，造成了内存中的空洞），可以通过重定位的方式将这些空洞填补，从而恢复内存的高效访问模式。这个过程就像“碎片整理”，通过移动数据来恢复内存的局部性。

重定位对性能的影响

1. 空间与时间局部性 (Spatial and Temporal Locality)：通过重定位，可以提升空间局部性和时间局部性，使得内存访问更加高效。空间局部性意味着相邻的数据项往往在同一缓存行中，这有助于提高缓存命中率；时间局部性意味着在短时间内访问相同数据的机会较高。
2. 性能损失的避免：通过保持数据的局部性，重定位可以避免由于内存碎片和无效内存访问而导致的性能下降。

总结

• 内存碎片和不稳定地址是高效计算中的一个难题，尤其是在需要频繁创建和销毁对象的场景中。为了避免这些问题，稳定索引和内存重定位成为了提高性能的有效手段。
• 稳定索引通过引入间接访问提供了一种数据访问的稳定机制，即使数据位置发生变化，程序仍然可以通过索引来获取数据。
• 重定位技术允许在数据位置不再最优时，重新排列数据，从而恢复其高效的内存访问模式。通过这种方式，可以提升时间局部性和空间局部性，大大提高性能。
• 数据方向优化（Data Orientation）提供了一种新的思路，即通过对数据的精确控制和管理，利用内存访问的局部性优化来提升程序的整体性能。

总结：

值管理器 (Value Managers)

在处理数据方向优化 (Data Orientation)和重定位 (Relocatability)的问题时，值管理器是一个至关重要的概念。它帮助我们更好地管理值的生命周期、分配、释放和与其他对象的交互，尤其是在面向对象设计与性能优化之间找到平衡时。

当前问题和挑战

1. 值管理器的需求：我们看到，在将数据分散存储为列式表示后（例如使用组件句柄而非传统的对象），仍然需要一种机制来在“正常”对象和“分散”对象之间进行交互。尤其是，许多非分散意识型的函数（例如标准库的std::optional和std::vector）依赖于传统的对象表示，并且它们与分散存储的实体之间的互操作性是一个非常微妙的问题。
2. std::optional 和内存分配器问题：例如，std::optional<T>本身并不使用分配器，但它可能包含一个使用分配器的类型（如std::vector<T>）。这种设计的潜在问题在于：std::optional可能会阻碍使用自定义分配器的能力，因为它没有提供为其内部值类型提供分配器的选项。
3. 值管理的概念：值管理器的主要任务是管理值的生命周期，包括：如何为值分配内存、如何处理类型擦除和如何应对内存碎片等。管理值的任务通常由“值管理器”承担，而这个概念是当前标准库尚未充分表达的。

值管理器的类型

1. 类型擦除中的值管理：类型擦除（如std::any和std::function）通常会“忘记”值的类型，而这个类型的管理则变成了更为复杂的问题。不同的值管理器关注的事项不同，具体有：
   • 局部值管理：如对内存对齐和缓冲区大小的管理。
   • 非局部值管理：如内存分配、隐藏间接访问、利用间接访问等。
2. 数据分散与异构数据集合的管理：当数据被分散存储为不同的数组时，值管理器需要能够处理这些数据，并且能够确保不同类型的值（例如std::vector<int>和std::vector<std::string>）的正确管理。
3. 重定位的管理：对于需要重定位的值，管理器需要能够处理前向映射和反向映射的问题，即如何在数据发生重定位时，保持访问的一致性。

Zoo 类型擦除和值管理

在处理类型擦除时，Zoo 类型擦除分离了值管理和外部接口（即“提供”）。这意味着我们将值管理和如何提供值（例如通过虚拟表或模板编程）分离，以便可以更好地优化性能和灵活性。

• 值管理：核心任务是为值提供生命周期管理、内存分配和释放，并确保其在数据重定位过程中不会丢失信息。
• 外部接口：提供用于值访问的接口，确保通过间接访问能够高效管理类型擦除的对象。

关键成功

• 类型擦除的分离：通过将值管理与其他方面的优化（如多态支持和并行继承等）分开，能够更加专注于性能的提升。
• 模板编程接口：值管理器的设计应该采用类似 Alexandrescu 的策略设计模式（Policy Design Pattern），使得程序员能够灵活地管理值和类型，同时保持代码的高效性和可维护性。

结论：

• 语言和库的改进非常关键，特别是反射和类型擦除等功能的引入，可以大大提高程序的灵活性。
• 编程人员应更多地运用数据方向优化和重定位技术，因为它们可以显著提升性能，尤其是在处理大量动态数据时。
• 值管理器是处理这些技术时不可忽视的工具，它将帮助我们更好地管理和操作分散存储的数据，从而提升程序的性能和可维护性。