diff options
author | Matthias Wachs <wachs@net.in.tum.de> | 2011-05-25 15:56:53 +0000 |
---|---|---|
committer | Matthias Wachs <wachs@net.in.tum.de> | 2011-05-25 15:56:53 +0000 |
commit | 78ceb540486869c70e70ce2f52edb4a5b071bbd6 (patch) | |
tree | 7f0977f4daf810106075b480151912d647b87596 /src/transport/perf_transport_ats.c | |
parent | f64ce67c0568e8b94487dd9d103af804f3421701 (diff) | |
download | gnunet-78ceb540486869c70e70ce2f52edb4a5b071bbd6.tar.gz gnunet-78ceb540486869c70e70ce2f52edb4a5b071bbd6.zip |
renaming
Diffstat (limited to 'src/transport/perf_transport_ats.c')
-rw-r--r-- | src/transport/perf_transport_ats.c | 266 |
1 files changed, 266 insertions, 0 deletions
diff --git a/src/transport/perf_transport_ats.c b/src/transport/perf_transport_ats.c new file mode 100644 index 000000000..46e2e8c1a --- /dev/null +++ b/src/transport/perf_transport_ats.c | |||
@@ -0,0 +1,266 @@ | |||
1 | /* | ||
2 | This file is part of GNUnet. | ||
3 | (C) 2009 Christian Grothoff (and other contributing authors) | ||
4 | |||
5 | GNUnet is free software; you can redistribute it and/or modify | ||
6 | it under the terms of the GNU General Public License as published | ||
7 | by the Free Software Foundation; either version 3, or (at your | ||
8 | option) any later version. | ||
9 | |||
10 | GNUnet is distributed in the hope that it will be useful, but | ||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU General Public License | ||
16 | along with GNUnet; see the file COPYING. If not, write to the | ||
17 | Free Software Foundation, Inc., 59 Temple Place - Suite 330, | ||
18 | Boston, MA 02111-1307, USA. | ||
19 | */ | ||
20 | /** | ||
21 | * @file testing/per_transport_ats.c | ||
22 | * @brief testcase for ats functionality | ||
23 | */ | ||
24 | #include "platform.h" | ||
25 | #include "gnunet_time_lib.h" | ||
26 | #include "gauger.h" | ||
27 | #if HAVE_LIBGLPK | ||
28 | #include <glpk.h> | ||
29 | #endif | ||
30 | |||
31 | #define VERBOSE GNUNET_NO | ||
32 | |||
33 | #define EXECS 5 | ||
34 | |||
35 | |||
36 | #if HAVE_LIBGLPK | ||
37 | static int executions = EXECS; | ||
38 | static uint64_t exec_time[EXECS]; | ||
39 | |||
40 | static uint64_t sim_no_opt_avg; | ||
41 | static uint64_t sim_with_opt_avg; | ||
42 | static uint64_t mlp_no_opt_avg; | ||
43 | static uint64_t mlp_with_opt_avg; | ||
44 | |||
45 | static glp_prob * prob; | ||
46 | |||
47 | static struct GNUNET_TIME_Absolute start; | ||
48 | static struct GNUNET_TIME_Absolute end; | ||
49 | |||
50 | |||
51 | void solve_mlp(int presolve) | ||
52 | { | ||
53 | int result, solution; | ||
54 | |||
55 | glp_iocp opt_mlp; | ||
56 | glp_init_iocp(&opt_mlp); | ||
57 | opt_mlp.msg_lev = GLP_MSG_OFF; | ||
58 | opt_mlp.presolve = GLP_OFF; | ||
59 | |||
60 | result = glp_intopt (prob, &opt_mlp); | ||
61 | solution = glp_mip_status (prob); | ||
62 | GNUNET_assert ((solution == 5) && (result==0)); | ||
63 | } | ||
64 | |||
65 | void solve_lp(int presolve) | ||
66 | { | ||
67 | int result, solution; | ||
68 | |||
69 | glp_smcp opt_lp; | ||
70 | glp_init_smcp(&opt_lp); | ||
71 | |||
72 | opt_lp.msg_lev = GLP_MSG_OFF; | ||
73 | if (presolve==GNUNET_YES) opt_lp.presolve = GLP_ON; | ||
74 | else opt_lp.presolve = GLP_OFF; | ||
75 | |||
76 | result = glp_simplex(prob, &opt_lp); | ||
77 | solution = glp_get_status (prob); | ||
78 | GNUNET_assert ((solution == 5) && (result==0)); | ||
79 | } | ||
80 | |||
81 | /* Modify quality constraint */ | ||
82 | void modify_qm(int start, int length, int values_to_change) | ||
83 | { | ||
84 | //int * ind = GNUNET_malloc (length * sizeof (int)); | ||
85 | //double *val = GNUNET_malloc (length * sizeof (double)); | ||
86 | int ind[1000]; | ||
87 | double val[1000]; | ||
88 | |||
89 | int res = 0; | ||
90 | int c = start, c2=1; | ||
91 | while (c<=(start+values_to_change)) | ||
92 | { | ||
93 | res = glp_get_mat_row(prob, c, ind, val); | ||
94 | |||
95 | printf("%i %i \n", c, res); | ||
96 | for (c2=0; c2<res; c2++) | ||
97 | { | ||
98 | printf("%i = %f \n", ind[c2], val[c2]); | ||
99 | } | ||
100 | |||
101 | c++; | ||
102 | } | ||
103 | //glp_set_mat_row(prob, start, length, ind, val); | ||
104 | } | ||
105 | |||
106 | |||
107 | |||
108 | void bench_simplex_optimization(char * file, int executions) | ||
109 | { | ||
110 | |||
111 | int c; | ||
112 | prob = glp_create_prob(); | ||
113 | glp_read_lp(prob, NULL, file); | ||
114 | |||
115 | solve_lp(GNUNET_YES); | ||
116 | |||
117 | for (c=0; c<executions;c++) | ||
118 | { | ||
119 | start = GNUNET_TIME_absolute_get(); | ||
120 | solve_lp(GNUNET_NO); | ||
121 | end = GNUNET_TIME_absolute_get(); | ||
122 | |||
123 | exec_time[c] = GNUNET_TIME_absolute_get_difference(start, end).rel_value; | ||
124 | |||
125 | sim_with_opt_avg += exec_time[c]; | ||
126 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Simplex /w optimization iterations %i: %llu \n", c, exec_time[c]); | ||
127 | } | ||
128 | |||
129 | glp_delete_prob(prob); | ||
130 | } | ||
131 | |||
132 | |||
133 | void bench_simplex_no_optimization(char * file, int executions) | ||
134 | { | ||
135 | |||
136 | int c; | ||
137 | prob = glp_create_prob(); | ||
138 | glp_read_lp(prob, NULL, file); | ||
139 | |||
140 | for (c=0; c<executions;c++) | ||
141 | { | ||
142 | start = GNUNET_TIME_absolute_get(); | ||
143 | solve_lp(GNUNET_YES); | ||
144 | end = GNUNET_TIME_absolute_get(); | ||
145 | |||
146 | exec_time[c] = GNUNET_TIME_absolute_get_difference(start, end).rel_value; | ||
147 | |||
148 | sim_no_opt_avg += exec_time[c]; | ||
149 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Simplex iterations %i: %llu \n", c, exec_time[c]); | ||
150 | } | ||
151 | |||
152 | glp_delete_prob(prob); | ||
153 | } | ||
154 | |||
155 | void bench_mlp_no_optimization(char * file, int executions) | ||
156 | { | ||
157 | |||
158 | int c; | ||
159 | prob = glp_create_prob(); | ||
160 | glp_read_lp(prob, NULL, file); | ||
161 | |||
162 | for (c=0; c<executions;c++) | ||
163 | { | ||
164 | start = GNUNET_TIME_absolute_get(); | ||
165 | solve_lp(GNUNET_YES); | ||
166 | solve_mlp (GNUNET_NO); | ||
167 | end = GNUNET_TIME_absolute_get(); | ||
168 | |||
169 | exec_time[c] = GNUNET_TIME_absolute_get_difference(start, end).rel_value; | ||
170 | |||
171 | mlp_no_opt_avg += exec_time[c]; | ||
172 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MLP iterations no optimization %i: %llu \n", c, exec_time[c]); | ||
173 | } | ||
174 | |||
175 | glp_delete_prob(prob); | ||
176 | } | ||
177 | |||
178 | |||
179 | void bench_mlp_with_optimization(char * file, int executions, int changes) | ||
180 | { | ||
181 | int c; | ||
182 | prob = glp_create_prob(); | ||
183 | glp_read_lp(prob, NULL, file); | ||
184 | |||
185 | solve_lp(GNUNET_YES); | ||
186 | |||
187 | for (c=0; c<executions;c++) | ||
188 | { | ||
189 | start = GNUNET_TIME_absolute_get(); | ||
190 | //modify_qm(906, 0, 0); | ||
191 | solve_lp(GNUNET_NO); | ||
192 | solve_mlp (GNUNET_NO); | ||
193 | end = GNUNET_TIME_absolute_get(); | ||
194 | |||
195 | exec_time[c] = GNUNET_TIME_absolute_get_difference(start, end).rel_value; | ||
196 | |||
197 | mlp_with_opt_avg += exec_time[c]; | ||
198 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MLP /w optimization iterations %i: %llu \n", c, exec_time[c]); | ||
199 | } | ||
200 | |||
201 | glp_delete_prob(prob); | ||
202 | } | ||
203 | |||
204 | #if 0 | ||
205 | void modify_cr (int start, int length, int count) | ||
206 | { | ||
207 | //int * ind = GNUNET_malloc (length * sizeof (int)); | ||
208 | //double *val = GNUNET_malloc (length * sizeof (double)); | ||
209 | int ind[500]; | ||
210 | double val[500]; | ||
211 | int res = 0; | ||
212 | int c = start, c2=1; | ||
213 | while (c<=(start+count)) | ||
214 | { | ||
215 | res = glp_get_mat_row(prob, c, ind, val); | ||
216 | |||
217 | printf("row index: %i non-zero elements: %i \n", c, res); | ||
218 | for (c2=1; c2<=res; c2++) | ||
219 | { | ||
220 | printf("%i = %f ", ind[c2], val[c2]); | ||
221 | } | ||
222 | c++; | ||
223 | printf ("\n----\n"); | ||
224 | } | ||
225 | //glp_set_mat_row(prob, start, length, ind, val); | ||
226 | } | ||
227 | #endif | ||
228 | #endif | ||
229 | |||
230 | int main (int argc, char *argv[]) | ||
231 | { | ||
232 | int ret = 0; | ||
233 | GNUNET_log_setup ("perf-transport-ats", | ||
234 | #if VERBOSE | ||
235 | "DEBUG", | ||
236 | #else | ||
237 | "INFO", | ||
238 | #endif | ||
239 | NULL); | ||
240 | |||
241 | #if !HAVE_LIBGLPK | ||
242 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "GLPK not installed, exiting testcase\n"); | ||
243 | return 0; | ||
244 | #else | ||
245 | |||
246 | char * file = "ats_mlp_p100_m400.problem"; | ||
247 | // char * file = "mlps/ats_mlp_p500_m2000.problem"; | ||
248 | bench_simplex_no_optimization (file, executions); | ||
249 | bench_simplex_optimization (file, executions); | ||
250 | bench_mlp_no_optimization (file, executions); | ||
251 | bench_mlp_with_optimization (file, executions, 0); | ||
252 | |||
253 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Simplex no optimization average: %llu\n", sim_no_opt_avg / EXECS); | ||
254 | GAUGER ("TRANSPORT","GLPK simplex 100 peers 400 addresses no optimization", sim_no_opt_avg / EXECS, "ms"); | ||
255 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Simplex optimization average: %llu\n", sim_with_opt_avg / EXECS); | ||
256 | GAUGER ("TRANSPORT","GLPK simplex 100 peers 400 addresses with optimization", sim_with_opt_avg / EXECS, "ms"); | ||
257 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MLP no optimization average: %llu\n", mlp_no_opt_avg / EXECS); | ||
258 | GAUGER ("TRANSPORT","GLPK MLP 100 peers 400 addresses no optimization", mlp_no_opt_avg / EXECS, "ms"); | ||
259 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MLP optimization average: %llu\n", mlp_with_opt_avg / EXECS); | ||
260 | GAUGER ("TRANSPORT","GLPK MLP 100 peers 400 addresses with optimization", mlp_with_opt_avg / EXECS, "ms"); | ||
261 | |||
262 | #endif | ||
263 | return ret; | ||
264 | } | ||
265 | |||
266 | /* end of per_transport_ats.c*/ | ||