← Back to branch summary

~ubuntu-branches/ubuntu/raring/ceph/raring

« back to all changes in this revision

Viewing changes to src/test/common/ObjectContents.cc

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2012-06-08 15:54:37 UTC
  • mfrom: (0.3.9)
  • mto: This revision was merged to the branch mainline in revision 13.
  • Revision ID: package-import@ubuntu.com-20120608155437-30vek4y2gu92vhad
Tags: upstream-0.44.1
Import upstream version 0.44.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/test/common/ObjectContents.cc
 
1
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
 
2
#include "ObjectContents.h"
 
3
#include "include/buffer.h"
 
4
#include <iostream>
 
5
#include <map>
 
6
 
 
7
bool test_object_contents()
 
8
{
 
9
  ObjectContents c, d;
 
10
  assert(!c.exists());
 
11
  c.debug(std::cerr);
 
12
  c.write(10, 10, 10);
 
13
  assert(c.exists());
 
14
  assert(c.size() == 20);
 
15
 
 
16
  c.debug(std::cerr);
 
17
  bufferlist bl;
 
18
  for (ObjectContents::Iterator iter = c.get_iterator();
 
19
       iter.valid();
 
20
       ++iter) {
 
21
    bl.append(*iter);
 
22
  }
 
23
  assert(bl.length() == 20);
 
24
 
 
25
  bufferlist bl2;
 
26
  for (unsigned i = 0; i < 8; ++i) bl2.append(bl[i]);
 
27
  c.write(10, 8, 4);
 
28
  c.debug(std::cerr);
 
29
  ObjectContents::Iterator iter = c.get_iterator();
 
30
  iter.seek_to(8);
 
31
  for (uint64_t i = 8;
 
32
       i < 12;
 
33
       ++i, ++iter) {
 
34
    bl2.append(*iter);
 
35
  }
 
36
  for (unsigned i = 12; i < 20; ++i) bl2.append(bl[i]);
 
37
  assert(bl2.length() == 20);
 
38
 
 
39
  for (ObjectContents::Iterator iter3 = c.get_iterator();
 
40
       iter.valid();
 
41
       ++iter) {
 
42
    assert(bl2[iter3.get_pos()] == *iter3);
 
43
  }
 
44
 
 
45
  assert(bl2[0] == '\0');
 
46
  assert(bl2[7] == '\0');
 
47
 
 
48
  interval_set<uint64_t> to_clone;
 
49
  to_clone.insert(5, 10);
 
50
  d.clone_range(c, to_clone);
 
51
  assert(d.size() == 15);
 
52
 
 
53
  c.debug(std::cerr);
 
54
  d.debug(std::cerr);
 
55
 
 
56
  ObjectContents::Iterator iter2 = d.get_iterator();
 
57
  iter2.seek_to(5);
 
58
  for (uint64_t i = 5; i < 15; ++i, ++iter2) {
 
59
    std::cerr << "i is " << i << std::endl;
 
60
    assert(iter2.get_pos() == i);
 
61
    assert(*iter2 == bl2[i]);
 
62
  }
 
63
  return true;
 
64
}
 
65
 
 
66
 
 
67
unsigned int ObjectContents::Iterator::get_state(uint64_t _pos)
 
68
{
 
69
  if (parent->seeds.count(_pos)) {
 
70
    return parent->seeds[_pos];
 
71
  }
 
72
  seek_to(_pos - 1);
 
73
  return current_state;
 
74
}
 
75
 
 
76
void ObjectContents::clone_range(ObjectContents &other,
 
77
                                 interval_set<uint64_t> &intervals)
 
78
{
 
79
  interval_set<uint64_t> written_to_clone;
 
80
  written_to_clone.intersection_of(intervals, other.written);
 
81
 
 
82
  interval_set<uint64_t> zeroed = intervals;
 
83
  zeroed.subtract(written_to_clone);
 
84
 
 
85
  written.union_of(intervals);
 
86
  written.subtract(zeroed);
 
87
 
 
88
  for (interval_set<uint64_t>::iterator i = written_to_clone.begin();
 
89
       i != written_to_clone.end();
 
90
       ++i) {
 
91
    uint64_t start = i.get_start();
 
92
    uint64_t len = i.get_len();
 
93
 
 
94
    unsigned int seed = get_iterator().get_state(start+len);
 
95
 
 
96
    seeds[start+len] = seed;
 
97
    seeds.erase(seeds.lower_bound(start), seeds.lower_bound(start+len));
 
98
 
 
99
    seeds[start] = other.get_iterator().get_state(start);
 
100
    seeds.insert(other.seeds.upper_bound(start),
 
101
                 other.seeds.lower_bound(start+len));
 
102
  }
 
103
 
 
104
  if (intervals.range_end() > _size)
 
105
    _size = intervals.range_end();
 
106
  _exists = true;
 
107
  return;
 
108
}
 
109
 
 
110
void ObjectContents::write(unsigned int seed,
 
111
                           uint64_t start,
 
112
                           uint64_t len)
 
113
{
 
114
  _exists = true;
 
115
  unsigned int _seed = get_iterator().get_state(start+len);
 
116
  seeds[start+len] = _seed;
 
117
  seeds.erase(seeds.lower_bound(start),
 
118
              seeds.lower_bound(start+len));
 
119
  seeds[start] = seed;
 
120
 
 
121
  interval_set<uint64_t> to_write;
 
122
  to_write.insert(start, len);
 
123
  written.union_of(to_write);
 
124
 
 
125
  if (start + len > _size)
 
126
    _size = start + len;
 
127
  return;
 
128
}