← Back to branch summary

~ps10gel/ubuntu/xenial/trafficserver/6.2.0

« back to all changes in this revision

Viewing changes to test/SDKtest/client/Config.cc

  • Committer: Bazaar Package Importer
  • Author(s): Arno Toell
  • Date: 2011-01-13 11:49:18 UTC
  • Revision ID: james.westby@ubuntu.com-20110113114918-vu422h8dknrgkj15
Tags: upstream-2.1.5-unstable
Import upstream version 2.1.5-unstable

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/SDKtest/client/Config.cc
 
1
/** @file
 
2
 
 
3
  A brief file description
 
4
 
 
5
  @section license License
 
6
 
 
7
  Licensed to the Apache Software Foundation (ASF) under one
 
8
  or more contributor license agreements.  See the NOTICE file
 
9
  distributed with this work for additional information
 
10
  regarding copyright ownership.  The ASF licenses this file
 
11
  to you under the Apache License, Version 2.0 (the
 
12
  "License"); you may not use this file except in compliance
 
13
  with the License.  You may obtain a copy of the License at
 
14
 
 
15
      http://www.apache.org/licenses/LICENSE-2.0
 
16
 
 
17
  Unless required by applicable law or agreed to in writing, software
 
18
  distributed under the License is distributed on an "AS IS" BASIS,
 
19
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 
20
  See the License for the specific language governing permissions and
 
21
  limitations under the License.
 
22
 */
 
23
 
 
24
/*************************** -*- Mod: C++ -*- *********************
 
25
 
 
26
  Config.cc
 
27
******************************************************************/
 
28
#include <ctype.h>
 
29
 
 
30
 
 
31
//   ^[ ]*#                             --> return
 
32
//   ^[ ]*$                             --> return
 
33
//   ^[ ]*\([^ ]*\)[ ]*=[ ]*\([^ ]*\)[ ]*$   --> lhs=\1  rhs=\2
 
34
 
 
35
#include "Config.h"
 
36
 
 
37
void
 
38
process_line(int line_no, char *line, int line_size, char *lhs, char *rhs)
 
39
{
 
40
  int i, j;
 
41
  i = 0;
 
42
  lhs[0] = rhs[0] = '\0';
 
43
  while (i < line_size && isspace(line[i]))
 
44
    i++;
 
45
  if (i == line_size)
 
46
    return;
 
47
  if (line[i] == '#')
 
48
    return;
 
49
  j = 0;
 
50
  while (i < line_size && !isspace(line[i]) && (line[i] != '=')) {
 
51
    lhs[j++] = line[i++];
 
52
  }
 
53
  if (i == line_size) {
 
54
    printf("Syntax error in config file line %d\n", line_no);
 
55
    exit(1);
 
56
  }
 
57
  lhs[j++] = '\0';
 
58
  while (i < line_size && isspace(line[i]))
 
59
    i++;
 
60
  if (i == line_size) {
 
61
    printf("Syntax error in config file line %d\n", line_no);
 
62
    exit(1);
 
63
  }
 
64
  if (line[i] != '=') {
 
65
    printf("Syntax error in config file line %d\n", line_no);
 
66
    exit(1);
 
67
  }
 
68
  i++;
 
69
  while (i < line_size && isspace(line[i]))
 
70
    i++;
 
71
  if (i == line_size) {
 
72
    printf("Syntax error in config file line %d\n", line_no);
 
73
    exit(1);
 
74
  }
 
75
  j = 0;
 
76
  while (i < line_size && !isspace(line[i])) {
 
77
    rhs[j++] = line[i++];
 
78
  }
 
79
  rhs[j++] = '\0';
 
80
}
 
81
 
 
82
 
 
83
void
 
84
Config::read_docsize_dist(long warmup)
 
85
{
 
86
  int end_of_file = 0;
 
87
  int n, i;
 
88
  long size;
 
89
  double prob, avg_doc_size = 0.0;
 
90
  int QOS_found = 0;
 
91
  num_sizes = 0;
 
92
  docsize_size_sum = 0;
 
93
  do {
 
94
    n = fscanf(docsize_dist_file_p, "%ld %lf", &size, &prob);
 
95
    if (n == EOF) {             /*fscanf will return number of matched items. If it
 
96
                                   returns EOF that means none were matched */
 
97
      end_of_file = 1;
 
98
    } else if (n == 2) {
 
99
      sizes[num_sizes] = size;
 
100
      if (size == QOS_docsize)
 
101
        QOS_found = 1;
 
102
      if (num_sizes == 0) {
 
103
        cumulative_size_prob[num_sizes] = prob;
 
104
      } else {
 
105
        cumulative_size_prob[num_sizes] = cumulative_size_prob[num_sizes - 1] + prob;
 
106
      }
 
107
      num_sizes++;
 
108
      avg_doc_size += prob * size;
 
109
      docsize_size_sum += size;
 
110
    } else {
 
111
      fprintf(stderr, "Error in docsize_dist_file\n");
 
112
      exit(1);
 
113
    }
 
114
  } while (!end_of_file);
 
115
  printf("Average Doc Size according to the specified distribution: %.2f\n", avg_doc_size);
 
116
  if (debug) {
 
117
    for (i = 0; i < num_sizes; i++) {
 
118
      printf("%7ld %.2f\n", sizes[i], cumulative_size_prob[i]);
 
119
    }
 
120
  }
 
121
  if ((cumulative_size_prob[num_sizes - 1]<0.99999) || (cumulative_size_prob[num_sizes - 1]> 1.00001)) {
 
122
    fprintf(stderr, "Error in docsize_dist_file: prob add up to %f\n", cumulative_size_prob[num_sizes - 1]);
 
123
    exit(1);
 
124
  }
 
125
  if (QOS_docsize != 0) {
 
126
    if (QOS_found) {
 
127
      if (!warmup) {
 
128
        fprintf(stderr, "Note: Only documents of QOS_docsize %d bytes will be included in histograms.\n", QOS_docsize);
 
129
      }
 
130
    } else {
 
131
      fprintf(stderr, "Error in QOS_docsize: %d is not in the document distribution\n", QOS_docsize);
 
132
      exit(1);
 
133
    }
 
134
  }
 
135
}
 
136
 
 
137
void
 
138
Config::read_thinktime_dist()
 
139
{
 
140
  int end_of_file = 0;
 
141
  int n, i;
 
142
  long thinktime;
 
143
  double prob, avg_thinktime = 0.0;
 
144
  num_thinktimes = 0;
 
145
  do {
 
146
    n = fscanf(thinktime_dist_file_p, "%ld %lf", &thinktime, &prob);
 
147
    if (n == EOF) {             /*fscanf will return number of matched items. If it
 
148
                                   returns EOF that means none were matched */
 
149
      end_of_file = 1;
 
150
    } else if (n == 2) {
 
151
      thinktimes[num_thinktimes] = thinktime;
 
152
      if (num_thinktimes == 0) {
 
153
        cumulative_thinktime_prob[num_thinktimes] = prob;
 
154
      } else {
 
155
        cumulative_thinktime_prob[num_thinktimes] = cumulative_thinktime_prob[num_thinktimes - 1] + prob;
 
156
      }
 
157
      num_thinktimes++;
 
158
      avg_thinktime += prob * thinktime;
 
159
    } else {
 
160
      fprintf(stderr, "Error in thinktime_dist_file\n");
 
161
      exit(1);
 
162
    }
 
163
  } while (!end_of_file);
 
164
  printf("\n");
 
165
  printf("Average Think Time according to the specified distribution: %.2f\n", avg_thinktime);
 
166
  printf("Thinktime probabilities:\n");
 
167
  for (i = 0; i < num_thinktimes; i++) {
 
168
    printf("%3ld %.2f\n", thinktimes[i], cumulative_thinktime_prob[i]);
 
169
  }
 
170
  printf("\n");
 
171
  if ((cumulative_thinktime_prob[num_thinktimes - 1] < 0.99999) ||
 
172
      (cumulative_thinktime_prob[num_thinktimes - 1] > 1.00001)) {
 
173
    fprintf(stderr, "Error in thinktime_dist_file: prob add up to %f\n", cumulative_thinktime_prob[num_thinktimes - 1]);
 
174
    exit(1);
 
175
  }
 
176
}
 
177
void
 
178
Config::read_target_byterate_dist()
 
179
{
 
180
  int end_of_file = 0;
 
181
  int n, i;
 
182
  long target_byterate;
 
183
  double prob;
 
184
  num_target_byterates = 0;
 
185
  do {
 
186
    n = fscanf(target_byterate_dist_file_p, "%ld %lf", &target_byterate, &prob);
 
187
    if (n == EOF) {             /*fscanf will return number of matched items. If it
 
188
                                   returns EOF that means none were matched */
 
189
      end_of_file = 1;
 
190
    } else if (n == 2) {
 
191
      target_byterates[num_target_byterates] = target_byterate;
 
192
      if (num_target_byterates == 0) {
 
193
        cumulative_target_byterate_prob[num_target_byterates] = prob;
 
194
      } else {
 
195
        cumulative_target_byterate_prob[num_target_byterates] =
 
196
          cumulative_target_byterate_prob[num_target_byterates - 1] + prob;
 
197
      }
 
198
      num_target_byterates++;
 
199
    } else {
 
200
      fprintf(stderr, "Error in target_byterate_dist file\n");
 
201
      exit(1);
 
202
    }
 
203
  } while (!end_of_file);
 
204
  printf("Byterate probabilities:\n");
 
205
  for (i = 0; i < num_target_byterates; i++) {
 
206
    printf("%3ld %.2f\n", target_byterates[i], cumulative_target_byterate_prob[i]);
 
207
  }
 
208
  if ((cumulative_target_byterate_prob[num_target_byterates - 1]
 
209
       < 0.99999) || (cumulative_target_byterate_prob[num_target_byterates - 1]
 
210
                      > 1.00001)) {
 
211
    fprintf(stderr, "Error in target_byterate_dist_file: prob add up to %f\n",
 
212
            cumulative_target_byterate_prob[num_target_byterates - 1]);
 
213
    exit(1);
 
214
  }
 
215
  printf("\n");
 
216
}
 
217
Config::Config(long warmup, char *config_file, TSPlugin * aplug_in, int aread_timeout)
 
218
{
 
219
  char line[MAX_LINE_SIZE], lhs[MAX_LINE_SIZE], rhs[MAX_LINE_SIZE];
 
220
  int c;
 
221
  int end_of_file = 0;
 
222
  int line_no, i;
 
223
 
 
224
#ifdef _PLUG_IN
 
225
  plug_in = aplug_in;
 
226
#endif
 
227
 
 
228
  /* Default Values */
 
229
#ifdef OLD_DEFAULT
 
230
  strcpy(target_host, "localhost");
 
231
  strcpy(target_port, "8090");
 
232
 
 
233
#else
 
234
  strcpy(target_host, "");
 
235
  strcpy(target_port, "");
 
236
 
 
237
#endif
 
238
  strcpy(document_base, "");
 
239
  synthetic = 1;
 
240
  strcpy(log_file, "sample.log");
 
241
  users = 1;
 
242
  execution_interval = 10;
 
243
  reporting_interval = 1000000;
 
244
  histogram_max = 30.0;
 
245
  histogram_resolution = 0.5;
 
246
  round_trip_time_cutoff = 2000;        /* msec */
 
247
  connect_time_cutoff = 500;    /* msec */
 
248
  first_byte_latency_cutoff = 1000;     /* msec */
 
249
  debug = 0;
 
250
  ssl = 0;
 
251
  read_timeout = aread_timeout;
 
252
  hotset = 1;
 
253
  docset = 1;
 
254
  hitrate = 100;
 
255
  keepalive = 1;
 
256
  QOS_docsize = 0;
 
257
  num_origin_servers = 0;
 
258
  strcpy(docsize_dist_file, "docsize.specweb");
 
259
  strcpy(thinktime_dist_file, "thinktime.0");
 
260
  strcpy(target_byterate_dist_file, "byterate.fast");
 
261
 
 
262
  if (!(conf_file = fopen(config_file, "r"))) {
 
263
    fprintf(stderr, "Error: could not open the config file %s\n", config_file);
 
264
    perror("Error: Config File Open");
 
265
    exit(1);
 
266
  }
 
267
  line_no = 1;
 
268
  end_of_file = 0;
 
269
  do {
 
270
    i = 0;
 
271
    do {
 
272
      line[i++] = (c = getc(conf_file));
 
273
    } while (c != '\n' && c != EOF && i < MAX_LINE_SIZE);
 
274
    if (i == MAX_LINE_SIZE) {
 
275
      fprintf(stderr, "Error in Config File: Lines can only be %d chars long\n", MAX_LINE_SIZE);
 
276
      exit(1);
 
277
    }
 
278
    if (c == EOF) {
 
279
      end_of_file = 1;
 
280
    }
 
281
    /* last char is either newline or EOF, so skip it */
 
282
    i--;
 
283
    line[i] = '\0';
 
284
    if (i > 0) {
 
285
      process_line(line_no, line, i, lhs, rhs);
 
286
 
 
287
#ifdef _PLUG_IN
 
288
      // target_host, target_port, and document_base
 
289
      // will be passed to the TSOptionProcess() later, and
 
290
      // comments are skipped.
 
291
      if ((strcmp(lhs, "target_host") || strcmp(lhs, "target_port") || strcmp(lhs, "document_base")) && strcmp(lhs, "")) {
 
292
        if (plug_in->options_process_fcn) {
 
293
          (plug_in->options_process_fcn) (lhs, rhs);
 
294
        }
 
295
      }
 
296
#endif
 
297
 
 
298
      if (!strcmp(lhs, "target_host")) {
 
299
        strcpy(target_host, rhs);
 
300
      } else if (!strcmp(lhs, "target_port")) {
 
301
        strcpy(target_port, rhs);
 
302
      } else if (!strcmp(lhs, "document_base")) {
 
303
        strcpy(document_base, rhs);
 
304
      } else if (!strcmp(lhs, "synthetic")) {
 
305
        synthetic = atoi(rhs);
 
306
      } else if (!strcmp(lhs, "log_file")) {
 
307
        strcpy(log_file, rhs);
 
308
      } else if (!strcmp(lhs, "users")) {
 
309
        users = atoi(rhs);
 
310
        assert((users) > 0);
 
311
      } else if (!strcmp(lhs, "execution_interval")) {
 
312
        execution_interval = atoi(rhs);
 
313
        assert((execution_interval) > 0);
 
314
      } else if (!strcmp(lhs, "reporting_interval")) {
 
315
        reporting_interval = atoi(rhs);
 
316
        assert((reporting_interval) > 0);
 
317
      } else if (!strcmp(lhs, "histogram_max")) {
 
318
        histogram_max = atof(rhs);
 
319
        assert((histogram_max) > 0.0);
 
320
        if (histogram_max > 1000.0) {
 
321
          fprintf(stderr, "Error: histogram times are (now) specified in seconds.  %f sec is too big.\n",
 
322
                  histogram_max);
 
323
          exit(1);
 
324
        }
 
325
      } else if (!strcmp(lhs, "histogram_resolution")) {
 
326
        histogram_resolution = atof(rhs);
 
327
        assert((histogram_resolution) > 0.0);
 
328
      } else if (!strcmp(lhs, "round_trip_cutoff")) {
 
329
        round_trip_time_cutoff = atol(rhs);
 
330
        assert(round_trip_time_cutoff > 0);
 
331
      } else if (!strcmp(lhs, "first_byte_cutoff")) {
 
332
        first_byte_latency_cutoff = atol(rhs);
 
333
        assert(first_byte_latency_cutoff > 0);
 
334
      } else if (!strcmp(lhs, "connect_cutoff")) {
 
335
        connect_time_cutoff = atol(rhs);
 
336
        assert(connect_time_cutoff > 0);
 
337
      } else if (!strcmp(lhs, "debug")) {
 
338
        debug = atoi(rhs);
 
339
        assert(((debug) == 0) || ((debug) == 1));
 
340
      } else if (!strcmp(lhs, "ssl")) {
 
341
        ssl = atoi(rhs);
 
342
        assert(((ssl) == 0) || ((ssl) == 1));
 
343
      } else if (!strcmp(lhs, "read_timeout")) {
 
344
        read_timeout = atoi(rhs);
 
345
        assert((read_timeout) > 0);
 
346
      } else if (!strcmp(lhs, "hotset")) {
 
347
        hotset = atof(rhs);
 
348
        assert((hotset) > 0);
 
349
      } else if (!strcmp(lhs, "docset")) {
 
350
        docset = atof(rhs);
 
351
        assert((docset) > 0);
 
352
      } else if (!strcmp(lhs, "hitrate")) {
 
353
        hitrate = atoi(rhs);
 
354
        assert((hitrate) >= 0 && (hitrate) <= 100);
 
355
      } else if (!strcmp(lhs, "keepalive")) {
 
356
        keepalive = atoi(rhs);
 
357
        assert((keepalive) > 0);
 
358
      } else if (!strcmp(lhs, "origin_servers")) {
 
359
        int j = 0, k;
 
360
        num_origin_servers = 0;
 
361
        while ((line[j] != '\0') && (line[j] != '='))
 
362
          j++;
 
363
        if (line[j] == '=')
 
364
          j++;
 
365
        while (line[j] != '\0') {
 
366
          assert((num_origin_servers) < MAX_ORIGIN_SERVERS);
 
367
          while ((line[j] != '\0') && isspace(line[j]))
 
368
            j++;
 
369
          if (line[j] != '\0') {
 
370
            for (k = 0; ((line[j] != '\0') && !isspace(line[j])); k++) {
 
371
              origin_server_names[num_origin_servers][k] = line[j++];
 
372
            }
 
373
            origin_server_names[num_origin_servers++][k] = '\0';
 
374
          }
 
375
        }
 
376
        char *p;
 
377
        for (j = 0; j < num_origin_servers; j++) {
 
378
          p = strrchr(origin_server_names[j], ':');
 
379
          if ((p == NULL) || (p == origin_server_names[j])) {
 
380
            fprintf(stderr, "No port supplied for origin server %d: '%s'\n", j, origin_server_names[j]);
 
381
            exit(1);
 
382
          }
 
383
          origin_server_ports[j] = p + 1;
 
384
          *p = '\0';
 
385
        }
 
386
      } else if (!strcmp(lhs, "docsize_dist_file")) {
 
387
        strcpy(docsize_dist_file, rhs);
 
388
      } else if (!strcmp(lhs, "thinktime_dist_file")) {
 
389
        strcpy(thinktime_dist_file, rhs);
 
390
      } else if (!strcmp(lhs, "byterate_dist_file")) {
 
391
        strcpy(target_byterate_dist_file, rhs);
 
392
      } else if (!strcmp(lhs, "QOS_docsize")) {
 
393
        QOS_docsize = atoi(rhs);
 
394
      } else if (line[0] == '#') {
 
395
        /* ignore comment */
 
396
      } else {
 
397
        /* printf("Unrecognized input in config file line %d\n", line_no); exit(1); */
 
398
      }
 
399
    }
 
400
    line_no++;
 
401
  } while (!end_of_file);
 
402
 
 
403
  if (num_origin_servers == 0) {
 
404
    fprintf(stderr, "No origin servers specified.\n");
 
405
    exit(1);
 
406
  }
 
407
 
 
408
  if ((strlen(target_host) == 0) || (strlen(target_port) == 0)) {
 
409
    direct = 1;
 
410
    fprintf(stderr, "target_host and/or target_port not specified -- will connect directly to origin servers\n");
 
411
  } else {
 
412
    direct = 0;
 
413
  }
 
414
 
 
415
 
 
416
  hotset_access_ratio = hitrate / 100.0;
 
417
  read_timeout *= 1000;         /* convert into msec */
 
418
  if (warmup) {
 
419
    reporting_interval = 9999999;       /* Some large value */
 
420
    execution_interval = 9999999;       /* Some large value */
 
421
    synthetic = 1;
 
422
    keepalive = 1;
 
423
  }
 
424
  if (fclose(conf_file)) {
 
425
    fprintf(stderr, "Error: could not close the config file %s\n", config_file);
 
426
    perror("Error: Config File Close");
 
427
    exit(1);
 
428
  }
 
429
  if (!synthetic) {
 
430
    docsize_dist_file_p = NULL;
 
431
    if (!(log_file_p = fopen(log_file, "r"))) {
 
432
      fprintf(stderr, "Error: could not open the log file %s\n", log_file);
 
433
      perror("Error: Log File Open");
 
434
      exit(1);
 
435
    }
 
436
  } else {
 
437
    log_file_p = NULL;
 
438
    /* Round-off hotset and docset */
 
439
    if (!(docsize_dist_file_p = fopen(docsize_dist_file, "r"))) {
 
440
      fprintf(stderr, "Error: could not open the docsize_dist_file %s\n", docsize_dist_file);
 
441
      perror("Error: DocSize Dist File Open");
 
442
      exit(1);
 
443
    }
 
444
    read_docsize_dist(warmup);
 
445
    if (fclose(docsize_dist_file_p)) {
 
446
      fprintf(stderr, "Error: could not close the docsize_dist file %s\n", docsize_dist_file);
 
447
      perror("Error: Docsize File Close");
 
448
      exit(1);
 
449
    }
 
450
    if (debug) {
 
451
      printf("Hotset %f num_origin_servers %d num_sizes %d\n", hotset, num_origin_servers, num_sizes);
 
452
      printf("Docset %f num_origin_servers %d num_sizes %d\n", docset, num_origin_servers, num_sizes);
 
453
    }
 
454
    hotset = (double) (ceil(hotset * 1.0 / (num_origin_servers * num_sizes)) * (num_origin_servers * num_sizes));
 
455
 
 
456
    docset = (double) (ceil(docset * 1.0 / (num_origin_servers * num_sizes)) * (num_origin_servers * num_sizes));
 
457
  }
 
458
  if (warmup) {                 // Don't need thinktimes or target_byterate
 
459
    fprintf(stderr, "Total size of hotset: %.1f MByte\n",
 
460
            (((double) hotset / (double) num_sizes) * (double) docsize_size_sum) / (1024.0 * 1024.0));
 
461
    num_thinktimes = 1;
 
462
    thinktimes[0] = 0;
 
463
    cumulative_thinktime_prob[0] = 1.0;
 
464
    num_target_byterates = 1;
 
465
    target_byterates[0] = -1;
 
466
    cumulative_target_byterate_prob[0] = 1.0;
 
467
    if (users > MAX_WARMUP_USERS) {
 
468
      fprintf(stderr, "Reducing number of users for warmup from %d to %d\n", users, MAX_WARMUP_USERS);
 
469
      users = MAX_WARMUP_USERS;
 
470
    }
 
471
  } else {
 
472
    if (!(thinktime_dist_file_p = fopen(thinktime_dist_file, "r"))) {
 
473
      fprintf(stderr, "Error: could not open the thinktime_dist_file %s\n", thinktime_dist_file);
 
474
      perror("Error: Thinktime Dist File Open");
 
475
      exit(1);
 
476
    }
 
477
    read_thinktime_dist();
 
478
    if (fclose(thinktime_dist_file_p)) {
 
479
      fprintf(stderr, "Error: could not close the thinktime_dist file %s\n", thinktime_dist_file);
 
480
      perror("Error: Thinktime File Close");
 
481
      exit(1);
 
482
    }
 
483
    if (!(target_byterate_dist_file_p = fopen(target_byterate_dist_file, "r"))) {
 
484
      fprintf(stderr, "Error: could not open the target_byterate_dist_file %s\n", target_byterate_dist_file);
 
485
      perror("Error: Target ByteRate Dist File Open");
 
486
      exit(1);
 
487
    }
 
488
    read_target_byterate_dist();
 
489
    if (fclose(target_byterate_dist_file_p)) {
 
490
      fprintf(stderr, "Error: could not close the target_byterate_dist file %s\n", target_byterate_dist_file);
 
491
      perror("Error: Target ByteRate File Close");
 
492
      exit(1);
 
493
    }
 
494
  }
 
495
 
 
496
 
 
497
#ifdef _PLUG_IN
 
498
  if (plug_in->options_process_fcn) {
 
499
    (plug_in->options_process_fcn) ("target_host", target_host);
 
500
    (plug_in->options_process_fcn) ("target_port", target_port);
 
501
    (plug_in->options_process_fcn) ("document_base", document_base);
 
502
  }
 
503
#endif
 
504
 
 
505
 
 
506
  printf("target_host '%s'\n", target_host);
 
507
  printf("target_port '%s'\n", target_port);
 
508
  // printf("synthetic %d\n",synthetic);
 
509
  // printf("log_file '%s'\n", log_file);
 
510
  printf("users %d\n", users);
 
511
  printf("execution_interval %d\n", execution_interval);
 
512
  printf("reporting_interval %d\n", reporting_interval);
 
513
  printf("debug %d\n", debug);
 
514
  printf("ssl %d\n", ssl);
 
515
  printf("read_timeout %d\n", read_timeout);
 
516
  printf("adjusted hotset %.0f\n", hotset);
 
517
  printf("adjusted docset %.0f \n", docset);
 
518
  printf("hitrate %d \n", hitrate);
 
519
  printf("keepalive %d\n", keepalive);
 
520
  printf("num_origin_servers %d\n", num_origin_servers);
 
521
 
 
522
  /////////////////////////////
 
523
#ifdef _PLUG_IN
 
524
  if (plug_in->options_process_finish_fcn) {
 
525
    (plug_in->options_process_finish_fcn) ();
 
526
  }
 
527
#endif
 
528
  /////////////////////////////
 
529
}