测试mktime和localtime_r性能及优化方法

2713阅读　0评论2011-12-22　Aquester
分类：LINUX


点击(此处)折叠或打开

  1. // 编译方法：g++ -g -o x x.cpp或g++ -O2 -o x x.cpp，两种编译方式性能基本相同。
  2. //
  3. // 结论：
  4. // 1) 环境变量TZ和isdst均不影响localtime_r的性能
  5. // 2) 环境变量TZ严重影响mktime和localtime的性能
  6. // 3) mktime性能不受isdst值的影响，localtime性能与isdst值无关
  7. // *4) 另外需要注意localtime_r为非信号安全函数，
  8. // 不能在信号处理过程中调用，否则可能发生死锁等问题
  9. //
  10. // 64位机器性能数据（与32位CPU不同）：
  11. /*
  12. $ ./x 1000000
  13. test: localtime ...
  14. TZ is NULL: 2629ms
  15. TZ is empty: 177ms
  16. TZ is Asia/Shanghai: 177ms

  18. test: localtime_r ...
  19. TZ is NULL and isdst=1: 124ms
  20. TZ is NULL and isdst=0: 125ms
  21. TZ is NULL and isdst=-1: 124ms
  22. TZ is NULL and isdst undefined: 124ms
  23. TZ is empty and isdst=1: 124ms
  24. TZ is empty and isdst=0: 124ms
  25. TZ is empty and isdst=-1: 124ms
  26. TZ is empty and isdst undefined: 124ms
  27. TZ is Asia/Shanghai and isdst=1: 124ms
  28. TZ is Asia/Shanghai and isdst=0: 125ms
  29. TZ is Asia/Shanghai and isdst=-1: 124ms
  30. TZ is Asia/Shanghai and isdst undefined: 124ms

  32. test: mktime ...
  33. TZ is NULL and isdst=1: 2657ms
  34. TZ is NULL and isdst=0: 2654ms
  35. TZ is NULL and isdst=-1: 2661ms
  36. TZ is NULL and isdst undefined: 2672ms
  37. TZ is empty and isdst=1: 232ms
  38. TZ is empty and isdst=0: 232ms
  39. TZ is empty and isdst=-1: 232ms
  40. TZ is empty and isdst undefined: 230ms
  41. TZ is Asia/Shanghai and isdst=1: 233ms
  42. TZ is Asia/Shanghai and isdst=0: 231ms
  43. TZ is Asia/Shanghai and isdst=-1: 232ms
  44. TZ is Asia/Shanghai and isdst undefined: 231ms
  45. */
  46. // 32位机器性能数据（与64位CPU不同）：
  47. /*
  48. > ./x 1000000
  49. test: localtime ...
  50. TZ is NULL: 1510ms
  51. TZ is empty: 252ms
  52. TZ is Asia/Shanghai: 255ms

  54. test: localtime_r ...
  55. TZ is NULL and isdst=1: 157ms
  56. TZ is NULL and isdst=0: 159ms
  57. TZ is NULL and isdst=-1: 159ms
  58. TZ is NULL and isdst undefined: 158ms
  59. TZ is empty and isdst=1: 158ms
  60. TZ is empty and isdst=0: 160ms
  61. TZ is empty and isdst=-1: 157ms
  62. TZ is empty and isdst undefined: 158ms
  63. TZ is Asia/Shanghai and isdst=1: 157ms
  64. TZ is Asia/Shanghai and isdst=0: 156ms
  65. TZ is Asia/Shanghai and isdst=-1: 156ms
  66. TZ is Asia/Shanghai and isdst undefined: 157ms

  68. test: mktime ...
  69. TZ is NULL and isdst=1: 1542ms
  70. TZ is NULL and isdst=0: 1547ms
  71. TZ is NULL and isdst=-1: 1542ms
  72. TZ is NULL and isdst undefined: 1566ms
  73. TZ is empty and isdst=1: 327ms
  74. TZ is empty and isdst=0: 324ms
  75. TZ is empty and isdst=-1: 325ms
  76. TZ is empty and isdst undefined: 323ms
  77. TZ is Asia/Shanghai and isdst=1: 323ms
  78. TZ is Asia/Shanghai and isdst=0: 326ms
  79. TZ is Asia/Shanghai and isdst=-1: 326ms
  80. TZ is Asia/Shanghai and isdst undefined: 324ms
  81. */
  82. // localtime_r相关源代码：
  83. /*
  84. // The C Standard says that localtime and gmtime return the same pointer.
  85. struct tm _tmbuf; // 全局变量

  87. struct tm * __localtime_r (t, tp)
  88.      const time_t *t;
  89.      struct tm *tp;
  90. {
  91.   return __tz_convert (t, 1, tp);
  92. }

  94. // 非线程安全版本，用到了全局变量_tmbuf
  95. struct tm * localtime(t)
  96.      const time_t *t;
  97. {
  98.   return __tz_convert (t, 1, &_tmbuf);
  99. }

  101. struct tm * __tz_convert (const time_t *timer, int use_localtime, struct tm *tp)
  102. {
  103.   。。。
  104.   // 信号处理函数中调用非信号安全函数，可能造成死锁的地方
  105.   __libc_lock_lock (tzset_lock);
  106.   
  107.   // localtime_r未用到_tmbuf，只是localtime使用它！！！
  108.   // 因此对于localtime_r，传递给tzset_internal的第一个参数总是为0（tp != &_tmpbuf），
  109.   // 而对于localtime，它传递给tzset_internal的第一个参数总是为1
  110.   tzset_internal (tp == &_tmbuf && use_localtime, 1);
  111.   。。。
  112. }

  114. // 决定性能的函数，原因是可能涉及文件操作，
  115. // 因此要想提升性能，则应当想办法避免操作文件！！！
  116. static void internal_function
  117. tzset_internal (always, explicit)
  118.      int always;
  119.      int explicit;
  120. {
  121.   static int is_initialized; // 静态变量
  122.   const char *tz;

  124.   // 对于mktime，参数always值总是为1
  125.   // 对于localtime，参数always值总是为1
  126.   // 对于localtime_r，参数always值总是为0
  127.   if (is_initialized && !always)
  128.     return; // 对于localtime_r第一次调用后，后续都在这里直接返回！
  129.   is_initialized = 1;

  131.   tz = getenv ("TZ");
  132.   if (tz == NULL && !explicit)
  133.     tz = TZDEFAULT;
  134.   if (tz && *tz == '\0')
  135.     tz = "Universal";
  136.   if (tz && *tz == ':')
  137.     ++tz;

  139.   // 如果不设置环境变量TZ，则下面这个if语句总是不成立！！！
  140.   // 因此只有设置了环境变量TZ，才有可能在这里直接返回而不进入读文件操作__tzfile_read
  141.   if (old_tz != NULL && tz != NULL && strcmp (tz, old_tz) == 0)
  142.     return; // 在这里返回则可以避免走到文件操作__tzfile_read
  143.   if (tz == NULL)
  144.     tz = TZDEFAULT;

  146.   tz_rules[0].name = NULL;
  147.   tz_rules[1].name = NULL;

  149.   // Save the value of `tz'.
  150.   free (old_tz);
  151.   old_tz = tz ? __strdup (tz) : NULL;

  153.   // 读文件，性能慢的原因
  154.   __tzfile_read (tz, 0, NULL); // Try to read a data file.
  155.   if (__use_tzfile)
  156.     return;
  157.   。。。
  158. }
  159. */
  160. // mktime相关源代码：
  161. /*
  162. time_t mktime (struct tm *tp)
  163. {
  164. #ifdef _LIBC
  165.   // POSIX.1 8.1.1 requires that whenever mktime() is called, the
  166.   // time zone names contained in the external variable 'tzname' shall
  167.   // be set as if the tzset() function had been called.
  168.   __tzset ();
  169. #endif

  171.   // __mktime_internal为全内存计算，因此无性能问题
  172.   return __mktime_internal (tp, __localtime_r, &localtime_offset);
  173. }

  175. void __tzset (void)
  176. {
  177.   __libc_lock_lock (tzset_lock);

  179.   // 和localtime_r一样也会调用tzset_internal
  180.   tzset_internal (1, 1);

  182.   if (!__use_tzfile)
  183.     {
  184.       // Set `tzname'.
  185.       __tzname[0] = (char *) tz_rules[0].name;
  186.       __tzname[1] = (char *) tz_rules[1].name;
  187.     }

  189.   __libc_lock_unlock (tzset_lock);
  190. }
  191. */
  192. #include <stdio.h>
  193. #include <sys/time.h>
  194. #include <time.h>
  195. #include <stdlib.h>

  197. static void test_localtime(int M); // 测试localtime性能
  198. static void test_localtime_r(int M); // 测试localtime_r性能
  199. static void test_mktime(int M); // 测试mktime性能

  201. int main(int argc, char* argv[])
  202. {
  203.     const int M = (argc<2)? 1000000: atoi(argv[1]);

  205.     test_localtime(M);
  206.     printf("\n");
  207.     test_localtime_r(M);
  208.     printf("\n");
  209.     test_mktime(M);

  211.     return 0;
  212. }

  214. // test_localtime
  215. void test_localtime(int M)
  216. {
  217.     int i;
  218.     time_t now = time(NULL);
  219.     struct timeval tv1, tv2;

  221.     printf("test: localtime ...\n");
  222.     unsetenv("TZ");

  224.     // test1
  225.     {
  226.         struct tm* result1;
  227.         gettimeofday(&tv1, NULL);
  228.         for (i=0; i<M; ++i)
  229.         {
  230.             result1 = localtime(&now);
  231.         }
  232.         gettimeofday(&tv2, NULL);
  233.         printf("TZ is NULL: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  234.     }
  235.     
  236.     setenv("TZ", "", 0);

  238.     // test2
  239.     {
  240.         struct tm* result2;
  241.         gettimeofday(&tv1, NULL);
  242.         for (i=0; i<M; ++i)
  243.         {
  244.             result2 = localtime(&now);
  245.         }
  246.         gettimeofday(&tv2, NULL);
  247.         printf("TZ is empty: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  248.     }

  250.     setenv("TZ", "Asia/Shanghai", 0);

  252.     // test3
  253.     {
  254.         struct tm* result3;
  255.         gettimeofday(&tv1, NULL);
  256.         for (i=0; i<M; ++i)
  257.         {
  258.             result3 = localtime(&now);
  259.         }
  260.         gettimeofday(&tv2, NULL);
  261.         printf("TZ is Asia/Shanghai: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  262.     }
  263. }

  265. // test_localtime_r
  266. void test_localtime_r(int M)
  267. {
  268.     int i;
  269.     time_t now = time(NULL);
  270.     struct timeval tv1, tv2;
  271.   
  272.     printf("test: localtime_r ...\n");
  273.     unsetenv("TZ");

  275.     // test1
  276.     {
  277.         struct tm result1;
  278.         result1.tm_isdst = 1;
  279.         gettimeofday(&tv1, NULL);
  280.         for (i=0; i<M; ++i)
  281.         {
  282.             localtime_r(&now, &result1);
  283.         }
  284.         gettimeofday(&tv2, NULL);
  285.         printf("TZ is NULL and isdst=1: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  286.     }

  288.     // test2
  289.     {
  290.         struct tm result2;
  291.         result2.tm_isdst = 0;
  292.         gettimeofday(&tv1, NULL);
  293.         for (i=0; i<M; ++i)
  294.         {
  295.             localtime_r(&now, &result2);
  296.         }
  297.         gettimeofday(&tv2, NULL);
  298.         printf("TZ is NULL and isdst=0: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  299.     }

  301.     // test3
  302.     {
  303.         struct tm result3;
  304.         result3.tm_isdst = -1;
  305.         gettimeofday(&tv1, NULL);
  306.         for (i=0; i<M; ++i)
  307.         {
  308.             localtime_r(&now, &result3);
  309.         }
  310.         gettimeofday(&tv2, NULL);
  311.         printf("TZ is NULL and isdst=-1: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  312.     }

  314.     // test4
  315.     {
  316.         struct tm result4;
  317.         gettimeofday(&tv1, NULL);
  318.         for (i=0; i<M; ++i)
  319.         {
  320.             localtime_r(&now, &result4);
  321.         }
  322.         gettimeofday(&tv2, NULL);
  323.         printf("TZ is NULL and isdst undefined: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  324.     }
  325.     
  326.     setenv("TZ", "", 0);

  328.     // test5
  329.     {
  330.         struct tm result5;
  331.         result5.tm_isdst = 1;
  332.         gettimeofday(&tv1, NULL);
  333.         for (i=0; i<M; ++i)
  334.         {
  335.             localtime_r(&now, &result5);
  336.         }
  337.         gettimeofday(&tv2, NULL);
  338.         printf("TZ is empty and isdst=1: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  339.     }

  341.     // test6
  342.     {
  343.         struct tm result6;
  344.         result6.tm_isdst = 0;
  345.         gettimeofday(&tv1, NULL);
  346.         for (i=0; i<M; ++i)
  347.         {
  348.             localtime_r(&now, &result6);
  349.         }
  350.         gettimeofday(&tv2, NULL);
  351.         printf("TZ is empty and isdst=0: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  352.     }

  354.     // test7
  355.     {
  356.         struct tm result7;
  357.         result7.tm_isdst = -1;
  358.         gettimeofday(&tv1, NULL);
  359.         for (i=0; i<M; ++i)
  360.         {
  361.             localtime_r(&now, &result7);
  362.         }
  363.         gettimeofday(&tv2, NULL);
  364.         printf("TZ is empty and isdst=-1: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  365.     }

  367.     // test8
  368.     {
  369.         struct tm result8;
  370.         result8.tm_isdst = -1;
  371.         gettimeofday(&tv1, NULL);
  372.         for (i=0; i<M; ++i)
  373.         {
  374.             localtime_r(&now, &result8);
  375.         }
  376.         gettimeofday(&tv2, NULL);
  377.         printf("TZ is empty and isdst undefined: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  378.     }

  380.     setenv("TZ", "Asia/Shanghai", 0);

  382.     // test9
  383.     {
  384.         struct tm result9;
  385.         result9.tm_isdst = 1;
  386.         gettimeofday(&tv1, NULL);
  387.         for (i=0; i<M; ++i)
  388.         {
  389.             localtime_r(&now, &result9);
  390.         }
  391.         gettimeofday(&tv2, NULL);
  392.         printf("TZ is Asia/Shanghai and isdst=1: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  393.     }

  395.     // test10
  396.     {
  397.         struct tm result10;
  398.         result10.tm_isdst = 0;
  399.         gettimeofday(&tv1, NULL);
  400.         for (i=0; i<M; ++i)
  401.         {
  402.             localtime_r(&now, &result10);
  403.         }
  404.         gettimeofday(&tv2, NULL);
  405.         printf("TZ is Asia/Shanghai and isdst=0: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  406.     }

  408.     // test11
  409.     {
  410.         struct tm result11;
  411.         result11.tm_isdst = -1;
  412.         gettimeofday(&tv1, NULL);
  413.         for (i=0; i<M; ++i)
  414.         {
  415.             localtime_r(&now, &result11);
  416.         }
  417.         gettimeofday(&tv2, NULL);
  418.         printf("TZ is Asia/Shanghai and isdst=-1: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  419.     }

  421.     // test12
  422.     {
  423.         struct tm result12;
  424.         gettimeofday(&tv1, NULL);
  425.         for (i=0; i<M; ++i)
  426.         {
  427.             localtime_r(&now, &result12);
  428.         }
  429.         gettimeofday(&tv2, NULL);
  430.         printf("TZ is Asia/Shanghai and isdst undefined: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  431.     }
  432. }

  434. // test_mktime
  435. void test_mktime(int M)
  436. {
  437.     int i;
  438.     time_t now = time(NULL);
  439.     struct timeval tv1, tv2;

  441.     printf("test: mktime ...\n");
  442.     unsetenv("TZ");

  444.     // test1
  445.     {
  446.         struct tm result1;
  447.         localtime_r(&now, &result1);
  448.         result1.tm_isdst = 1;
  449.         gettimeofday(&tv1, NULL);
  450.         for (i=0; i<M; ++i)
  451.         {
  452.             mktime(&result1);
  453.         }
  454.         gettimeofday(&tv2, NULL);
  455.         printf("TZ is NULL and isdst=1: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  456.     }

  458.     // test2
  459.     {
  460.         struct tm result2;
  461.         localtime_r(&now, &result2);
  462.         result2.tm_isdst = 0;
  463.         gettimeofday(&tv1, NULL);
  464.         for (i=0; i<M; ++i)
  465.         {
  466.             mktime(&result2);
  467.         }
  468.         gettimeofday(&tv2, NULL);
  469.         printf("TZ is NULL and isdst=0: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  470.     }

  472.     // test3
  473.     {
  474.         struct tm result3;
  475.         localtime_r(&now, &result3);
  476.         result3.tm_isdst = -1;
  477.         gettimeofday(&tv1, NULL);
  478.         for (i=0; i<M; ++i)
  479.         {
  480.             mktime(&result3);
  481.         }
  482.         gettimeofday(&tv2, NULL);
  483.         printf("TZ is NULL and isdst=-1: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  484.     }

  486.     // test4
  487.     {
  488.         struct tm result4;
  489.         localtime_r(&now, &result4);
  490.         gettimeofday(&tv1, NULL);
  491.         for (i=0; i<M; ++i)
  492.         {
  493.             mktime(&result4);
  494.         }
  495.         gettimeofday(&tv2, NULL);
  496.         printf("TZ is NULL and isdst undefined: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  497.     }

  499.     setenv("TZ", "", 0);

  501.     // test5
  502.     {
  503.         struct tm result5;
  504.         localtime_r(&now, &result5);
  505.         result5.tm_isdst = 1;
  506.         gettimeofday(&tv1, NULL);
  507.         for (i=0; i<M; ++i)
  508.         {
  509.             mktime(&result5);
  510.         }
  511.         gettimeofday(&tv2, NULL);
  512.         printf("TZ is empty and isdst=1: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  513.     }

  515.     // test6
  516.     {
  517.         struct tm result6;
  518.         localtime_r(&now, &result6);
  519.         result6.tm_isdst = 0;
  520.         gettimeofday(&tv1, NULL);
  521.         for (i=0; i<M; ++i)
  522.         {
  523.             mktime(&result6);
  524.         }
  525.         gettimeofday(&tv2, NULL);
  526.         printf("TZ is empty and isdst=0: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  527.     }

  529.     // test7
  530.     {
  531.         struct tm result7;
  532.         localtime_r(&now, &result7);
  533.         result7.tm_isdst = -1;
  534.         gettimeofday(&tv1, NULL);
  535.         for (i=0; i<M; ++i)
  536.         {
  537.             mktime(&result7);
  538.         }
  539.         gettimeofday(&tv2, NULL);
  540.         printf("TZ is empty and isdst=-1: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  541.     }

  543.     // test8
  544.     {
  545.         struct tm result8;
  546.         localtime_r(&now, &result8);
  547.         gettimeofday(&tv1, NULL);
  548.         for (i=0; i<M; ++i)
  549.         {
  550.             mktime(&result8);
  551.         }
  552.         gettimeofday(&tv2, NULL);
  553.         printf("TZ is empty and isdst undefined: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  554.     }

  556.     setenv("TZ", "Asia/Shanghai", 0);

  558.     // test9
  559.     {
  560.         struct tm result9;
  561.         localtime_r(&now, &result9);
  562.         result9.tm_isdst = 1;
  563.         gettimeofday(&tv1, NULL);
  564.         for (i=0; i<M; ++i)
  565.         {
  566.             mktime(&result9);
  567.         }
  568.         gettimeofday(&tv2, NULL);
  569.         printf("TZ is Asia/Shanghai and isdst=1: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  570.     }

  572.     // test10
  573.     {
  574.         struct tm result10;
  575.         localtime_r(&now, &result10);
  576.         result10.tm_isdst = 0;
  577.         gettimeofday(&tv1, NULL);
  578.         for (i=0; i<M; ++i)
  579.         {
  580.             mktime(&result10);
  581.         }
  582.         gettimeofday(&tv2, NULL);
  583.         printf("TZ is Asia/Shanghai and isdst=0: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  584.     }

  586.     // test11
  587.     {
  588.         struct tm result11;
  589.         localtime_r(&now, &result11);
  590.         result11.tm_isdst = -1;
  591.         gettimeofday(&tv1, NULL);
  592.         for (i=0; i<M; ++i)
  593.         {
  594.             mktime(&result11);
  595.         }
  596.         gettimeofday(&tv2, NULL);
  597.         printf("TZ is Asia/Shanghai and isdst=-1: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  598.     }

  600.     // test12
  601.     {
  602.         struct tm result12;
  603.         localtime_r(&now, &result12);
  604.         gettimeofday(&tv1, NULL);
  605.         for (i=0; i<M; ++i)
  606.         {
  607.             mktime(&result12);
  608.         }
  609.         gettimeofday(&tv2, NULL);
  610.         printf("TZ is Asia/Shanghai and isdst undefined: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  611.     }
  612. }

上一篇：awk给外部变量赋值
下一篇：高效的使用stl::map和std::set