]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | [/============================================================================== |
2 | Copyright (C) 2001-2011 Joel de Guzman | |
3 | Copyright (C) 2001-2011 Hartmut Kaiser | |
4 | ||
5 | Distributed under the Boost Software License, Version 1.0. (See accompanying | |
6 | file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) | |
7 | ===============================================================================/] | |
8 | ||
9 | [section:numeric_performance Performance of Numeric Generators] | |
10 | ||
11 | [section:int_performance Comparing the performance of a single int_ generator] | |
12 | ||
13 | These performance measurements are centered around default formatting of a | |
14 | single `int` integer number using different libraries and methods. | |
15 | The overall execution times for those examples are compared below. We compare | |
16 | using `sprintf`, C++ iostreams, __boost_format__, and __karma__. | |
17 | ||
18 | For the full source code of the performance test please see here: | |
19 | [@../../workbench/karma/int_generator.cpp int_generator.cpp]. All the | |
20 | measurements have been done by executing `1e7` iterations for each | |
21 | formatting type (NUMITERATIONS is set to `1e7` in the code shown below). | |
22 | ||
23 | [import ../../workbench/karma/int_generator.cpp] | |
24 | ||
25 | Code used to measure the performance for `ltoa`: | |
26 | ||
27 | [karma_int_performance_ltoa] | |
28 | ||
29 | Code used to measure the performance for standard C++ iostreams: | |
30 | ||
31 | [karma_int_performance_iostreams] | |
32 | ||
33 | Code used to measure the performance for __boost_format__: | |
34 | ||
35 | [karma_int_performance_format] | |
36 | ||
37 | Code used to measure the performance for __karma__ using a plain character buffer: | |
38 | ||
39 | [karma_int_performance_plain] | |
40 | ||
41 | The following table shows the overall performance results collected | |
42 | while using different compilers. All times are in seconds measured for `1e7` | |
43 | iterations (platform: Windows7, Intel Core Duo(tm) Processor, 2.8GHz, 4GByte RAM). | |
44 | For a more readable comparison of the results see this | |
45 | [link spirit.karma.int_performance figure]. | |
46 | ||
47 | [table Performance comparison for a single int (all times in [s], `1e7` iterations) | |
48 | [[Library] [gcc 4.4.0 (32 bit)] [VC++ 10 (32 bit)] [Intel 11.1 (32 bit)] [gcc 4.4.0 (64 bit)] [VC++ 10 (64 bit)] [Intel 11.1 (64 bit)]] | |
49 | [[ltoa] [1.542] [0.895] [0.884] [1.163] [1.099] [0.906]] | |
50 | [[iostreams] [6.548] [13.727] [11.898] [3.464] [8.316] [8.115]] | |
51 | [[__boost_format__] [16.998] [21.813] [20.477] [17.464] [14.662] [13.646]] | |
52 | [[__karma__ int_] [1.421] [0.744] [0.697] [1.072] [0.953] [0.606]] | |
53 | ] | |
54 | ||
55 | [fig int_performance.png..Performance comparison for a single int..spirit.karma.int_performance] | |
56 | ||
57 | [endsect] | |
58 | ||
59 | [/////////////////////////////////////////////////////////////////////////////] | |
60 | [section:double_performance Comparing the performance of a single double_ generator] | |
61 | ||
62 | These performance measurements are centered around default formatting of a | |
63 | single `double` floating point number using different libraries and methods. | |
64 | The overall execution times for those examples are compared below. We compare | |
65 | using `sprintf`, C++ iostreams, __boost_format__, and __karma__. | |
66 | ||
67 | For the full source code of the performance test please see here: | |
68 | [@../../workbench/karma/double_performance.cpp double_performance.cpp]. All the | |
69 | measurements have been done by executing `1e6` iterations for each | |
70 | formatting type (NUMITERATIONS is set to `1e6` in the code shown below). | |
71 | ||
72 | [import ../../workbench/karma/double_performance.cpp] | |
73 | ||
74 | Code used to measure the performance for `sprintf`: | |
75 | ||
76 | [karma_double_performance_printf] | |
77 | ||
78 | Code used to measure the performance for standard C++ iostreams: | |
79 | ||
80 | [karma_double_performance_iostreams] | |
81 | ||
82 | Code used to measure the performance for __boost_format__: | |
83 | ||
84 | [karma_double_performance_format] | |
85 | ||
86 | The following code shows the common definitions used by all __karma__ performance | |
87 | measurements as listed below: | |
88 | ||
89 | [karma_double_performance_definitions] | |
90 | ||
91 | Code used to measure the performance for __karma__ using a plain character buffer: | |
92 | ||
93 | [karma_double_performance_plain] | |
94 | ||
95 | The following table shows the overall performance results collected | |
96 | while using different compilers. All times are in seconds measured for `1e6` | |
97 | iterations (platform: Windows7, Intel Core Duo(tm) Processor, 2.8GHz, 4GByte RAM). | |
98 | For a more readable comparison of the results see this | |
99 | [link spirit.karma.double_performance figure]. | |
100 | ||
101 | [table Performance comparison for a single double (all times in [s], `1e6` iterations) | |
102 | [[Library] [gcc 4.4.0 (32 bit)] [VC++ 10 (32 bit)] [Intel 11.1 (32 bit)] [gcc 4.4.0 (64 bit)] [VC++ 10 (64 bit)] [Intel 11.1 (64 bit)]] | |
103 | [[sprintf] [0.755] [0.965] [0.880] [0.713] [0.807] [0.694]] | |
104 | [[iostreams] [2.316] [2.624] [1.964] [1.634] [1.468] [1.354]] | |
105 | [[__boost_format__] [3.188] [3.737] [2.878] [3.217] [2.672] [2.011]] | |
106 | [[__karma__ double_] [0.813] [0.561] [0.368] [0.426] [0.260] [0.218]] | |
107 | ] | |
108 | ||
109 | [fig double_performance.png..Performance comparison for a single double..spirit.karma.double_performance] | |
110 | ||
111 | [endsect] | |
112 | ||
113 | [////////////////////////////////////////////////////////////////////////////] | |
114 | [section:format_performance Comparing the performance of a sequence of several generators] | |
115 | ||
116 | These performance measurements are centered around formatting of a sequence of | |
117 | different items, including 2 `double` floating point numbers using different | |
118 | libraries and methods. The overall execution times for those examples are | |
119 | compared below. We compare using `sprintf`, C++ iostreams, __boost_format__, | |
120 | and __karma__. | |
121 | ||
122 | For the full source code of the performance test please see here: | |
123 | [@../../workbench/karma/format_performance.cpp format_performance.cpp]. All the | |
124 | measurements have been done by doing `1e6` iterations for each formatting | |
125 | type (NUMITERATIONS is set to `1e6`). | |
126 | ||
127 | [import ../../workbench/karma/format_performance.cpp] | |
128 | ||
129 | Code used to measure the performance for sprintf: | |
130 | ||
131 | [karma_format_performance_printf] | |
132 | ||
133 | Code used to measure the performance for standard iostreams: | |
134 | ||
135 | [karma_format_performance_iostreams] | |
136 | ||
137 | Code used to measure the performance for __boost_format__: | |
138 | ||
139 | [karma_format_performance_format] | |
140 | ||
141 | The following code shows the common definitions used by all __karma__ | |
142 | performance measurements as listed below: | |
143 | ||
144 | [karma_format_performance_definitions] | |
145 | ||
146 | Code used to measure the performance for __karma__ using a plain character | |
147 | buffer: | |
148 | ||
149 | [karma_format_performance_plain] | |
150 | ||
151 | The following table shows the overall performance results collected | |
152 | while using different compilers. All times are in seconds measured for `1e6` | |
153 | iterations (platform: Windows7, Intel Core Duo(tm) Processor, 2.8GHz, 4GByte RAM). | |
154 | For a more readable comparison of the results see this | |
155 | [link spirit.karma.format_performance figure]. | |
156 | ||
157 | [table Performance comparison for a sequence of several items (all times in [s], `1e6` iterations) | |
158 | [[Library] [gcc 4.4.0 (32 bit)] [VC++ 10 (32 bit)] [Intel 11.1 (32 bit)] [gcc 4.4.0 (64 bit)] [VC++ 10 (64 bit)] [Intel 11.1 (64 bit)]] | |
159 | [[sprintf] [1.725] [1.892] [1.903] [1.469] [1.608] [1.493]] | |
160 | [[iostreams] [4.827] [5.287] [4.444] [3.112] [3.319] [2.877]] | |
161 | [[__boost_format__] [5.881] [7.089] [5.801] [5.455] [5.254] [4.164]] | |
162 | [[__karma__] [1.942] [1.242] [0.999] [1.334] [0.758] [0.686]] | |
163 | ] | |
164 | ||
165 | [fig format_performance.png..Performance comparison for a sequence of several items..spirit.karma.format_performance] | |
166 | ||
167 | [endsect] | |
168 | ||
169 | [endsect] |