*/
package TransactionalIO.core;
-
-
-
-
import TransactionalIO.exceptions.AbortedException;
import TransactionalIO.benchmarks.benchmark;
import TransactionalIO.benchmarks.customhandler;
* @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<ReentrantLock> heldoffsetlocks;
- private Vector heldoffsetlocks;
-
+ private Vector heldoffsetlocks;
//private Vector<ReentrantLock> heldblocklocks;
private Vector heldblocklocks;
-
//private HashMap<INode, Vector<TransactionalFile>> AccessedFiles;
- private HashMap AccessedFiles;
-
-
+ private HashMap AccessedFiles;
//private HashMap<INode, HashMap<Integer, BlockAccessModesEnum> > accessedBlocks;
- private HashMap accessedBlocks;
-
- //private HashMap<TransactionalFile, TransactionLocalFileAttributes> LocaltoGlobalMappings;
+ private HashMap accessedBlocks;
+ //private HashMap<TransactionalFile, TransactionLocalFileAttributes> 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/*<TransactionalFile, TransactionLocalFileAttributes >*/();
writeBuffer = new HashMap();
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;
}
public void setContentionmanager(ContentionManager contentionmanager) {
this.contentionmanager = contentionmanager;
}
-
public HashMap getWriteBuffer() {
return writeBuffer;
}
-
+
public HashMap getAccessedFiles() {
return AccessedFiles;
}
-
+
public boolean isWritesmerged() {
return writesmerged;
}
this.writesmerged = writesmerged;
}
-
-
-
-
-
public HashMap getGlobaltoLocalMappings() {
return GlobaltoLocalMappings;
}
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()*/);
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);
}
}
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();
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() {
}
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();
+}*/
*/
package TransactionalIO.core;
-
-
import TransactionalIO.Utilities.Range;
import TransactionalIO.exceptions.AbortedException;
import TransactionalIO.exceptions.PanicException;
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;
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;
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")) {
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;
}
}
}
- 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);
}
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);
}
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)) {
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];
}
}
- 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);
}
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]);
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<m; i++){
+ }
+ for (int i = st; i < m; i++) {
block = this.inodestate.getBlockDataStructure(Integer.valueOf(k));
me.getHeldblocklocks().add(block.getLock().readLock());
}
throw new AbortedException();
}
}
-
- int size = -1;
- size = invokeNativepread(readdata, tmp.getLocaloffset(), readdata.length);
- tmp.setLocaloffset(tmp.getLocaloffset() + size);
-
- if (size == 0)
- size = -1;
- if (me.getStatus() == Status.ABORTED) {
- for (int i=st; i<=end; i++){
- block = this.inodestate.getBlockDataStructure(Integer.valueOf(i));
- me.getHeldblocklocks().add(block.getLock().readLock());
- }
- throw new AbortedException();
+
+ int size = -1;
+ size = invokeNativepread(readdata, tmp.getLocaloffset(), readdata.length);
+ tmp.setLocaloffset(tmp.getLocaloffset() + size);
+
+ if (size == 0) {
+ size = -1;
+ }
+ if (me.getStatus() == Status.ABORTED) {
+ for (int i = st; i <= end; i++) {
+ block = this.inodestate.getBlockDataStructure(Integer.valueOf(i));
+ me.getHeldblocklocks().add(block.getLock().readLock());
+ }
+ throw new AbortedException();
}
for (int k = st; k <= end; k++) {
- block = this.inodestate.getBlockDataStructure(Integer.valueOf(k));
- block.getLock().readLock().unlock();
+ block = this.inodestate.getBlockDataStructure(Integer.valueOf(k));
+ block.getLock().readLock().unlock();
}
return size;
public void setInode(INode inode) {
this.inode = inode;
}
-
- public void lockOffset(ExtendedTransaction me){
- boolean locked = false;
- while (me.getStatus() == Status.ACTIVE) { //locking the offset
- offsetlock.lock();
- locked = true;
- break;
- }
-
- if (me.getStatus() != Status.ACTIVE){
- if (locked)
- me.getHeldoffsetlocks().add(offsetlock);
- throw new AbortedException();
+
+ public void lockOffset(ExtendedTransaction me) {
+ boolean locked = false;
+ while (me.getStatus() == Status.ACTIVE) { //locking the offset
+
+ offsetlock.lock();
+ locked = true;
+ break;
+ }
+
+ if (me.getStatus() != Status.ACTIVE) {
+ if (locked) {
+ me.getHeldoffsetlocks().add(offsetlock);
}
+ throw new AbortedException();
+ }
}
-
- public void mergeWrittenData(ExtendedTransaction me/*TreeMap target, byte[] data, Range to_be_merged_data_range*/){
-
- boolean flag = false;
- Vector vec = (Vector) me.getWriteBuffer().get(this.inode);
- Range intersectedrange = new Range(0, 0);
- Iterator it1 = vec.iterator();
- WriteOperations wrp;
- WriteOperations wrp2;
- Vector toberemoved = new Vector();
- while (it1.hasNext()) {
- wrp = (WriteOperations) (it1.next());
-
- if (toberemoved.contains(wrp)){
+
+ public void mergeWrittenData(ExtendedTransaction me/*TreeMap target, byte[] data, Range to_be_merged_data_range*/) {
+
+ boolean flag = false;
+ Vector vec = (Vector) me.getWriteBuffer().get(this.inode);
+ Range intersectedrange = new Range(0, 0);
+ Iterator it1 = vec.iterator();
+ WriteOperations wrp;
+ WriteOperations wrp2;
+ Vector toberemoved = new Vector();
+ while (it1.hasNext()) {
+ wrp = (WriteOperations) (it1.next());
+
+ if (toberemoved.contains(wrp)) {
+ continue;
+ }
+
+ Iterator it2 = vec.listIterator();
+ while (it2.hasNext()) {
+ flag = false;
+ wrp2 = (WriteOperations) (it2.next());
+
+ if ((wrp2 == wrp) || toberemoved.contains(wrp2)) {
continue;
}
-
- Iterator it2 = vec.listIterator();
- while (it2.hasNext()) {
- flag = false;
- wrp2 = (WriteOperations) (it2.next());
-
- if ((wrp2 == wrp) || toberemoved.contains(wrp2)){
- continue;
- }
-
- if (wrp.getRange().hasIntersection(wrp2.getRange())) {
- flag = true;
- intersectedrange = wrp2.getRange().intersection(wrp.getRange());
- toberemoved.add(wrp2);
- }
-
-
- 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;
- }
+ if (wrp.getRange().hasIntersection(wrp2.getRange())) {
+ flag = true;
+ intersectedrange = wrp2.getRange().intersection(wrp.getRange());
+ toberemoved.add(wrp2);
+ }
- 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();
- }
+ 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;
+}*/
projects / IRC.git / commitdiff