1

我有一个Element具有一些功能的类，如下所示：

def clean(self):
    self.dirty = False

我有 1024 个元素，我正在循环调用clean它们中的每一个。while 1:

如果我停止调用该clean方法，游戏帧率会从 76 fps 上升到 250 fps。

这很令人不安。我真的必须如此小心，以免完全落后于我的代码吗？

编辑（这是完整的代码）：

250 fps 代码

for layer in self.layers:
            elements = self.layers[layer]
            for element in elements:
                if element.getDirty():
                    element.update()
                    self.renderImage(element.getImage(), element.getRenderPos())

                    element.clean()

76fps代码

for layer in self.layers:
            elements = self.layers[layer]
            for element in elements:
                if element.getDirty():
                    element.update()
                    self.renderImage(element.getImage(), element.getRenderPos())

                element.clean()

2编辑（这是分析结果）：

Sat Feb  9 22:39:58 2013    stats.dat

         23060170 function calls (23049668 primitive calls) in 27.845 seconds

   Ordered by: internal time
   List reduced from 613 to 20 due to restriction <20>

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
  3720076    5.971    0.000   12.048    0.000 element.py:47(clean)
      909    4.869    0.005   17.918    0.020 chipengine.py:30(updateElements)
  3742947    4.094    0.000    5.443    0.000 copy.py:67(copy)
     4101    3.972    0.001    3.972    0.001 engine.py:152(killScheduledElements)
    11773    1.321    0.000    1.321    0.000 {method 'blit' of 'pygame.Surface' objects}
        4    1.210    0.302    1.295    0.324 resourceloader.py:14(__init__)
  3720076    0.918    0.000    0.918    0.000 element.py:55(getDirty)
     1387    0.712    0.001    0.712    0.001 {built-in method flip}
  3742947    0.705    0.000    0.705    0.000 copy.py:102(_copy_immutable)
  3728284    0.683    0.000    0.683    0.000 {method 'copy' of 'pygame.Rect' objects}
  3743140    0.645    0.000    0.645    0.000 {method 'get' of 'dict' objects}
     5494    0.566    0.000    0.637    0.000 element.py:89(isBeclouded)
     2296    0.291    0.000    0.291    0.000 {built-in method get}
        1    0.267    0.267    0.267    0.267 {built-in method init}
     1387    0.244    0.000   25.714    0.019 engine.py:67(updateElements)
     2295    0.143    0.000    0.143    0.000 {method 'tick' of 'Clock' objects}
    11764    0.095    0.000    0.169    0.000 element.py:30(update)
  8214/17    0.062    0.000    4.455    0.262 engine.py:121(createElement)
       40    0.052    0.001    0.052    0.001 {built-in method load_extended}
    36656    0.046    0.000    0.067    0.000 element.py:117(isCollidingWith)
4

2 回答 2

1

分析表明，在分析期间调用 clean 方法大约需要 28 秒中的 6 秒。在此期间，它也被调用了 370 万次。

这意味着您显示的循环必须是软件的主循环。该主循环也只做以下事情：

  1. 检查元素是否脏。
  2. 如果是，它会绘制它。
  3. 然后清洗它。

由于大多数元素不是脏的（update() 只被调用了这 370 万个循环中的 11000 个），最终结果是你的主循环现在只做一件事：检查元素是否脏，然后调用 .clean( ） 在上面。

通过仅在元素脏时调用 clean，您有效地将主循环减半。

我真的必须如此小心，以免完全落后于我的代码吗？

是的。如果你有一个非常紧的循环，大部分时间什么都不做，那么你必须确保这个循环实际上是紧的。

这很令人不安。

不，这是一个基本的计算事实。

于 2013-02-10T03:51:42.923 回答
0

（评论，但我的统计数据低到“评论”）

如果你调用 element.getDirty() 370 万次，它只脏了 11000 次，你应该保留一个脏列表，而不是每次都轮询。

也就是说，不设置脏标志，而是将脏元素添加到脏元素列表中。看起来您可能需要为每一层创建一个脏列表。

于 2013-02-10T07:45:39.170 回答