image::tblit的构造、复制效率

ancientcc

display渲染的一大任务是分层渲染(drawing_buffer_commit)，分层渲染的单元是tblit。由于分层渲染单元很多，而且每次分层渲染都是要重新构造整个drawing_buffer_，这就让凸显一个问题，如果花在tblit的构造、复制时间较多，会影响app的整体效率。

tblit的效率到底是多少，让看一次运行实例，测试机是2015年出的Macbook proc。
测试时tblit中的loc类型是image::locator。

1. 
   
2. void do_test()
   
3. {
   
4.         const int size = 1100;
   
5.         image::get_image("misc/0.png");
   
6.         image::tblit* blit_buf[size];
   
7.         for (int loop = 0; loop < 5; loop ++) {
   
8.                 std::vector<image::tblit> blits, blits2;
   
9.                 uint32_t start_ticks = SDL_GetTicks();
   
10.                 // blits.reserve(size);
    
11.                 for (int i = 0; i < size; i ++) {
    
12.                         blits.push_back(image::tblit("misc/0.png", image::UNSCALED));
    
13.                 }
    
14.                 uint32_t ticks1 = SDL_GetTicks();
    
15.                 blits2 = blits;
    
16.                 uint32_t ticks2 = SDL_GetTicks();
    
17. 
    
18.                 for (int i = 0; i < size; i ++) {
    
19.                         blit_buf[i] = new image::tblit("misc/0.png", image::UNSCALED);
    
20.                 }
    
21.                 uint32_t ticks3 = SDL_GetTicks();
    
22.                 for (int i = 0; i < size; i ++) {
    
23.                         delete blit_buf[i];
    
24.                 }
    
25.                 posix_print("#%i, tblit, push_back: %u, copy: %u, new: %u, delete %u\n", loop,
    
26.                         ticks1 - start_ticks, ticks2 - ticks1, ticks3 - ticks2, SDL_GetTicks() - ticks3);
    
27. 
    
28.                 start_ticks = SDL_GetTicks();
    
29.                 std::vector<surface> surfs, surfs2;
    
30.                 start_ticks = SDL_GetTicks();
    
31.                 for (int i = 0; i < size; i ++) {
    
32.                         surfs.push_back(image::get_image("misc/0.png"));
    
33.                 }
    
34.                 ticks1 = SDL_GetTicks();
    
35.                 surfs2 = surfs;
    
36.                 posix_print("#%i, surface, push_back: %u, copy: %u\n", loop, ticks1 - start_ticks, SDL_GetTicks() - ticks1);
    
37.         }
    
38. }
    

复制代码

输出

1. 
   
2. #0, tblit, push_back: 3, copy: 1, new: 7, delete 5
   
3. #0, surface, push_back: 1, copy: 0
   
4. #1, tblit, push_back: 3, copy: 1, new: 7, delete 6
   
5. #1, surface, push_back: 1, copy: 0
   
6. #2, tblit, push_back: 3, copy: 0, new: 8, delete 5
   
7. #2, surface, push_back: 2, copy: 0
   
8. #3, tblit, push_back: 4, copy: 0, new: 8, delete 6
   
9. #3, surface, push_back: 1, copy: 0
   
10. #4, tblit, push_back: 3, copy: 0, new: 8, delete 5
    
11. #4, surface, push_back: 2, copy: 0
    

复制代码

这就意味着，如果不作任何优化，要渲染1000个单元，那每次drawing_buffer_commit单单花在构造tblit上的时间就要3毫秒（如果image::locator中的modifications_不是空，那将消耗更多时间）。对app场景，一次要渲染1000个单元也是常见的事。

上面还计算了new、delete花费的时间。有人认为std::vector::push_back不得不存在复制构造操作，为提高效率想避免这个操作，于是用指针数组方法，像“image::tblit* buf[1000]”。但从以上结果看到，new、delete要比std::vector的复制构造多耗费时间。相比push_back，例子中new/delete多这么多，这当中有Debug原因，Release时会缩小差距，但相比push_back还是没优势。

如何提高image::tblit复制效率

• image::tblit中的loc类型改为"image::locator*"；
• 给image::tblit::loc赋值时使用函数image::get_locator。
  
  1. std::set<locator> locators;
     
  2. const locator& get_locator(const locator& locator)
     
  3. {
     
  4.         std::set<image::locator>::const_iterator it = locators.find(locator);
     
  5.         if (it != locators.end()) {
     
  6.                 return *it;
     
  7.         }
     
  8.         std::pair<std::set<image::locator>::const_iterator, bool> res = locators.insert(locator);
     
  9.         return *res.first;
     
  10. }

  复制代码
  
  
• app只会增加不会删除locators中单元，保证image::tblit中的loc一直有效。