《游戏编程模式》（7）

Chapter 17 数据局部性

通过合理组织数据利用CPU缓存机制来加快内存访问速度。

数据局部性：多级缓存加快了最近访问过的数据的邻近内存的访问速度，保持数据位于连续的内存中可以提高性能。

 

找到出现性能问题的地方，不要把时间浪费在非频繁执行的代码上。

为了做到缓存友好，可能会牺牲继承、接口等这些手段带来的好处。

 

连续数组：

AIComponent* aiComponents =
    new AIComponent[MAX_ENTITIES];
PhysicsComponent* physicsComponents =
    new PhysicsComponent[MAX_ENTITIES];
RenderComponent* renderComponents =
    new RenderComponent[MAX_ENTITIES]; 

while (!gameOver)
{
  // Process AI.
  for (int i = 0; i < numEntities; i++)
  {
    aiComponents[i].update();
  } 

  // Update physics.
  for (int i = 0; i < numEntities; i++)
  {
    physicsComponents[i].update();
  } 

  // Draw to screen.
  for (int i = 0; i < numEntities; i++)
  {
    renderComponents[i].render();
  } 

  // Other game loop machinery for timing...

} 

相比GameEntity里几个指针指向对应component的方案，这个方案提高了每帧执行游戏循环时的缓存命中。

 

包装数据：

void ParticleSystem::update()
{
  for (int i = 0; i < numParticles_; i++)
  {
    if (particles_[i].isActive())
    {
      particles_[i].update();
    }
  }
}

更新所有粒子，之前的判断引发CPU预测失准和流水线停顿。

解决方案是跟踪被激活粒子的数目：

1. 当粒子被激活时将它与第一个未激活粒子交换位置；
2. 当粒子被灭时将它与最后那个激活的粒子交换位置。

for (int i = 0; i < numActive_; i++)
{
  particles[i].update();
}
 

void ParticleSystem::activateParticle(int index)
{
  // Shouldn't already be active!
  assert(index >= numActive_);
 
  // Swap it with the first inactive particle
  // right after the active ones.
  Particle temp = particles_[numActive_];
  particles_[numActive_] = particles_[index];
  particles_[index] = temp;
 
  // Now there's one more.
  numActive_++;

} 

void ParticleSystem::deactivateParticle(int index)
{
  // Shouldn't already be inactive!
  assert(index < numActive_); 

  // There's one fewer.
  numActive_--;

  // Swap it with the last active particle
  // right before the inactive ones.
  Particle temp = particles_[numActive_];
  particles_[numActive_] = particles_[index];
  particles_[index] = temp;

}

 

冷热分解：

将数据结构分解为冷热两部分：

1. 热数据 每帧需要用到的数据；
2. 冷数据 不会被频繁使用的数据（分配一个指针塞下）

class AIComponent
{

public:
  // Methods...

private:
  Animation* animation_;
  double energy_;
  Vector goalPos_;
 
  LootDrop* loot_;

};

class LootDrop
{
  friend class AIComponent;

  LootType drop_;
  int minDrops_;
  int maxDrops_;
  double chanceOfDrop_;

};

 

 

Chapter 18 脏标记模式

将工作推迟到必要时进行以避免不必要的工作。

衍生数据由原始数据经过一些代价高昂的操作确定。用一个脏标记跟踪衍生数据是否与原始数据同步，同步时使用缓存数据，不同步时则重新计算衍生数据并清除标记。

 

脏标记模式增加了代码复杂性：

1. 用代码复杂性换取性能的优化；
2. 太慢的计算不行，如一帧内处理不完的；
3. 必须保证每次状态改动都设置标记（单一API封装）。 

Example：

矩阵计算

class Transform
{

public:
  static Transform origin(); 

  Transform combine(Transform& other);

};

GraphNode（初始化dirty_为true）

class GraphNode
{

public:
  GraphNode(Mesh* mesh)
  : mesh_(mesh),
    local_(Transform::origin()),
    dirty_(true)
  {}

  void renderMesh(Mesh* mesh, Transform transform);

  // Other methods... 

private:
  Transform world_;
  bool dirty_;

  Transform local_;
  Mesh* mesh_;

  GraphNode* children_[MAX_CHILDREN];
  int numChildren_;

};

设置Transform并设置dirty

void GraphNode::setTransform(Transform local)
{
  local_ = local;
  dirty_ = true;
}

渲染：

void GraphNode::render(Transform parentWorld, bool dirty)
{
  dirty |= dirty_;
  if (dirty)
  {
    world_ = local_.combine(parentWorld);
    dirty_ = false;
  } 

  if (mesh_) renderMesh(mesh_, world_);
 
  for (int i = 0; i < numChildren_; i++)
  {
    children_[i]->render(world_, dirty);
  }
}

检查脏标记并把它继续传给子节点。