From: navid Date: Mon, 24 Nov 2008 22:25:12 +0000 (+0000) Subject: *** empty log message *** X-Git-Tag: buildscript^7~7 X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=8d08e020229ffec1429c3e02a9e53555d446239b;p=IRC.git *** empty log message *** --- diff --git a/Robust/Transactions/NativeFunctions.c b/Robust/Transactions/NativeFunctions.c new file mode 100644 index 00000000..61465771 --- /dev/null +++ b/Robust/Transactions/NativeFunctions.c @@ -0,0 +1,77 @@ +/* + * File: HelloWorld.cpp + * Author: navid + * + * Created on September 3, 2008, 2:17 PM + */ + + #include + #include + #include + #include + #include + #include + #include + #include "NativeFunctions.h" + + JNIEXPORT jlong JNICALL Java_TransactionalIO_core_TransactionalFileWrapperFactory_getINodeNative + (JNIEnv *env, jobject obj, jstring filename) + { + struct stat status_buf; + jlong inodenum; + // stat("/home/navid/myfile.txt",&status_buf); + char *str = (*env)->GetStringUTFChars(env, filename, 0); +// printf("\n"); +// printf("File Name is: %s \n", str); + if (stat(str,&status_buf)<0) + inodenum = -1; + else + { +// printf("Inode number is: %lu \n", status_buf.st_ino); + inodenum = status_buf.st_ino; + } + (*env)->ReleaseStringUTFChars(env, filename, str); + return inodenum; + } + + + JNIEXPORT jint JNICALL Java_TransactionalIO_core_TransactionalFile_nativepread(JNIEnv *env, jobject obj2, jbyteArray buff, jlong offset, jint size, jobject fobj ) { + signed char str[200]; + size_t nativesize = size; + off_t nativeoffset =offset; + + + jclass cls2 = (*env) ->GetObjectClass(env, fobj); + + + jfieldID fid3 = (*env)->GetFieldID(env, cls2,"fd", "I"); + + jobject fp = (*env)->GetIntField(env, fobj, fid3); + + int res = pread((int)fp, str,nativesize ,nativeoffset); + + (*env) -> SetByteArrayRegion(env, buff, 0, res, str); + + return res; + } + + JNIEXPORT jint JNICALL Java_TransactionalIO_core_ExtendedTransaction_nativepwrite(JNIEnv *env, jobject obj2, jbyteArray buff, jlong offset, jint size, jobject fobj ) { + + jbyteArray str; + size_t nativesize = (*env)->GetArrayLength(env, buff); + off_t nativeoffset =offset; + + + jclass cls2 = (*env) ->GetObjectClass(env, fobj); + + str = (*env) -> GetByteArrayElements(env, buff, NULL); + + jfieldID fid3 = (*env)->GetFieldID(env, cls2,"fd", "I"); + + jobject fp = (*env)->GetIntField(env, fobj, fid3); + + int res = pwrite((int)fp, str,nativesize ,nativeoffset); + + + return res; + } diff --git a/Robust/Transactions/TransactionalIO/dist/TransactionalIO.jar b/Robust/Transactions/TransactionalIO/dist/TransactionalIO.jar index df7a3390..ee602652 100644 Binary files a/Robust/Transactions/TransactionalIO/dist/TransactionalIO.jar and b/Robust/Transactions/TransactionalIO/dist/TransactionalIO.jar differ diff --git a/Robust/Transactions/TransactionalIO/src/TransactionalIO/core/ExtendedTransaction.java b/Robust/Transactions/TransactionalIO/src/TransactionalIO/core/ExtendedTransaction.java index e7f11488..9a9ce7b6 100644 --- a/Robust/Transactions/TransactionalIO/src/TransactionalIO/core/ExtendedTransaction.java +++ b/Robust/Transactions/TransactionalIO/src/TransactionalIO/core/ExtendedTransaction.java @@ -4,10 +4,6 @@ */ package TransactionalIO.core; - - - - import TransactionalIO.exceptions.AbortedException; import TransactionalIO.benchmarks.benchmark; import TransactionalIO.benchmarks.customhandler; @@ -41,62 +37,48 @@ import java.util.logging.Logger; * @author navid */ public class ExtendedTransaction implements TransactionStatu { - - + private native int nativepwrite(byte buff[], long offset, int size, FileDescriptor fd); + { System.load("/home/navid/libkooni.so"); } - private boolean flag = true; - public TransactionStatu memorystate; + public TransactionStatu memorystate; private PropertyChangeSupport changes = new PropertyChangeSupport(this); public int starttime; public int endtime; - public TreeMap msg = new TreeMap(); public int numberofwrites; public int numberofreads; - - public enum Status {ABORTED, ACTIVE, COMMITTED}; + + public enum Status { + + ABORTED, ACTIVE, COMMITTED + }; private boolean writesmerged = true; - //private Vector heldoffsetlocks; - private Vector heldoffsetlocks; - + private Vector heldoffsetlocks; //private Vector heldblocklocks; private Vector heldblocklocks; - //private HashMap> AccessedFiles; - private HashMap AccessedFiles; - - + private HashMap AccessedFiles; //private HashMap > accessedBlocks; - private HashMap accessedBlocks; - - //private HashMap LocaltoGlobalMappings; + private HashMap accessedBlocks; + //private HashMap LocaltoGlobalMappings; private HashMap GlobaltoLocalMappings; - public HashMap merge_for_writes_done; - - - - private HashMap writeBuffer; - private ContentionManager contentionmanager; private /*volatile*/ Status status; - private int id; - - public ExtendedTransaction() { - // super(); - // id = Integer.valueOf(Thread.currentThread().getName().substring(7)); - heldblocklocks = new Vector() ; - heldoffsetlocks= new Vector(); + // super(); + // id = Integer.valueOf(Thread.currentThread().getName().substring(7)); + heldblocklocks = new Vector(); + heldoffsetlocks = new Vector(); AccessedFiles = new HashMap(); GlobaltoLocalMappings = new HashMap/**/(); writeBuffer = new HashMap(); @@ -104,92 +86,56 @@ public class ExtendedTransaction implements TransactionStatu { accessedBlocks = new HashMap(); merge_for_writes_done = new HashMap(); writesmerged = true; - // setContentionmanager(new BaseManager()); + // setContentionmanager(new BaseManager()); // beginTransaction(); - + } - - public ExtendedTransaction(TransactionStatu memorystate){ + + public ExtendedTransaction(TransactionStatu memorystate) { this(); - /* heldblocklocks = new Vector() ; - heldoffsetlocks= new Vector(); - AccessedFiles = new HashMap(); - GlobaltoLocalMappings = new HashMap(); - writeBuffer = new HashMap(); - status = Status.ACTIVE; - accessedBlocks = new HashMap(); - merge_for_writes_done = new HashMap(); - writesmerged = true;*/ - this.memorystate = memorystate ; + + this.memorystate = memorystate; } - - private int invokeNativepwrite(byte buff[], long offset, int size, RandomAccessFile file) { + + private int invokeNativepwrite(byte buff[], long offset, int size, RandomAccessFile file) { try { - //System.out.println(buff.length); - // System.out.println(offset); return nativepwrite(buff, offset, buff.length, file.getFD()); } catch (IOException ex) { - + Logger.getLogger(TransactionalFile.class.getName()).log(Level.SEVERE, null, ex); return -1; } - + } - - public void beginTransaction(){ + + public void beginTransaction() { this.addPropertyChangeListener(new customhandler(Status.ABORTED)); } - - - - + public void abort() { - synchronized(this){ - // Status oldst = getStatus(); - /* synchronized(benchmark.lock){ - System.out.println("be ga raftim 0"); - }*/ + synchronized (this) { + this.status = Status.ABORTED; - if (this.memorystate !=null && !(this.memorystate).isAborted()){ - /* synchronized(benchmark.lock){ - System.out.println(Thread.currentThread() +" be ga raftim 1 file"); - }*/ + if (this.memorystate != null && !(this.memorystate).isAborted()) { this.memorystate.abortThisSystem(); - /* synchronized(benchmark.lock){ - System.out.println(Thread.currentThread() + " be ga raftim 2 file"); - }*/ } - // Thread[] group = new Thread[30]; - // Thread.currentThread().enumerate(group); - // group[this.id].interrupt(); - /*synchronized(benchmark.lock){ - System.out.println("/////////////"); - System.out.println(Thread.currentThread() + " " +Thread.currentThread().enumerate(group)); - System.out.println(Thread.currentThread() + " " +group[0]); - System.out.println(Thread.currentThread() + " " +group[1]); - System.out.println(Thread.currentThread() + " " +group[2]); - System.out.println("/////////////"); - }*/ - - - // this.changes.firePropertyChange("status", oldst, Status.ABORTED); + } } - + public Status getStatus() { return status; } - + public boolean isActive() { return this.getStatus() == Status.ACTIVE; } - - + public boolean isAborted() { return this.getStatus() == Status.ABORTED; } - + public ContentionManager getContentionmanager() { return contentionmanager; } @@ -197,16 +143,15 @@ public class ExtendedTransaction implements TransactionStatu { public void setContentionmanager(ContentionManager contentionmanager) { this.contentionmanager = contentionmanager; } - public HashMap getWriteBuffer() { return writeBuffer; } - + public HashMap getAccessedFiles() { return AccessedFiles; } - + public boolean isWritesmerged() { return writesmerged; } @@ -215,11 +160,6 @@ public class ExtendedTransaction implements TransactionStatu { this.writesmerged = writesmerged; } - - - - - public HashMap getGlobaltoLocalMappings() { return GlobaltoLocalMappings; } @@ -228,31 +168,26 @@ public class ExtendedTransaction implements TransactionStatu { return accessedBlocks; } - - public ContentionManager getBlockContentionManager(){ + public ContentionManager getBlockContentionManager() { return ManagerRepository.getBlockcm(); } - - public ContentionManager getOffsetContentionManager(){ + + public ContentionManager getOffsetContentionManager() { return ManagerRepository.getOffsetcm(); } - + public TreeMap getSortedFileAccessMap(HashMap hmap) { /*TreeMap sortedMap = new TreeMap(hmap); return sortedMap;*/ return new TreeMap(hmap); } - - - public void setStatus(Status st){ + + public void setStatus(Status st) { Status oldst = getStatus(); this.status = st; this.changes.firePropertyChange("status", oldst, st); } - - - public void addFile(TransactionalFile tf, long offsetnumber/*, TransactionLocalFileAttributes tmp*/) { TransactionLocalFileAttributes tmp = new TransactionLocalFileAttributes(offsetnumber/*, tf.getInodestate().commitedfilesize.get()*/); @@ -269,294 +204,122 @@ public class ExtendedTransaction implements TransactionStatu { merge_for_writes_done.put(tf.getInode(), Boolean.TRUE); } - public boolean lockOffsets() { /// Locking offsets for File Descriptors TreeMap hm = getSortedFileAccessMap(AccessedFiles); - Iterator iter = hm.keySet().iterator(); - + Iterator iter = hm.keySet().iterator(); + while (iter.hasNext() && (this.getStatus() == Status.ACTIVE)) { INode key = (INode) iter.next(); - + Vector vec = (Vector) AccessedFiles.get(key); Collections.sort(vec); Iterator it = vec.iterator(); - while (it.hasNext()){ + while (it.hasNext()) { TransactionalFile value = (TransactionalFile) it.next(); - while (this.getStatus() ==Status.ACTIVE){ - //if (value.offsetlock.tryLock()) { + while (this.getStatus() == Status.ACTIVE) { value.offsetlock.lock(); - - // synchronized(value.getCommitedoffset()){ - // value.getCommitedoffset().setOffsetOwner(this); - - // this.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Locked the offset lock in commit for file " + value.getInode() + " from descriptor "+ value.getSequenceNum() +"\n"); - heldoffsetlocks.add(value.offsetlock); - - //else - // getContentionmanager().resolveConflict(this, value.getCommitedoffset()); - break; - //} - } - if (this.getStatus() != Status.ACTIVE){ - - - return false; - } - } - // outercounter++; - } - if (this.getStatus() != Status.ACTIVE){ - - - return false; - } - return true; - } - - /*public boolean commit() { /// Locking offsets for File Descriptors - Map hm = getSortedFileAccessMap(FilesAccesses); - //lock phase - Iterator iter = hm.keySet().iterator(); - TransactionLocalFileAttributes value; - while (iter.hasNext() && (this.getStatus() == Status.ACTIVE)) { - INode key = (INode) iter.next(); - value = (TransactionLocalFileAttributes) hm.get(key); - synchronized(value.getCurrentcommitedoffset()){ - if (value.offsetlock.tryLock()) { - value.getCurrentcommitedoffset().setOffsetOwner(this); - heldblocklocks.add(value.offsetlock); - Iterator it = value.getCurrentcommitedoffset().getOffsetReaders().iterator(); // for in-place aborting visible readers strategy - while (it.hasNext()) - { - ExtendedTransaction tr = (ExtendedTransaction) it.next(); - tr.abort(); - } + heldoffsetlocks.add(value.offsetlock); + break; + } - } - } - getOffsetContentionManager().resolveConflict(this, value.getCurrentcommitedoffset().getOffsetOwner()); - } - return true; - } */ - - /*public boolean commit() { /// Locking offsets for File Descriptors with checking strategy + if (this.getStatus() != Status.ACTIVE) { + - Map hm = getSortedFileAccessMap(FilesAccesses); - //lock phase - Iterator iter = hm.keySet().iterator(); - TransactionLocalFileAttributes value; - while (iter.hasNext() && (this.getStatus() == Status.ACTIVE)) { - INode key = (INode) iter.next(); - value = (TransactionLocalFileAttributes) hm.get(key); - - if (value.isValidatelocaloffset()) { - if (value.getCopylocaloffset() == value.currentcommitedoffset.getOffsetnumber()) { - value.offsetlock.lock(); - heldoffsetlocks.add(value.offsetlock); - if (!(value.getCopylocaloffset() == value.currentcommitedoffset.getOffsetnumber())) { - unlockAllLocks(); - return false; - } - } else { - unlockAllLocks(); return false; } - } else { - value.offsetlock.lock(); - heldoffsetlocks.add(value.offsetlock); } + } - }*/ + if (this.getStatus() != Status.ACTIVE) { - + return false; + } + return true; + } public boolean lockBlock(BlockDataStructure block, BlockAccessModesEnum mode/*, GlobalINodeState adapter, BlockAccessModesEnum mode, int expvalue, INode inode, TransactionLocalFileAttributes tf*/) { - - //boolean locked = false; Lock lock; - - - - if (mode == BlockAccessModesEnum.READ){ - lock = block.getLock().readLock(); - - - } - else { - + if (mode == BlockAccessModesEnum.READ) { + lock = block.getLock().readLock(); + } else { + lock = block.getLock().writeLock(); - } - + while (this.getStatus() == Status.ACTIVE) { - //synchronized(block){ - - // if (lock.tryLock()) { - lock.lock(); - // synchronized(benchmark.lock){ - // System.out.println(Thread.currentThread() + " Lock the block lock for " + lock +" number " + block.getBlocknumber()); - // } - heldblocklocks.add(lock); - // block.setOwner(this); - return true; - // } - - - //getContentionmanager().resolveConflict(this, block); + lock.lock(); + heldblocklocks.add(lock); + return true; } - return false; } - /* - public boolean lockBlock(BlockDataStructure block, Adapter adapter, BlockAccessModesEnum mode, int expvalue) { // from here for visible readers strategy - while (this.getStatus() == Status.ACTIVE) { - if (lock.tryLock()) { - Thread.onAbortOnce(new Runnable() { - - public void run() { - lock.unlock(); - } - }); - - heldblocklocks.add(lock); - - synchronized (adapter) { - block.setOwner(this); - // Iterator it = block.getReaders().iterator(); - // while (it.hasNext()) - // { - // ExtendedTransaction tr = (ExtendedTransaction) it.next(); - // tr.abort(); - // } - } - - return true; - } else { - getBlockContentionManager().resolveConflict(this, block.getOwner()); - } - } - return false;*/ - - - /* - public boolean lockBlock(BlockDataStructure block, Adapter adapter, BlockAccessModesEnum mode, int expvalue) { // versioning strat - while (this.getStatus() == Status.ACTIVE) { - if (lock.tryLock()) { - Thread.onAbortOnce(new Runnable() { - - public void run() { - lock.unlock(); - } - }); - - heldblocklocks.add(lock); - if (mode != BlockAccessModesEnum.WRITE) { egy - if (block.getVersion().get() != expvalue) { - unlockAllLocks(); - return false; - } - } - synchronized (adapter) { - block.setOwner(this); - } - - return true; - } else { - getContentionManager().resolveConflict(this, block.getOwner()); - } - } - return false; - }*/ public void prepareCommit() { - if (this.status != Status.ACTIVE) + if (this.status != Status.ACTIVE) { throw new AbortedException(); - + } boolean ok = true; - if (!lockOffsets()) - { -// unlockAllLocks(); - // this.msg.put(System.nanoTime(),Thread.currentThread().getName() + " Aborted \n"); - /* synchronized(benchmark.lock){ - benchmark.msg += Thread.currentThread().getName() + " Aborted in prepare commit\n"; - }*/ - //Thread.currentThread().stop(); + if (!lockOffsets()) { throw new AbortedException(); } - + /////////////////////////// - - + + Map hm = getWriteBuffer(); - + Iterator iter = hm.keySet().iterator(); WriteOperations value; Vector vec = new Vector(); while (iter.hasNext() && (this.getStatus() == Status.ACTIVE) && ok) { - //int expvalue = 0; - INode key = (INode) iter.next(); vec = (Vector) hm.get(key); Collections.sort(vec); Iterator it = vec.iterator(); - while (it.hasNext()){ - + while (it.hasNext()) { + value = (WriteOperations) it.next(); - if (value.isUnknownoffset()){ - + if (value.isUnknownoffset()) { + long start; long end; - - //synchronized(value.getOwnertransactionalFile().getCommitedoffset()){ - start = value.getRange().getStart() - value.getBelongingto().getCopylocaloffset() + value.getOwnertransactionalFile().getCommitedoffset().getOffsetnumber(); - end = value.getRange().getEnd() - value.getBelongingto().getCopylocaloffset() + value.getOwnertransactionalFile().getCommitedoffset().getOffsetnumber(); - if (value.getBelongingto().isUnknown_inital_offset_for_write()){ - value.getBelongingto().setLocaloffset(value.getBelongingto().getLocaloffset() - value.getBelongingto().getCopylocaloffset() + value.getOwnertransactionalFile().getCommitedoffset().getOffsetnumber()); - value.getBelongingto().setUnknown_inital_offset_for_write(false); - } - - //} - // System.out.println("start write " + start); - /// System.out.println("end write " + end); + start = value.getRange().getStart() - value.getBelongingto().getCopylocaloffset() + value.getOwnertransactionalFile().getCommitedoffset().getOffsetnumber(); + end = value.getRange().getEnd() - value.getBelongingto().getCopylocaloffset() + value.getOwnertransactionalFile().getCommitedoffset().getOffsetnumber(); + if (value.getBelongingto().isUnknown_inital_offset_for_write()) { + value.getBelongingto().setLocaloffset(value.getBelongingto().getLocaloffset() - value.getBelongingto().getCopylocaloffset() + value.getOwnertransactionalFile().getCommitedoffset().getOffsetnumber()); + value.getBelongingto().setUnknown_inital_offset_for_write(false); + } + int startblock = FileBlockManager.getCurrentFragmentIndexofTheFile(start); int targetblock = FileBlockManager.getTargetFragmentIndexofTheFile(start, value.getRange().getEnd() - value.getRange().getStart()); - + TreeMap sset; - if (this.getAccessedBlocks().get(key) != null){ - sset = (TreeMap) this.getAccessedBlocks().get(key); + if (this.getAccessedBlocks().get(key) != null) { + sset = (TreeMap) this.getAccessedBlocks().get(key); + } else { + sset = new TreeMap(); + this.getAccessedBlocks().put(key, sset); } - - else{ - sset = new TreeMap(); - this.getAccessedBlocks().put(key, sset); - } - + for (int i = startblock; i <= targetblock; i++) { - if (sset.containsKey(Integer.valueOf(i))){ - if (sset.get(Integer.valueOf(i)) != BlockAccessModesEnum.WRITE) + if (sset.containsKey(Integer.valueOf(i))) { + if (sset.get(Integer.valueOf(i)) != BlockAccessModesEnum.WRITE) { sset.put(Integer.valueOf(i), BlockAccessModesEnum.READ_WRITE); - } - else + } + } else { sset.put(Integer.valueOf(i), BlockAccessModesEnum.WRITE); - - // tt.add(Integer.valueOf(i)); + } } - + value.getRange().setStart(start); value.getRange().setEnd(end); - - // System.out.println(Thread.currentThread().); - // System.out.println(value.getRange().getStart()); - // System.out.println(value.getRange().getEnd()); - // System.out.println("---------------"); - //this.getAccessedBlocks().put(value.getOwnertransactionalFile().getInode(), sset); } } @@ -564,250 +327,83 @@ public class ExtendedTransaction implements TransactionStatu { Iterator it = this.getAccessedBlocks().keySet().iterator(); while (it.hasNext() && (this.getStatus() == Status.ACTIVE)) { - INode inode = (INode) it.next(); - GlobalINodeState inodestate = TransactionalFileWrapperFactory.getTateransactionalFileINodeState(inode); - TreeMap vec2 = (TreeMap) this.getAccessedBlocks().get(inode); - Iterator iter2 = vec2.keySet().iterator(); - while(iter2.hasNext()){ - Integer num = (Integer) iter2.next(); - - //BlockDataStructure blockobj = (BlockDataStructure) inodestate.lockmap.get(num); - BlockDataStructure blockobj; - // if (((BlockAccessModesEnum)vec2.get(num)) == BlockAccessModesEnum.WRITE){ - blockobj = inodestate.getBlockDataStructure(num); - // } - // else - // blockobj = (BlockDataStructure) inodestate.lockmap.get(num); - - ok = this.lockBlock(blockobj, (BlockAccessModesEnum)vec2.get(num)); - if (ok == false) - break; - /* synchronized(benchmark.lock){ - benchmark.msg += Thread.currentThread().getName() + " Locked the Block Number " + blockobj.getBlocknumber() +" for " + inode + "\n"; - }*/ - // this.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Locked the Block Number " + blockobj.getBlocknumber() + " for file " + inode + "\n"); - } - } - - if (this.getStatus() != Status.ACTIVE){ - // unlockAllLocks(); - // this.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Aborted \n"); - /* synchronized(benchmark.lock){ - benchmark.msg += Thread.currentThread().getName() + " Aborted \n"; - }*/ - // Thread.currentThread().stop(); - throw new AbortedException(); - } - abortAllReaders(); - - // } - //expvalue = ((Integer) value.getBlockversions().get(it)).intValue(); //for versioning strategy - /*if (!(value.isValidatelocaloffset())) { - if (((BlockAccessModesEnum) (value.getAccesedblocks().get(blockno))) != BlockAccessModesEnum.WRITE) { //versioning strategy - - /if (blockobj.getVersion().get() == expvalue) { - - ok = this.lock(blockobj, value.adapter, (BlockAccessModesEnum) (value.getAccesedblocks().get(blockno)), expvalue); - if (ok == false) { - // unlockAllLocks(); - break; - } - } else { - ok = false; - break; - } - } else { - - ok = this.lock(blockobj, value.adapter, (BlockAccessModesEnum) (value.getAccesedblocks().get(blockno)), expvalue); - if (ok == false) { - break; - } - } - } - - - if (!(ok)) { - unlockAllLocks(); - throw new AbortedException(); - }*/ - } - - public void commitChanges(){ - - // this.msg.put(System.nanoTime(), Thread.currentThread().getName() + " is committing \n"); - - - - //synchronized(benchmark.lock){ - // System.out.println(Thread.currentThread().getName() + " is commiting"); - //} - - - Map hm = getWriteBuffer(); - Iterator iter = hm.keySet().iterator(); - Iterator it; - WriteOperations writeop; - Vector vec; - while (iter.hasNext() && (this.getStatus() == Status.ACTIVE)) { - INode key = (INode) iter.next(); - - vec = (Vector) hm.get(key); - Collections.sort(vec); - it = vec.iterator(); - while (it.hasNext()){ - - - //value = (WriteOperations) it.next(); - // writeop = (WriteOperations) writeBuffer.get(key); - writeop = (WriteOperations) it.next(); - // System.out.println(writeop); - Byte[] data = new Byte[(int) (writeop.getRange().getEnd() - writeop.getRange().getStart())]; - byte[] bytedata = new byte[(int) (writeop.getRange().getEnd() - writeop.getRange().getStart())]; - data = (Byte[]) writeop.getData(); - - for (int i = 0; i < data.length; i++) { - bytedata[i] = data[i]; - } - - // try { - // - // writeop.getOwnertransactionalFile().file.seek(writeop.getRange().getStart()); - // System.out.println(Thread.currentThread() + " range " + writeop.getRange().getStart()); - // writeop.getOwnertransactionalFile().file.write(bytedata); - invokeNativepwrite(bytedata, writeop.getRange().getStart(), bytedata.length, writeop.getOwnertransactionalFile().file); - // System.out.println(Thread.currentThread() + " " + bytedata); - - // } catch (IOException ex) { - // Logger.getLogger(ExtendedTransaction.class.getName()).log(Level.SEVERE, null, ex); - // } - // - + INode inode = (INode) it.next(); + GlobalINodeState inodestate = TransactionalFileWrapperFactory.getTateransactionalFileINodeState(inode); + TreeMap vec2 = (TreeMap) this.getAccessedBlocks().get(inode); + Iterator iter2 = vec2.keySet().iterator(); + while (iter2.hasNext()) { + Integer num = (Integer) iter2.next(); + + BlockDataStructure blockobj = inodestate.getBlockDataStructure(num); + + ok = this.lockBlock(blockobj, (BlockAccessModesEnum) vec2.get(num)); + if (ok == false) { + break; } } - - /*if (((FileAccessModesEum) (this.FilesAccessModes.get(key))) == FileAccessModesEum.APPEND) { - try { - Range range = (Range) value.getWrittendata().firstKey(); - - - //synchronized(value.adapter){ - //value.f.seek(value.adapter.commitedfilesize.get()); - value.f.seek(value.getFilelength()); - //} - - Byte[] data = new Byte[(int) (range.getEnd() - range.getStart())]; - byte[] bytedata = new byte[(int) (range.getEnd() - range.getStart())]; - data = (Byte[]) value.getWrittendata().get(range); + } - for (int i = 0; i < data.length; i++) { - bytedata[i] = data[i]; - } - value.f.write(bytedata); + if (this.getStatus() != Status.ACTIVE) { - } catch (IOException ex) { - Logger.getLogger(ExtendedTransaction.class.getName()).log(Level.SEVERE, null, ex); - } + throw new AbortedException(); + } + abortAllReaders(); - } else if (((FileAccessModesEum) (this.FilesAccessModes.get(key))) == FileAccessModesEum.READ) { - continue; - } - else if (value.relocatablewrite && value.getContinious_written_data() != null){ - - - } - else if (!(value.getNon_Speculative_Writtendata().isEmpty())) { - int tobeaddedoffset = 0; + } - if (value.isValidatelocaloffset()) { - tobeaddedoffset = 0; - } else { - tobeaddedoffset = (int) (value.getCurrentcommitedoffset().getOffsetnumber() - value.getCopylocaloffset()); - } - Iterator it = value.getNon_Speculative_Writtendata().keySet().iterator(); - int counter = 0; - while (it.hasNext() && (this.getStatus() == Status.ACTIVE)) { - try { - Range range = (Range) it.next(); + public void commitChanges() { - - value.f.seek(range.getStart() + tobeaddedoffset); + Map hm = getWriteBuffer(); + Iterator iter = hm.keySet().iterator(); + Iterator it; + WriteOperations writeop; + Vector vec; + while (iter.hasNext() && (this.getStatus() == Status.ACTIVE)) { + INode key = (INode) iter.next(); - Byte[] data = new Byte[(int) (range.getEnd() - range.getStart())]; - byte[] bytedata = new byte[(int) (range.getEnd() - range.getStart())]; - data = (Byte[]) value.getNon_Speculative_Writtendata().get(range); + vec = (Vector) hm.get(key); + Collections.sort(vec); + it = vec.iterator(); + while (it.hasNext()) { - for (int i = 0; i < data.length; i++) { - bytedata[i] = data[i]; - } - value.f.write(bytedata); - counter++; + writeop = (WriteOperations) it.next(); + Byte[] data = new Byte[(int) (writeop.getRange().getEnd() - writeop.getRange().getStart())]; + byte[] bytedata = new byte[(int) (writeop.getRange().getEnd() - writeop.getRange().getStart())]; + data = (Byte[]) writeop.getData(); - } catch (IOException ex) { - Logger.getLogger(ExtendedTransaction.class.getName()).log(Level.SEVERE, null, ex); - } - } - } else { - continue; + for (int i = 0; i < data.length; i++) { + bytedata[i] = data[i]; } + invokeNativepwrite(bytedata, writeop.getRange().getStart(), bytedata.length, writeop.getOwnertransactionalFile().file); } + } - - iter = hm.keySet().iterator(); - while (iter.hasNext() ) { - INode key = (INode) iter.next(); - value = (TransactionLocalFileAttributes) hm.get(key); - Iterator it = value.getAccesedblocks().keySet().iterator(); - - while (it.hasNext()) { - Integer blockno = (Integer) it.next(); - synchronized (value.adapter) { - //BlockDataStructure blockobj = (BlockDataStructure) value.adapter.lockmap.get(blockno); - //blockobj.getVersion().getAndIncrement(); for versioning strategy - //value.getCurrentcommitedoffset().setOffsetnumber(value.getLocaloffset()); - //value.adapter.commitedfilesize.getAndSet(value.getFilelength()); - } - } - }*/ Iterator k = GlobaltoLocalMappings.keySet().iterator(); - while (k.hasNext()){ + while (k.hasNext()) { TransactionalFile trf = (TransactionalFile) (k.next()); - // synchronized(trf.getCommitedoffset()){ - trf.getCommitedoffset().setOffsetnumber(((TransactionLocalFileAttributes)GlobaltoLocalMappings.get(trf)).getLocaloffset()); - /*synchronized(benchmark.lock){ - System.out.println(Thread.currentThread() + " KIRIR " +GlobaltoLocalMappings.get(trf).getLocaloffset()); - }*/ - // } + trf.getCommitedoffset().setOffsetnumber(((TransactionLocalFileAttributes) GlobaltoLocalMappings.get(trf)).getLocaloffset()); } - //unlockAllLocks(); - } public void unlockAllLocks() { Iterator it = heldblocklocks.iterator(); while (it.hasNext()) { - - Lock lock = (Lock) it.next(); - lock.unlock(); - - /*synchronized(benchmark.lock){ - System.out.println(Thread.currentThread().getName() + " Released the block lock for " + lock); - }*/ + + Lock lock = (Lock) it.next(); + lock.unlock(); } heldblocklocks.clear(); - + it = heldoffsetlocks.iterator(); while (it.hasNext()) { - ReentrantLock lock = (ReentrantLock) it.next(); - lock.unlock(); - // synchronized(benchmark.lock){ - // System.out.println(Thread.currentThread().getName() + " Released the offset lock for "+ lock +"\n"); - // } + ReentrantLock lock = (ReentrantLock) it.next(); + lock.unlock(); } heldoffsetlocks.clear(); } - - public void abortAllReaders(){ + + public void abortAllReaders() { TreeMap hm = getSortedFileAccessMap(AccessedFiles); //lock phase Iterator iter = hm.keySet().iterator(); @@ -816,86 +412,60 @@ public class ExtendedTransaction implements TransactionStatu { INode key = (INode) iter.next(); Vector vec = (Vector) AccessedFiles.get(key); Iterator it = vec.iterator(); - while (it.hasNext()) - { - - value = (TransactionalFile)it.next(); - - //value = (TransactionalFile) hm.get(key); - //System.out.println(value.getCommitedoffset().getOffsetReaders()); - - Iterator it2 = value.getCommitedoffset().getOffsetReaders().iterator(); // for visible readers strategy - while ( it2.hasNext()) - { - - ExtendedTransaction tr = (ExtendedTransaction) it2.next(); - if (tr != this) - tr.abort(); + while (it.hasNext()) { + + value = (TransactionalFile) it.next(); + Iterator it2 = value.getCommitedoffset().getOffsetReaders().iterator(); // for visible readers strategy + + while (it2.hasNext()) { + ExtendedTransaction tr = (ExtendedTransaction) it2.next(); + if (tr != this) { + tr.abort(); } - value.getCommitedoffset().getOffsetReaders().clear(); - //} + } + value.getCommitedoffset().getOffsetReaders().clear(); } - - - + TreeMap vec2; - if (accessedBlocks.get(key) != null){ + if (accessedBlocks.get(key) != null) { vec2 = (TreeMap) accessedBlocks.get(key); - } - else{ + } else { vec2 = new TreeMap(); } GlobalINodeState inodestate = TransactionalFileWrapperFactory.getTateransactionalFileINodeState(key); Iterator it2 = vec2.keySet().iterator(); - - while (it2.hasNext()) - { - - Integer num = (Integer)it2.next(); - if (vec2.get(num) != BlockAccessModesEnum.READ) - { - BlockDataStructure blockobj = (BlockDataStructure) inodestate.getBlockDataStructure(num);//lockmap.get(num); - Iterator it4 = blockobj.getReaders().iterator(); // from here for visible readers strategy - - while (it4.hasNext()) - { - + + while (it2.hasNext()) { + + Integer num = (Integer) it2.next(); + if (vec2.get(num) != BlockAccessModesEnum.READ) { + BlockDataStructure blockobj = (BlockDataStructure) inodestate.getBlockDataStructure(num);//lockmap.get(num); + + Iterator it4 = blockobj.getReaders().iterator(); // from here for visible readers strategy + + while (it4.hasNext()) { + ExtendedTransaction tr = (ExtendedTransaction) it4.next(); - if (this != tr) + if (this != tr) { tr.abort(); + } } blockobj.getReaders().clear(); - + } } - - - - - /* SortedSet sst = (SortedSet) this.getAccessedBlocks().get(key); - Iterator it3 = sst.iterator(); - while (it3.hasNext()){ - Integer num = (Integer)it.next(); - BlockDataStructure blockobj = (BlockDataStructure) value.getInodestate().lockmap.get(num); - Iterator it4 = blockobj.getReaders().iterator(); // from here for visible readers strategy - while (it4.hasNext()) - { - ExtendedTransaction tr = (ExtendedTransaction) it3.next(); - tr.abort(); - } - }*/ - + } } - - public void addPropertyChangeListener(PropertyChangeListener listener){ - this.changes.addPropertyChangeListener("status",listener); + + public void addPropertyChangeListener(PropertyChangeListener listener) { + this.changes.addPropertyChangeListener("status", listener); } - - public void removePropertyChangeListener(PropertyChangeListener listener){ - this.changes.removePropertyChangeListener("status",listener); + + public void removePropertyChangeListener(PropertyChangeListener listener) { + this.changes.removePropertyChangeListener("status", listener); } public TransactionStatu getOtherSystem() { @@ -927,18 +497,101 @@ public class ExtendedTransaction implements TransactionStatu { } public boolean isCommitted() { - if (this.status == Status.COMMITTED) + if (this.status == Status.COMMITTED) { return true; - - return false; - + } + return false; + } - - - } - - +/* +public boolean lockBlock(BlockDataStructure block, Adapter adapter, BlockAccessModesEnum mode, int expvalue) { // from here for visible readers strategy +while (this.getStatus() == Status.ACTIVE) { +if (lock.tryLock()) { +Thread.onAbortOnce(new Runnable() { + +public void run() { +lock.unlock(); +} +}); + +heldblocklocks.add(lock); + +synchronized (adapter) { +block.setOwner(this); +// Iterator it = block.getReaders().iterator(); +// while (it.hasNext()) +// { +// ExtendedTransaction tr = (ExtendedTransaction) it.next(); +// tr.abort(); +// } +} + +return true; +} else { +getBlockContentionManager().resolveConflict(this, block.getOwner()); +} +} +return false;*/ +/* +public boolean lockBlock(BlockDataStructure block, Adapter adapter, BlockAccessModesEnum mode, int expvalue) { // versioning strat +while (this.getStatus() == Status.ACTIVE) { +if (lock.tryLock()) { +Thread.onAbortOnce(new Runnable() { + +public void run() { +lock.unlock(); +} +}); + +heldblocklocks.add(lock); +if (mode != BlockAccessModesEnum.WRITE) { egy +if (block.getVersion().get() != expvalue) { +unlockAllLocks(); +return false; +} +} +synchronized (adapter) { +block.setOwner(this); +} + +return true; +} else { +getContentionManager().resolveConflict(this, block.getOwner()); +} +} +return false; +}*/ +// } +//expvalue = ((Integer) value.getBlockversions().get(it)).intValue(); //for versioning strategy + /*if (!(value.isValidatelocaloffset())) { +if (((BlockAccessModesEnum) (value.getAccesedblocks().get(blockno))) != BlockAccessModesEnum.WRITE) { //versioning strategy + +/if (blockobj.getVersion().get() == expvalue) { + +ok = this.lock(blockobj, value.adapter, (BlockAccessModesEnum) (value.getAccesedblocks().get(blockno)), expvalue); +if (ok == false) { +// unlockAllLocks(); +break; +} +} else { +ok = false; +break; +} +} else { + +ok = this.lock(blockobj, value.adapter, (BlockAccessModesEnum) (value.getAccesedblocks().get(blockno)), expvalue); +if (ok == false) { +break; +} +} +} + + +if (!(ok)) { +unlockAllLocks(); +throw new AbortedException(); +}*/ diff --git a/Robust/Transactions/TransactionalIO/src/TransactionalIO/core/TransactionalFile.java b/Robust/Transactions/TransactionalIO/src/TransactionalIO/core/TransactionalFile.java index 8c4a31a7..2e460d66 100644 --- a/Robust/Transactions/TransactionalIO/src/TransactionalIO/core/TransactionalFile.java +++ b/Robust/Transactions/TransactionalIO/src/TransactionalIO/core/TransactionalFile.java @@ -4,8 +4,6 @@ */ package TransactionalIO.core; - - import TransactionalIO.Utilities.Range; import TransactionalIO.exceptions.AbortedException; import TransactionalIO.exceptions.PanicException; @@ -22,32 +20,26 @@ import java.io.RandomAccessFile; import java.nio.ByteBuffer; import java.util.Collections; import java.util.Iterator; -import java.util.SortedSet; import java.util.TreeMap; -import java.util.TreeSet; import java.util.Vector; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; import java.util.logging.Level; import java.util.logging.Logger; -import sun.misc.ConditionLock; /** * * @author navid */ +public class TransactionalFile implements Comparable { - -public class TransactionalFile implements Comparable{ - - private native int nativepread(byte buff[], long offset, int size, FileDescriptor fd); + private native int nativepwrite(byte buff[], long offset, int size, FileDescriptor fd); + { System.load("/home/navid/libkooni.so"); } - - public RandomAccessFile file; private INode inode; private int sequenceNum = 0; @@ -59,14 +51,13 @@ public class TransactionalFile implements Comparable{ public boolean appendmode = false; public ReentrantLock offsetlock; private GlobalOffset committedoffset; - private GlobalINodeState inodestate ; - - + private GlobalINodeState inodestate; + public TransactionalFile(String filename, String mode) { - - + + File f = new File(filename); - + if ((!(f.exists()))) { to_be_created = true; file = null; @@ -78,18 +69,18 @@ public class TransactionalFile implements Comparable{ offsetlock = new ReentrantLock(); file = new RandomAccessFile(f, mode); } catch (FileNotFoundException ex) { - + Logger.getLogger(TransactionalFile.class.getName()).log(Level.SEVERE, null, ex); } - + } inode = TransactionalFileWrapperFactory.getINodefromFileName(filename); inodestate = TransactionalFileWrapperFactory.createTransactionalFile(inode, filename, mode); - - + + sequenceNum = inodestate.seqNum; inodestate.seqNum++; - + if (mode.equals("rw")) { writemode = true; } else if (mode.equals("a")) { @@ -98,30 +89,38 @@ public class TransactionalFile implements Comparable{ if (inodestate != null) { synchronized (inodestate) { - committedoffset = new GlobalOffset(0); + committedoffset = new GlobalOffset(0); } } - - + + } private int invokeNativepread(byte buff[], long offset, int size) { try { return nativepread(buff, offset, size, file.getFD()); } catch (IOException ex) { - + Logger.getLogger(TransactionalFile.class.getName()).log(Level.SEVERE, null, ex); return -1; } - + + } + public int invokeNativepwrite(byte buff[], long offset, int size, RandomAccessFile file) { + try { + return nativepwrite(buff, offset, buff.length, file.getFD()); + } catch (IOException ex) { + + Logger.getLogger(TransactionalFile.class.getName()).log(Level.SEVERE, null, ex); + return -1; + } + } - public int getSequenceNum() { return sequenceNum; } - public GlobalOffset getCommitedoffset() { return committedoffset; } @@ -142,80 +141,77 @@ public class TransactionalFile implements Comparable{ } } - public long getFilePointer(){ - + public long getFilePointer() { + ExtendedTransaction me = Wrapper.getTransaction(); TransactionLocalFileAttributes tmp = null; - + if (me == null) { return non_Transactional_getFilePointer(); } - - if (!(me.getGlobaltoLocalMappings().containsKey(this))){ - me.addFile(this, 0); + + if (!(me.getGlobaltoLocalMappings().containsKey(this))) { + me.addFile(this, 0); } - + tmp = (TransactionLocalFileAttributes) me.getGlobaltoLocalMappings().get(this); - if ((tmp.getOffsetdependency() == OffsetDependency.WRITE_DEPENDENCY_1) || (tmp.getOffsetdependency() == OffsetDependency.NO_ACCESS)){ - tmp.setOffsetdependency(OffsetDependency.READ_DEPENDENCY); - - long target; - lockOffset(me); - - if (!(this.committedoffset.getOffsetReaders().contains(me))){ - this.committedoffset.getOffsetReaders().add(me); - - } - - tmp.setLocaloffset(tmp.getLocaloffset() + this.committedoffset.getOffsetnumber() - tmp.getCopylocaloffset()); - target = this.committedoffset.getOffsetnumber() - tmp.getCopylocaloffset(); - - - offsetlock.unlock(); - Iterator it; + if ((tmp.getOffsetdependency() == OffsetDependency.WRITE_DEPENDENCY_1) || (tmp.getOffsetdependency() == OffsetDependency.NO_ACCESS)) { + tmp.setOffsetdependency(OffsetDependency.READ_DEPENDENCY); + + long target; + lockOffset(me); + + if (!(this.committedoffset.getOffsetReaders().contains(me))) { + this.committedoffset.getOffsetReaders().add(me); + + } + + tmp.setLocaloffset(tmp.getLocaloffset() + this.committedoffset.getOffsetnumber() - tmp.getCopylocaloffset()); + target = this.committedoffset.getOffsetnumber() - tmp.getCopylocaloffset(); + + + offsetlock.unlock(); + Iterator it; + + if ((me.getWriteBuffer().get(inode)) != null) { - if ((me.getWriteBuffer().get(inode)) != null) - { - it = ((Vector) (me.getWriteBuffer().get(inode))).iterator(); - while (it.hasNext()){ + while (it.hasNext()) { WriteOperations wrp = (WriteOperations) it.next(); - if (wrp.getBelongingto()== tmp && wrp.isUnknownoffset()) + if (wrp.getBelongingto() == tmp && wrp.isUnknownoffset()) { wrp.setUnknownoffset(false); - wrp.getRange().setStart(target + wrp.getRange().getStart()); - wrp.getRange().setEnd(target + wrp.getRange().getEnd()); - } - } - + } + wrp.getRange().setStart(target + wrp.getRange().getStart()); + wrp.getRange().setEnd(target + wrp.getRange().getEnd()); + } + } + } - - + + tmp.setUnknown_inital_offset_for_write(false); return tmp.getLocaloffset(); } - + public void seek(long offset) { ExtendedTransaction me = Wrapper.getTransaction(); - + if (me == null) { non_Transactional_Seek(offset); return; - } - - else { - TransactionLocalFileAttributes tmp = null; - if (!(me.getGlobaltoLocalMappings().containsKey(this))){ + } else { + TransactionLocalFileAttributes tmp = null; + if (!(me.getGlobaltoLocalMappings().containsKey(this))) { me.addFile(this, offset); } tmp = (TransactionLocalFileAttributes) me.getGlobaltoLocalMappings().get(this); - - if (tmp.getOffsetdependency() == OffsetDependency.NO_ACCESS) + + if (tmp.getOffsetdependency() == OffsetDependency.NO_ACCESS) { tmp.setOffsetdependency(OffsetDependency.NO_DEPENDENCY); - - else if (tmp.getOffsetdependency() == OffsetDependency.WRITE_DEPENDENCY_1) + } else if (tmp.getOffsetdependency() == OffsetDependency.WRITE_DEPENDENCY_1) { tmp.setOffsetdependency(OffsetDependency.WRITE_DEPENDENCY_2); - + } tmp.setUnknown_inital_offset_for_write(false); tmp.setLocaloffset(offset); } @@ -228,50 +224,53 @@ public class TransactionalFile implements Comparable{ int size = b.length; int result = 0; if (me == null) { // not a transaction, but any I/O operation even though within a non-transaction is considered a single opertion transactiion + return non_Transactional_Read(b); } + if (!(me.getGlobaltoLocalMappings().containsKey(this))) { + me.addFile(this, 0); + } - if (me.getGlobaltoLocalMappings().containsKey(this)){ - + if (me.getGlobaltoLocalMappings().containsKey(this)) { + TransactionLocalFileAttributes tmp = (TransactionLocalFileAttributes) me.getGlobaltoLocalMappings().get(this); tmp.setUnknown_inital_offset_for_write(false); - + OffsetDependency dep = tmp.getOffsetdependency(); - if ((dep == OffsetDependency.WRITE_DEPENDENCY_1) || - (dep == OffsetDependency.NO_ACCESS) || - (dep == OffsetDependency.WRITE_DEPENDENCY_2)) - { - tmp.setOffsetdependency(OffsetDependency.READ_DEPENDENCY); - lockOffset(me); - - if (dep != OffsetDependency.WRITE_DEPENDENCY_2){ - tmp.setLocaloffset(tmp.getLocaloffset() + this.committedoffset.getOffsetnumber() - tmp.getCopylocaloffset()); - } - - if (!(this.committedoffset.getOffsetReaders().contains(me))){ - this.committedoffset.getOffsetReaders().add(me); - - } - - offsetlock.unlock(); + if ((dep == OffsetDependency.WRITE_DEPENDENCY_1) || + (dep == OffsetDependency.NO_ACCESS) || + (dep == OffsetDependency.WRITE_DEPENDENCY_2)) { + tmp.setOffsetdependency(OffsetDependency.READ_DEPENDENCY); + lockOffset(me); + + if (dep != OffsetDependency.WRITE_DEPENDENCY_2) { + tmp.setLocaloffset(tmp.getLocaloffset() + this.committedoffset.getOffsetnumber() - tmp.getCopylocaloffset()); + } + + if (!(this.committedoffset.getOffsetReaders().contains(me))) { + this.committedoffset.getOffsetReaders().add(me); + + } + + offsetlock.unlock(); } - - + + makeWritestDependent(me); - - - if ((Boolean)me.merge_for_writes_done.get(inode) == Boolean.FALSE){ - mergeWrittenData(me); + + + if ((Boolean) me.merge_for_writes_done.get(inode) == Boolean.FALSE) { + mergeWrittenData(me); } - + long loffset = tmp.getLocaloffset(); markAccessedBlocks(me, loffset, size, BlockAccessModesEnum.READ); - + Vector writebuffer; - if ((me.getWriteBuffer().get(this.inode)) != null) + if ((me.getWriteBuffer().get(this.inode)) != null) { writebuffer = (Vector) (me.getWriteBuffer().get(this.inode)); - else { + } else { writebuffer = new Vector(); me.getWriteBuffer().put(this.inode, writebuffer); } @@ -279,14 +278,14 @@ public class TransactionalFile implements Comparable{ Range writerange = null; Range[] intersectedrange = new Range[writebuffer.size()]; WriteOperations[] markedwriteop = new WriteOperations[writebuffer.size()]; - + int counter = 0; boolean in_local_buffer = false; - - + + Iterator it = writebuffer.iterator(); while (it.hasNext()) { - + WriteOperations wrp = (WriteOperations) it.next(); writerange = wrp.getRange(); if (writerange.includes(readrange)) { @@ -298,23 +297,23 @@ public class TransactionalFile implements Comparable{ if (writerange.hasIntersection(readrange)) { intersectedrange[counter] = readrange.intersection(writerange); markedwriteop[counter] = wrp; - + counter++; } } if (in_local_buffer) { // the read one from local buffer - result = readFromBuffer(b, tmp, markedwriteop[counter],writerange); + + result = readFromBuffer(b, tmp, markedwriteop[counter], writerange); return result; - } - - else{ + } else { + if (counter == 0) { // all the read straight from file + result = readFromFile(me, b, tmp); - } - - else { // some parts from file others from buffer + } else { // some parts from file others from buffer + for (int i = 0; i < counter; i++) { Byte[] data = markedwriteop[i].getData(); byte[] copydata = new byte[data.length]; @@ -337,72 +336,76 @@ public class TransactionalFile implements Comparable{ } } - lockOffset(me); + // lockOffset(me); + me.getHeldoffsetlocks().add(offsetlock); boolean locked = false; BlockDataStructure block; for (int k = 0; k < occupiedblocks.size(); k++) { // locking the block locks - - while (me.getStatus() == Status.ACTIVE) { - block = this.inodestate.getBlockDataStructure((Integer)(occupiedblocks.get(k)));//(BlockDataStructure) tmp.adapter.lockmap.get(Integer.valueOf(k))); + + while (me.getStatus() == Status.ACTIVE) { + block = this.inodestate.getBlockDataStructure((Integer) (occupiedblocks.get(k)));//(BlockDataStructure) tmp.adapter.lockmap.get(Integer.valueOf(k))); + block.getLock().readLock().lock(); - if (!(block.getReaders().contains(me))){ - block.getReaders().add(me); - } - locked = true; - //me.getHeldblocklocks().add(block.getLock().readLock()); - break; - } - if (me.getStatus() == Status.ABORTED) { - int m; - if (locked) { - m = k + 1; - } else { - m = k; - } - for (int i = 0; i < m; i++) { - block = this.inodestate.getBlockDataStructure((Integer)(occupiedblocks.get(k))); - me.getHeldblocklocks().add(block.getLock().readLock()); - } - - locked = false; - throw new AbortedException(); + if (!(block.getReaders().contains(me))) { + block.getReaders().add(me); + } + locked = true; + //me.getHeldblocklocks().add(block.getLock().readLock()); + break; + } + if (me.getStatus() == Status.ABORTED) { + int m; + if (locked) { + m = k + 1; + } else { + m = k; + } + for (int i = 0; i < m; i++) { + block = this.inodestate.getBlockDataStructure((Integer) (occupiedblocks.get(k))); + me.getHeldblocklocks().add(block.getLock().readLock()); + } + + locked = false; + throw new AbortedException(); } } - + for (int i = 0; i < non_intersected_ranges.length; i++) { - try { - - file.seek(non_intersected_ranges[i].getStart()); - int tmpsize = file.read(b, (int) (non_intersected_ranges[i].getStart() - readrange.getStart()), (int) (non_intersected_ranges[i].getEnd() - non_intersected_ranges[i].getStart())); + // try { + int sizetoread = (int) (non_intersected_ranges[i].getEnd() - non_intersected_ranges[i].getStart()); + byte[] tmpdt = new byte[(int) (non_intersected_ranges[i].getEnd() - non_intersected_ranges[i].getStart())]; + int tmpsize = invokeNativepread(tmpdt, non_intersected_ranges[i].getStart(), sizetoread); + System.arraycopy(tmpdt, 0, b, (int) (non_intersected_ranges[i].getStart() - readrange.getStart()), sizetoread); + //file.seek(non_intersected_ranges[i].getStart()); + //int tmpsize = file.read(b, (int) (non_intersected_ranges[i].getStart() - readrange.getStart()), (int) (non_intersected_ranges[i].getEnd() - non_intersected_ranges[i].getStart())); result += tmpsize; - } catch (IOException ex) { - Logger.getLogger(TransactionalFile.class.getName()).log(Level.SEVERE, null, ex); - } + // } catch (IOException ex) { + // Logger.getLogger(TransactionalFile.class.getName()).log(Level.SEVERE, null, ex); + // } } - - if (me.getStatus() == Status.ABORTED) { + + if (me.getStatus() == Status.ABORTED) { for (int k = 0; k < occupiedblocks.size(); k++) { - block = this.inodestate.getBlockDataStructure((Integer)(occupiedblocks.get(k))); + block = this.inodestate.getBlockDataStructure((Integer) (occupiedblocks.get(k))); me.getHeldblocklocks().add(block.getLock().readLock()); } throw new AbortedException(); } for (int k = 0; k < occupiedblocks.size(); k++) { - block = this.inodestate.getBlockDataStructure((Integer)(occupiedblocks.get(k)));//(BlockDataStructure) tmp.adapter.lockmap.get(Integer.valueOf(k))); - block.getLock().readLock().unlock(); + block = this.inodestate.getBlockDataStructure((Integer) (occupiedblocks.get(k)));//(BlockDataStructure) tmp.adapter.lockmap.get(Integer.valueOf(k))); + + block.getLock().readLock().unlock(); } - // me.unlockAllLocks(); - offsetlock.unlock(); + // offsetlock.unlock(); tmp.setLocaloffset(tmp.getLocaloffset() + result); } - + return result; } - } else { // add to the readers list - - me.addFile(this, 0); + } else { // add to the readers list + // me.addFile(this, 0); return read(b); } @@ -421,15 +424,15 @@ public class TransactionalFile implements Comparable{ if (me == null) // not a transaction { - + non_Transactional_Write(data); return; } - + if (me.getGlobaltoLocalMappings().containsKey(this)) // { - - + + Byte[] by = new Byte[size]; for (int i = 0; i < size; i++) { by[i] = Byte.valueOf(data[i]); @@ -437,88 +440,85 @@ public class TransactionalFile implements Comparable{ TransactionLocalFileAttributes tmp = ((TransactionLocalFileAttributes) (me.getGlobaltoLocalMappings().get(this))); Vector dummy; - if (((Vector)(me.getWriteBuffer().get(this.inode))) != null){ - dummy = new Vector((Vector)(me.getWriteBuffer().get(this.inode))); - } - else + if (((Vector) (me.getWriteBuffer().get(this.inode))) != null) { + dummy = new Vector((Vector) (me.getWriteBuffer().get(this.inode))); + } else { dummy = new Vector(); - + } dummy.add(new WriteOperations(by, new Range(tmp.getLocaloffset(), tmp.getLocaloffset() + by.length), tmp.isUnknown_inital_offset_for_write(), this, tmp)); me.getWriteBuffer().put(this.inode, dummy); - + long loffset = tmp.getLocaloffset(); - - + + tmp.setLocaloffset(tmp.getLocaloffset() + by.length); - + me.merge_for_writes_done.put(inode, Boolean.FALSE); - - if (!(tmp.isUnknown_inital_offset_for_write())){ + + if (!(tmp.isUnknown_inital_offset_for_write())) { markAccessedBlocks(me, loffset, size, BlockAccessModesEnum.WRITE); } - if (tmp.getOffsetdependency() == OffsetDependency.NO_ACCESS) + if (tmp.getOffsetdependency() == OffsetDependency.NO_ACCESS) { tmp.offsetdependency = OffsetDependency.WRITE_DEPENDENCY_1; - + } } else { me.addFile(this, 0); write(data); } } - - private void markAccessedBlocks(ExtendedTransaction me,long loffset, int size, BlockAccessModesEnum mode){ - + private void markAccessedBlocks(ExtendedTransaction me, long loffset, int size, BlockAccessModesEnum mode) { + TreeMap map; - - if (me.getAccessedBlocks().get(this.getInode()) != null) + + if (me.getAccessedBlocks().get(this.getInode()) != null) { map = (TreeMap) me.getAccessedBlocks().get(this.getInode()); - else{ + } else { map = new TreeMap(); me.getAccessedBlocks().put(this.inode, map); } int startblock = FileBlockManager.getCurrentFragmentIndexofTheFile(loffset); int targetblock = FileBlockManager.getTargetFragmentIndexofTheFile(loffset, size); for (int i = startblock; i <= targetblock; i++) { - if (map.containsKey(Integer.valueOf(i))){ - if (map.get(Integer.valueOf(i)) != mode){ + if (map.containsKey(Integer.valueOf(i))) { + if (map.get(Integer.valueOf(i)) != mode) { map.put(Integer.valueOf(i), BlockAccessModesEnum.READ_WRITE); - } - } - else{ - map.put(Integer.valueOf(i), mode); + } + } else { + map.put(Integer.valueOf(i), mode); } } } - + private int readFromFile(ExtendedTransaction me, byte[] readdata, TransactionLocalFileAttributes tmp) { int st = FileBlockManager.getCurrentFragmentIndexofTheFile(tmp.getLocaloffset()); int end = FileBlockManager.getTargetFragmentIndexofTheFile(tmp.getLocaloffset(), readdata.length); - - BlockDataStructure block = null; - boolean locked = false; + + BlockDataStructure block = null; + boolean locked = false; for (int k = st; k <= end; k++) { while (me.getStatus() == Status.ACTIVE) { - + block = this.inodestate.getBlockDataStructure(Integer.valueOf(k)); - + block.getLock().readLock().lock(); - - if (!(block.getReaders().contains(me))){ - block.getReaders().add(me); - } - locked = true; - break; + + if (!(block.getReaders().contains(me))) { + block.getReaders().add(me); + } + locked = true; + break; } if (me.getStatus() == Status.ABORTED) { int m; - if (locked){ - m = k+1; - } - else + if (locked) { + m = k + 1; + } else { m = k; - for (int i=st; i= wrp.getRange().getEnd()) { - suffixdata = new Byte[(int) (wrp2.getRange().getEnd() - intersectedrange.getEnd())]; - suffixdata = (Byte[]) (wrp2.getData()); - startsuffix = intersectedrange.getEnd() - wrp2.getRange().getStart(); - suffixsize = (int)(wrp2.getRange().getEnd() - intersectedrange.getEnd()); - suffix = true; - endsuffix = wrp2.getRange().getEnd(); - } + long startprefix = 0; + long endsuffix = 0; + long startsuffix = 0; + int prefixsize = 0; + int suffixsize = 0; + int intermediatesize = 0; + Byte[] prefixdata = null; + Byte[] suffixdata = null; + boolean prefix = false; + boolean suffix = false; + if (flag) { + + + if (wrp.getRange().getStart() < wrp2.getRange().getStart()) { + prefixdata = new Byte[(int) (wrp2.getRange().getStart() - wrp.getRange().getStart())]; + prefixdata = (Byte[]) (wrp.getData()); + startprefix = wrp.getRange().getStart(); + prefixsize = (int) (intersectedrange.getStart() - startprefix); + intermediatesize = (int) (intersectedrange.getEnd() - intersectedrange.getStart()); + prefix = true; + } else if (wrp2.getRange().getStart() <= wrp.getRange().getStart()) { + prefixdata = new Byte[(int) (wrp.getRange().getStart() - wrp2.getRange().getStart())]; + prefixdata = (Byte[]) (wrp2.getData()); + startprefix = wrp2.getRange().getStart(); + prefixsize = (int) (intersectedrange.getStart() - startprefix); + intermediatesize = (int) (intersectedrange.getEnd() - intersectedrange.getStart()); + prefix = true; + } - else if (wrp.getRange().getEnd() > wrp2.getRange().getEnd()) { - suffixdata = new Byte[(int) (wrp.getRange().getEnd() - intersectedrange.getEnd())]; - suffixdata = (Byte[]) (wrp.getData()); - startsuffix = intersectedrange.getEnd() - wrp.getRange().getStart(); - suffixsize = (int)(wrp.getRange().getEnd() - intersectedrange.getEnd()); - endsuffix = wrp.getRange().getEnd(); - suffix = true; + if (wrp2.getRange().getEnd() >= wrp.getRange().getEnd()) { + + suffixdata = new Byte[(int) (wrp2.getRange().getEnd() - intersectedrange.getEnd())]; + suffixdata = (Byte[]) (wrp2.getData()); + startsuffix = intersectedrange.getEnd() - wrp2.getRange().getStart(); + suffixsize = (int) (wrp2.getRange().getEnd() - intersectedrange.getEnd()); + suffix = true; + endsuffix = wrp2.getRange().getEnd(); + } else if (wrp.getRange().getEnd() > wrp2.getRange().getEnd()) { + suffixdata = new Byte[(int) (wrp.getRange().getEnd() - intersectedrange.getEnd())]; + suffixdata = (Byte[]) (wrp.getData()); + startsuffix = intersectedrange.getEnd() - wrp.getRange().getStart(); + suffixsize = (int) (wrp.getRange().getEnd() - intersectedrange.getEnd()); + endsuffix = wrp.getRange().getEnd(); + suffix = true; - } - - Byte[] data_to_insert; - - if ((prefix) && (suffix)) { - data_to_insert = new Byte[(int) (endsuffix - startprefix)]; - System.arraycopy(prefixdata, 0, data_to_insert, 0, prefixsize); - System.arraycopy(wrp2.getData(), (int)(intersectedrange.getStart() - wrp2.getRange().getStart()), data_to_insert, prefixsize, intermediatesize); - System.arraycopy(suffixdata, (int)startsuffix, data_to_insert, (prefixsize + intermediatesize), suffixsize); - wrp.setData(data_to_insert); - wrp.setRange(new Range(startprefix, endsuffix)); - } - } + + Byte[] data_to_insert; + + if ((prefix) && (suffix)) { + data_to_insert = new Byte[(int) (endsuffix - startprefix)]; + System.arraycopy(prefixdata, 0, data_to_insert, 0, prefixsize); + System.arraycopy(wrp2.getData(), (int) (intersectedrange.getStart() - wrp2.getRange().getStart()), data_to_insert, prefixsize, intermediatesize); + System.arraycopy(suffixdata, (int) startsuffix, data_to_insert, (prefixsize + intermediatesize), suffixsize); + wrp.setData(data_to_insert); + wrp.setRange(new Range(startprefix, endsuffix)); + } + } } - Iterator it = toberemoved.iterator(); - while (it.hasNext()) - vec.remove(it.next()); - - toberemoved.clear(); - Collections.sort(vec); - me.merge_for_writes_done.put(inode, Boolean.TRUE); + } + Iterator it = toberemoved.iterator(); + while (it.hasNext()) { + vec.remove(it.next()); + } + toberemoved.clear(); + Collections.sort(vec); + me.merge_for_writes_done.put(inode, Boolean.TRUE); } - - public void non_Transactional_Write(byte[] data){ - - Vector heldlocks = new Vector(); - offsetlock.lock(); - int startblock = FileBlockManager.getCurrentFragmentIndexofTheFile(committedoffset.getOffsetnumber()); - int targetblock = FileBlockManager.getTargetFragmentIndexofTheFile(committedoffset.getOffsetnumber(), data.length); - for (int i = startblock; i <= targetblock; i++) { - BlockDataStructure block =this.inodestate.getBlockDataStructure(i); - block.getLock().writeLock().lock(); - heldlocks.add(block.getLock().writeLock()); - - } - try { + public void non_Transactional_Write(byte[] data) { - file.seek(committedoffset.getOffsetnumber()); - file.write(data); - - committedoffset.setOffsetnumber(committedoffset.getOffsetnumber() +data.length); - - } catch (IOException ex) { - Logger.getLogger(TransactionalFile.class.getName()).log(Level.SEVERE, null, ex); - } finally { - unlockLocks(heldlocks); - offsetlock.unlock(); - } + Vector heldlocks = new Vector(); + offsetlock.lock(); + int startblock = FileBlockManager.getCurrentFragmentIndexofTheFile(committedoffset.getOffsetnumber()); + int targetblock = FileBlockManager.getTargetFragmentIndexofTheFile(committedoffset.getOffsetnumber(), data.length); + for (int i = startblock; i <= targetblock; i++) { + BlockDataStructure block = this.inodestate.getBlockDataStructure(i); + block.getLock().writeLock().lock(); + heldlocks.add(block.getLock().writeLock()); + + } + + try { + invokeNativepwrite(data, committedoffset.getOffsetnumber(), data.length, file); + //file.seek(committedoffset.getOffsetnumber()); + //file.write(data); + committedoffset.setOffsetnumber(committedoffset.getOffsetnumber() + data.length); + + //} catch (IOException ex) { + // Logger.getLogger(TransactionalFile.class.getName()).log(Level.SEVERE, null, ex); + } finally { + unlockLocks(heldlocks); + offsetlock.unlock(); + } } - - public int non_Transactional_Read(byte[] b){ + + public int non_Transactional_Read(byte[] b) { int size = -1; Vector heldlocks = new Vector(); boolean flag = true; offsetlock.lock(); - int startblock; - int targetblock; + int startblock; + int targetblock; startblock = FileBlockManager.getCurrentFragmentIndexofTheFile(committedoffset.getOffsetnumber()); targetblock = FileBlockManager.getTargetFragmentIndexofTheFile(committedoffset.getOffsetnumber(), size); for (int i = startblock; i <= targetblock; i++) { BlockDataStructure block = this.inodestate.getBlockDataStructure(i); - block.getLock().readLock().lock(); - heldlocks.add(block.getLock().readLock()); + block.getLock().readLock().lock(); + heldlocks.add(block.getLock().readLock()); } size = invokeNativepread(b, committedoffset.getOffsetnumber(), b.length); - committedoffset.setOffsetnumber(committedoffset.getOffsetnumber() +size); - if (!(committedoffset.getOffsetReaders().isEmpty())){ - Iterator it2 = committedoffset.getOffsetReaders().iterator(); // for visible readers strategy - while ( it2.hasNext()) - { + committedoffset.setOffsetnumber(committedoffset.getOffsetnumber() + size); + if (!(committedoffset.getOffsetReaders().isEmpty())) { + Iterator it2 = committedoffset.getOffsetReaders().iterator(); // for visible readers strategy + + while (it2.hasNext()) { ExtendedTransaction tr = (ExtendedTransaction) it2.next(); tr.abort(); - } - committedoffset.getOffsetReaders().clear(); + } + committedoffset.getOffsetReaders().clear(); } unlockLocks(heldlocks); offsetlock.unlock(); - if (size == 0) + if (size == 0) { size = -1; - - return size; + } + return size; } - - public void non_Transactional_Seek(long offset){ + + public void non_Transactional_Seek(long offset) { offsetlock.lock(); - committedoffset.setOffsetnumber(offset); + committedoffset.setOffsetnumber(offset); offsetlock.unlock(); } - public long non_Transactional_getFilePointer(){ + public long non_Transactional_getFilePointer() { long offset = -1; - + offsetlock.lock(); - offset = committedoffset.getOffsetnumber(); + offset = committedoffset.getOffsetnumber(); offsetlock.unlock(); - + return offset; } - + public int compareTo(Object arg0) { TransactionalFile tf = (TransactionalFile) arg0; - if (this.inode.getNumber() < tf.inode.getNumber()) + if (this.inode.getNumber() < tf.inode.getNumber()) { return -1; - else if (this.inode.getNumber() > tf.inode.getNumber()) + } else if (this.inode.getNumber() > tf.inode.getNumber()) { return 1; - else { - if (this.sequenceNum < tf.sequenceNum) + } else { + if (this.sequenceNum < tf.sequenceNum) { return -1; - else + } else { return 1; + } } } - - public void makeWritestDependent(ExtendedTransaction me){// make the writes absolute and dependent on ofset value + + public void makeWritestDependent(ExtendedTransaction me) {// make the writes absolute and dependent on ofset value + Iterator it; - if (me.getWriteBuffer().get(inode) != null) - { + if (me.getWriteBuffer().get(inode) != null) { it = ((Vector) (me.getWriteBuffer().get(inode))).iterator(); - while (it.hasNext()){ + while (it.hasNext()) { - WriteOperations wrp = (WriteOperations) it.next(); - if (wrp.isUnknownoffset()){ + WriteOperations wrp = (WriteOperations) it.next(); + if (wrp.isUnknownoffset()) { wrp.setUnknownoffset(false); wrp.getOwnertransactionalFile().lockOffset(me); - wrp.getRange().setStart(wrp.getOwnertransactionalFile().committedoffset.getOffsetnumber() - - wrp.getBelongingto().getCopylocaloffset() - + wrp.getRange().getStart()); - wrp.getRange().setEnd(wrp.getOwnertransactionalFile().committedoffset.getOffsetnumber() - - wrp.getBelongingto().getCopylocaloffset() - + wrp.getRange().getEnd()); - if ((wrp.getBelongingto().getOffsetdependency() == OffsetDependency.WRITE_DEPENDENCY_1) || - (wrp.getBelongingto().offsetdependency == OffsetDependency.NO_ACCESS) || - (wrp.getBelongingto().getOffsetdependency() == OffsetDependency.WRITE_DEPENDENCY_2)){ - wrp.getBelongingto().setOffsetdependency(OffsetDependency.READ_DEPENDENCY); - wrp.getBelongingto().setUnknown_inital_offset_for_write(false); - if (!(wrp.getOwnertransactionalFile().committedoffset.getOffsetReaders().contains(me))) - wrp.getOwnertransactionalFile().committedoffset.getOffsetReaders().add(me); - wrp.getBelongingto().setLocaloffset(wrp.getBelongingto().getLocaloffset() + wrp.getOwnertransactionalFile().committedoffset.getOffsetnumber() - wrp.getBelongingto().getCopylocaloffset()); + wrp.getRange().setStart(wrp.getOwnertransactionalFile().committedoffset.getOffsetnumber() - wrp.getBelongingto().getCopylocaloffset() + wrp.getRange().getStart()); + wrp.getRange().setEnd(wrp.getOwnertransactionalFile().committedoffset.getOffsetnumber() - wrp.getBelongingto().getCopylocaloffset() + wrp.getRange().getEnd()); + if ((wrp.getBelongingto().getOffsetdependency() == OffsetDependency.WRITE_DEPENDENCY_1) || + (wrp.getBelongingto().offsetdependency == OffsetDependency.NO_ACCESS) || + (wrp.getBelongingto().getOffsetdependency() == OffsetDependency.WRITE_DEPENDENCY_2)) { + wrp.getBelongingto().setOffsetdependency(OffsetDependency.READ_DEPENDENCY); + wrp.getBelongingto().setUnknown_inital_offset_for_write(false); + if (!(wrp.getOwnertransactionalFile().committedoffset.getOffsetReaders().contains(me))) { + wrp.getOwnertransactionalFile().committedoffset.getOffsetReaders().add(me); } - wrp.getOwnertransactionalFile().offsetlock.unlock(); - markAccessedBlocks(me, (int)wrp.getRange().getStart(), (int)(wrp.getRange().getEnd() - wrp.getRange().getStart()), BlockAccessModesEnum.WRITE); + wrp.getBelongingto().setLocaloffset(wrp.getBelongingto().getLocaloffset() + wrp.getOwnertransactionalFile().committedoffset.getOffsetnumber() - wrp.getBelongingto().getCopylocaloffset()); + } + wrp.getOwnertransactionalFile().offsetlock.unlock(); + markAccessedBlocks(me, (int) wrp.getRange().getStart(), (int) (wrp.getRange().getEnd() - wrp.getRange().getStart()), BlockAccessModesEnum.WRITE); - } + } } } - + } +} +// for block versioning mechanism + /*if (!(validateBlocksVersions(startblock, targetblock))) { ////check to see if version are still valid +throw new AbortedException(); + +}*/ +/* +int expvalue = ((Integer) tmp.getBlockversions().get(Integer.valueOf(k))).intValue(); +while (me.getStatus() == Status.ACTIVE) { +BlockDataStructure block = ((BlockDataStructure) tmp.adapter.lockmap.get(Integer.valueOf(k))); +if (block.getLock().tryLock()) { +heldlocks.add(block.getLock()); +if (!(block.getVersion().get() == expvalue)) { // for block versioning mechanism +me.abort(); } - - - // for block versioning mechanism - /*if (!(validateBlocksVersions(startblock, targetblock))) { ////check to see if version are still valid - - throw new AbortedException(); - - }*/ - /* - int expvalue = ((Integer) tmp.getBlockversions().get(Integer.valueOf(k))).intValue(); - while (me.getStatus() == Status.ACTIVE) { - BlockDataStructure block = ((BlockDataStructure) tmp.adapter.lockmap.get(Integer.valueOf(k))); - if (block.getLock().tryLock()) { - heldlocks.add(block.getLock()); - if (!(block.getVersion().get() == expvalue)) { // for block versioning mechanism - me.abort(); - } - else { - break; - } - } - else { - me.getContentionManager().resolveConflict(me, block.getOwner()); - } - } - if (me.getStatus() == Status.ABORTED) { - unlockLocks(heldlocks); - offsetlock.unlock(); - throw new AbortedException(); - } - } - }*/ - - +else { +break; +} +} +else { +me.getContentionManager().resolveConflict(me, block.getOwner()); +} +} +if (me.getStatus() == Status.ABORTED) { +unlockLocks(heldlocks); +offsetlock.unlock(); +throw new AbortedException(); +} +} +}*/ /* public boolean validateBlocksVersions(int startblock, int targetblock) { // For Block Versioning Mechanism - boolean valid = true; - ExtendedTransaction me = ExtendedTransaction.getTransaction(); - TransactionLocalFileAttributes tmp = ((TransactionLocalFileAttributes) (me.getFilesAccesses().get(this.getInode()))); - for (int i = startblock; i <= targetblock; i++) { - int expvalue = ((Integer) tmp.getBlockversions().get(Integer.valueOf(i))).intValue(); - BlockDataStructure block = ((BlockDataStructure) tmp.adapter.lockmap.get(Integer.valueOf(i))); - if (expvalue != block.getVersion().get()) { - valid = false; - break; - } - } - - return valid; - }*/ +boolean valid = true; +ExtendedTransaction me = ExtendedTransaction.getTransaction(); +TransactionLocalFileAttributes tmp = ((TransactionLocalFileAttributes) (me.getFilesAccesses().get(this.getInode()))); +for (int i = startblock; i <= targetblock; i++) { +int expvalue = ((Integer) tmp.getBlockversions().get(Integer.valueOf(i))).intValue(); +BlockDataStructure block = ((BlockDataStructure) tmp.adapter.lockmap.get(Integer.valueOf(i))); +if (expvalue != block.getVersion().get()) { +valid = false; +break; +} +} + +return valid; +}*/