2 * To change this template, choose Tools | Templates
3 * and open the template in the editor.
5 package TransactionalIO.core;
9 import TransactionalIO.Utilities.Range;
10 import TransactionalIO.exceptions.AbortedException;
11 import TransactionalIO.exceptions.PanicException;
12 import TransactionalIO.benchmarks.benchmark;
13 import TransactionalIO.core.ExtendedTransaction.Status;
14 import TransactionalIO.interfaces.BlockAccessModesEnum;
15 import TransactionalIO.interfaces.OffsetDependency;
16 import com.sun.org.apache.bcel.internal.generic.IFEQ;
18 import java.io.FileDescriptor;
19 import java.io.FileNotFoundException;
20 import java.io.IOException;
21 import java.io.RandomAccessFile;
22 import java.nio.ByteBuffer;
23 import java.util.Collections;
24 import java.util.Iterator;
25 import java.util.SortedSet;
26 import java.util.TreeMap;
27 import java.util.TreeSet;
28 import java.util.Vector;
29 import java.util.concurrent.locks.Lock;
30 import java.util.concurrent.locks.ReentrantLock;
31 import java.util.logging.Level;
32 import java.util.logging.Logger;
33 import sun.misc.ConditionLock;
41 public class TransactionalFile implements Comparable{
43 private native int nativepwrite(byte buff[], long offset, int size, FileDescriptor fd);
44 private native int nativepread(byte buff[], long offset, int size, FileDescriptor fd);
48 System.load("/home/navid/libkooni.so");
52 public RandomAccessFile file;
54 private int sequenceNum = 0;
55 public static int currenSeqNumforInode = 0;
56 /* public AtomicLong commitedoffset;
57 public AtomicLong commitedfilesize;*/
58 public boolean to_be_created = false;
59 public boolean writemode = false;
60 public boolean appendmode = false;
61 public ReentrantLock offsetlock;
62 private GlobalOffset committedoffset;
63 private GlobalINodeState inodestate ;
66 public TransactionalFile(String filename, String mode) {
69 File f = new File(filename);
71 if ((!(f.exists()))) {
79 offsetlock = new ReentrantLock();
80 file = new RandomAccessFile(f, mode);
81 } catch (FileNotFoundException ex) {
83 Logger.getLogger(TransactionalFile.class.getName()).log(Level.SEVERE, null, ex);
87 inode = TransactionalFileWrapperFactory.getINodefromFileName(filename);
88 inodestate = TransactionalFileWrapperFactory.createTransactionalFile(inode, filename, mode);
91 sequenceNum = inodestate.seqNum;
98 if (mode.equals("rw")) {
100 } else if (mode.equals("a")) {
104 if (inodestate != null) {
105 synchronized (inodestate) {
107 // if (!(to_be_created)) {
109 // adapter.commitedfilesize.set(0);
113 //commitedoffset.setOffsetnumber(0);
114 committedoffset = new GlobalOffset(0);
116 committedoffset = new GlobalOffset(file.length());
119 } catch (IOException ex) {
120 Logger.getLogger(TransactionalFile.class.getName()).log(Level.SEVERE, null, ex);
128 private int invokeNativepread(byte buff[], long offset, int size) {
130 return nativepread(buff, offset, size, file.getFD());
131 } catch (IOException ex) {
133 Logger.getLogger(TransactionalFile.class.getName()).log(Level.SEVERE, null, ex);
139 public int invokeNativepwrite(byte buff[], long offset, int size, RandomAccessFile file) {
141 //System.out.println(buff.length);
142 // System.out.println(offset);
143 return nativepwrite(buff, offset, buff.length, file.getFD());
144 } catch (IOException ex) {
146 Logger.getLogger(TransactionalFile.class.getName()).log(Level.SEVERE, null, ex);
155 public int getSequenceNum() {
160 public GlobalOffset getCommitedoffset() {
161 return committedoffset;
164 public GlobalINodeState getInodestate() {
168 /* public TransactionalFile(Adapter adapter, RandomAccessFile file) {
170 this.adapter = adapter;
172 decriptors = new Vector();
175 public void copyTransactionalFile(TransactionalFile tf){
177 int tmp = tf.commitedoffset.get();
178 boolean flag = tf.to_be_created;
179 FileDescriptor fd = tf.file.getFD();
180 Adapter ad = new Adapter(tf.adapter);
181 } catch (IOException ex) {
182 Logger.getLogger(TransactionalFile.class.getName()).log(Level.SEVERE, null, ex);
186 /* public BlockDataStructure getBlockDataStructure(int blocknumber) {
187 synchronized (inodestate.lockmap) {
188 if (inodestate.lockmap.containsKey(blocknumber)) {
190 return ((BlockDataStructure) (inodestate.lockmap.get(Long.valueOf(blocknumber))));
193 BlockDataStructure tmp = new BlockDataStructure(getInode(), blocknumber);
194 inodestate.lockmap.put(Integer.valueOf(blocknumber), tmp);
203 public INode getInode() {
206 /* public boolean deleteBlockLock(int blocknumber){
207 synchronized(adapter.lockmap){
208 //adapter.lockmap.get(blocknumber)
209 if (adapter.lockmap.containsKey(blocknumber)){
210 if (((BlockLock)(adapter.lockmap.get(blocknumber))).referncount == 0){
211 adapter.lockmap.remove(adapter.lockmap.get(blocknumber));
222 public void close() {
225 } catch (IOException ex) {
226 Logger.getLogger(TransactionalFile.class.getName()).log(Level.SEVERE, null, ex);
230 public long getFilePointer(){
232 ExtendedTransaction me = Wrapper.getTransaction();
233 TransactionLocalFileAttributes tmp = null;
236 return non_Transactional_getFilePointer();
239 if (!(me.getGlobaltoLocalMappings().containsKey(this))){
241 //if (!(me.getFilesAccesses().containsKey(this.inode))) {
242 tmp = new TransactionLocalFileAttributes(0);/*, tf.getInodestate().commitedfilesize.get();*/
245 if (me.getAccessedFiles().containsKey(this.getInode())){
246 dummy = (Vector) me.getAccessedFiles().get(this.getInode());
249 dummy = new Vector();
250 me.getAccessedFiles().put(this.getInode(), dummy);
255 // this.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Unlocked the offset lock " + tf.offsetlock + " for file " + tf.getInode() + " form descriptor " + tf.getSequenceNum());
257 me.getGlobaltoLocalMappings().put(this, tmp);
258 me.merge_for_writes_done.put(this.getInode(), Boolean.TRUE);
265 tmp = (TransactionLocalFileAttributes) me.getGlobaltoLocalMappings().get(this);
266 if ((tmp.getOffsetdependency() == OffsetDependency.WRITE_DEPENDENCY_1) || (tmp.getOffsetdependency() == OffsetDependency.NO_ACCESS)){
267 tmp.setOffsetdependency(OffsetDependency.READ_DEPENDENCY);
268 //System.out.println("sad");
269 //synchronized(this.committedoffset)
274 if (!(this.committedoffset.getOffsetReaders().contains(me))){
275 this.committedoffset.getOffsetReaders().add(me);
276 /*synchronized(benchmark.lock){
277 benchmark.msg += Thread.currentThread().getName() + " Added to Offset Readers for file " + this.inode + " from descriptor "+ this.sequenceNum +"\n";
279 // me.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Added to Offset Readers for file " + this.inode + " from descriptor "+ this.sequenceNum +"\n");
280 /* synchronized(benchmark.lock){
281 System.out.println(Thread.currentThread().getName() + " Added to Offset Readers for file " + this.inode + " from descriptor "+ this.sequenceNum +"\n");
285 tmp.setLocaloffset(tmp.getLocaloffset() + this.committedoffset.getOffsetnumber() - tmp.getCopylocaloffset());
286 target = this.committedoffset.getOffsetnumber() - tmp.getCopylocaloffset();
290 //me.getHeldoffsetlocks().remove(offsetlock);
294 if ((me.getWriteBuffer().get(inode)) != null)
297 it = ((Vector) (me.getWriteBuffer().get(inode))).iterator();
298 while (it.hasNext()){
299 WriteOperations wrp = (WriteOperations) it.next();
300 if (wrp.getBelongingto() == tmp && wrp.isUnknownoffset())
301 wrp.setUnknownoffset(false);
302 /*wrp.getRange().setStart(wrp.getOwnertransactionalFile().committedoffset.getOffsetnumber() - wrp.getBelongingto().getCopylocaloffset() + wrp.getRange().getStart());
303 wrp.getRange().setEnd(wrp.getOwnertransactionalFile().committedoffset.getOffsetnumber() - wrp.getBelongingto().getCopylocaloffset() + wrp.getRange().getEnd());*/
304 wrp.getRange().setStart(target + wrp.getRange().getStart());
305 wrp.getRange().setEnd(target + wrp.getRange().getEnd());
314 tmp.setUnknown_inital_offset_for_write(false);
316 /* synchronized(benchmark.lock){
317 benchmark.msg += Thread.currentThread().getName() + " Read the offset value for the file " + this.inode +" from descriptor " + this.sequenceNum + "\n";
319 me.msg += Thread.currentThread().getName() + " Read the offset value for the file " + this.inode +" from descriptor " + this.sequenceNum + "\n";*/
320 /* synchronized(benchmark.lock){
321 System.out.println("offset " + Thread.currentThread() + " " + tmp.getLocaloffset());
323 return tmp.getLocaloffset();
326 public void seek(long offset) {
329 throw new PanicException("Cannot seek into a file opened in append mode");
331 ExtendedTransaction me = Wrapper.getTransaction();
334 non_Transactional_Seek(offset);
339 // if (me.getStatus() != Status.ACTIVE)
340 // throw new AbortedException();
342 TransactionLocalFileAttributes tmp = null;
343 //tf.offsetlock.lock();
345 //this.heldoffsetlocks.remove(tf.offsetlock);
346 //tf.offsetlock.unlock();
347 if (!(me.getGlobaltoLocalMappings().containsKey(this))){
348 //if (!(me.getFilesAccesses().containsKey(this.inode))) {
349 tmp = new TransactionLocalFileAttributes(offset);/*, tf.getInodestate().commitedfilesize.get();*/
352 if (me.getAccessedFiles().containsKey(this.getInode())){
353 dummy = (Vector) me.getAccessedFiles().get(this.getInode());
356 dummy = new Vector();
357 me.getAccessedFiles().put(this.getInode(), dummy);
362 // this.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Unlocked the offset lock " + tf.offsetlock + " for file " + tf.getInode() + " form descriptor " + tf.getSequenceNum());
364 me.getGlobaltoLocalMappings().put(this, tmp);
365 me.merge_for_writes_done.put(this.getInode(), Boolean.TRUE);
369 tmp = (TransactionLocalFileAttributes) me.getGlobaltoLocalMappings().get(this);
370 //tmp = ((TransactionLocalFileAttributes) (me.getFilesAccesses().get(this.getInode())));
372 if (tmp.getOffsetdependency() == OffsetDependency.NO_ACCESS)
373 tmp.setOffsetdependency(OffsetDependency.NO_DEPENDENCY);
375 else if (tmp.getOffsetdependency() == OffsetDependency.WRITE_DEPENDENCY_1)
376 tmp.setOffsetdependency(OffsetDependency.WRITE_DEPENDENCY_2);
378 tmp.setUnknown_inital_offset_for_write(false);
380 tmp.setLocaloffset(offset);
383 /* synchronized(benchmark.lock){
384 System.out.println(tmp.getLocaloffset());
386 // me.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Seeked to the file" + this.inode +" from descriptor " + this.sequenceNum + "\n");
390 public int read(byte[] b) {
393 throw new PanicException("Cannot seek into a file opened in append mode");
396 boolean firsttime = false;
397 ExtendedTransaction me = Wrapper.getTransaction();
403 if (me == null) { // not a transaction, but any I/O operation even though within a non-transaction is considered a single opertion transactiion
404 return non_Transactional_Read(b);
407 //if (me.getStatus() != Status.ACTIVE)
408 // throw new AbortedException();
411 if (me.getGlobaltoLocalMappings().containsKey(this)){
414 Vector locktracker = new Vector();
415 TreeMap hm = me.getSortedFileAccessMap(me.getAccessedFiles());;
416 Vector vec = (Vector)hm.get(inode);
417 Iterator vecit = vec.iterator();
418 while(vecit.hasNext()){
419 TransactionalFile tr = (TransactionalFile)vecit.next();
420 TransactionLocalFileAttributes tmp = (TransactionLocalFileAttributes) me.getGlobaltoLocalMappings().get(tr);
422 if ((tmp.getOffsetdependency() == OffsetDependency.WRITE_DEPENDENCY_1) || (tmp.offsetdependency == OffsetDependency.NO_ACCESS) || (tmp.getOffsetdependency() == OffsetDependency.WRITE_DEPENDENCY_2)){
423 tmp.setUnknown_inital_offset_for_write(false);
424 tmp.setOffsetdependency(OffsetDependency.READ_DEPENDENCY);
426 System.out.printtln(Thread.currentThread() + " kiri");
427 if (!(tr.committedoffset.getOffsetReaders().contains(me))){
428 tr.committedoffset.getOffsetReaders().add(me);
429 target = this.committedoffset.getOffsetnumber() - tmp.getCopylocaloffset();
430 me.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Added to Offset Readers for file " + this.inode + " from descriptor "+ this.sequenceNum +"\n");
438 TransactionLocalFileAttributes tmp = (TransactionLocalFileAttributes) me.getGlobaltoLocalMappings().get(this);
439 tmp.setUnknown_inital_offset_for_write(false);
440 if ((tmp.getOffsetdependency() == OffsetDependency.WRITE_DEPENDENCY_1) || (tmp.offsetdependency == OffsetDependency.NO_ACCESS) || (tmp.getOffsetdependency() == OffsetDependency.WRITE_DEPENDENCY_2)){
441 //System.out.println(Thread.currentThread() + " here");
442 //synchronized(this.committedoffset){
444 if (tmp.getOffsetdependency() != OffsetDependency.WRITE_DEPENDENCY_2){
445 tmp.setLocaloffset(tmp.getLocaloffset() + this.committedoffset.getOffsetnumber() - tmp.getCopylocaloffset());
448 tmp.setOffsetdependency(OffsetDependency.READ_DEPENDENCY);
449 if (!(this.committedoffset.getOffsetReaders().contains(me))){
450 this.committedoffset.getOffsetReaders().add(me);
451 /* synchronized(benchmark.lock){
452 System.out.println("adding offset " + committedoffset + " " +Thread.currentThread());
454 /* synchronized(benchmark.lock){
455 benchmark.msg += Thread.currentThread().getName() + " Added to Offset Readers for file " + this.inode + " from descriptor "+ this.sequenceNum +"\n";
457 // me.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Added to Offset Readers for file " + this.inode + " from descriptor "+ this.sequenceNum +"\n");
458 /*synchronized(benchmark.lock){
459 System.out.println(Thread.currentThread().getName() + " Added to Offset Readers for file " + this.inode + " from descriptor "+ this.sequenceNum);
464 // me.getHeldoffsetlocks().remove(offsetlock);
468 if (me.getWriteBuffer().get(inode) != null)
469 //if (!(((Vector)(me.getWriteBuffer().get(inode))).isEmpty()))
471 it = ((Vector) (me.getWriteBuffer().get(inode))).iterator();
472 while (it.hasNext()){
474 WriteOperations wrp = (WriteOperations) it.next();
475 if (wrp.isUnknownoffset()){
476 wrp.setUnknownoffset(false);
477 //synchronized(wrp.getOwnertransactionalFile().committedoffset){
478 wrp.getOwnertransactionalFile().lockOffset(me);
480 wrp.getRange().setStart(wrp.getOwnertransactionalFile().committedoffset.getOffsetnumber() - wrp.getBelongingto().getCopylocaloffset() + wrp.getRange().getStart());
481 wrp.getRange().setEnd(wrp.getOwnertransactionalFile().committedoffset.getOffsetnumber() - wrp.getBelongingto().getCopylocaloffset() + wrp.getRange().getEnd());
482 if ((wrp.getBelongingto().getOffsetdependency() == OffsetDependency.WRITE_DEPENDENCY_1) || (wrp.getBelongingto().offsetdependency == OffsetDependency.NO_ACCESS) || (wrp.getBelongingto().getOffsetdependency() == OffsetDependency.WRITE_DEPENDENCY_2)){
483 wrp.getBelongingto().setOffsetdependency(OffsetDependency.READ_DEPENDENCY);
484 wrp.getBelongingto().setUnknown_inital_offset_for_write(false);
485 if (!(wrp.getOwnertransactionalFile().committedoffset.getOffsetReaders().contains(me)))
486 wrp.getOwnertransactionalFile().committedoffset.getOffsetReaders().add(me);
487 wrp.getBelongingto().setLocaloffset(wrp.getBelongingto().getLocaloffset() + wrp.getOwnertransactionalFile().committedoffset.getOffsetnumber() - wrp.getBelongingto().getCopylocaloffset());
488 /* synchronized(benchmark.lock){
489 benchmark.msg += Thread.currentThread().getName() + " Added to Offset Readers for file " + this.inode + " from descriptor "+ wrp.getOwnertransactionalFile().sequenceNum +"\n";
491 // me.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Added to Offset Readers for file " + this.inode + " from descriptor "+ wrp.getOwnertransactionalFile().sequenceNum +"\n");
494 // me.getHeldoffsetlocks().remove(wrp.getOwnertransactionalFile().offsetlock);
495 wrp.getOwnertransactionalFile().offsetlock.unlock();
501 markAccessedBlocks(me, (int)wrp.getRange().getStart(), (int)(wrp.getRange().getEnd() - wrp.getRange().getStart()), BlockAccessModesEnum.WRITE);
502 // markWriteBlocks((int)wrp.getRange().getStart(), (int)(wrp.getRange().getEnd() - wrp.getRange().getStart()));
507 /* if (!(me.isWritesmerged())){
508 // synchronized(benchmark.lock){
509 // System.out.println("ssssad " + Thread.currentThread() + " " + me.getWriteBuffer());
513 // System.out.println("ssssad " + Thread.currentThread() + " " + me.getWriteBuffer());
514 if ((Boolean)me.merge_for_writes_done.get(inode) == Boolean.FALSE){
515 // synchronized(benchmark.lock){
516 System.out.println("ssssad " + Thread.currentThread() + " " + me.getWriteBuffer());
517 mergeWrittenData(me);
522 long loffset = tmp.getLocaloffset();
523 markAccessedBlocks(me, loffset, size, BlockAccessModesEnum.READ);
527 if ((me.getWriteBuffer().get(this.inode)) != null)
528 writebuffer = (Vector) (me.getWriteBuffer().get(this.inode));
530 writebuffer = new Vector();
531 me.getWriteBuffer().put(this.inode, writebuffer);
533 Range readrange = new Range(loffset, loffset + size);
534 Range writerange = null;
535 Range[] intersectedrange = new Range[writebuffer.size()];
536 WriteOperations[] markedwriteop = new WriteOperations[writebuffer.size()];
543 boolean flag = false;
544 //System.out.println("yani che>??");
546 it = writebuffer.iterator();
547 while (it.hasNext()) {
549 WriteOperations wrp = (WriteOperations) it.next();
550 writerange = wrp.getRange();
551 if (writerange.includes(readrange)) {
552 markedwriteop[counter] = wrp;
557 if (writerange.hasIntersection(readrange)) {
558 intersectedrange[counter] = readrange.intersection(writerange);
559 markedwriteop[counter] = wrp;
566 // for block versioning mechanism
567 /*if (!(validateBlocksVersions(startblock, targetblock))) { ////check to see if version are still valid
569 throw new AbortedException();
574 result = readFromBuffer(b, tmp, markedwriteop[counter],writerange);
576 /* synchronized(benchmark.lock){
577 benchmark.msg += Thread.currentThread().getName() + " Read " + this.inode + " from descriptor "+ this.sequenceNum +"\n";
580 // me.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Read " + this.inode + " from descriptor "+ this.sequenceNum +"\n");
587 /* synchronized(benchmark.lock){
588 System.out.println("here" +Thread.currentThread());
592 result = readFromFile(me, b, tmp);
596 for (int i = 0; i < counter; i++) {
599 Byte[] data = markedwriteop[i].getData();
600 byte[] copydata = new byte[data.length];
602 for (int j = 0; j < data.length; j++) {
603 copydata[j] = data[j].byteValue();
605 System.arraycopy(copydata, (int) (intersectedrange[i].getStart() - markedwriteop[i].getRange().getStart()), b, (int) (intersectedrange[i].getStart() - readrange.getStart()), (int) (Math.min(intersectedrange[i].getEnd(), readrange.getEnd()) - intersectedrange[i].getStart()));
606 result += Math.min(intersectedrange[i].getEnd(), readrange.getEnd()) - intersectedrange[i].getStart();
609 Range[] non_intersected_ranges = readrange.minus(intersectedrange, counter);
610 Vector occupiedblocks = new Vector();
611 Vector heldlocks = new Vector();
612 for (int i = 0; i < non_intersected_ranges.length; i++) {
613 int st = FileBlockManager.getCurrentFragmentIndexofTheFile(non_intersected_ranges[i].getStart());
614 int en = FileBlockManager.getCurrentFragmentIndexofTheFile(non_intersected_ranges[i].getEnd());
615 for (int j = st; j <= en; j++) {
616 if (!(occupiedblocks.contains(Integer.valueOf(j)))) {
617 occupiedblocks.add(Integer.valueOf(j));
625 me.getHeldoffsetlocks().add(offsetlock);
628 for (int k = 0; k < occupiedblocks.size(); k++) { // locking the block locks
630 while (me.getStatus() == Status.ACTIVE) {
632 BlockDataStructure block = this.inodestate.getBlockDataStructure((Integer)(occupiedblocks.get(k)));//(BlockDataStructure) tmp.adapter.lockmap.get(Integer.valueOf(k)));
634 //synchronized(block){
636 // if (block.getLock().readLock().tryLock()) {
637 block.getLock().readLock().lock();
638 /* synchronized(benchmark.lock){
639 benchmark.msg += Thread.currentThread().getName() + " Locked The Block Number " + block.getBlocknumber()+ " for file " + this.inode + " from descriptor "+ this.sequenceNum +"\n";
641 // me.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Added The Block Number " + block.getBlocknumber()+ " for file " + this.inode + " from descriptor "+ this.sequenceNum +"\n");
642 //synchronized (block){
643 if (!(block.getReaders().contains(me))){
644 /* synchronized(benchmark.lock){
645 benchmark.msg += Thread.currentThread().getName() + " Added to Block Readers for Block Number " + block.getBlocknumber()+ " for file " + this.inode + " from descriptor "+ this.sequenceNum +"\n";
647 // me.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Added to Block Readers for Block Number " + block.getBlocknumber()+ " for file " + this.inode + " from descriptor "+ this.sequenceNum +"\n");
648 block.getReaders().add(me);
650 me.getHeldblocklocks().add(block.getLock().readLock());
651 //heldlocks.add(block.getLock().readLock());
656 // me.getContentionmanager().resolveConflict(me, block);
660 if (me.getStatus() == Status.ABORTED) {
661 //unlockLocks(heldlocks);
662 //offsetlock.unlock();
663 // me.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Aborted in locking blocks in read\n");
664 /* synchronized(benchmark.lock){
665 benchmark.msg += Thread.currentThread().getName() + " Aborted \n";
667 // Thread.currentThread().stop();
668 throw new AbortedException();
672 int expvalue = ((Integer) tmp.getBlockversions().get(Integer.valueOf(k))).intValue();
673 while (me.getStatus() == Status.ACTIVE) {
674 BlockDataStructure block = ((BlockDataStructure) tmp.adapter.lockmap.get(Integer.valueOf(k)));
675 if (block.getLock().tryLock()) {
676 heldlocks.add(block.getLock());
677 if (!(block.getVersion().get() == expvalue)) { // for block versioning mechanism
685 me.getContentionManager().resolveConflict(me, block.getOwner());
688 if (me.getStatus() == Status.ABORTED) {
689 unlockLocks(heldlocks);
691 throw new AbortedException();
697 for (int i = 0; i < non_intersected_ranges.length; i++) {
699 synchronized(benchmark.lock){
700 System.out.println("read start " + non_intersected_ranges[i].getStart());
702 file.seek(non_intersected_ranges[i].getStart());
703 int tmpsize = file.read(b, (int) (non_intersected_ranges[i].getStart() - readrange.getStart()), (int) (non_intersected_ranges[i].getEnd() - non_intersected_ranges[i].getStart()));
705 } catch (IOException ex) {
707 //unlockLocks(heldlocks);
708 //offsetlock.unlock();
709 Logger.getLogger(TransactionalFile.class.getName()).log(Level.SEVERE, null, ex);
713 tmp.setLocaloffset(tmp.getLocaloffset() + result);
714 // unlockLocks(heldlocks);
715 // offsetlock.unlock();
717 /*synchronized(benchmark.lock){
718 benchmark.msg += Thread.currentThread().getName() + " Read from file " + this.inode + " from descriptor "+ this.sequenceNum +"\n";
720 // me.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Read from file " + this.inode + " from descriptor "+ this.sequenceNum +"\n");
724 } else { // add to the readers list
725 System.out.println("form read???");
732 public void write(byte[] data) throws IOException {
735 throw new IOException();
739 ExtendedTransaction me = Wrapper.getTransaction();
740 int size = data.length;
743 if (me == null) // not a transaction
746 non_Transactional_Write(data);
750 //else if (me.getFilesAccesses().containsKey(this.getInode())) //
752 // if (me.getStatus() != Status.ACTIVE)
753 // throw new AbortedException();
755 if (me.getGlobaltoLocalMappings().containsKey(this)) //
759 Byte[] by = new Byte[size];
760 for (int i = 0; i < size; i++) {
761 by[i] = Byte.valueOf(data[i]);
763 TransactionLocalFileAttributes tmp = ((TransactionLocalFileAttributes) (me.getGlobaltoLocalMappings().get(this)));
766 newwriterange = new Range((((Range) (tm.firstKey())).getStart()), (((Range) (tm.firstKey())).getEnd()) + size);
767 Range range = new Range((((Range) (tm.firstKey())).getStart()), (((Range) (tm.firstKey())).getEnd()));
768 Byte[] appenddata = new Byte[(int) (newwriterange.getEnd() - newwriterange.getStart())];
769 Byte[] tempor = new Byte[(int) (range.getEnd() - range.getStart())];
770 System.arraycopy(tempor, 0, appenddata, 0, tempor.length);
771 System.arraycopy(by, 0, appenddata, tempor.length, by.length);
773 tm.put(newwriterange, appenddata);
774 tmp.setLocaloffset(loffset + size);
775 tmp.setFilelength(tmp.getFilelength() + size);
780 if (((Vector)(me.getWriteBuffer().get(this.inode))) != null){
781 dummy = new Vector((Vector)(me.getWriteBuffer().get(this.inode)));
784 dummy = new Vector();
785 /* synchronized(benchmark.lock){
786 System.out.println(Thread.currentThread() + " gg " + tmp.getLocaloffset() + " " + (tmp.getLocaloffset()+by.length));
788 /*if (!(tmp.isUnknown_inital_offset_for_write())){
790 tmp.setLocaloffset(this.committedoffset.getOffsetnumber());
794 dummy.add(new WriteOperations(by, new Range(tmp.getLocaloffset(), tmp.getLocaloffset() + by.length), tmp.isUnknown_inital_offset_for_write(), this, tmp));
795 me.getWriteBuffer().put(this.inode, dummy);
797 long loffset = tmp.getLocaloffset();
800 tmp.setLocaloffset(tmp.getLocaloffset() + by.length);
802 me.merge_for_writes_done.put(inode, Boolean.FALSE);
803 //me.setWritesmerged(false);
807 if (!(tmp.isUnknown_inital_offset_for_write())){
808 markAccessedBlocks(me, loffset, size, BlockAccessModesEnum.WRITE);
809 // markWriteBlocks(loffset, size);
812 int startblock = FileBlockManager.getCurrentFragmentIndexofTheFile(loffset);
813 int targetblock = FileBlockManager.getTargetFragmentIndexofTheFile(loffset, size);
814 for (int i = startblock; i <= targetblock; i++) {
815 if (me.getAccessedBlocks().containsKey(Integer.valueOf(i))) {
816 if (((BlockAccessModesEnum) (me.getAccessedBlocks().get(Integer.valueOf(i)))) == BlockAccessModesEnum.READ) {
817 me.getAccessedBlocks().put(Integer.valueOf(i), BlockAccessModesEnum.READ_WRITE);
820 me.getAccessedBlocks().put(Integer.valueOf(i), BlockAccessModesEnum.WRITE);
821 // tmp.getBlockversions().put(Integer.valueOf(i), Integer.valueOf(getBlockDataStructure(i).getVersion().get())); //For Block Versioning Mechanism
826 if (tmp.getOffsetdependency() == OffsetDependency.NO_ACCESS)
827 tmp.offsetdependency = OffsetDependency.WRITE_DEPENDENCY_1;
831 /*if ((tmp.access_from_absolute_offset) || !(tmp.relocatablewrite))
833 int startblock = FileBlockManager.getCurrentFragmentIndexofTheFile(loffset);
834 int targetblock = FileBlockManager.getTargetFragmentIndexofTheFile(loffset, size);
835 for (int i = startblock; i <= targetblock; i++) {
836 if (tmp.getAccesedblocks().containsKey(Integer.valueOf(i))) {
837 if (((BlockAccessModesEnum) (tmp.getAccesedblocks().get(Integer.valueOf(i)))) == BlockAccessModesEnum.READ) {
838 tmp.getAccesedblocks().put(Integer.valueOf(i), BlockAccessModesEnum.READ_WRITE);
841 tmp.getAccesedblocks().put(Integer.valueOf(i), BlockAccessModesEnum.WRITE);
842 // tmp.getBlockversions().put(Integer.valueOf(i), Integer.valueOf(getBlockDataStructure(i).getVersion().get())); //For Block Versioning Mechanism
847 if (tmp.access_from_absolute_offset){
849 mergeWrittenData(tmp.getNon_Speculative_Writtendata(), data, newwriterange);
850 tmp.setLocaloffset(loffset + size);
851 if (tmp.getLocaloffset() > tmp.getFilelength()) {
852 tmp.setFilelength(tmp.getLocaloffset());
857 else // for comtimious determingin the accessed block is postpond till commit instant
859 Byte[] dd = new Byte[size];
860 System.arraycopy(by, 0, dd, 0, size);
861 if (!(tmp.getSpeculative_Writtendata().isEmpty())){
863 Range lastrange = (Range) tmp.getSpeculative_Writtendata().lastKey();
864 if (lastrange.getEnd() == newwriterange.getStart()){
865 dd = new Byte[(int)(size + lastrange.getEnd() - lastrange.getStart())];
866 System.arraycopy(((Byte[])tmp.getSpeculative_Writtendata().get(lastrange)), 0, dd, 0, (int)(lastrange.getEnd() - lastrange.getStart()));
867 System.arraycopy(by, 0, dd, (int)(lastrange.getEnd() - lastrange.getStart()), size);
868 newwriterange = new Range(lastrange.getStart(), size + lastrange.getEnd());
869 tmp.getSpeculative_Writtendata().remove(lastrange);
874 tmp.getSpeculative_Writtendata().put(newwriterange, dd);
876 tmp.setLocaloffset(loffset + size);
877 if (tmp.getLocaloffset() > tmp.getFilelength()) {
878 tmp.setFilelength(tmp.getLocaloffset());
888 if (tmp.accessmode == TransactionLocalFileAttributes.MODE.READ)
889 tmp.accessmode = TransactionLocalFileAttributes.MODE.READ_WRITE;
890 else if (tmp.accessmode == TransactionLocalFileAttributes.MODE.WRITE)
891 simpleWritetoBuffer(by, newwriterange, tm);
893 // me.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Writes to " + this.inode + " from descriptor "+ this.sequenceNum +"\n");
896 // System.out.println("form write??");
897 // me.addFile(this/*, TransactionLocalFileAttributes.MODE.WRITE*/);
898 //if (!(me.getGlobaltoLocalMappings().containsKey(this))){
899 //if (!(me.getFilesAccesses().containsKey(this.inode))) {
900 TransactionLocalFileAttributes tmp = new TransactionLocalFileAttributes(0);/*, tf.getInodestate().commitedfilesize.get();*/
903 if (me.getAccessedFiles().containsKey(this.getInode())){
904 dummy = (Vector) me.getAccessedFiles().get(this.getInode());
907 dummy = new Vector();
908 me.getAccessedFiles().put(this.getInode(), dummy);
913 // this.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Unlocked the offset lock " + tf.offsetlock + " for file " + tf.getInode() + " form descriptor " + tf.getSequenceNum());
915 me.getGlobaltoLocalMappings().put(this, tmp);
916 me.merge_for_writes_done.put(this.getInode(), Boolean.TRUE);
923 /* synchronized(benchmark.lock){
924 benchmark.msg += Thread.currentThread().getName() + " Writes to " + this.inode + " from descriptor "+ this.sequenceNum +"\n";
931 private void markAccessedBlocks(ExtendedTransaction me,long loffset, int size, BlockAccessModesEnum mode){
935 if (me.getAccessedBlocks().get(this.getInode()) != null)
936 map = (TreeMap) me.getAccessedBlocks().get(this.getInode());
939 me.getAccessedBlocks().put(this.inode, map);
941 int startblock = FileBlockManager.getCurrentFragmentIndexofTheFile(loffset);
942 int targetblock = FileBlockManager.getTargetFragmentIndexofTheFile(loffset, size);
943 for (int i = startblock; i <= targetblock; i++) {
944 if (map.containsKey(Integer.valueOf(i))){
945 if (map.get(Integer.valueOf(i)) != mode){
946 map.put(Integer.valueOf(i), BlockAccessModesEnum.READ_WRITE);
950 map.put(Integer.valueOf(i), mode);
953 /*int startblock = FileBlockManager.getCurrentFragmentIndexofTheFile(loffset);
954 int targetblock = FileBlockManager.getTargetFragmentIndexofTheFile(loffset, size);
955 for (int i = startblock; i <= targetblock; i++) {
956 if (me.getAccessedBlocks().containsKey(Integer.valueOf(i))) {
957 if (((BlockAccessModesEnum) (me.getAccessedBlocks().get(Integer.valueOf(i)))) == BlockAccessModesEnum.READ) {
958 me.getAccessedBlocks().put(Integer.valueOf(i), BlockAccessModesEnum.READ_WRITE);
963 me.getAccessedBlocks().put(Integer.valueOf(i), BlockAccessModesEnum.WRITE);
964 // tmp.getBlockversions().put(Integer.valueOf(i), Integer.valueOf(getBlockDataStructure(i).getVersion().get())); //For Block Versioning Mechanism
969 /* private void markWriteBlocks(long loffset, int size){
970 ExtendedTransaction me = CustomThread.getTransaction();
972 if (me.writeBlocks.get(this.inode) != null)
973 tt = (SortedSet) me.writeBlocks.get(this.inode);
976 me.writeBlocks.put(this.inode, tt);
979 int startblock = FileBlockManager.getCurrentFragmentIndexofTheFile(loffset);
980 int targetblock = FileBlockManager.getTargetFragmentIndexofTheFile(loffset, size);
981 for (int i = startblock; i <= targetblock; i++) {
982 tt.add(Integer.valueOf(i));
986 private int readFromFile(ExtendedTransaction me, byte[] readdata, TransactionLocalFileAttributes tmp) {
989 //ExtendedTransaction me = Wrapper.getTransaction();
990 int st = FileBlockManager.getCurrentFragmentIndexofTheFile(tmp.getLocaloffset());
991 int end = FileBlockManager.getTargetFragmentIndexofTheFile(tmp.getLocaloffset(), readdata.length);
993 BlockDataStructure block = null;
994 boolean locked = false;
995 for (int k = st; k <= end; k++) {
996 // int expvalue = ((Integer) tmp.getBlockversions().get(Integer.valueOf(k))).intValue(); // all comments here for versioning mechanism
997 while (me.getStatus() == Status.ACTIVE) {
998 //BlockDataStructure block = ((BlockDataStructure) this.inodestate.lockmap.get(Integer.valueOf(k)));
999 // BlockDataStructure block;
1000 //if (me.getAccessedBlocks().get(inode))
1001 block = this.inodestate.getBlockDataStructure(Integer.valueOf(k));
1003 block.getLock().readLock().lock();
1004 // me.getHeldblocklocks().add(block.getLock().readLock());
1005 if (!(block.getReaders().contains(me))){
1006 block.getReaders().add(me);
1009 // if (!(block.getVersion().get() == expvalue)) {
1016 me.getContentionmanager().resolveConflict(me, block);
1020 if (me.getStatus() == Status.ABORTED) {
1027 for (int i=st; i<m; i++){
1028 /* System.out.println("///////////////////");
1029 synchronized(benchmark.lock){
1030 System.out.println(block.getBlocknumber() + " =? " + i);
1032 block = this.inodestate.getBlockDataStructure(Integer.valueOf(k));
1033 me.getHeldblocklocks().add(block.getLock().readLock());
1034 // System.out.println("///////////////////");
1039 throw new AbortedException();
1043 if (me.getStatus() == Status.ABORTED) {
1044 for (int i=st; i<=end; i++){
1045 block = this.inodestate.getBlockDataStructure(Integer.valueOf(i));
1046 me.getHeldblocklocks().add(block.getLock().readLock());
1048 throw new AbortedException();
1053 //ByteBuffer buffer = ByteBuffer.wrap(readdata);
1054 //size = file.getChannel().read(buffer, tmp.getLocaloffset());
1055 size = invokeNativepread(readdata, tmp.getLocaloffset(), readdata.length);
1057 // synchronized(benchmark.lock){
1058 // if (Integer.valueOf(Thread.currentThread().getName().substring(7)) == 0)
1059 /* for (int i =0; i<readdata.length; i++)
1060 System.out.println(Thread.currentThread() + " " + (char)readdata[i]);
1062 // file.seek(tmp.getLocaloffset());
1063 // size = file.read(readdata);
1065 tmp.setLocaloffset(tmp.getLocaloffset() + size);
1071 /* while (it.hasNext()) {
1073 Lock lock = (Lock) it.next();
1076 // me.getHeldblocklocks().clear();
1079 if (me.getStatus() == Status.ABORTED) {
1080 for (int i=st; i<=end; i++){
1081 block = this.inodestate.getBlockDataStructure(Integer.valueOf(i));
1082 me.getHeldblocklocks().add(block.getLock().readLock());
1084 throw new AbortedException();
1086 for (int k = st; k <= end; k++) {
1087 block = this.inodestate.getBlockDataStructure(Integer.valueOf(k));
1088 block.getLock().readLock().unlock();
1095 private int readFromBuffer(byte[] readdata, TransactionLocalFileAttributes tmp, WriteOperations wrp, Range writerange) {
1096 /*synchronized(benchmark.lock){
1097 System.out.println("in read buffer " + Thread.currentThread());
1100 long loffset = tmp.getLocaloffset();
1102 Byte[] data = (Byte[]) wrp.getData();
1103 byte[] copydata = new byte[data.length];
1105 for (int i = 0; i < data.length; i++) {
1106 copydata[i] = data[i].byteValue();
1108 System.arraycopy(copydata, (int) (loffset - writerange.getStart()), readdata, 0, readdata.length);
1109 tmp.setLocaloffset(tmp.getLocaloffset() + readdata.length);
1110 return readdata.length;
1114 public void simpleWritetoBuffer(Byte[] data, Range newwriterange, TreeMap tm) {
1115 tm.put(newwriterange, data);
1118 public void unlockLocks(Vector heldlocks) {
1119 for (int i = 0; i < heldlocks.size(); i++) {
1120 ((Lock) heldlocks.get(i)).unlock();
1125 /* public boolean validateBlocksVersions(int startblock, int targetblock) { // For Block Versioning Mechanism
1126 boolean valid = true;
1127 ExtendedTransaction me = ExtendedTransaction.getTransaction();
1128 TransactionLocalFileAttributes tmp = ((TransactionLocalFileAttributes) (me.getFilesAccesses().get(this.getInode())));
1129 for (int i = startblock; i <= targetblock; i++) {
1130 int expvalue = ((Integer) tmp.getBlockversions().get(Integer.valueOf(i))).intValue();
1131 BlockDataStructure block = ((BlockDataStructure) tmp.adapter.lockmap.get(Integer.valueOf(i)));
1132 if (expvalue != block.getVersion().get()) {
1143 public void setInode(INode inode) {
1147 public void lockOffset(ExtendedTransaction me){
1149 // System.out.println(Integer.getInteger(me.getStatus().toString()));
1150 // lo.lockWhen(sequenceNum);
1151 boolean locked = false;
1152 while (me.getStatus() == Status.ACTIVE) { //locking the offset
1153 //synchronized(this.commitedoffset){
1154 // System.out.println("Trying");
1156 // offsetlock.lockInterruptibly();
1159 // catch(InterruptedException e){
1160 // System.out.println("dsadsa");
1163 //me.getHeldoffsetlocks().add(offsetlock);
1169 // if (offsetlock.tryLock()) {
1170 // synchronized(this.commitedoffset){
1171 // this.commitedoffset.setOffsetOwner(me);
1172 //System.out.println(Thread.currentThread().getName() + " grabbd the lock");
1174 /* synchronized(benchmark.lock){
1175 benchmark.msg += Thread.currentThread().getName() + " Locked the offset lock for " + this.inode + " from descriptor "+ this.sequenceNum +"\n";
1177 /* synchronized(benchmark.lock){
1178 System.out.println(Thread.currentThread() + "LOCked the offset lock " + offsetlock);
1181 //offsetlocks.add(offsetlock);
1182 // me.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Locked the offset lock for file " + this.inode + " from descriptor "+ this.sequenceNum +"\n");
1186 //me.getContentionmanager().resolveConflict(me, this.commitedoffset);
1189 // if (me.getStatus() != Status.ACTIVE){
1191 // me.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Aborted in lock offset\n");
1192 /*synchronized(benchmark.lock){
1193 benchmark.msg += Thread.currentThread().getName() + " Aborted \n";
1195 // CustomThread.getTransaction().setStatus(Status.ACTIVE);
1196 // CustomThread.getProgram().execute();
1197 // if (offsetlock.isHeldByCurrentThread())
1199 // offsetlock.unlock();
1200 //unlockOffsetLocks();
1201 /* synchronized(benchmark.lock){
1202 System.out.println("aborting " + committedoffset + " " +Thread.currentThread());
1204 //Thread.currentThread().stop();
1205 if (me.getStatus() != Status.ACTIVE){
1207 me.getHeldoffsetlocks().add(offsetlock);
1208 throw new AbortedException();
1214 public void mergeWrittenData(ExtendedTransaction me/*TreeMap target, byte[] data, Range to_be_merged_data_range*/){
1216 //ExtendedTransaction me = Wrapper.getTransaction();
1217 boolean flag = false;
1218 Vector vec = (Vector) me.getWriteBuffer().get(this.inode);
1219 Range intersectedrange = new Range(0, 0);
1220 Iterator it1 = vec.iterator();
1221 WriteOperations wrp;
1222 WriteOperations wrp2;
1223 Vector toberemoved = new Vector();
1224 while (it1.hasNext()) {
1225 wrp = (WriteOperations) (it1.next());
1227 if (toberemoved.contains(wrp)){
1231 Iterator it2 = vec.listIterator();
1232 while (it2.hasNext()) {
1234 wrp2 = (WriteOperations) (it2.next());
1235 /*if (wrp2.getRange().includes(wrp.getRange())) {
1237 intersect = wrp2.getRange().intersection(wrp.getRange());
1241 if ((wrp2 == wrp) || toberemoved.contains(wrp2)){
1245 if (wrp.getRange().hasIntersection(wrp2.getRange())) {
1247 intersectedrange = wrp2.getRange().intersection(wrp.getRange());
1248 toberemoved.add(wrp2);
1252 long startprefix = 0;
1254 long startsuffix = 0;
1257 int intermediatesize = 0;
1258 Byte[] prefixdata = null;
1259 Byte[] suffixdata = null;
1260 boolean prefix = false;
1261 boolean suffix = false;
1265 if (wrp.getRange().getStart() < wrp2.getRange().getStart()) {
1266 prefixdata = new Byte[(int) (wrp2.getRange().getStart() - wrp.getRange().getStart())];
1267 prefixdata = (Byte[]) (wrp.getData());
1268 startprefix = wrp.getRange().getStart();
1269 prefixsize = (int)(intersectedrange.getStart() - startprefix);
1270 intermediatesize = (int)(intersectedrange.getEnd() -intersectedrange.getStart());
1274 else if (wrp2.getRange().getStart() <= wrp.getRange().getStart()) {
1275 prefixdata = new Byte[(int) (wrp.getRange().getStart() - wrp2.getRange().getStart())];
1276 prefixdata = (Byte[]) (wrp2.getData());
1277 startprefix = wrp2.getRange().getStart();
1278 prefixsize = (int)(intersectedrange.getStart() - startprefix);
1279 intermediatesize = (int)(intersectedrange.getEnd() -intersectedrange.getStart());
1283 if (wrp2.getRange().getEnd() >= wrp.getRange().getEnd()) {
1285 suffixdata = new Byte[(int) (wrp2.getRange().getEnd() - intersectedrange.getEnd())];
1286 suffixdata = (Byte[]) (wrp2.getData());
1287 startsuffix = intersectedrange.getEnd() - wrp2.getRange().getStart();
1288 suffixsize = (int)(wrp2.getRange().getEnd() - intersectedrange.getEnd());
1290 //System.out.println("wrp2 > wrp");
1292 endsuffix = wrp2.getRange().getEnd();
1293 //suffixstart = (int) (intersectedrange[i].getEnd() - intersectedrange[i].getStart());
1296 else if (wrp.getRange().getEnd() > wrp2.getRange().getEnd()) {
1297 suffixdata = new Byte[(int) (wrp.getRange().getEnd() - intersectedrange.getEnd())];
1298 suffixdata = (Byte[]) (wrp.getData());
1299 startsuffix = intersectedrange.getEnd() - wrp.getRange().getStart();
1300 suffixsize = (int)(wrp.getRange().getEnd() - intersectedrange.getEnd());
1301 // System.out.println("wrp2 < wrp");
1302 endsuffix = wrp.getRange().getEnd();
1306 /* System.out.println("prefix start:" + startprefix);
1307 System.out.println("suffix end:" + endsuffix);
1308 System.out.println("suffix start:" + startsuffix);
1309 System.out.println("intermediate start:" + intermediatetart);
1311 System.out.println("suffix size:" + suffixsize);*/
1314 Byte[] data_to_insert;
1316 if ((prefix) && (suffix)) {
1317 data_to_insert = new Byte[(int) (endsuffix - startprefix)];
1318 System.arraycopy(prefixdata, 0, data_to_insert, 0, prefixsize);
1319 System.arraycopy(wrp2.getData(), (int)(intersectedrange.getStart() - wrp2.getRange().getStart()), data_to_insert, prefixsize, intermediatesize);
1320 System.arraycopy(suffixdata, (int)startsuffix, data_to_insert, (prefixsize + intermediatesize), suffixsize);
1321 wrp.setData(data_to_insert);
1322 wrp.setRange(new Range(startprefix, endsuffix));
1328 Iterator it = toberemoved.iterator();
1329 while (it.hasNext())
1330 vec.remove(it.next());
1332 toberemoved.clear();
1333 Collections.sort(vec);
1334 me.merge_for_writes_done.put(inode, Boolean.TRUE);
1335 //me.setWritesmerged(true);
1337 /*} else if (prefix) {
1338 data_to_insert = new Byte[(int) (to_be_merged_data_range.getStart() - start + size)];
1339 System.arraycopy(prefixdata, 0, data_to_insert, 0, (int) (to_be_merged_data_range.getStart() - start));
1340 System.arraycopy(by, 0, data_to_insert, (int) (to_be_merged_data_range.getStart() - start), size);
1341 to_be_merged_data_range.setStart(start);
1342 } else if (suffix) {
1343 data_to_insert = new Byte[(int) (to_be_merged_data_range.getEnd() - end + size)];
1344 System.arraycopy(by, 0, data_to_insert, 0, size);
1345 System.arraycopy(suffixdata, suffixstart, data_to_insert, size, (int) (end - to_be_merged_data_range.getEnd()));
1346 to_be_merged_data_range.setEnd(end);
1348 data_to_insert = new Byte[size];
1349 System.arraycopy(data_to_insert, (int) (to_be_merged_data_range.getStart() - start), by, 0, size);
1351 //target.put(to_be_merged_data_range, data_to_insert);
1355 int datasize = (int) (oldwriterange.getEnd() - oldwriterange.getStart());
1356 Byte[] original = (Byte[]) (wrp.getData());
1357 byte[] originaldata = new byte[datasize];
1359 //for (int i = 0; i < data.length; i++) {
1360 // originaldata[i] = original[i].byteValue();
1362 System.arraycopy(data, 0, originaldata, (int) (to_be_merged_data_range.getStart() - oldwriterange.getStart()), size);
1363 Byte[] to_be_inserted = new Byte[datasize];
1365 for (int i = 0; i < datasize; i++) {
1366 to_be_inserted[i] = Byte.valueOf(originaldata[i]);
1368 target.put(oldwriterange, to_be_inserted);
1371 } else if (counter == 0) {
1372 target.put(to_be_merged_data_range, data);
1377 int suffixstart = 0;
1380 Byte[] prefixdata = null;
1381 Byte[] suffixdata = null;
1382 boolean prefix = false;
1383 boolean suffix = false;
1385 for (int i = 0; i < counter; i++) {
1386 if (markedwriteranges[i].getStart() < to_be_merged_data_range.getStart()) {
1387 prefixdata = new Byte[(int) (to_be_merged_data_range.getStart() - markedwriteranges[i].getStart())];
1388 prefixdata = (Byte[]) (target.get(markedwriteranges[i]));
1389 start = markedwriteranges[i].getStart();
1390 //newdata = new Byte[size + newwriterange.getStart() - markedwriteranges[i].getStart()];
1391 //System.arraycopy(by, 0, newdata, newwriterange.getStart() - markedwriteranges[i].getStart(), size);
1392 //System.arraycopy(originaldata, 0, newdata, 0, newwriterange.getStart() - markedwriteranges[i].getStart());
1394 //newwriterange.setStart(markedwriteranges[i].getStart());
1398 } else if (markedwriteranges[i].getEnd() > to_be_merged_data_range.getEnd()) {
1400 suffixdata = new Byte[(int) (markedwriteranges[i].getStart() - to_be_merged_data_range.getStart())];
1401 suffixdata = (Byte[]) (target.get(markedwriteranges[i]));
1402 end = markedwriteranges[i].getEnd();
1404 //Byte [] originaldata = (Byte [])(tmp.getWrittendata().get(markedwriteranges[i]));
1405 //newdata = new Byte[size + newwriterange.getStart() - markedwriteranges[i].getStart()];
1406 //System.arraycopy(originaldata, 0, newdata, 0, newwriterange.getStart() - markedwriteranges[i].getStart());
1408 //newwriterange.setStart(markedwriteranges[i].getStart());
1409 ///newwriterange.setEnd(markedwriteranges[i].getEnd());
1411 suffixstart = (int) (intersectedrange[i].getEnd() - intersectedrange[i].getStart());
1412 //tm.remove(markedwriteranges[i]);
1414 target.remove(markedwriteranges[i]);
1417 Byte[] data_to_insert;
1419 if ((prefix) && (suffix)) {
1420 data_to_insert = new Byte[(int) (to_be_merged_data_range.getStart() - start + size - to_be_merged_data_range.getEnd() + end)];
1421 System.arraycopy(prefixdata, 0, data_to_insert, 0, (int) (to_be_merged_data_range.getStart() - start));
1422 System.arraycopy(by, 0, data_to_insert, (int) (to_be_merged_data_range.getStart() - start), size);
1423 System.arraycopy(suffixdata, suffixstart, data_to_insert, (int) (size + to_be_merged_data_range.getStart() - start), (int) (end - to_be_merged_data_range.getEnd()));
1424 to_be_merged_data_range.setStart(start);
1425 to_be_merged_data_range.setEnd(end);
1426 } else if (prefix) {
1427 data_to_insert = new Byte[(int) (to_be_merged_data_range.getStart() - start + size)];
1428 System.arraycopy(prefixdata, 0, data_to_insert, 0, (int) (to_be_merged_data_range.getStart() - start));
1429 System.arraycopy(by, 0, data_to_insert, (int) (to_be_merged_data_range.getStart() - start), size);
1430 to_be_merged_data_range.setStart(start);
1431 } else if (suffix) {
1432 data_to_insert = new Byte[(int) (to_be_merged_data_range.getEnd() - end + size)];
1433 System.arraycopy(by, 0, data_to_insert, 0, size);
1434 System.arraycopy(suffixdata, suffixstart, data_to_insert, size, (int) (end - to_be_merged_data_range.getEnd()));
1435 to_be_merged_data_range.setEnd(end);
1437 data_to_insert = new Byte[size];
1438 System.arraycopy(data_to_insert, (int) (to_be_merged_data_range.getStart() - start), by, 0, size);
1440 target.put(to_be_merged_data_range, data_to_insert);
1446 public void non_Transactional_Write(byte[] data){
1448 Vector heldlocks = new Vector();
1449 boolean flag = true;
1451 int startblock = FileBlockManager.getCurrentFragmentIndexofTheFile(committedoffset.getOffsetnumber());
1452 int targetblock = FileBlockManager.getTargetFragmentIndexofTheFile(committedoffset.getOffsetnumber(), data.length);
1453 for (int i = startblock; i <= targetblock; i++) {
1454 BlockDataStructure block =this.inodestate.getBlockDataStructure(i);
1455 //if (block.getLock().writeLock().tryLock()) {
1456 block.getLock().writeLock().lock();
1457 heldlocks.add(block.getLock().writeLock());
1459 // unlockLocks(heldlocks);
1460 // offsetlock.unlock();
1467 throw new PanicException("The I/O operation could not be done to contention for the file");
1473 file.seek(committedoffset.getOffsetnumber());
1476 committedoffset.setOffsetnumber(committedoffset.getOffsetnumber() +data.length);
1478 } catch (IOException ex) {
1479 Logger.getLogger(TransactionalFile.class.getName()).log(Level.SEVERE, null, ex);
1481 unlockLocks(heldlocks);
1482 offsetlock.unlock();
1487 public int non_Transactional_Read(byte[] b){
1489 Vector heldlocks = new Vector();
1490 boolean flag = true;
1494 startblock = FileBlockManager.getCurrentFragmentIndexofTheFile(committedoffset.getOffsetnumber());
1495 targetblock = FileBlockManager.getTargetFragmentIndexofTheFile(committedoffset.getOffsetnumber(), size);
1496 /* long offset = committedoffset.getOffsetnumber();
1497 committedoffset.setOffsetnumber(committedoffset.getOffsetnumber() +b.length);
1498 if (!(committedoffset.getOffsetReaders().isEmpty())){
1499 Iterator it2 = committedoffset.getOffsetReaders().iterator(); // for visible readers strategy
1500 while ( it2.hasNext())
1502 ExtendedTransaction tr = (ExtendedTransaction) it2.next();
1505 committedoffset.getOffsetReaders().clear();
1507 offsetlock.unlock();*/
1509 for (int i = startblock; i <= targetblock; i++) {
1510 BlockDataStructure block = this.inodestate.getBlockDataStructure(i);
1511 //if (block.getLock().readLock().tryLock()) {
1512 block.getLock().readLock().lock();
1513 heldlocks.add(block.getLock().readLock());
1515 unlockLocks(heldlocks);
1516 offsetlock.unlock();
1528 //ByteBuffer buffer = ByteBuffer.wrap(b);
1529 //System.out.println(committedoffset.getOffsetnumber());
1530 //size = file.getChannel().read(buffer, offset);
1531 //file.seek(committedoffset.getOffsetnumber());
1532 // size = file.read(b);
1533 size = invokeNativepread(b, committedoffset.getOffsetnumber(), b.length);
1536 committedoffset.setOffsetnumber(committedoffset.getOffsetnumber() +size);
1537 if (!(committedoffset.getOffsetReaders().isEmpty())){
1538 Iterator it2 = committedoffset.getOffsetReaders().iterator(); // for visible readers strategy
1539 while ( it2.hasNext())
1541 ExtendedTransaction tr = (ExtendedTransaction) it2.next();
1544 committedoffset.getOffsetReaders().clear();
1547 // } catch (IOException ex) {
1548 // Logger.getLogger(TransactionalFile.class.getName()).log(Level.SEVERE, null, ex);
1551 unlockLocks(heldlocks);
1552 offsetlock.unlock();
1561 public void non_Transactional_Seek(long offset){
1564 //file.seek(offset);
1565 //synchronized(adapter){
1566 committedoffset.setOffsetnumber(offset);
1567 // inodestate.commitedfilesize.set(offset);
1569 //} catch (IOException ex) {
1570 /// Logger.getLogger(TransactionalFile.class.getName()).log(Level.SEVERE, null, ex);
1572 offsetlock.unlock();
1576 public long non_Transactional_getFilePointer(){
1583 //synchronized(adapter){
1584 offset = committedoffset.getOffsetnumber();
1586 // } catch (IOException ex) {
1587 // Logger.getLogger(TransactionalFile.class.getName()).log(Level.SEVERE, null, ex);
1589 offsetlock.unlock();
1594 public int compareTo(Object arg0) {
1595 TransactionalFile tf = (TransactionalFile) arg0;
1596 if (this.inode.getNumber() < tf.inode.getNumber())
1598 else if (this.inode.getNumber() > tf.inode.getNumber())
1601 if (this.sequenceNum < tf.sequenceNum)