|
1
21 package com.db4o.inside.freespace;
22
23 import com.db4o.*;
24 import com.db4o.foundation.*;
25 import com.db4o.inside.slots.*;
26
27
28 public class FreespaceManagerRam extends FreespaceManager {
29
30 private final TreeIntObject _finder = new TreeIntObject(0);
31
32 private Tree _freeByAddress;
33
34 private Tree _freeBySize;
35
36 public FreespaceManagerRam(YapFile file){
37 super(file);
38 }
39
40 public void traverseFreeSlots(final Visitor4 visitor) {
41 Tree.traverse(_freeByAddress, new Visitor4() {
42 public void visit(Object  obj) {
43 FreeSlotNode node = (FreeSlotNode) obj;
44 int address = node._key;
45 int length = node._peer._key;
46 visitor.visit(new Slot(address, length));
47 }
48 });
49 }
50
51 private void addFreeSlotNodes(int a_address, int a_length) {
52 FreeSlotNode addressNode = new FreeSlotNode(a_address);
53 addressNode.createPeer(a_length);
54 _freeByAddress = Tree.add(_freeByAddress, addressNode);
55 _freeBySize = Tree.add(_freeBySize, addressNode._peer);
56 }
57
58 public void beginCommit() {
59 }
61
62 public void debug(){
63 if(Debug.freespace){
64 System.out.println("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
65 System.out.println("Dumping RAM based address index");
66 _freeByAddress.traverse(new Visitor4() {
67
68 public void visit(Object a_object) {
69 System.out.println(a_object);
70 }
71
72 });
73 System.out.println("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
74 System.out.println("Dumping RAM based length index");
75 _freeBySize.traverse(new Visitor4() {
76 public void visit(Object a_object) {
77 System.out.println(a_object);
78 }
79 });
80 System.out.println("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
81 }
82 }
83
84 public void endCommit() {
85 }
87
88 public void free(int a_address, int a_length) {
89
90 if (a_address <= 0) {
91 return;
92 }
93
94 if (a_length <= discardLimit()) {
95 return;
96 }
97
98 if(DTrace.enabled){
99 DTrace.FREE_RAM.logLength(a_address, a_length);
100 }
101
102 a_length = _file.blocksFor(a_length);
103 _finder._key = a_address;
104 FreeSlotNode sizeNode;
105 FreeSlotNode addressnode = (FreeSlotNode) Tree.findSmaller(_freeByAddress, _finder);
106 if ((addressnode != null)
107 && ((addressnode._key + addressnode._peer._key) == a_address)) {
108 sizeNode = addressnode._peer;
109 _freeBySize = _freeBySize.removeNode(sizeNode);
110 sizeNode._key += a_length;
111 FreeSlotNode secondAddressNode = (FreeSlotNode) Tree
112 .findGreaterOrEqual(_freeByAddress, _finder);
113 if ((secondAddressNode != null)
114 && (a_address + a_length == secondAddressNode._key)) {
115 sizeNode._key += secondAddressNode._peer._key;
116 _freeBySize = _freeBySize
117 .removeNode(secondAddressNode._peer);
118 _freeByAddress = _freeByAddress
119 .removeNode(secondAddressNode);
120 }
121 sizeNode.removeChildren();
122 _freeBySize = Tree.add(_freeBySize, sizeNode);
123 } else {
124 addressnode = (FreeSlotNode) Tree.findGreaterOrEqual(
125 _freeByAddress, _finder);
126 if ((addressnode != null)
127 && (a_address + a_length == addressnode._key)) {
128 sizeNode = addressnode._peer;
129 _freeByAddress = _freeByAddress.removeNode(addressnode);
130 _freeBySize = _freeBySize.removeNode(sizeNode);
131 sizeNode._key += a_length;
132 addressnode._key = a_address;
133 addressnode.removeChildren();
134 sizeNode.removeChildren();
135 _freeByAddress = Tree.add(_freeByAddress, addressnode);
136 _freeBySize = Tree.add(_freeBySize, sizeNode);
137 } else {
138 addFreeSlotNodes(a_address, a_length);
139 }
140 }
141 if (Debug.xbytes) {
142 if(! Debug.freespaceChecker){
143 _file.debugWriteXBytes(a_address, a_length * blockSize());
144 }
145 }
146 }
147
148 public void freeSelf() {
149 }
152
153 public int freeSize() {
154 final MutableInt mint = new MutableInt();
155 Tree.traverse(_freeBySize, new Visitor4() {
156 public void visit(Object obj) {
157 FreeSlotNode node = (FreeSlotNode) obj;
158 mint.add(node._key);
159 }
160 });
161 return mint.value();
162 }
163
164 public int getSlot(int length) {
165 int address = getSlot1(length);
166
167 if(address != 0){
168
169 if(DTrace.enabled){
170 DTrace.GET_FREESPACE_RAM.logLength(address, length);
171 }
172 }
173 return address;
174 }
175
176 public int getSlot1(int length) {
177 length = _file.blocksFor(length);
178 _finder._key = length;
179 _finder._object = null;
180 _freeBySize = FreeSlotNode.removeGreaterOrEqual((FreeSlotNode) _freeBySize, _finder);
181
182 if (_finder._object == null) {
183 return 0;
184 }
185
186 FreeSlotNode node = (FreeSlotNode) _finder._object;
187 int blocksFound = node._key;
188 int address = node._peer._key;
189 _freeByAddress = _freeByAddress.removeNode(node._peer);
190 if (blocksFound > length) {
191 addFreeSlotNodes(address + length, blocksFound - length);
192 }
193 return address;
194 }
195
196
197 public void migrate(final FreespaceManager newFM) {
198 if(_freeByAddress != null){
199 _freeByAddress.traverse(new Visitor4() {
200 public void visit(Object a_object) {
201 FreeSlotNode fsn = (FreeSlotNode)a_object;
202 int address = fsn._key;
203 int length = fsn._peer._key;
204 newFM.free(address, length);
205 }
206 });
207 }
208 }
209
210 public void onNew(YapFile file) {
211 }
213
214 public void read(int freeSlotsID) {
215 if (freeSlotsID <= 0){
216 return;
217 }
218 if(discardLimit() == Integer.MAX_VALUE){
219 return;
220 }
221 YapWriter reader = _file.readWriterByID(trans(), freeSlotsID);
222 if (reader == null) {
223 return;
224 }
225
226 FreeSlotNode.sizeLimit = discardLimit();
227
228 _freeBySize = new TreeReader(reader, new FreeSlotNode(0), true).read();
229
230 final Tree.ByRef addressTree = new Tree.ByRef();
231 if (_freeBySize != null) {
232 _freeBySize.traverse(new Visitor4() {
233
234 public void visit(Object a_object) {
235 FreeSlotNode node = ((FreeSlotNode) a_object)._peer;
236 addressTree.value = Tree.add(addressTree.value, node);
237 }
238 });
239 }
240 _freeByAddress = addressTree.value;
241
242 if(! Debug.freespace){
243 _file.free(freeSlotsID, YapConst.POINTER_LENGTH);
244 _file.free(reader.getAddress(), reader.getLength());
245 }
246 }
247
248 public void start(int slotAddress) {
249 }
251
252 public byte systemType() {
253 return FM_RAM;
254 }
255
256 private final Transaction trans(){
257 return _file.getSystemTransaction();
258 }
259
260 public int write(boolean shuttingDown){
261 if(! shuttingDown){
262 return 0;
263 }
264 int freeBySizeID = 0;
265 int length = TreeInt.byteCount((TreeInt)_freeBySize);
266
267 Pointer4 ptr = _file.newSlot(trans(), length);
268 freeBySizeID = ptr._id;
269 YapWriter sdwriter = new YapWriter(trans(), length);
270 sdwriter.useSlot(freeBySizeID, ptr._address, length);
271 TreeInt.write(sdwriter, (TreeInt)_freeBySize);
272 sdwriter.writeEncrypt();
273 trans().writePointer(ptr._id, ptr._address, length);
274 return freeBySizeID;
275 }
276
277 public int entryCount() {
278 return Tree.size(_freeByAddress);
279 }
280
281
282
283 }
284 |
Popular Tags |
Java API By Example, From Geeks To Geeks.