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

2023-10-31 09:58:04


点击(此处)折叠或打开

  1. // 测试mktime和localtime_r性能及优化方法
  2. //
  3. // 编译方法：g++ -g -o x x.cpp或g++ -O2 -o x x.cpp，两种编译方式性能基本相同。
  4. //
  5. // 结论：
  6. // 1) 环境变量TZ和isdst均不影响localtime_r的性能（第一次调用了除外）
  7. // 2) 环境变量TZ严重影响localtime的性能
  8. // 3) 环境变量TZ和isdst均会严重影响mktime的性能
  9. // *4) 注意mktime的参数即是输入参数也是输出参数，它会修改isdst值
  10. // *5) 另外需要注意localtime_r为非信号安全函数，
  11. // 不能在信号处理过程中调用，否则可能发生死锁等问题
  12. //
  13. // 64位机器性能数据（与32位CPU不同）：
  14. /*
  15. $ ./x 1000000
  16. test: localtime ...
  17. TZ is NULL: 2457ms
  18. TZ is empty: 172ms
  19. TZ is Asia/Shanghai: 173ms

  21. test: localtime_r ...
  22. TZ is NULL and isdst=1: 125ms
  23. TZ is NULL and isdst=0: 125ms
  24. TZ is NULL and isdst=-1: 125ms
  25. TZ is NULL and isdst undefined: 125ms
  26. TZ is empty and isdst=1: 125ms
  27. TZ is empty and isdst=0: 125ms
  28. TZ is empty and isdst=-1: 125ms
  29. TZ is empty and isdst undefined: 127ms
  30. TZ is Asia/Shanghai and isdst=1: 126ms
  31. TZ is Asia/Shanghai and isdst=0: 125ms
  32. TZ is Asia/Shanghai and isdst=-1: 125ms
  33. TZ is Asia/Shanghai and isdst undefined: 125ms

  35. test: mktime ...
  36. TZ is NULL and isdst=1: 635841ms
  37. TZ is NULL and isdst=0: 2583ms
  38. TZ is NULL and isdst=-1: 2596ms
  39. TZ is NULL and isdst undefined: 2579ms
  40. TZ is empty and isdst=1: 122377ms
  41. TZ is empty and isdst=0: 229ms
  42. TZ is empty and isdst=-1: 230ms
  43. TZ is empty and isdst undefined: 229ms
  44. TZ is Asia/Shanghai and isdst=1: 122536ms
  45. TZ is Asia/Shanghai and isdst=0: 228ms
  46. TZ is Asia/Shanghai and isdst=-1: 230ms
  47. TZ is Asia/Shanghai and isdst undefined: 228ms
  48. */

  50. // 32位机器性能数据（与64位CPU不同）：
  51. /*
  52. $ ./x 1000000
  53. test: localtime ...
  54. TZ is NULL: 1445ms
  55. TZ is empty: 252ms
  56. TZ is Asia/Shanghai: 252ms

  58. test: localtime_r ...
  59. TZ is NULL and isdst=1: 161ms
  60. TZ is NULL and isdst=0: 160ms
  61. TZ is NULL and isdst=-1: 161ms
  62. TZ is NULL and isdst undefined: 161ms
  63. TZ is empty and isdst=1: 160ms
  64. TZ is empty and isdst=0: 161ms
  65. TZ is empty and isdst=-1: 161ms
  66. TZ is empty and isdst undefined: 161ms
  67. TZ is Asia/Shanghai and isdst=1: 161ms
  68. TZ is Asia/Shanghai and isdst=0: 161ms
  69. TZ is Asia/Shanghai and isdst=-1: 161ms
  70. TZ is Asia/Shanghai and isdst undefined: 161ms

  72. test: mktime ...
  73. TZ is NULL and isdst=1: 199375ms
  74. TZ is NULL and isdst=0: 1488ms
  75. TZ is NULL and isdst=-1: 1483ms
  76. TZ is NULL and isdst undefined: 1497ms
  77. TZ is empty and isdst=1: 161057ms
  78. TZ is empty and isdst=0: 325ms
  79. TZ is empty and isdst=-1: 328ms
  80. TZ is empty and isdst undefined: 326ms
  81. TZ is Asia/Shanghai and isdst=1: 161558ms
  82. TZ is Asia/Shanghai and isdst=0: 321ms
  83. TZ is Asia/Shanghai and isdst=-1: 335ms
  84. TZ is Asia/Shanghai and isdst undefined: 328ms
  85. */
  86. // localtime_r相关源代码：
  87. /*
  88. // The C Standard says that localtime and gmtime return the same pointer.
  89. struct tm _tmbuf; // 全局变量

  91. struct tm * __localtime_r (t, tp)
  92.      const time_t *t;
  93.      struct tm *tp;
  94. {
  95.   return __tz_convert (t, 1, tp);
  96. }

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

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

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

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

  135.   tz = getenv ("TZ");
  136.   if (tz == NULL && !explicit)
  137.     tz = TZDEFAULT;
  138.   if (tz && *tz == '\0')
  139.     tz = "Universal";
  140.   if (tz && *tz == ':')
  141.     ++tz;

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

  150.   tz_rules[0].name = NULL;
  151.   tz_rules[1].name = NULL;

  153.   // Save the value of `tz'.
  154.   free (old_tz);
  155.   old_tz = tz ? __strdup (tz) : NULL;

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

  175.   // __mktime_internal会调用localtime_r，
  176.   // isdst的取值在这里会严重影响到mktime的性能
  177.   return __mktime_internal (tp, __localtime_r, &localtime_offset);
  178. }

  180. void __tzset (void)
  181. {
  182.   __libc_lock_lock (tzset_lock);

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

  187.   if (!__use_tzfile)
  188.     {
  189.       // Set `tzname'.
  190.       __tzname[0] = (char *) tz_rules[0].name;
  191.       __tzname[1] = (char *) tz_rules[1].name;
  192.     }

  194.   __libc_lock_unlock (tzset_lock);
  195. }
  196. */
  197. #include stdlib.h>
  198. #include stdio.h>
  199. #include string.h>
  200. #include sys/time.h>
  201. #include time.h>

  203. static void test_localtime(int M); // 测试localtime性能
  204. static void test_localtime_r(int M); // 测试localtime_r性能
  205. static void test_mktime(int M); // 测试mktime性能

  207. int main(int argc, char* argv[])
  208. {
  209.     const int M = (argc2)? 1000000: atoi(argv[1]);

  211.     test_localtime(M);
  212.     printf("\n");
  213.     test_localtime_r(M);
  214.     printf("\n");
  215.     test_mktime(M);

  217.     return 0;
  218. }

  220. // test_localtime
  221. void test_localtime(int M)
  222. {
  223.     int i;
  224.     time_t now = time(NULL);
  225.     struct timeval tv1, tv2;

  227.     printf("test: localtime ...\n");
  228.     unsetenv("TZ");

  230.     // test1
  231.     {
  232.         struct tm* result1;
  233.         gettimeofday(&tv1, NULL);
  234.         for (i=0; iM; ++i)
  235.         {
  236.             result1 = localtime(&now);
  237.         }
  238.         gettimeofday(&tv2, NULL);
  239.         printf("TZ is NULL: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  240.     }
  241.     
  242.     setenv("TZ", "", 0);

  244.     // test2
  245.     {
  246.         struct tm* result2;
  247.         gettimeofday(&tv1, NULL);
  248.         for (i=0; iM; ++i)
  249.         {
  250.             result2 = localtime(&now);
  251.         }
  252.         gettimeofday(&tv2, NULL);
  253.         printf("TZ is empty: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  254.     }

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

  258.     // test3
  259.     {
  260.         struct tm* result3;
  261.         gettimeofday(&tv1, NULL);
  262.         for (i=0; iM; ++i)
  263.         {
  264.             result3 = localtime(&now);
  265.         }
  266.         gettimeofday(&tv2, NULL);
  267.         printf("TZ is Asia/Shanghai: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  268.     }
  269. }

  271. // test_localtime_r
  272. void test_localtime_r(int M)
  273. {
  274.     int i;
  275.     time_t now = time(NULL);
  276.     struct timeval tv1, tv2;

  278.     printf("test: localtime_r ...\n");
  279.     unsetenv("TZ");

  281.     // test1
  282.     {
  283.         struct tm result1;
  284.         gettimeofday(&tv1, NULL);
  285.         for (i=0; iM; ++i)
  286.         {
  287.             struct tm result1_;
  288.             memcpy(&result1_, &result1, sizeof(result1_));
  289.             result1_.tm_isdst = 1;
  290.             localtime_r(&now, &result1_);
  291.         }
  292.         gettimeofday(&tv2, NULL);
  293.         printf("TZ is NULL and isdst=1: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  294.     }

  296.     // test2
  297.     {
  298.         struct tm result2;
  299.         gettimeofday(&tv1, NULL);
  300.         for (i=0; iM; ++i)
  301.         {
  302.             struct tm result2_;
  303.             memcpy(&result2_, &result2, sizeof(result2_));
  304.             result2_.tm_isdst = 0;
  305.             localtime_r(&now, &result2_);
  306.         }
  307.         gettimeofday(&tv2, NULL);
  308.         printf("TZ is NULL and isdst=0: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  309.     }

  311.     // test3
  312.     {
  313.         struct tm result3;
  314.         gettimeofday(&tv1, NULL);
  315.         for (i=0; iM; ++i)
  316.         {
  317.             struct tm result3_;
  318.             memcpy(&result3_, &result3, sizeof(result3_));
  319.             result3_.tm_isdst = -1;
  320.             localtime_r(&now, &result3_);
  321.         }
  322.         gettimeofday(&tv2, NULL);
  323.         printf("TZ is NULL and isdst=-1: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  324.     }

  326.     // test4
  327.     {
  328.         struct tm result4;
  329.         gettimeofday(&tv1, NULL);
  330.         for (i=0; iM; ++i)
  331.         {
  332.             struct tm result4_;
  333.             memcpy(&result4_, &result4, sizeof(result4_));
  334.             localtime_r(&now, &result4_);
  335.         }
  336.         gettimeofday(&tv2, NULL);
  337.         printf("TZ is NULL and isdst undefined: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  338.     }

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

  342.     // test5
  343.     {
  344.         struct tm result5;
  345.         gettimeofday(&tv1, NULL);
  346.         for (i=0; iM; ++i)
  347.         {
  348.             struct tm result5_;
  349.             memcpy(&result5_, &result5, sizeof(result5_));
  350.             result5_.tm_isdst = 1;
  351.             localtime_r(&now, &result5_);
  352.         }
  353.         gettimeofday(&tv2, NULL);
  354.         printf("TZ is empty and isdst=1: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  355.     }

  357.     // test6
  358.     {
  359.         struct tm result6;
  360.         gettimeofday(&tv1, NULL);
  361.         for (i=0; iM; ++i)
  362.         {
  363.             struct tm result6_;
  364.             memcpy(&result6_, &result6, sizeof(result6_));
  365.             result6_.tm_isdst = 0;
  366.             localtime_r(&now, &result6_);
  367.         }
  368.         gettimeofday(&tv2, NULL);
  369.         printf("TZ is empty and isdst=0: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  370.     }

  372.     // test7
  373.     {
  374.         struct tm result7;
  375.         gettimeofday(&tv1, NULL);
  376.         for (i=0; iM; ++i)
  377.         {
  378.             struct tm result7_;
  379.             memcpy(&result7_, &result7, sizeof(result7_));
  380.             result7_.tm_isdst = -1;
  381.             localtime_r(&now, &result7_);
  382.         }
  383.         gettimeofday(&tv2, NULL);
  384.         printf("TZ is empty and isdst=-1: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  385.     }

  387.     // test8
  388.     {
  389.         struct tm result8;
  390.         gettimeofday(&tv1, NULL);
  391.         for (i=0; iM; ++i)
  392.         {
  393.             struct tm result8_;
  394.             memcpy(&result8_, &result8, sizeof(result8_));
  395.             result8_.tm_isdst = -1;
  396.             localtime_r(&now, &result8_);
  397.         }
  398.         gettimeofday(&tv2, NULL);
  399.         printf("TZ is empty and isdst undefined: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  400.     }

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

  404.     // test9
  405.     {
  406.         struct tm result9;
  407.         gettimeofday(&tv1, NULL);
  408.         for (i=0; iM; ++i)
  409.         {
  410.             struct tm result9_;
  411.             memcpy(&result9_, &result9, sizeof(result9_));
  412.             result9_.tm_isdst = 1;
  413.             localtime_r(&now, &result9_);
  414.         }
  415.         gettimeofday(&tv2, NULL);
  416.         printf("TZ is Asia/Shanghai and isdst=1: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  417.     }

  419.     // test10
  420.     {
  421.         struct tm result10;
  422.         gettimeofday(&tv1, NULL);
  423.         for (i=0; iM; ++i)
  424.         {
  425.             struct tm result10_;
  426.             memcpy(&result10_, &result10, sizeof(result10_));
  427.             result10_.tm_isdst = 0;
  428.             localtime_r(&now, &result10_);
  429.         }
  430.         gettimeofday(&tv2, NULL);
  431.         printf("TZ is Asia/Shanghai and isdst=0: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  432.     }

  434.     // test11
  435.     {
  436.         struct tm result11;
  437.         gettimeofday(&tv1, NULL);
  438.         for (i=0; iM; ++i)
  439.         {
  440.             struct tm result11_;
  441.             memcpy(&result11_, &result11, sizeof(result11_));
  442.             result11_.tm_isdst = -1;
  443.             localtime_r(&now, &result11_);
  444.         }
  445.         gettimeofday(&tv2, NULL);
  446.         printf("TZ is Asia/Shanghai and isdst=-1: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  447.     }

  449.     // test12
  450.     {
  451.         struct tm result12;
  452.         gettimeofday(&tv1, NULL);
  453.         for (i=0; iM; ++i)
  454.         {
  455.             struct tm result12_;
  456.             memcpy(&result12_, &result12, sizeof(result12_));
  457.             localtime_r(&now, &result12_);
  458.         }
  459.         gettimeofday(&tv2, NULL);
  460.         printf("TZ is Asia/Shanghai and isdst undefined: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  461.     }
  462. }

  464. // test_mktime
  465. void test_mktime(int M)
  466. {
  467.     int i;
  468.     time_t now = time(NULL);
  469.     struct timeval tv1, tv2;

  471.     printf("test: mktime ...\n");
  472.     unsetenv("TZ");

  474.     // test1
  475.     {
  476.         struct tm result1;
  477.         localtime_r(&now, &result1);
  478.         gettimeofday(&tv1, NULL);
  479.         for (i=0; iM; ++i)
  480.         {
  481.             struct tm result1_;
  482.             memcpy(&result1_, &result1, sizeof(result1_));
  483.             result1_.tm_isdst = 1;
  484.             mktime(&result1_);
  485.         }
  486.         gettimeofday(&tv2, NULL);
  487.         printf("TZ is NULL and isdst=1: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  488.     }

  490.     // test2
  491.     {
  492.         struct tm result2;
  493.         localtime_r(&now, &result2);
  494.         gettimeofday(&tv1, NULL);
  495.         for (i=0; iM; ++i)
  496.         {
  497.             struct tm result2_;
  498.             memcpy(&result2_, &result2, sizeof(result2_));
  499.             result2_.tm_isdst = 0;
  500.             mktime(&result2_);
  501.         }
  502.         gettimeofday(&tv2, NULL);
  503.         printf("TZ is NULL and isdst=0: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  504.     }

  506.     // test3
  507.     {
  508.         struct tm result3;
  509.         localtime_r(&now, &result3);
  510.         gettimeofday(&tv1, NULL);
  511.         for (i=0; iM; ++i)
  512.         {
  513.             struct tm result3_;
  514.             memcpy(&result3_, &result3, sizeof(result3_));
  515.             result3_.tm_isdst = -1;
  516.             mktime(&result3_);
  517.         }
  518.         gettimeofday(&tv2, NULL);
  519.         printf("TZ is NULL and isdst=-1: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  520.     }

  522.     // test4
  523.     {
  524.         struct tm result4;
  525.         localtime_r(&now, &result4);
  526.         gettimeofday(&tv1, NULL);
  527.         for (i=0; iM; ++i)
  528.         {
  529.             struct tm result4_;
  530.             memcpy(&result4_, &result4, sizeof(result4_));
  531.             mktime(&result4_);
  532.         }
  533.         gettimeofday(&tv2, NULL);
  534.         printf("TZ is NULL and isdst undefined: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  535.     }

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

  539.     // test5
  540.     {
  541.         struct tm result5;
  542.         localtime_r(&now, &result5);
  543.         gettimeofday(&tv1, NULL);
  544.         for (i=0; iM; ++i)
  545.         {
  546.             struct tm result5_;
  547.             memcpy(&result5_, &result5, sizeof(result5_));
  548.             result5_.tm_isdst = 1;
  549.             mktime(&result5_);
  550.         }
  551.         gettimeofday(&tv2, NULL);
  552.         printf("TZ is empty and isdst=1: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  553.     }

  555.     // test6
  556.     {
  557.         struct tm result6;
  558.         localtime_r(&now, &result6);
  559.         gettimeofday(&tv1, NULL);
  560.         for (i=0; iM; ++i)
  561.         {
  562.             struct tm result6_;
  563.             memcpy(&result6_, &result6, sizeof(result6_));
  564.             result6_.tm_isdst = 0;
  565.             mktime(&result6_);
  566.         }
  567.         gettimeofday(&tv2, NULL);
  568.         printf("TZ is empty and isdst=0: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  569.     }

  571.     // test7
  572.     {
  573.         struct tm result7;
  574.         localtime_r(&now, &result7);
  575.         gettimeofday(&tv1, NULL);
  576.         for (i=0; iM; ++i)
  577.         {
  578.             struct tm result7_;
  579.             memcpy(&result7_, &result7, sizeof(result7_));
  580.             result7_.tm_isdst = -1;
  581.             mktime(&result7_);
  582.         }
  583.         gettimeofday(&tv2, NULL);
  584.         printf("TZ is empty and isdst=-1: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  585.     }

  587.     // test8
  588.     {
  589.         struct tm result8;
  590.         localtime_r(&now, &result8);
  591.         gettimeofday(&tv1, NULL);
  592.         for (i=0; iM; ++i)
  593.         {
  594.             struct tm result8_;
  595.             memcpy(&result8_, &result8, sizeof(result8_));
  596.             mktime(&result8_);
  597.         }
  598.         gettimeofday(&tv2, NULL);
  599.         printf("TZ is empty and isdst undefined: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  600.     }

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

  604.     // test9
  605.     {
  606.         struct tm result9;
  607.         localtime_r(&now, &result9);
  608.         gettimeofday(&tv1, NULL);
  609.         for (i=0; iM; ++i)
  610.         {
  611.             struct tm result9_;
  612.             memcpy(&result9_, &result9, sizeof(result9_));
  613.             result9_.tm_isdst = 1;
  614.             mktime(&result9_);
  615.         }
  616.         gettimeofday(&tv2, NULL);
  617.         printf("TZ is Asia/Shanghai and isdst=1: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  618.     }

  620.     // test10
  621.     {
  622.         struct tm result10;
  623.         localtime_r(&now, &result10);
  624.         gettimeofday(&tv1, NULL);
  625.         for (i=0; iM; ++i)
  626.         {
  627.             struct tm result10_;
  628.             memcpy(&result10_, &result10, sizeof(result10_));
  629.             result10_.tm_isdst = 0;
  630.             mktime(&result10_);
  631.         }
  632.         gettimeofday(&tv2, NULL);
  633.         printf("TZ is Asia/Shanghai and isdst=0: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  634.     }

  636.     // test11
  637.     {
  638.         struct tm result11;
  639.         localtime_r(&now, &result11);
  640.         gettimeofday(&tv1, NULL);
  641.         for (i=0; iM; ++i)
  642.         {
  643.             struct tm result11_;
  644.             memcpy(&result11_, &result11, sizeof(result11_));
  645.             result11_.tm_isdst = -1;
  646.             mktime(&result11_);
  647.         }
  648.         gettimeofday(&tv2, NULL);
  649.         printf("TZ is Asia/Shanghai and isdst=-1: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  650.     }

  652.     // test12
  653.     {
  654.         struct tm result12;
  655.         localtime_r(&now, &result12);
  656.         gettimeofday(&tv1, NULL);
  657.         for (i=0; iM; ++i)
  658.         {
  659.             struct tm result12_;
  660.             memcpy(&result12_, &result12, sizeof(result12_));
  661.             mktime(&result12_);
  662.         }
  663.         gettimeofday(&tv2, NULL);
  664.         printf("TZ is Asia/Shanghai and isdst undefined: %ums\n", (tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
  665.     }
  666. }


上一篇：PostgreSQL 11 1万亿 tpcb 性能测试 on 阿里云ECS + ESSD + zfs/lvm2条带 + block_size=32K


下一篇：外网访问内网Redis数据库