← Back to branch summary

~ubuntu-branches/ubuntu/utopic/xdelta3/utopic

« back to all changes in this revision

Viewing changes to examples/speed_test.c

  • Committer: Bazaar Package Importer
  • Author(s): A Mennucc1
  • Date: 2007-11-19 13:37:26 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20071119133726-3ox2si4jd08donx2
Tags: 0s.dfsg-1
New upstream release

Show diffs side-by-side

added added

removed removed

Lines of Context:
examples/speed_test.c
 
1
/* Copyright (C) 2007 Josh MacDonald */
 
2
 
 
3
#define NOT_MAIN 1
 
4
 
 
5
#include "xdelta3.h"
 
6
#include "xdelta3.c"
 
7
 
 
8
usize_t bench_speed(const uint8_t *from_buf, const size_t from_len,
 
9
                 const uint8_t *to_buf, const size_t to_len,
 
10
                 uint8_t *delta_buf, const size_t delta_alloc,
 
11
                 int flags) {
 
12
  usize_t delta_size;
 
13
  int ret = xd3_encode_memory(to_buf, to_len, from_buf, from_len,
 
14
                              delta_buf, &delta_size, delta_alloc, flags);
 
15
  if (ret != 0) {
 
16
    fprintf(stderr, "encode failure: %d: %s\n", ret, xd3_strerror(ret));
 
17
    abort();
 
18
  }
 
19
  return delta_size;
 
20
}
 
21
 
 
22
int read_whole_file(const char *name,
 
23
                    uint8_t **buf_ptr,
 
24
                    size_t *buf_len) {
 
25
  main_file file;
 
26
  int ret;
 
27
  xoff_t len;
 
28
  size_t nread;
 
29
  main_file_init(&file);
 
30
  file.filename = name;
 
31
  ret = main_file_open(&file, name, XO_READ);
 
32
  if (ret != 0) {
 
33
    goto exit;
 
34
  }
 
35
  ret = main_file_stat(&file, &len, 1);
 
36
  if (ret != 0) {
 
37
    goto exit;
 
38
  }
 
39
  
 
40
  (*buf_len) = (size_t)len;
 
41
  (*buf_ptr) = main_malloc(*buf_len);
 
42
  ret = main_file_read(&file, *buf_ptr, *buf_len, &nread,
 
43
                       "read failed");
 
44
  if (ret == 0 && *buf_len == nread) {
 
45
    ret = 0;
 
46
  } else {
 
47
    fprintf(stderr, "invalid read\n");
 
48
    ret = XD3_INTERNAL;
 
49
  }
 
50
 exit:
 
51
  main_file_cleanup(&file);
 
52
  return ret;
 
53
}
 
54
 
 
55
int main(int argc, char **argv) {
 
56
  int repeat, level;
 
57
  char *from, *to;
 
58
  uint8_t *from_buf = NULL, *to_buf = NULL, *delta_buf = NULL;
 
59
  size_t from_len, to_len, delta_alloc, delta_size = 0;
 
60
  long start, finish;
 
61
  int i, ret;
 
62
  int flags;
 
63
 
 
64
  if (argc != 5) {
 
65
    fprintf(stderr, "usage: speed_test LEVEL COUNT FROM TO\n");
 
66
    return 1;
 
67
  }
 
68
 
 
69
  level = atoi(argv[1]);
 
70
  repeat = atoi(argv[2]);
 
71
  from = argv[3];
 
72
  to = argv[4];
 
73
  flags = (level << XD3_COMPLEVEL_SHIFT) & XD3_COMPLEVEL_MASK;
 
74
 
 
75
  if ((ret = read_whole_file(from, &from_buf, &from_len)) ||
 
76
      (ret = read_whole_file(to, &to_buf, &to_len))) {
 
77
    fprintf(stderr, "read_whole_file error\n");
 
78
    goto exit;
 
79
  }
 
80
 
 
81
  delta_alloc = to_len * 11 / 10;
 
82
  delta_buf = main_malloc(delta_alloc);
 
83
 
 
84
  start = get_millisecs_now();
 
85
 
 
86
  for (i = 0; i < repeat; ++i) {
 
87
    delta_size = bench_speed(from_buf, from_len, to_buf, to_len, delta_buf, delta_alloc, flags);
 
88
  }
 
89
 
 
90
  finish = get_millisecs_now();
 
91
 
 
92
  fprintf(stderr,
 
93
          "STAT: encode %3.2f ms from %s to %s repeat %d %dbit delta %d\n",
 
94
          (double)(finish - start) / repeat, from, to, repeat, sizeof (xoff_t) * 8, delta_size);
 
95
 
 
96
  ret = 0;
 
97
 
 
98
  if (0) {
 
99
  exit:
 
100
    ret = 1;
 
101
  }
 
102
    
 
103
  main_free(to_buf);
 
104
  main_free(from_buf);
 
105
  main_free(delta_buf);
 
106
  return ret;
 
107
}