軟件工程——數獨 性能測試1

一、    開發環境

l  Windows10 版本號1903

l  RAM 16GB 3200MHz 三星

l  AMD Ryzen 7 2700X 3.90GHz

l  SSD 三星 MZVLB1TOHALR-00000

二、    文件讀入

在進行測試的過程中發現1e6的數據讀入大概需要300秒，遠遠高於寫入的6秒鐘。顯然由於硬盤限制寫入時間應該大於讀入，因此文件讀入代碼必然是有問題的，時間是不可接受的。

原文件讀入的代碼如下：

1. inline void mallocSudoku(Sudoku& s)  
   1. {  
   2.     if (s == nullptr)  
   3.     {  
   4.         s = new int* [10];  
   5.         for (int i = 0; i < 10; i++)  
   6.         {  
   7.             s[i] = new int[10];  
   8.         }  
   9. 10.     }  

11. }  

1. 12.   

13. inline void freeSudoku(Sudoku& s)  

14. {  

1. 15.     if (s != nullptr)  
2. 16.     {  
3. 17.         for (int i = 0; i < 10; i++)  
4. 18.         {  
5. 19.             delete[] s[i];  
6. 20.         }  
7. 21.         delete[] s;  
8. 22.         s = nullptr;  
9. 23.     }  

24. }  

1. 25.   

26. inline void readLineFromFile(char* line)  

27. {  

1. 28.     char* tmp = new char;  
2. 29.     DWORD num_bytes_read = 0;  
3. 30.     for (int i = 0; i < 9; i++)//依據約定，一行最多有9個數字  
4. 31.     {  
5. 32.         *tmp = 0;  
6. 33.         while (*tmp < '0' || *tmp > '9')  
7. 34.         {  
8. 35.             if (ReadFile(h_sudoku_problem_txt, tmp, 1, &num_bytes_read, NULL) && num_bytes_read == 0)  
9. 36.             {  
10. 37.                 is_end = true;  
11. 38.                 return;  
12. 39.             }  
13. 40.             //num_bytes_read++;  
14. 41.         }  
15. 42.         line[i] = *tmp;  
16. 43.     }  
17. 44.     delete tmp;  

45. }  

1. 46.   

47. inline bool getSudokuFromFile(Sudoku s)  

48. {  

1. 49.     char* line = new char[9];  
2. 50.     for (int i = 0; i < 9; i++)  
3. 51.     {  
4. 52.         readLineFromFile(line);  
5. 53.         if (is_end)  
6. 54.             return false;  
7. 55.         for (int j = 0; j < 9; j++)  
8. 56.             s[i + 1][j + 1] = line[j] - '0';  
9. 57.     }  
10. 58.   
11. 59.     delete[] line;  
12. 60.     return true;  

61. }  

1. 62.   

63. //一次性讀入一千個數獨  

64. inline void readSudoku()  

65. {  

1. 66.     for (int i = 0; i < BUFF_SIZE; i++)  
2. 67.     {  
3. 68.         Sudoku tmp = nullptr;  
4. 69.         mallocSudoku(tmp);  
5. 70.         if (getSudokuFromFile(tmp) == false)  
6. 71.         {  
7. 72.             freeSudoku(tmp);  
8. 73.             return;  
9. 74.         }  
10. 75.         buff.push_back(tmp);  
11. 76.     }  
12. 77.     return;  
13. }  

 

分析代碼，不難發現問題所在，那就是調用一次ReadFile只讀入了一個字節的數據。原代碼主要是考慮到可能的數獨文件格式問題，通過再次閱讀問題要求，發現數獨問題文件格式是固定的，因此可一次讀入163個字節（與輸出一致）。由於最後一個數獨的後面沒有空行，因此讀入的數據是162個字節，由此可以作爲結束判斷。另外一方面，可以一次性讀入多個數獨進行分析。若讀入字節數小於163的整數倍，則已讀完。經過一系列測試，代碼修改如下：

1. inline void toSudoku(char* tmp, DWORD& n_bytes_read)  
   1. {  
   2.     //由於讀取時的限制，num_of_sudoku_in_buff <= BUFF_SIZE  
   3.     num_of_sudoku_in_buff = n_bytes_read / num_bytes_of_sudoku_infile;  
   4.     if (is_end)//因爲結束時，向下取整，少了一個  
   5.     {  
   6.         num_of_sudoku_in_buff++;  
   7.     }  
   8.     for (int i = 0, j = 0; i < num_of_sudoku_in_buff; i++, j++)  
   9. 10.     {  
   10. 11.         Sudoku s = buff[i];  
   11. 12.         for (int row_idx = 1, col_idx = 1; j < (i + 1) * num_bytes_of_sudoku_infile - 1; j++, j++)  
   12. 13.         {  
   13. 14.             s[row_idx][col_idx++] = tmp[j] - '0';  
   14. 15.             if (col_idx == 10)  
   15. 16.             {  
   16. 17.                 row_idx++;  
   17. 18.                 col_idx = 1;  
   18. 19.             }  
   19. 20.         }  
   20. 21.     }  

22. }  

1. 23.   

24. //一次性讀入一千個數獨  

25. inline void readSudoku()  

26. {  

1. 27.     char* tmp = new char[num_bytes_of_sudoku_infile * BUFF_SIZE + 10];  
2. 28.     ReadFile(h_sudoku_problem_txt, tmp, num_bytes_of_sudoku_infile * BUFF_SIZE, &n_bytes_read, NULL);  
3. 29.     if (num_bytes_of_sudoku_infile * BUFF_SIZE > n_bytes_read)  
4. 30.         is_end = true;  
5. 31.     toSudoku(tmp, n_bytes_read);  
6. 32.     return;  
7. }  

 

 

同時在文件讀入修改中，將原先的vector更改爲了數組形式，通過提前申請空間的方式減少了在獲取數獨和求解數獨後釋放數獨空間的時間。

在只更改文件讀入方式的情況下，時間從300秒降到了11秒，在將vector更改爲數獨數組之後，減少了new 和 delete的時間，又降低到了8秒鐘。